Planet F#

Circle packing in AutoCAD: creating an Apollonian gasket using F# Part 1

Kean Walmsley — Fri, 10 Feb 2012 06:44:51 +0000

Why do we need partial application? – Part 2 of n – Simulating type classes in C# and F#

Tue, 31 Jan 2012 16:48:58 +0000

This is yet another blog post in my Currying and Partial application series. This is what I have posted so far:

In this post I want to show you a way to simulate type classes in C# and F#. Type classes are this wonderful feature in Haskell which allow you to specify constraints on your polymorphic types. We don’t have this in C# nor F#.

Let’s start with the following problem: We want to compute the sum of the squares of arbitrary numbers. We want to write something like this:

The problem is we don’t have a generic * function and of course we’d also need a generic + operator and maybe a generic zero. Obviously we need a constraint on the generic parameter T since + might not be defined for any type. So let’s define an interface for numbers:

Nothing special here, so let’s get straight to the implementation for integers and doubles:

So far so good. With this in our pocket we rewrite SumOfSquares() into this:

The trick is that we pass the concrete implementation as the first parameter into our function. This works exactly like a type constraint or as Simon Peyton-Jones would say: the vtable travels into the function. Notice that we don’t have access to the definition of in nor double. There is no way for us to express that int or double implement a number interface.

Now let’s try this out:

As you can see, this is perfectly type safe. We now have a way for poor man’s type classes in C#. Yay!

Now what has this to do with partial application? Let’s look at the same thing in F#:

We’re using a lot of partial application here. Exercise: Try to spot all the places.

Ok, you’re right. This post might be a little bit far away from the partial application stuff, but it’s still related. Somehow.

F#/C# Contract Position for Silverlight/HTML 5 User Interface Development at Microsoft Research, Cambridge, UK

Mon, 30 Jan 2012 17:32:00 +0000

