Phillip Trelford's Array

POKE 36879,255

Random Art

Earlier in the year I came across a Stanford coding assignment inspired by Andrej Bauer’s Random Art. Pictures are built using randomly chosen mathematical expressions that take an x and y value and return a colour. The implementation on Andrej’s site uses OCaml, but is closed source, however a clear Python example is given.

F# version

The Python version worked out-of-the-box but took a while to render (10s of seconds) so I rewrote it in F# (a language based on OCaml) to improve generation time (to less than a second).

The random pictures are unsurprisingly a bit hit and miss so I set up a script to generate batches of 1000 and then sifted through to find ones I liked, here’s a few examples:

Random0093 tartan
Random0937 Random - Copy (9)


The image generation is a heavy compute task, running on my i7 Desktop was noticeably faster than my MBP. For yet faster generation the F# code was trivial to parallelise using the Array.Parallel module.

You can run the F# version on Linux, Mac or Windows, just run this snippet as an F# script:


Go version

I’ve been picking up the Go programming language recently, just out of curiosity, and thought this would be an interesting task to try.

Initially I’d used Notepad and the command line on Windows, for this task I switched to Mac and the Atom editor with go-plus, which gives syntax colouring and some code completion and appears to be a relatively popular choice nowadays:

Go Editors

Aside: for editing F# in Atom try the excellent atom-fsharp

Rather than building a UI, I simply used Go’s image package which supports setting pixels and saving images.

Here’s a skeleton using a fixed function:

To produce random art I used an interface to define expressions with each type defined using a structure and associated evaluation function. The expressions are then randomly selected and then composed. The source is available as a gist.

Here's some pictures from the first run:

output472 output518
output164 output670


Comparing implementations

The F# and Go implementations feel quite close. In F# I used a discriminated union to define the expression types and functions for evaluation. Similarly in Go I used structures to define the expression data and functions for evaluation. In both cases separating the concerns of data representation and evaluation. In effect, if we ignore the curly braces, programming in Go feels to me more akin to programming in F# than programming C# or Java. Other similarities include multiple return values in Go and first class tuples in F#, and Go’s defer and F#’s use keyword for simple resource management.


Hands On Random Art Class

If you’re interested in producing your own random art, I’ll be running a free class at the F#unctional Londoners in October, where we’ll explore some different formulas.

Getting Go

Go is a programming language developed at Google, loosely based on C, adding garbage collection and built-in concurrency primitives (goroutines).

I’ve looked at Go briefly in the past, at a Strangeloop workshop in 2012 and later reading An Introduction to Programming in Go, but until now not really done anything with it.

Go Cover

Recently I’ve been hearing some positive things about Go, so I thought I’d give it a go this evening on a simple task: downloading and unzipping a Nuget package.

Some language highlights:

  • Extensive libraries of functions with good documentation
  • Named and anonymous functions
  • Multiple return values from functions
  • No semi-colons required
  • No class inheritance hierarchies
  • Easy cleanup with the defer statement

Go is easy to install (an msi in Windows) and I found Notepad and the command line compiler sufficient to complete the tasks.

Task 1: List Nuget package versions

Nuget has a web API that returns the available versions of a specified package as a JSON array.

This task was pretty easy using Go’s http and json libraries:

Task 2: Download a Nuget package (zip) file

Again the http package made light work of this task:

Task 3: Download and Unzip a Nuget package

Yet again I simply needed to import a package this time the zip package:


For the Nuget download task, Go was easy to pick up and quite pleasant; syntax-wise it felt a little lighter than C#, but in the bigger scheme of things was still a way off the lightness that comes with F# and OCaml's type inference. That said, if I had to choose between C# and Go, then I'd be tempted to give Go another go.

Introducing FunSharp

FunSharp is a new cross-platform open source graphics library, based on Small Basic’s library, with a typed API crafted for the sharp languages, F# and C#.

Drawing graphics is quick and easy:


And when you ask FunSharp to draw graphics it will just go and open a window to view it for you:


FunSharp provides similar functionality to Python’s PyGame, used for developing games, and Processing used for visual art.

You can call FunSharp immediately from the F# REPL or build full-blown applications using F# and C#.

It’s an ideal library for beginners or anyone who just wants  to get stuff on the screen quickly.

With this in mind FunSharp works seamlessly on Raspberry Pi, Linux and Windows.

Getting Started

If you haven’t already, you’ll need to install F# on your machine, follow these instructions:

  • Linux (for Raspbian follow the Debian instructions)
  • Windows (install Xamarin Studio or Visual Studio)

Get the FunSharp source from GitHub using Clone or Download Zip, then load the FunSharp solution into MonoDevelop or Visual Studio and starting playing with the samples.


  • FunSharp is built on Mono’s cross platform graphics libraries Xwt and Gtk# libraries which must be referenced.
  • currently apps must run in 32-bit mode.


FunSharp has a Turtle module, which can be used to make fun shapes:

Turtle.X <- 150.
Turtle.Y <- 150.
for i in 0..5..200 do




FunSharp can be used to make games quickly and easily. I’ve ported several games written for Small Basic requiring only minor modifications:


Have fun!