Phillip Trelford's Array

POKE 36879,255

Metadata: data about data

Compilers for statically typed languages like C# and F# maintain data about types from programs. This type data is used at design time to provide IntelliSense and during compilation to generate new types and bind to existing types. We can think about this type data in the abstract as data about data, or Metadata. In statically typed languages the typed Metadata is typically imported and generated from typed programs.


Question:

What if a compiler could be augmented with metadata from other sources, say a database or an XML DTD or a DSL?

Answer:

Then we could map to data easily inside our programs without resorting to either late binding or a code generation step!!!


Examples of accessing attributes of an XML element

1: Late-binding with string literals (F#)

let person = XElement.Parse("<Person Name=\"Bob\"/>")
let name = person.Attribute(XName.Get "Name").Value

 

2: Late-binding with dynamic lookup (F#)

// Define dynamic lookup operator
let (?) (el:XElement) (name:string) = el.Attribute(XName.Get name).Value
// Lookup Name attribute
let name = person?Name

 

3: Code generation using XSD.exe (C#)

string xml = "<Person Name=\"Bob\"/>";
var s = new XmlSerializer(typeof(Person));
var person = s.Deserialize(new StringReader(xml)) as Person;
var name = person.Name;

 

4: Hypothetical code binding (F#)

let person = XmlProvider.LoadXml("<Person Name=\"Bob\"/>")
let name = person.Name

 

The first 1st and 2nd methods using late-binding in effect use string-literals so lack type safety. The 3rd method required a code generation step that generated a whopping 62 lines of C# code to map 1 XML element with a single attribute.

The 4th (hypothetical) method provides all the immediacy benefits of a dynamic language like Python with the compile time safety and ease of use of a statically typed language.

PDC 2010: The Future of F#: Data & Services at Your Finger Tips – Don Syme:

Programming today exhibits a voracious appetite for information, and one of the most important trends in languages today is to make access to data and services fluent and seamless. Come and see the latest from the F# team, and learn how we are extending F# to embed the analytical programmer instantly in a world of typed data and services, whether they be web, enterprise, client or local.

From the slides that are now up on the PDC site, it looks like F# 3.0 is about to deliver!

Game of Life

Last week I had the pleasure of attending Software Craftsmanship 2010 at the magnificent Bletchley Park mansion on a gloriously sunny autumn’s day.

BletchleyPark

One of the great sessions I attended was Michael Hunger’s:

Using the Game Of Life to code, discuss language, paradigms and approaches

Michael used a video of Jon Conway himself to explain the rules; which he followed up by showing a very interesting implementation using APL. Afterwards we all paired up to try implementations in various languages. After about half an hour my pair came up with the following F# implementation.

Initialise a board as a 2D Array:

let width, height = 12,12
let board = Array2D.init width height (fun x y -> 0)

Computing the next generation of life requires finding the neighbours of a specified cell:

let computeNeighbours x y (board:int[,]) =
    let getValue (x,y) =
        let x = (x + width) % width
        let y = (y + height) % height
        board.[x,y]
    [
        -1,-1;0,-1;1,-1;
        -1,0;      1,0;
        -1,1 ;0,1;1,1;  
    ]
    |> Seq.map (fun (dx,dy) -> x+dx,y+dy)
    |> Seq.map getValue
    |> Seq.sum

To compute the next generation the current board is mapped to a new one, computing life  by matching the result of the compute neighbours function to the rules of life:

let doGeneration board =
    board 
    |> Array2D.mapi (fun x y n ->
        match n, computeNeighbours x y board with
        | _, 3 -> 1
        | n, 2 -> n
        | _, _ -> 0
    )

The board is shown to both the console and Visual Studio output window:

let show (board:int[,]) =
    for y = 0 to height-1 do    
        for x = 0 to width-1 do
            let v = if board.[x,y] = 0 then '0' else '1'
            Console.Write v
            Debug.Write v
        Console.WriteLine ()
        Debug.WriteLine ""
    Console.WriteLine(String('-',width))
    Debug.WriteLine(String('-',width))

Finally the board is set up and a number of generations are run:

do  [7,7;8,7;9,7;9,6;8,5]        
    |> List.iter (fun (x,y) -> board.[x,y] <- 1)
do  let mutable current = board
    for i = 1 to 10 do
        show current
        current <- doGeneration current
    done  

A visually prettier implementations was achieved using JavaScript and HTML during the exercise. So just for fun I tried running the F# code inside WebSharper (which converts F# code directly to JavaScript). A few minor changes required:

  • The 2D Array for the board was replaced with a Jagged Array
  • The output was converted to HTML
  • The loop changed to an Asynchronous Workflow

You can see the WebSharper version running here: http://trelford.com/life

Coincidentally Adam Granicz of Intellifactory, who was very recently awarded an F# MVP, will be giving a talk about his WebSharper product this Tuesday October 12th; along with Can Erten on Backtracking, for the Functional Londoner’s Meetup Group at Skills Matter!

GameOfLife.fs (1.36 kb)

GameOfLifeWebSharper.fs (2.55 kb)

TickSpec: Production Ready

The TickSpec F# Behavioural Driven Development (BDD) project started on CodePlex just over a month ago, and is now in use in production for at least one commercial application. TickSpec executes plain text specifications written in the Gherkin business language against a .Net implementation using reflection and regular expressions (like Cucumber does for Ruby). All English language Gherkin keywords are supported including Background and Examples, along with Bullet Points which are TickSpec specific.

The project now includes support and samples for 3 popular .Net Unit Testing Frameworks:

Screen shot of the MbUnit’s Icarus GUI Test Runner:

TickSpecMbUnit

TickSpec gives the ability to step through plain text feature files in Visual Studio and see the current value of template placeholders of the executing Example:

WinningPositions

Debug support is achieved using Reflection.Emit which executes an IL code representation of the source files at runtime. This allows it to be used from any .Net language, and avoids the need to install a Visual Studio plug-in. Plain text specification files can easily be added to a project as an Embedded Resource.

See TickSpec in action in the following video (includes sound):

 

Yet despite all these features, the TickSpec distribution is still lightweight (<100K) comprising a single standalone assembly (TickSpec.dll). And inside there is support for both C# and F# step definitions using either instance or static methods. So that given the following specification:

Given a bullet list of:

  • 1
  • 2
  • 3

Then the following F# step definition will be passed an array of integer values:

let [<Given>] ``a bullet list of`` (xs:int[]) = ()

 

And also for C# given the regular expression is specified as an argument of the attribute:

[Given(@"a bullet list of")]
public void GivenABulletListOfNumbers(int[] xs)
{
}

 

Get started with the binary, source and examples at: http://tickspec.com and for more information on BDD check out the following free fun e-book: http://www.cuke4ninja.com/