Microsoft Research Cambridge has available a 6-month contract position for development of web-based user interfaces for designing and simulating computer models of biological systems. We are looking for an experienced and highly-motivated individual to produce easy-to-use interfaces for the software tools developed by our Computational Science Lab. The aim of the post is to produce user interfaces to simplify and encourage the trial and adoption of our research prototypes within the wider research community, and the initial focus of the work will be on software for Biological Computation (http://research.microsoft.com/biology).

The user interfaces will be for a family of modelling languages, which are being used in a number of key scientific projects, from building computational circuits in DNA (http://research.microsoft.com/dna), to genetic engineering of living cells (http://research.microsoft.com/gec), to understanding and predicting the response of the human immune system (http://research.microsoft.com/spim). The candidate will be working in an exciting new field at the intersection of computer science and biology, and the results of the project could potentially have an impact on a broad community of researchers, both in academia and industry.

The first phase of the project will involve investigating the feasibility of translating existing computational modelling software from Silverlight to HTML5, with the help of existing translation tools such as Websharper (http://www.websharper.com) and Sharpkit (http://sharpkit.net).

The second phase of the project will involve investigating the feasibility of translating a Silverlight visual editor to HTML5. The visual editor relies on a C# library for graph layout, developed within Microsoft Research (http://research.microsoft.com/msagl). There is also an opportunity to extend the C# library to improve its visual editing capabilities.

This is an exciting opportunity to work at the intersection of cutting-edge software development, visual programming language design, and research into computational modelling of complex natural systems The candidate must be willing to work in Cambridge, UK, and the contract is for 6 months with the possibility of extending this to 2 years. Interested candidates should contact Andrew Phillips (firstname.lastname@microsoft.com) with a CV. The start date is flexible, however the position is available from February 2012.

Duration: 6 months

Location: Cambridge, UK

Required skills:

HTML5, Silverlight, WPF, C# programming
User interface development
Ability to capture user requirements and translate these into easy-to-use tools

Additional desired skills:

Knowledge of automatic graph layout algorithms
Experience in developing visual editors
Experience in F# programming

Currying and uncurrying in C# and F#

Mon, 30 Jan 2012 17:00:29 +0000

In the last couple of days I started to write some posts about Currying and Partial application:

This time I want to show you how we can write a higher-order function which allows us to curry another function. Remember the multiplication function from the first post and it’s curried form:

Currying

The question is: how can we automate this transformation process? Remember we want to have the curryied form for partial application:

Let’s look at the signature of the desired Curry-function: in our case it has to take Func<int, int, int> and returns Func<int, Func<int, int>>.

If we generalize the ints to generic parameters and fix the signature then the implementation is trivial (Compiler Driven Programming). There is exactly one way to make this work:

The F# implementation does exactly the same, but without all the annoying the type hints:

Uncurrying

Of course you can undo the currying by applying a generic Uncurry-function:

And in F# this looks like this:

Libraries

Currying and Uncurrying are two very important concepts in functional programming so they are included in a couple of libraries:

You can find it at the top of the Prelude in FSharpx (read more).
You can find it in the Haskell Prelude.
You can find similar functions in Scalaz.
Adrian Lang wrote a library called partial-js which allows to do something similar in JavaScript.

Why do we need partial application? – Part 1 of n – Fluent interfaces and piping

Sun, 29 Jan 2012 10:34:35 +0000

My last blog post was yet another introduction to Currying and Partial application. Now I want to put the focus more on the why part. Why do we want to have our functions in curryied form most of the time? This is the first part of a small blog post series and shows partial application in F# pipelines.

Using “Fluent interfaces” is a popular technique to write code in a more readable form. In languages like C# they also provide a way to create the code much faster. On every . we get IntelliSense and this gives us a “fluid” way of writing.

Let’s consider the following task: we want to compute the sum of the square roots of all odd numbers between 1 and 100. In C# we can use the LINQ method chaining approach in order to do something like this:

Now how does this look in F#? It’s basically the same. We replace every . with the |> operator and use the analogous Seq.* functions:

Oups! What happened here? The F# compiler noticed a type error. Math.Sqrt needs a float as input but we gave it an int. C# uses implicit casts between int and float so we didn’t noticed the problem there. Implicit casts are a little bit problematic, at least if you want to have proper type inference so F# doesn’t have this feature. No problem, we are programmers so let’s add the conversion manually:

Notice that float is a function from int to float and not a cast.

Now you might ask: how does this all relate to partial application? The answer is simple: In every pipeline step we use a higher-order function (Seq.*) and apply the first parameter with a lambda. The second parameter is given via the |> operator from the line above.

By applying our rule of thumb from the last post were are able to remove the x parameters:

Now let’s step back to C#. Keeping this knowledge in mind we try to apply the same rule in order to get rid of the x parameters:

Oups again! Now we see same error in C#. In this case it doesn’t know how to apply the implicit cast. As I said they are “problematic”, but we know how to fix this:

Partial application in F# and C#

Fri, 27 Jan 2012 18:55:18 +0000

Today I had a conversation on twitter about partial application and type inference in F#. Partial application is a very important and useful concept and there are a lot of resources out there. Here is a short list of related material:

Uncovering the Unknown: Principles of Type Inference (video)
Wikipedia: Currying, Partial application, Type inference
StackOverflow: What is the difference between currying and partial application
HaskellWiki: Partial application
F# BootCamp Q&A on this blog

I promised to show a small sample and I hope this clarifies some of my points on twitter. Let’s consider a multiplication function in C#:

This function allows us to compute the product of two ints. But what can I do when I need a function which doubles its input? The solutions is easy: I just create a new function:

And when I need a function which triples its input? Same thing, just create another method. But can we do better?

Let’s transform the multiplication function into the curryied version. The transformation process is very easy once you see the pattern. It’s actually possible to write a function which curryies another function, but that’s something for another post. Anyway, here’s the curryied version:

It’s a little bit noisy with all the funky Funcs, but Ok. We can still write the double function in terms of multiply:

And of course we can use multiply directly (which might look a bit weird at first):

But we can also use it in another way, which we couldn’t really do before:

How cool is this? We just applied a single parameter and we got a new function without writing any method declarations. Unfortunately we wrote a lot of weird type declarations in order to get here, but hey.

Let’s move to a language which has type inference. Here’s the uncurryied version of multiply in F#:

The type signature tells us, that we have to give it a tuple of ints and then we get an int back. That’s exactly the same as in C#. Notice that we think about x1,x2 as only one parameter – a tuple. How can we get to the curryied form? It couldn’t be easier: just remove the parentheses and you’re done:

As you can see the type signature changes a little bit. The * is now just another arrow. This means we have basically the same as Func<int, Func<int, int>> but in a much nicer syntax. There is also another way to write this:

This looks like the C# version, but notice how nicely the arrows align to the type signature. If we want to use the multiply function than we can write something like this:

It’s also very easy to create partially applied functions:

And finally the point which made me write this post. There is a simple rule: whenever we have the same parameter as the last parameter of the left and the right side of a function definition, we can remove it. This leads us to:

Isn’t this beautiful?

Undertone – Programmable music in F#

Fri, 27 Jan 2012 11:35:17 +0000

Recently I sent a bit of time playing with Overtone. I’ve always been interested in music, but have little talent when it comes to playing instruments, so I really like the idea of a DSL for creating music. I was also inspired by one of my Christmas presents The Wave Watchers Companion to explore relationship between waves and sound. A secondary aim of playing with overtone was to learn a bit more about Clojure which is definitely one of the most interesting languages about at the moment. I tried to resist the urge to port it F#, just enjoy learning about Clojure, but many of the ideas that make Overtone fun would work well in F#, so I couldn’t resist giving it a go. Especially when I released that if I combined it with the technology behind tryfsharp.org which would mean people could just browse to a web page and start creating music immediately. To try Undertone click this link or the below screen shot:

To say Undertone is a port of Overtone is probably a little unfair. Undertone takes a few ideas from Overtone and reimplements them in F#. Perhaps the biggest difference is that Overtone is uses the SuperCollider synthesis engine to generate sounds, where as Undertone has it’s own generation engine based on some work by Charles Petzold on creating a sequencer in Silverlight. In Undertone a note or a tune is just a seq<float> (that’s IEnumerable<Double> for the C# folks) that oscillates between –1.0 and 1.0. Undertone provides 3 things, functions to help you generate individual notes – these are in the Undertone.Waves.Creation module, functions to transform notes – these are in the Undertone.Waves.Transformation module, and Player to play a sequences of notes – the Undertone.Player class.

So the creation of a note in Undertone would look something like this:

let myNote note octave =
    Creation.makeNote Creation.sawtooth 0.2 note octave
    // apply transformations to you're note to adjust the way it sounds
    |> Transformation.flatten 0.8
    |> Transformation.tapper 1.0 0.3

This note can then be visualized using F# Chart and looks like this:

One you have a note you’re happy with it’s then easy to sequence them using F#’s list comprehension syntax:

let tune =
    seq { yield! myNote Note.C 5
          yield! myNote Note.G 4
          yield! myNote Note.E 4
          yield! myNote Note.C 4
          yield! myNote Note.G 3
          yield! myNote Note.E 3
          yield! myNote Note.C 3
          yield! myNote Note.E 3
          yield! myNote Note.G 3
          yield! myNote Note.C 4
          yield! myNote Note.E 4
          yield! myNote Note.G 4
          yield! myNote Note.E 4 }

// play the tune
let player = Player.Play(tune, Repeat = true)

Although you can already make some interesting sounds with Undertone the project is in it’s infancy and there’s quite a few bits missing, notably:

- As there’s no direct way to port the sound generation technique used from Silverlight to .NET so there’s no way to play your tunes in the desktop version of F# interactive. This shouldn’t be that difficult to overcome, its just means writing a new .NET sound generation engine.

- There’s no way to visualize notes in Silverlight, so it would be nice to add a visualization capability

- More wave generation and transformation functions would be good, perhaps including functionality to extract real waves from WAV files, or other formats.

If your interested in improving the project, or just looking at the source, it can be found on github.

The name of the project, Undertone, was inspired by Overtone itself with a nod to Northern Irish punk rock band The Undertones.

96 Line F# Emulator + 960 bytes of HP-35 Microcode

Fri, 27 Jan 2012 00:57:00 +0000

[Part 3 of the HP Calc series]

In this post, we’ll create a 96-line F# emulator for the HP-35 calculator with which we’ll run the 960 byte (!) ROM image.

As you may well know, I am a calculator freak. The 40-year-old HP-35 is an especially wonderful device; being the world’s first scientific pocket calculator. I own a couple of them and keep one handy on my desk, but it’ll be useful to have a faithful command-line rendition.

Tiny ROM

Here is a base-64 encoding of the ROM. It was three chips, each with 256 10-bit words, for a total of 7,680 bits; just under 1KB:

let rom = // HP-35 v2 ROM

"N2/4kBdRJEIREFRQsXzDajZ7u+ILiQ+r6vqGuaSoqg//q+r6gwMwqmoEN07MDAACDUQRC7k"+

"Qn6EwsLiQyjb/q+r6hLmfqO13d27OMTg0oDSzt3qjb0uvpFtqh9uo3zbTI3y67jUVPfj+dR"+

"X0ocQzlq767EfR1hOVtbLF7i57hMRIPGiZtbou6Y7K/6a6kUX961RJBBLUHOzuVSqzk6wrq"+

"gag8qlKYrwd3tYHCsR/DLuvb4viIwPNilsApH+LLgwP5qAu/r+n6foSqP67pmmp/romEq+6"+

"O+oDr7qNhmUtMHFqpLDGmcN6rEmJv0GuskO1UTd7OZ6JM/fqBFUzd6sbCgFMfCQHMs0OKIU"+

"zNDlkNBKOu/VxOVTlj0U5PmvvP6pMP7o0lyNqev3M4NGOwxuvfKpeufUzqkURPKgqesZu77"+

"fz8uKFqChaiVAn65VBLN6mUopWYSVaimaU2u7viSbplqpJuhntJ6h3s6jkoi5B4uQze0o65"+

"oi3K5jiKy9jhUJelG3VQVz+74N6S3463+zJ0suS7Ujvaizuyy5Eko/7/iPM4Knit1Ymo65D"+

"KRYybYMm0jIYoybY5m3MUOm0jstzGrqZlRsz+mEZDOWJ6hUpemcxq6lcxq6rpVq7rcxoycY"+

"5gydSMhhjJxQycZxy6TtMVj72MhhmFYJhGJYFTawwu74gQRBDqWi6h3+w6g+ORBEFKRB4tO"+

"qPzkOByUgsqct3ixay+WRYHAss8twc5bbwQXperq16fsbRCBsrP7LsORAzrMdiGFYNiWIYF"+

"hmDYVjDAwBDit7WJ/gsu/qrqGLm7Ok6KjKwyu0QpKkl+7N0sSjIjt+7vsmoB4B0O7JKKSX6"+

"PgQz7/pWRIS2opljoUQ+7tGAOzl+AN/kulnYhHzJPueAdzG1gydZMnH+aMnF9bMnHfZxuWc"+

"fZ65TgaMNTsuBxDhsMfrm+Oc5nqszFZUBtVJT9mnZT9nsQ2uWzJt32jJtfWTJt/mDJtm2bd"+

"Mi7rmYjslF7+qesLxZZ+WQ5alzs40uqb5s8uw46rOi4zlmJR20YeZ52YGx15Ok4lJTDBzDY"+

"NgGIYVgGJY6uWfiS5fobtLrkW67foju74sRJC0t+lfks+DAkLOi6g+OX6f+uRbrm3Mxyleq"+

"8vsmu7LMXGa2xUAMktmfqMumJCJGYlg2BYRh2BY5v5mT45YsTs4PNsxd6r+wwLpi1tDlqm7"+

"PzOSrjp+x/pmOC7DHrkw2BYBgWHYliGAYVhWDY3frkuYaul7fqznq8tnzOwwmDYBgmFYgdTH7"

The authoring of this microcode by David Cochran was an amazing piece work and Peter Monta’s reverse engineering of the ROMs by literally cutting them open and optically extracting the bits is a pretty insane feat! I’ve talked quite a bit about all of this in past posts so I won’t go into detail here.

Perfect Fidelity Emulation

In well under 100 lines, here’s the emulator:

open System

open System.Collections

let calculator input output rom =

let r = Array.init 8 (fun _ -> Array.create 14 0)

let s = Array.create 12 0

let p = ref 0

let pc, offset, ret = ref 0, ref 0, ref 0

let carry, carry' = ref false, ref false

let visible, disp = ref false, ref ""

let waiting, lastKey = ref 0, ref 0

let halt = ref false

let exec code =

let doCarry res = carry := (res > 9 || res < 0); (res + 10) % 10

let doOp fn x y = doCarry (fn (fn x y) (if !carry then 1 else 0))

let iteric c fn (first, last) = carry := c; for i in first..last do fn i

let iteri fn = iteric !carry fn

let setreg a b = iteri (fun i -> r.[a].[i] <- r.[b].[i])

let zeroreg reg = setreg reg 7

let shiftl a (f,l) = for i in (List.rev [f..l]) do r.[a].[i] <- if i = f then 0 else r.[a].[i-1]

let shiftr a (f,l) = for i in f..l do r.[a].[i] <- if i = l then 0 else r.[a].[i+1]

let arith op a b c = iteri (fun i -> r.[a].[i] <- (doOp op) r.[b].[i] r.[c].[i])

let add = arith (+)

let sub = arith (-)

let regsgte a b = iteri (fun i -> (doOp (-)) r.[a].[i] r.[b].[i] |> ignore)

let regsgte1 a = iteric true (fun i -> carry := !carry && r.[a].[i] = 0)

let negcdec dec = iteric dec (fun i -> r.[2].[i] <- (doOp (-)) 0 r.[2].[i])

let opreg op a = iteric true (fun i -> r.[a].[i] <- (doOp op) r.[a].[i] 0)

let ifregzero a = iteri (fun i -> carry := !carry || r.[a].[i] <> 0)

let exchreg a b = iteri (fun i -> let t = r.[a].[i] in r.[a].[i] <- r.[b].[i];r.[b].[i]<-t)

let opp fn = p := (fn !p 1) &&& 0xf

let iterir fn = for i in 0..13 do fn i

let move pairs = iterir (fun i -> List.iter (fun (a, b) -> r.[a].[i] <- r.[b].[i]) pairs)

let n = (code &&& 0b1111111100) >>> 2

pc := (!pc + 1) % 256

match code &&& 0b11 with

| 0b11 -> if not !carry' then pc := n
| 0b01 -> ret := !pc; pc := n

| 0b10 –>
[| ifregzero 1; regsgte 0 2; setreg 2 1; zeroreg 2; shiftl 0; sub 2 0 2; setreg 0 2; add 2 0 2

regsgte 0 1; shiftr 2; shiftr 1; shiftr 0; sub 0 0 1; sub 0 0 2; add 0 0 1; add 0 0 2; zeroreg 1

regsgte1 2; negcdec false; negcdec true; setreg 1 0; opreg (-) 2; ifregzero 2; opreg (+) 2

exchreg 1 2; regsgte1 0; add 2 2 2; zeroreg 0; exchreg 0 1; opreg (-) 0; exchreg 0 2; opreg (+) 0

|].[16 * (n / 8 &&& 1) + (n / 16)] [|!p,!p; 3,12; 0,2; 0,13; 0,!p; 3,13; 2,2; 13,13|].[n % 8]

| 0b00 -> let arg = n / 16

match n % 16 with

| 0 -> () // no-op

| 1 -> s.[arg] <- 1

| 3 -> p := arg

| 4 when arg = 3 -> pc := !lastKey

| 4 when arg % 2 = 0 -> let r = arg / 2 in offset := r * 256

| 5 -> carry := s.[arg] <> 0; if arg = 0 then waiting := !waiting + 1

| 6 -> (if !p < 14 then r.[2].[!p] <- arg); opp (-)

| 7 -> opp (-)

| 9 -> s.[arg] <- 0

| 10 –>
match arg with

| 0 -> visible := not !visible

| 2 -> exchreg 2 6 (0, 13)

| 4 -> move [5, 4; 4, 3; 3, 2]

| 6 -> move [0, 3; 3, 4; 4, 5]

| 8 -> visible := false

| 10 -> setreg 2 6 (0, 13)

| 12 -> iterir (fun i -> let t = r.[2].[i] in move [2,3; 3,4; 4,5]; r.[5].[i] <- t)

| 14 -> for i in 0..13 do for j in 0..7 do r.[j].[i] <- 0

| 11 -> carry := !p = arg

| 12 -> pc := !ret

| 13 -> for i in 0..11 do s.[i] <- 0

| 15 -> p := (!p + 1) &&& 0xf

let display () =

if not !visible then "" else

let render i a b =

(if b >= 8 then " "

elif i = 2 || i = 13 then (if a >= 8 then "-" else " ")

else string a) + (if b = 2 then "." else "")

Array.mapi2 render r.[0] r.[1] |> Array.rev |> Array.fold (+) ""

let code = let bits = let toBits b = [|for s in 0..7 -> 0x80uy >>> s &&& b |> min 1uy|]

rom |> Convert.FromBase64String |> Array.collect toBits

[for i in 0..767 -> List.sum [for b in 0..9 -> (int bits.[i * 10 + 9 - b]) <<< b]]

let rec step () =

let disp' = display ()

if disp' <> !disp then output disp'; disp := disp'

carry' := !carry; carry := false

exec code.[!offset + !pc]

if !waiting > 1 then

match input () with

| Some k ->

match List.tryFind (fst >> (=) k)

             ['0',36; '1',28; '2',27; '3',26; '4',20; '5',19; '6',18; '7',52; '8',51; '9',50; '.',35; '-',54
              '+',22; '*',30; '/',38; 'p',34; '~',59; '!',0; 'x',58; 'a',44; 's',43; 'c',42; 't',40; 'l',3
              'g',4; 'e',2; '^',6; 'q',46; 'f',14; 'w',12; 'r',11; '>',10; '<',8; ',',56; ' ',62] with

| Some (_, addr) -> lastKey := addr; s.[0] <- 1; waiting := 0

| None -> halt := k = '`'

| None -> ()

if not !halt then step () else disp'

step ()

Given a ROM image and a pair of I/O functions, this will emulate the HP-35 perfectly.

What’s amazing really is that the only “mathy” operations we emulate are addition, subtraction and digit shifting. From this, all of the logarithm, trigonometry, etc. are implemented in microcode. Jacques Laporte’s site goes into great detail on how it works. It’s quite an interesting onion to unpeel!

On the real device, key presses cause jumps to particular ROM addresses. In the emulation, input comes from a (unit -> char option) function. The character mappings are:

Digits 0-9 and decimal (.)	Number input
+ - * /	Basic Arithmetic (+ - × ÷)
~	CHS (change sign)
SPACE or RETURN	ENTER
x	EEX (enter exponent)
,	CLX (clear X register)
p	π
^	x^y (x to y power)
g	LOG (log₁₀)
l	LN (log_e)
e	e^x (e to x power)
!	CLR (clear)
q	√x (sqrt x)
a	ARC
s	SIN
c	COS
t	TAN
f	¹/_x (reciprocal – “flip”)
w	x↔y (swap)
r	R↓ (roll down)
>	STO (store)
<	RCL (recall)
`	Quit

The “UI”

The calculator function above takes a ROM image and the pair of I/O functions. Again, input is a (unit -> char option) called repeatedly and output is a (string -> unit) which is passed the display (driven by the A and B registers) formatted exactly as you’d see it on the real device.

We can cobble together a quick console UI like so:

calculator

(fun () ->
if Console.KeyAvailable then

let k = Console.ReadKey true

if k.Key = ConsoleKey.Enter then Some ' '

elif k.Key = ConsoleKey.Escape then Some '`'

else Some (Char.ToLower k.KeyChar)

else None)

(printf "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b%s")

rom |> ignore

Tests

Another reason for passing in the I/O dependencies is to allow simple testing:

let test keys expected =

let keySequence = ref (List.ofSeq keys)

let testInput () =

match !keySequence with

| h :: t -> keySequence := t; Some h

| [] -> Some '`'

let res = calculator testInput (fun _ -> ()) rom

assert (res = expected)

test "~1.2345678909x~35" "-1.234567890-35" // entry

test "2 3+" " 5. " // add

test "3 2-" " 1. " // subtract

test "3 2*" " 6. " // multiply

test "3 2/" " 1.5 " // divide

test "4f" " .25 " // reciprocal

test "25q" " 5. " // square root

test "pl" " 1.144729886 " // ln

test "pg" " .4971498728 " // log

test "pe" " 23.14069264 " // exp

test "ps" " .054803665 " // sin

test "pc" " .9984971498 " // cos

test "pt" " .0548861507 " // tan

test "pgas" " 29.81161556 " // sin-1

test "pgac" " 60.18838444 " // cos-1

test "pat" " 72.34321286 " // tan-1

test "1 2 3 4 Swrrr" " 2. " // stack

test "123>456 ,<" " 123. " // memory

test "9sctatacas" " 9.002983113 " // "Calculator Forensics" result

test "9 2^" " 512. " // power

I keep this little guy handy now in my console window. I dropped it, along with the F# tools from previous HP-35 posts, in my github as well. Have fun with it if you like!

F# vs. Scala, My Take at Year Two

noreply@blogger.com (TechNeilogy) — Thu, 26 Jan 2012 16:35:00 +0000

I spent a lot of time over the last couple of years learning F#. Over the last six months, I’ve spent most of my time learning and working in Scala. During part of both those times, I was working on the same set of code, ported to both languages. So, though this topic has been covered before, I thought I’d add my few observations from that experience to the great F# vs. Scala debate.

1) From the standpoint of most programmers, the choice of F# vs. Scala is probably determined by a single external factor: whether one is targeting the .NET ecosystem or the Java ecosystem. So the real-world debate is less likely to be F# vs. Scala than it is to be F# vs. C# or Scala vs. Java.

2) If you know F#, you already know all the really hard stuff you need to know about Scala, and vice versa. Now I’m not saying there’s 100% overlap between the two languages; each has features and quirks that the other lacks. But if you’ve reasonably mastered either, you’ve already gotten into the functional/mixed paradigm mindset. You’ve scaled the cliffs of type inference, case classes, pattern matching, first-class functions, currying, continuations, monads, etc. To move from F# to Scala or vice versa, you may have to learn moderately different ways to express those ideas, but you don’t have to make the climb all over.

