Phillip Trelford's Array

Back on April Fool’s day Anthony Green published a funny article “How ‘Roslyn# Finally Unshackled Visual Basic From The Tyranny of the Pretty-Lister”, showing VB.Net with lower case keywords, and how it made it look cooler. And more recently Mads Torgersen gave an “Early View of C# 7” demonstrating pattern matching, a feature that didn’t make it into C# 6, and syntax for tuples.

Taking some inspiration from this I thought I’d add some new extensions to my own language project, Fun Basic (try it free on the Windows Store). But Fun Basic already supports lower case keywords and tuples with pattern matching (which I implemented about 2 years ago), so instead over the last week I’ve added some different language features including cleaner aesthetics for BASIC and JSON literal support.

Hipster BASIC

People often complain about the verbosity of VB.Net, I see two parts to this:

• End statements – End If, End While, End Select, etc.
• Casing – Dim is the same length as var, but var just looks smaller

Fun Basic now lets you write `end` and it will infer the type of end for you:

 while i < 10
    i = i - 1
 end

With the lower case keywords & simple end statement you could easily mistake this syntax for Ruby code.

JSON literals

VB.Net has XML literal support, which was a cool feature at the time, but these days XML is more associated with big enterprise, and all the hipsters are using JSON. With that in mind I’ve added JSON literal support to Fun BASIC:

name = "Phil"
age = 27
phil = {"name":name, "age":age}

This allows you to build up strings to send to web based services.

The syntax is also quite close to record syntax in ML, OCaml, F#, TypeScript etc.

Pattern matching

JSON literals are cool, but most of the time you’re using it the other way around, and consuming JSON from an API. For this I’ve added pattern matching over JSON literals.

For example say we want to get the temperature and humidity in London, we can use the Open Weather API, which spits back:

{"coord":{"lon":-0.13,"lat":51.51},
 "weather":[{"id":500,"main":"Rain","description":"light rain","icon":"10d"}],
 "base":"cmc stations",
 "main":{"temp":282.515,"pressure":1026.96,"humidity":97,"temp_min":282.515,"temp_max":282.515,
         "sea_level":1037.24,"grnd_level":1026.96},
 "wind":{"speed":5.75,"deg":228.012},"rain":{"3h":0.6475},"clouds":{"all":92},"dt":1447504501,
         "sys":{"message":0.003,"country":"GB","sunrise":1447485423,"sunset":1447517536},
 "id":2643743,
 "name":"London",
 "cod":200}

With the new Fun Basic pattern matching syntax we can easily extract the values of temp and humidity:

london = "http://api.openweathermap.org/data/2.5/weather?q=London,uk&appid=2de143494c0b295cca9337e1e96b00e0"
weather = Web.Get(london)
{"main":{"temp":temp, "humidity":humidity}} = weather

We can also use the pattern matching in a select case statement:

function ageGroup(person)
  select case person
    case { "age": Is >= 18 }
       return "Adult"
    case else
       return "Child"
  end       
end

sean = {"name":"sean", "age":9}
TextWindow.WriteLine(ageGroup(sean))

Summary

Both features were easy to implement (JSON literals took me the morning), and feel quite natural in the setting of BASIC, you can try them out now in Fun Basic, who knows one day we might see them in mainstream enterprise languages

Next week I’ll be heading over to the US for some tourism with a little speaking along the way:

• Sat 17th Oct – F# Gotham event (NYC)
• Sunday night flight to Seattle
• Mon 19th Oct – F# Seattle User Group
• Tuesday morning train to Portland
• Tue 20th Oct – Portland F# Meetup 
• Thursday afternoon flight to San Fran
• Thu 22nd Oct  - San Francisco F# Meetup
• Friday afternoon flight to LA!

Hope to see some of you on the way, and a big thanks to Rachel Reese and Jet.com for inviting me across the pond! :)

P.S. To see what a big tour looks like check out supreme F# tourist Mathias Brandewinder’s European adventure last year…

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:

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: http://fssnip.net/si

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:

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:

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.