Go Fern Fractal

I’m so stuck in system level programming in C and Go I almost forget how to do ‘normal’ stuff ;-P Therefore  I gave myself a small Go programming exercise, something with visual feedback. Recently I read this excellent post on how to draw a fractal in Clojure and I thought it would be fun to rewrite this in Go.

The fractal is a Barnsley Fern and is an example of an iterated function system. You take a  function which returns some values and you use the returned values as the input to the same function in the next step, and you keep doing that until eternity or you put a limit on the amount of steps.

With the Barnsley Fern fractal you have four transform function with input x and y. We give it a start point x and y, one of the randomly chosen transform functions will calculate a new x and y. We draw this as a point on an image and than give the new x and y the the next randomly chosen transform function and repeat this 10,000 times.

If you do this with specific parameters you will draw a fern:

And here is the source code:

package main

import (

func main() {
 m := image.NewRGBA(image.Rect(0, 0, 400, 400))
 blue := color.RGBA{0, 0, 0, 255}
 draw.Draw(m, m.Bounds(), &image.Uniform{blue}, image.ZP, draw.Src)
 drawFern(m, 400, 400, 10000)
 f, err := os.OpenFile("fern.png", os.O_CREATE | os.O_WRONLY, 0666)
 if(err != nil) {
 if err = png.Encode(f, m); err != nil {

func drawFern(m *image.RGBA, x float32, y float32, steps int) {
 if steps != 0 {
 x, y = transform(x, y)
 drawPoint(m, x, y)
 drawFern(m, x, y, steps - 1)

func drawPoint(m *image.RGBA, x float32, y float32) {
 b := m.Bounds()
 height := float32(b.Max.Y)
 width := float32(b.Max.X )
 scale := float32(height / 11)
 y = (height - 25) - (scale * y)
 x = (width / 2) + (scale * x)
 m.Set(int(x), int(y), color.RGBA{0, 255, 0, 255})

func transform(x float32, y float32) (float32, float32) {
 rnd := rand.Intn(101)
 switch {
 case rnd == 1: x, y = transformPoint(x,y, 0.0, 0.0, 0.0, 0.16, 0.0)
 case rnd <= 7: x, y = transformPoint(x,y, 0.2, -0.26, 0.23, 0.22, 0.0)
 case rnd <= 14: x, y = transformPoint(x,y, -0.15, 0.28, 0.26, 0.24, 0.44)
 case rnd <= 100: x, y = transformPoint(x,y, 0.85, 0.04, -0.04, 0.85, 1.6)
 return x, y

func transformPoint(x, y, a, b, c ,d , s float32) (float32, float32) {
 return ((a * x) + (b * y)), ((c * x) + (d * y) + s)

Moving targets

I’ve been working on SCTP (Stream Control Transmission Protocol) for a while now. Much error and learning involved. One of the things I discovered (or better said; learned the hard way) is that some functions needed by SCTP are deprecated in the last 12 months. My knowledge was based on the excellent Unix Networking Programming book (also known as UNP). And sctp.h in FreeBSD 8.2. However in December 2011 RFC 6458 got published. This document describes the mapping of SCTP into a sockets API.

The functions I used most: sctp_sendmsg() and sctp_recvmsg() are now replaced by sctp_sendv() and sctp_recvv(). (As of FreeBSD 8.3/9.0) But more interestingly the default way to send and receive messages can now be done with recvmsg() and sendmsg(). These two functions, according to UNP (14.5 p390), are the most general of all the I/O functions.

A quick look reveals these methods are in existence for a very long time.

So I’ve started reading RFC 6458, upgraded to FreeBSD 9 and am getting familiar with the sendmsg() and recvmsg() functions.


Debugging Go applications on FreeBSD

Go uses a standardised debugging standard called DWARF. Yes, the pun is intended because DWARF was developed alongside ELF (Executable and Linking Format)

The be able to debug you need a debugger wich understands this standard.  The version Go build emits is DWARF3, GDB version 7.x supports this version. The standard debugger (used to compile the system) is version 6 9DWARF2 only), so you need to install a newer one. (/usr/ports/devel/gdb is version 7.x).

Instead of the usual `go run MyBuggyProgram.go`, you need to first build the program:
go build MyBuggyProgram.go

and start it with the debugger:
/usr/local/bin/gdb74 EchoSCTPServer -d $GOROOT

The environment variable GOROOT is optional but is useful if you want to debug the Go code itself, it has to point to a directory where Go is build from source.

Once within the debugger the usual commands are valid:

  • Ctrl+l: clear screen.
  • run: run programme
  • break: set break point
  • next: execute current line and move on the next
  • print (variable): print the value of (variable)
  • step: step into a function while executing

An example debug session:

(gdb) b 33
Note: breakpoint 1 also set at pc 0x400c8b.
Breakpoint 2 at 0x400c8b: file /home/olivier/projects/msc-report-src/echo-go-sctp/server/EchoSCTPServer.go, line 33.
(gdb) run
(gdb) s
net.ListenPacket (net="sctp", addr="localhost:4242", noname=void) at /home/olivier/projects/go-sctp/src/pkg/net/dial.go:213
213 func ListenPacket(net, addr string) (PacketConn, error) {
(gdb) s
214 afnet, a, err := resolveNetAddr("listen", net, addr)
(gdb) n
215 if err != nil {
(gdb) p err
$1 = 0
(gdb) p a
$2 = {IP = {array = "\177", len = 4, cap = 4}, Port = 4242}

More info can be found on the Go blog

Happy debugging 🙂