Now the more technical stuff:

3) F# syntax is austere and a clean break with the curly brace world, whereas Scala retains much of the curly brace look and feel (while significantly cleaning it up). This was a deliberate decision on the part of the designers of Scala to ease the transition from Java. The result depends on your viewpoint: F# code is a more succinct if you’re used to reading it, but Scala is a little friendlier for newcomers.

4) Both languages are multi-paradigm, but F# favors functional programming whereas Scala favors object-oriented programming. This is not intended as a comment on the capabilities of the two languages, but rather on the “feel.” Both are clearly multi-paradigm, it’s just that on an FP to OOP scale of 0 – 9, F# feels more like a 4, and Scala feels more like a 6.

5) Scala programming rests on a foundation of traits, mixins, and the explicit management of types. Programmers making either the transition Java -> Scala, or C# -> F# -> Scala, will need to spend time mastering these concepts in order to take full advantage of Scala’s capabilities. (F# programmers from more academic backgrounds will already be more familiar with these things.)

6) F#’s higher-order libraries feel a little more pragmatic than do Scala’s. It’s not that you can do something in F# that you can’t do in Scala, it’s just that I’m often able to find a more precise higher-ordered function quicker in the F# documentation than in the Scala documentation. (To be fair to Scala, the libraries are evolving, and tend to get cleaner in each version.)

7) If you’re a .NET programmer without much open-source experience, getting started using Scala is likely to be both terrifying and exhilarating. What I mean is: if you do .NET programming, you have Visual Studio, and if you have Visual Studio, you have F#, and the F# you have just works – there, out-of-the box, batteries included. To do Scala, on the other hand, you’re going to have to put together a toolkit for yourself, sometimes pulling resources from various open-source concerns. But there are a couple of pieces of good news to temper this: first, Scala is much easier in this regard than much open-source software I’ve encountered; second, the inventors of Scala have started a concern called Typesafe to help centralize these resources (see sidebar links under Scala).

8) The community experience is excellent in both cases. Both the F# and the Scala communities are filled with excellent programmers who are passionate about the discipline. The users and committers of the two languages are their greatest assets.

I’ll end with two metaphors, the first about F# and Scala themselves, and the second about the two communities:

F# and Scala remind me of the cases of convergent evolution in the biological world. They have evolved in different ecosystems, but similar selection pressure has resulted in similar outcomes. And some of those pressures are among the most important in all of computing: correctness, concurrency, distributed computing, and maintainability.

And lastly, the F# and Scala communities are less like two rival groups of barbarians storming the same castle than they are like one group of barbarians temporarily divided so they can storm two different castles. (And storm them for their own good, lol.)

-Neil

Is Programming Less Exciting Today?

Wed, 25 Jan 2012 23:24:43 +0000

As discriminatory as this is going to sound, this one is for the old-timers. If you started programming after the turn of the milennium, I don’t know if you’re going to be able to follow the trend of this post—not out of any serious deficiency on your part, hardly that. But I think this is something only the old-timers are going to identify with. (And thus, do I alienate probably 80% of my readership, but so be it.)

Is it me, or is programming just less interesting today than it was two decades ago?

By all means, shake your smartphones and other mobile devices at me and say, “Dude, how can you say that?”, but in many ways programming for Android and iOS reminds me of programming for Windows and Mac OS two decades ago. HTML 5 and JavaScript remind me of ten years ago, the first time HTML and JavaScript came around. The discussions around programming languages remind me of the discussions around C++. The discussions around NoSQL remind me of the arguments both for and against relational databases. It all feels like we’ve been here before, with only the names having changed.

Don’t get me wrong—if any of you comment on the differences between HTML 5 now and HTML 3.2 then, or the degree of the various browser companies agreeing to the standard today against the “browser wars” of a decade ago, I’ll agree with you. This isn’t so much of a rational and logical discussion as it is an emotive and intuitive one. It just feels similar.

To be honest, I get this sense that across the entire industry right now, there’s a sort of malaise, a general sort of “Bah, nothing really all that new is going on anymore”. NoSQL is re-introducing storage ideas that had been around before but were discarded (perhaps injudiciously and too quickly) in favor of the relational model. Functional languages have obviously been in place since the 50’s (in Lisp). And so on.

More importantly, look at the Java community: what truly innovative ideas have emerged here in the last five years? Every new open-source project or commercial endeavor either seems to be a refinement of an idea before it (how many different times are we going to create a new Web framework, guys?) or an attempt to leverage an idea coming from somewhere else (be it from .NET or from Ruby or from JavaScript or….). With the upcoming .NET 4.5 release and Windows 8, Microsoft is holding out very little “new and exciting” bits for the community to invest emotionally in: we hear about “async” in C# 5 (something that F# has had already, thank you), and of course there is WinRT (another platform or virtual machine… sort of), and… well, honestly, didn’t we just do this a decade ago? Where is the WCFs, the WPFs, the Silverlights, the things that would get us fired up? Hell, even a new approach to data access might stir some excitement. Node.js feels like an attempt to reinvent the app server, but if you look back far enough you see that the app server itself was reinvented once (in the Java world) in Spring and other lightweight frameworks, and before that by people who actually thought to write their own web servers in straight Java. (And, for the record, the whole event-driven I/O thing is something that’s been done in both Java and .NET a long time before now.)

And as much as this is going to probably just throw fat on the fire, all the excitement around JavaScript as a language reminds me of the excitement about Ruby as a language. Does nobody remember that Sun did this once already, with Phobos? Or that Netscape did this with LiveScript? JavaScript on the server end is not new, folks. It’s just new to the people who’d never seen it before.

In years past, there has always seemed to be something deeper, something more exciting and more innovative that drives the industry in strange ways. Artificial Intelligence was one such thing: the search to try and bring computers to a state of human-like sentience drove a lot of interesting ideas and concepts forward, but over the last decade or two, AI seems to have lost almost all of its luster and momentum. User interfaces—specifically, GUIs—were another force for a while, until GUIs got to the point where they were so common and so deeply rooted in their chosen pasts (the single-button of the Mac, the menubar-per-window of Windows, etc) that they left themselves so little room for maneuver. At least this is one area where Microsoft is (maybe) putting the fatted sacred cow to the butcher’s knife, with their Metro UI moves in Windows 8… but only up to a point.

Maybe I’m just old and tired and should hang up my keyboard and go take up farming, then go retire to my front porch’s rocking chair and practice my Hey you kids! Getoffamylawn! or something. But before you dismiss me entirely, do me a favor and tell me: what gets you excited these days? If you’ve been programming for twenty years, what about the industry today gets your blood moving and your mind sharpened?

Enterprise consulting, mentoring or instruction. Java, C++, .NET or XML services. 1-day or multi-day workshops available. Contact me for details.

First F# Seattle Meetup This Saturday, Redmond

Wed, 25 Jan 2012 09:42:00 +0000

The first F# Seattle Meetup has been announced! It will be held this Saturday, on the Microsoft campus in Redmond.

http://www.meetup.com/FSharpSeattle/events/49365112/

Don

In this first meeting, we will introduce F# and the new features in F# 3.0 and how to use F# in the daily programming tasks.

F# Introduction and 3.0 New Features

Saturday, January 28, 2012, 2:30 PM

Microsoft building 32 - Room 1027

3620 163rd Avenue NE, Redmond, WA 98052

The Chinese remainder theorem

Tue, 24 Jan 2012 21:13:39 +0000

I hope to do a series covering some theory and implementation of the RSA algorithm in F# in the near future – and one of it’s main ingredients (for simplifying the hard calculations) is the Chinese remainder theorem – so … Continue reading →

London F# Meetup Group this Thursday: Pacman Kata

Tue, 24 Jan 2012 14:44:34 +0000

This Thursday, January 26, the F#unctional Londoners are holding an event to help you improve your F# coding skills! (This event may or may not be in celebration of Australia Day and India's Republic Day - you decide!)

This event will be a coding kata. If you don't know what this is, here's the description from Wikipedia:

Code Kata is a term coined by Dave Thomas, co-author of the book The Pragmatic Programmer, in a bow to the Japanese concept of kata in the martial arts. A code kata is an exercise in programming which helps a programmer hone their skills through practice and repetition.

Here's the story for the event:

Pacman finds himself in a grid filled with monsters. Will he be able to eat all the dots on the board before the monsters eat him?

pacman is on a grid filled with dots
pacman eats dots
pacman stops on walls
ghosts follow pacman...

The F#unctional Londonders Meetup Group starts 2012 with a hands-on coding Kata by implementing Pacman. This session is suitable for people new to F# who'd like to learn more and for more experienced F# developers looking to practice their skills. See also: http://codingdojo.org/cgi-bin/wiki.pl?KataPacMan for more info, and be sure to register your attendance here: http://skillsmatter.com/podcast/home/pacman-kata/js-2040

Don

Pong

phil — Sun, 22 Jan 2012 22:59:37 +0000

It’s a bit of a long story. A chain of events would unfurl that would lead me inextricably to writing a clone of a 70s video game. It started a few weeks ago while exploring early 90s dance tracks on Spotify, when I happened upon the seminal EP - Clonks Coming by the Sweet Exorcist. Later a lack of content on Spotify would push me towards YouTube and to find a hypnotic collage of Space Invaders, Beach Balls, Pong and the BBC test card girl.

Tapping along to the retro beeps on the train to London, a couple of white rectangles started moving up and down with the keyboard and a small white square began floating diagonally, and then the train reached King’s Cross. Much later a copy of RetroActivity would arrive in the post and I would return to the rectangles and make the white square bounce. Well, not before I had spent a few hours playing with Rebirth. The code is posted as an F# Snippet and fits happily in just under 100 lines. You can play in the browser if you have the Silverlight plug-in installed, just click inside to start the game.

Player 1 keys 'Q' - up, 'A' - down. Player 2 keys 'P' - up, 'L' – down.

Today I added a few beeps and a score, and put the project up on BitBucket. I started out trying the new SoundEffect classs in Silverlight 5 that promises low latency sound but unfortunately it seems a bit temperamental and I had to switch to using the old MediaElement class.

There’s a couple of reusable routines that are specific to gaming, the first is to know what keys are pressed at any instant in time:

type Keys (control:Control) =
    let mutable keysDown = Set.empty  
    do  control.KeyDown.Add (fun e -> keysDown <- keysDown.Add e.Key)
    do  control.KeyUp.Add (fun e -> keysDown <- keysDown.Remove e.Key)
    member keys.IsKeyDown key = keysDown.Contains key

The second is to synchronize the game updates with Silverlight’s rendering:

let run rate update =
    let rate = TimeSpan.FromSeconds(rate)
    let lastUpdate = ref DateTime.Now
    let residual = ref (TimeSpan())
    CompositionTarget.Rendering.Subscribe (fun _ -> 
        let now = DateTime.Now
        residual := !residual + (now - !lastUpdate)
        while !residual > rate do
            update(); residual := !residual - rate
        lastUpdate := now
    )

If you’re interested in playing and making simple games, or even just coding, why not pop down to Skills Matter in London this Thursday for a PacMan Kata.

F# 3.0 at TechDays France, Feb 7, Paris!

Sun, 22 Jan 2012 17:43:00 +0000

Just to mention that there will be a talk on F# 3.0 at TechDays France in Paris, on February 7, at 4pm.

F# 3.0: data, services, Web, cloud, at your fingertips (LAN209)

You can find all the details here: http://www.microsoft.com/france/mstechdays/programmes/parcours.aspx#SessionID=50dbf05c-e3fd-4129-b5d9-c2b458236728

Modern programming thrives on rich spaces of data, information and services. With F# 3.0 and Visual Studio 11, you now have a tool that massively simplifies information-rich analytical programming. F# 3.0 provides integrated support for F# Information Rich Programming, a new and powerful way of integrating data and services into your programming experience. In this talk, we will describe the new features of F# 3.0, including the first released version of F# Type Providers and F# Queries, with apps to leverage technologies such as SharePoint, Azure Data Market, OData, Entity Framework and SQL Server.