Robert Pickering's Strange Blog

Reasons to Come to Functional Programming eXchange 2012

Robert Pickering — Sun, 19 Feb 2012 18:12:46 GMT

For Functional Programming eXchange 2012 and I’ve tried to put together a programming that mixes the best the functional programming community has to give. I wanted both talks that show how functional programming languages can be used more effectively and that show off new up and coming language and new language features. I also wanted talks that gave feedback from project that were implemented using functional languages. I’m pleased to say we have plenty of both.

The day will kick off with David Pollak talking about Visi.Pro. One of the areas I’ve been thinking about a lot lately, outside of functional programming, is how tablets will affect the way we work. Clearly up take in the consumer market it is growing, and the new fashion of “Bring your own device” meet that tablets are making there way into the enterprise. But can people do useful work with these new devices? And if so how will they do it? David has come up an interesting answer, he’s betting that to make effective use of these new devices we need a new way to program them and has come up with the visi.io language and the visi.pro platform to help people create software and models using their iPads. If you care about trends in the tech industry, definitely one to watch.

Next we have 3 cases studies that show how Haskell, F# and Scala have been used to build complex real world application. First up Erik Hesselink will be talking about “SilkApp” a web application for help users to visual data in a more structured way, then Loic Denuziere will talk about creating the site fpish.net a large complex community site written in F# using WebShaper, finally Kevin Wright will talk about using AKKA to create a high-throughput and low latency RESTful/streaming event service at zeebox.

In the afternoon will see some more theoretical talks that’ll shows us how functional programming can be applied more effectively. First Andres Löh will talk about creating DSLs in Haskell, then Tomas Petricek will talk about F# 3.0’s new feature, Type Providers, Miles Sabin will talk about advanced uses of Scala and Bruce Durling will round of the day with an overview of Clojure and Incanter, clojure’s powerful data visualization library.

And if that wasn’t enough there’ll be chance to meet and socialize with our speakers and other FPX delegates all day along and quite possibly all evening long in the pub afterwards.

UPDATE: Just occurred to me I didn’t put a link into the full agenda, so here it is.

Undertone – Programmable music in F#

Robert Pickering — Fri, 27 Jan 2012 11:35:17 GMT

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.

The Combinator Approach to Programming Domain Specific Languages with F#

Robert Pickering — Fri, 04 Nov 2011 14:54:12 GMT

Just a quick note to say that my talk “The Combinator Approach to Programming Domain Specific Languages with F#” is now available on Skills Matter site. I’ve put the code on github.

If you enjoyed the talk I’ll be giving it again at CodeKen, the conference formally know as Stackoverflow Dev Days, on 14th/15th November.

Combinators are a really nice, and under appreciated, way to create DSLs and we go into them in depth on my Beginning F# course at Skills Matter. Book now for the march edition.

Some thoughts about Google’s new Dart programming language

Robert Pickering — Thu, 13 Oct 2011 05:51:01 GMT

Ever since it was announced that Dart would be announced at GOTO conference I’ve been wonder what dart would be like. I thought I’d take the time put down my initial thoughts here.

Is there a need for another language?

Tim Anderson poses the question nicely here, so I thought I’d have a stab at answering it. There are a lot of programming languages in the world, so there would seem to be limited space for a new one. However, I think Google are creating this language for two reasons:

1) they want improve the web by replacing JavaScript with something more sensible.

2) they want to get themselves and others off Java.

Those are two fairly bold statements, so I’ll try and justifier them, taking each in turn.

The first one is fairly easy to justify from the point of view this is Google’s motive for creating the language as we have the leaked memo. But it’s probably worth talking about whether replacing JavaScript is a good thing. I’m not a huge JavaScript fan, I do think JavaScript has showed itself to flexible enough to be extended in interesting ways by library writers, but ultimate that is enough for a language that has some huge glaring floors. So, yes a JavaScript replacement is a good thing in my opinion. However, there’s also the question of how feasible this is. At the moment Dart relies on being crossed compiled to JavaScript, which isn’t a hugely original idea. It’s true that Dart also runs well on a server, and this is enough to let Google claim Developers have not been able to create homogeneous systems that encompass both client and server, except for a few cases such as Node.js and Google Web Toolkit (GWT). I think that statement is completely untrue. There are many systems, including, but not limited to, WebSharper (my personal favorite), ScriptSharp, HappStack (thanks to BlazeHtml), that let developer's create systems in a homogeneous way. All use a cross compiling another language to JavaScript, the same approach that Dart will take at least initially. The big benefit of Dart would be if Google get Dart adopted by all browser venders as a language that executes in the browser. As they already control one browser it’s fairly certain it’ll be making it’s way into that soon, but the real question is will other vendors follow suite. As Dart is open source, theoretically it wouldn’t pose too much of a problem for open source browser like Firefox to integrate it, although who knows how Mozilla will feel about Google trying to push them around. And I think one can safely assume it won’t be at the top of the IE teams todo list. So, although a JavaScript replacement is needed, in my opinion at least, its doubtful that Dart will offer anything better than what’s already available, at least not for a very long time filled with Google lobbying the other browser vendors. Also if Dart is to replace JavaScript it might have been nice to aim a little higher and replace it with something better (see my thoughts on this in the section: What is Dart like as a language?).

To try and justify the second statement: it’s fairly well document that Google uses a lot of Java internally. It’s also fairly well document that Google are having a big spat with Oracle, the new owners of Java. So it’s not a great leap of imagination to think that Google would be interested in moving away from Java. Problem is where would they go? Clearly C# is out, as Google detest Microsoft as least as much as they do Oracle. So while there is lots of other languages out there they could use, there’s nothing out there that really leaps as the Java replacement (at least if you don’t want to go with C#). So my guess is that Google hope to sweep up programmers who are unhappy with both Microsoft and Google as well as get themselves off Java.

What is Dart like as a language?

Well for me it’s a disappointment. I guess the biggest disappointment is that the basic unit of code is a statement, rather than expression, meaning it is an imperative rather than a functional language. This is a fundamental design choice that can be altered, the rest of the remarks I’m going to make probably could be fixed in one way or another but this can’t be. So why might it have been a good idea to make the language expression orientated rather then statement orientated? Well much of the progress in modern object orientated programming has been inspired by functional programming, here I’m think of Linq and jquery as the prime examples but there are probably others. While these frameworks work well, they are somewhat limited by being built on top of statement orientated languages. For example one of the criticisms of Linq I hear most often is that Linq queries often end up being monolithic blocks that are difficult to pull apart and once they get bigger than, say, five lines, they become very difficult to understand. I’d contrast this to F# pipeline expressions, basically the equivalent, but in an expression ordinated language, which are easy to understand and to pull apart and refactor.

Apart from being imperative, Dart also seems very conservative, lacking useful features. This is not that surprising for a first cut of the language, but all the same, there’s nothing that leaps our and says use me for your next project. The things that I’d like to see that are missing are (and admittedly I haven’t spend as much time as I’d like looking at the language as I’d like so I could be wrong on any of these points):

- Tuples and currying. These greatly improve compositionality in a language, although it is good to see there are functions as first class values

- No immutability. And unless I missed it way to declare a value as being read-only, let alone nice a nice easy way to create a modified copy of a value.

- No pattern matching. Just makes so many difficult problems easy, hard to see why you wouldn’t put it into a language.

One good choice I think they made is that all concurrency must use actor model type mechanism called isolates. However, I do have one small quibble with this. With no immutability in the language how will they archive this isolation? Surely the actor will leak references all over the place. I could be wrong, but I strongly suspect this has been fixed with lots of fairy dust.

Google have said they are hoping for “rapid evolution” of Dart so it will be interesting to see what features do get added.

What is Dart made of?

As Dart is open source I thought it might be nice to peak under the covers and take a look at what dart is made up of. Once past the fairly broke process of installing depot_tools, so I could check out all the sources, it was fairly easy to do this using, yes you guessed it, an F# script. But before we dig into the numbers it’s probably best take a look at the top level of the source tree (only give a comment where it doesn’t seem obvious what the directory is for):

- client – a set of development tools for Dart
- compiler
- corelib – the core library for Dart
- editor – (presumably, as there’s no read me) an editor for Dart
- language – a parse based on antlrworks
- runtime
- samples
- tests
- third_party
- tools – not sure what this is about, seems to have some build stuff and syntax highlighting for vim

The file type counts are:

Extension	Count	Percent
.dart	3053	16.989427
.py	2993	16.655537
.java	2791	15.531441
.js	1059	5.893155
.html	1007	5.603784
.pm	895	4.980523
.gif	585	3.255426
.h	564	3.138564
.pl	543	3.021703
	472	2.626600
.cc	469	2.609905
.txt	359	1.997774

If we exclude the third_part directory:

Extension	Count	Percent
.dart	3053	46.145707
.java	1756	26.541717
.gif	483	7.300484
.cc	193	2.917170
.png	143	2.161427
.h	110	1.662636
.tlog	99	1.496372
.properties	79	1.194075
.py	78	1.178960
.obj	43	0.649940
.xml	41	0.619710

So we can see Dart is overwhelmingly written in Dart. Notable exceptions to this are the runtime directory which seems to be all C or C++ and compiler and editor which are java. The compiler readme file does contain a vague hint that it’s just a '”placeholder”, so presumably it’ll be bootstrapped at some point. It’s also worth noting that that third-party dir does seem to contain some stuff which isn’t actually used, for example I can see, closure_compiler_src but no evidence of Clusure being used.

Conclusion

Dart isn’t a language that leaps out at me and says use me for your next project, and that’s the key disappointment for me. However, politically, and by that I mean coming from Google and aiming to replace JavaScript, I think it’s in an interesting position, so for that reason I’ll be following the project.

First example of a very simple type provider

Robert Pickering — Sun, 18 Sep 2011 08:29:09 GMT

I have an idea for a type provider, so now that the type provider bits are finally publicly available I set to work building it. However it turns out just implementing a type provider is pretty tricky (not really that much of a surprise I supose), so I thought it was worth a quick blog post to run through the basics.

A type provider is a class that implements the interface ITypeProvider (fullname Microsoft.FSharp.Core.CompilerServices.ITypeProder), which lives in the assembly FSharp.Core.dll. Its definition is as follows:

public interface ITypeProvider : IDisposable
{
        event EventHandler Invalidate;
        IProvidedNamespace[] GetNamespaces();
        ParameterInfo[] GetStaticParameters(Type typeWithoutArguments);
        Type ApplyStaticArguments(Type typeWithoutArguments, string typeNameWithArguments, object[] staticArguments);
        Expression GetInvokerExpression(MethodBase syntheticMethodBase, ParameterExpression[] parameters);
}

(Sorry for the C#, it’s from a decompiled definition)

To implement this interface you must also implement the IProvidedNamespace interface:

public interface IProvidedNamespace
{
        string NamespaceName
        {
                get;
        }
        IProvidedNamespace[] GetNestedNamespaces();
        Type[] GetTypes();
        Type ResolveTypeName(string typeName);
}

Once implemented you need to add the TypeProviderAssembly attribute to your assembly, plus you need to mark your type provider with the atteibute TypeProvider. So a basic implementation would look something like:

[<assembly: TypeProviderAssembly>]
do()

type TypeProvidedNamespace(name, assembly) =
    do trace()
    interface IProvidedNamespace with
        member x.NamespaceName
            with get() =
                trace()
                name
        member x.GetNestedNamespaces() =
            trace()
            [||]
        member x.GetTypes() =
            trace()
            [|new ProvidedType("Atype", name, assembly, IsErased = true)|]

        member x.ResolveTypeName(typeName: string) =
            trace()
            null

[<TypeProvider>]
type TypeProviderRoot() =
    do trace()
    let theAssembly = typeof<TypeProviderRoot>.Assembly
    let invalidate = new Event<EventHandler,EventArgs>()
    interface ITypeProvider with
        [<CLIEvent>]
        member x.Invalidate = invalidate.Publish
        member x.GetNamespaces() =
            trace()
            [|new TypeProvidedNamespace("ExampleTypeProvider", theAssembly)|]
        member x.GetStaticParameters(typeWithoutArguments: Type) =
            trace()
            [||]
        member x.ApplyStaticArguments(typeWithoutArguments: Type, typeNameWithArguments: string, staticArguments: obj[]) =
            trace()
            null: Type
        member x.GetInvokerExpression(syntheticMethodBase: MethodBase, parameters: ParameterExpression[]) =
            trace()
            null: Expression
        member x.Dispose() =
            trace()
            ()

Not so tricky so far. When you reference and try to use you type provider the F# compiler creates a dynamic instance of the type provider and then calls GetNamespaces on the type provider and then on each returned namespace, each an implementation of IProvidedNamespace, it calls GetTypes(). This is the tricky bit, GetTypes returns an array of System.Types, so you need your own implemenation of System.Type. System.Type is an abstract type so there’s technically no difficultly in deriving from it, but it has a lot of abstract members, so there a lot of abstract members to implement. Worse still for some strange reason System.Type also has a couple of virtual methods that simply throw NotImplementedException as there implementation. One such method is GetCustomAttributesData, and this used by the F# compiler so it’s important that you implement it. It’s also important to take care when implementing GetAttributeFlagsImpl. This returns an TypeAttributes enum that tells the compiler various information about the type, such as whether it is public etc. Type provider adds an extra enumeration member IsErased, that tells the F# compiler whether the type provider generates types into the client assembly or whether the types generated are fully dynamic.

Anyway, once you’ve implmented System.Type you can simply return an instance from the GetTypes call and you’ve created your first provided type. Of course, for it to do anything interesting you need to also implement System.Reflection.MethodInfo, System.Reflection.PropertyInfo, and probably System.Reflection.ConstructorInfo, but I haven’t done this yet. So just about the only valid program you can write that uses the provided type is:

#r "bin\Debug\ExampleTypeProvider.dll";;

type t = ExampleTypeProvider.Atype

A word about testing

One annoying aspect of creating a type provider is you can’t really test it from within visual studio. As soon as VS opens a script or project with a reference to the type provider it takes a lock on the assembly containing the provider. This means the project containing the provider will no longer be able to compile as it won’t be able to overwrite the assembly in bin\debug. To get round this I created a simple script that used my type provider and executed it using fsi.

Well that about wraps it up for now. It looks like type providers will open up lots of fun options, but for the moment they take quite a bit of implementing. I’m thinking of taking my work so far and wrapping it up into a tool kit for implementing type providers, but we’ll have to see how that pans out. For now you can see the type provider on in my misc. F# example on github.

A few thoughts on build and Windows 8

Robert Pickering — Tue, 13 Sep 2011 20:09:12 GMT

I actually have the last two episodes of my RavenDB series ready to go, but doesn’t seem much point publishing them this week, so here’s a few thoughts on stuff from build and Windows 8 instead.

Firstly Windows 8: I thought the build keynotes did a nice job of selling Windows 8, although adjectives like super and amazing were used far too much for my tastes. I would like a Windows 8 tablet because it seems to do a nice job of bring it all together, yes it’s nothing you can’t get already from Apple (iPad, Mac Air, etc.) but you can’t yet get this in the same device form Apple. I don’t yet own a tablet, as I take my laptop nearly every where, so I don’t want to carry another device. I spend much of my time either emailing or code, I don’t think a tablet would change that much, but it would be nice to have a laptop that turned into a tablet for the times that I do want to read an article on the train or bus, or maybe watch a movie. I guess the question is, do most consumers fall into the same category as me? Do they need a device that can do laptop with keyboard and tablet or would simply a tablet do for there portable device? There’s also an interesting questing around will people start using the tablet style metro interface to do their jobs? I don’t pretend to know the answer to that but here’s why it’s an important question: (it seems to me that) most working programmers develop software for business to help people do there jobs better. Tablets are clearly consumer orientated at the moment, this has created something of a boom in consumer software for them. As a result of this boom more programmers have moved over to creating apps for both phones and tablets, but to me most software development jobs seems to be in developing apps for business. So will the trend for consumer apps continue or will we see this market mature and stagnate? Here I am prepared to say I think the we will see this market mature and then stagnate, leaving most programmers where they were before, building software for business. So if tablets want to remain an appealing platform for programmers then we’ll need to see business users adopting tablets for their work, so it will be interesting to see if this does happens.

As for build itself, I think clearly the doom sayers are wrong. Even this piece on ZDNet published today seems to me to be wrong. Yes “Metro” is clearly what Microsoft are pushing, but you can develop metro apps in .NET, it’s not just HTML5 and JS. I’ve looked though the program and yes there are many sessions on Metro and HTLM5, but there are also a lot of interesting looking sessions on .NET and other technical topics like Visual Studio, Azure and performance tuning (I haven’t counted but I would say at least as many if not more). Also, Metro in HTML5/JS troubles me a bit, if HTML5/JS is to be a good platform of development of Metro apps then surely it will need extensions to access all the Win8 specific stuff, and if it has extensions, then it’s not cross platform, so what’s the point?

Anyway, here’s the list of session’s I’ll be looking out for:

Optimal cloud performance with BranchCache

New techniques to develop low-latency network apps

Windows Server 8

Future directions for C# and Visual Basic

What's new in .NET Framework 4.5

Running Windows from an external USB drive with Windows To Go

Chalk talk for sensor and location support in Windows

Deep dive into the kernel of the .NET Framework

And saving the best for last:

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

Functional Programming eXchange 2012: Call for abstracts

Robert Pickering — Sun, 11 Sep 2011 16:18:18 GMT

We’ve decided to do it again. After the success of the Functional Programming eXchange 2011 and 2009, we have decided to put on another edition. Functional Programming eXchange 2012 will take place on Friday March 16^th March 2012, at the Skills Matter eXchange, in London.

The program is under construction, I’ve already started to invite speakers whose work in the functional programming community interests and excites me. I’m actively seeking other speakers so if you’d be interested in following in the footsteps of previous speakers such as: Simon Peyton Jones, Miles Sabin, David Pollak, Adam Granicz, Antonio Cisternino, Tomas Petricek, Jonas Boner, and Viktor Klang, then send an email with a talk abstract to talks_functionalpx@skillsmatter.com.

Talks should be about 45 minute long, though we may do some lightning 15 minute slots, depending on how the program comes together. Typically talks are explore concepts that often crop up in functional programming such as parallelism or domain specific languages, look at frameworks built in functional languages or are cases studies of using functional programming in industry.

I’m aiming to make the decision about which talks have been chosen around 14^th October so if you submit an abstract expect to hear from me around this time.

F#, RavenDB and PicoMvc – Creating an Autocomplete – The ETL

Robert Pickering — Thu, 08 Sep 2011 04:52:30 GMT

The first of this series covered our general aims how we’d be structuring the project. This post will cover how we get the data into RavenDB.

First we need to download the data. I got it obtained the data from this site, you need to click the “téléchanger la base” link under “Coordonnées géographiques des villes Françaises” here is the direct link. It’s not the best data source in the world, but it’s the best freely available one that I’ve found. Once you’ve unzipped the zip and converted it CSV the loading it into RavenDB is pretty straight forward.

First we need to design a type to hold the data:

type Commune =
    { mutable Id: string
      Name: string
      Postcode: string }

We’re only going to store the name of the commune its post code because that’s all we’re going to search on or show, so these are the two fields Name and Postcode. RavenDB is pretty robust when it comes to adding or deleting fields so it’s fine to start with a minimal set of data and add stuff later. The Id field is the unique identifier of the record it’s mutable because this just seems to work better with RavenDB. We could let RavenDB generate this for us but since INSEE, the French government’s bureau for statics and economic studies, assigns each village its own unique identifier and this is in the file, we’ll use this. In France several communes can share the same post code, so this would not be a good candidate for the identifier.

Once we’ve designed the type to store the commune data the code to load it from the file and store it in RavenDB is pretty straight forward:

let loadCommuneData() =
    use store = DocumentStore.OpenInitializedStore()
    let lines = File.ReadLines(Path.Combine(__SOURCE_DIRECTORY__, @"ville.csv"), System.Text.Encoding.Default)

    use session = store.OpenSession()
    session.Advanced.MaxNumberOfRequestsPerSession <- 30000
    lines
    |> Seq.skip 1
    |> Seq.iteri(fun i line ->
        let line = line.Split(';')
        match line with
        | [| name; nameCaps; postcode; inseeCode; region; latitude; longitude; eloignementf|] ->
            let id = sprintf "communes/%s" (inseeCode.Trim())
            printfn "Doing %i %s (%s)" i name id
            let place: Commune =
                { Id = id
                  Name = name.Trim()
                  Postcode = postcode.Trim() }
            session.Store(place)
            if i % 1000 = 0 then session.SaveChanges()
        | line -> printfn "Error in line: %A" line)
    session.SaveChanges()

There are just a few points worth highlighting:

- We use the new in .NET 4.0 File.ReadLines to give us an IEnumerable of all the lines in the file. This gives us a nice convenient way to read the file line by line without loading it all into memory.

- Notice we’re passing System.Text.Encoding.Default to File.ReadLines French communes often have accented characters in their names, so we need to ensure we’re using the right encoding.

- It’s necessary to set the session.Advanced.MaxNumberOfRequestsPerSession as this is limited to 10 by default, meaning that after 10 requests or stores the session would throw an exception. This is because in typical use of sessions, they are meant to be short lived, so this exception is meant as an early warning for developers. Since this is an atypical use of a session it’s okay to set this number. However, I think sessions cache the data that they store, so you may want to clear the session after each write to RavenDB. Doesn’t seem to make much difference in this case.

- We enumerate each row in the file using Seq.iteri this gives us the row plus the row number. We can use the row number to do a save every 1000 items (by calling .SaveChanges()), this seems to be more efficient than either saving after each row or trying to save the whole lot all at once. I haven’t done much experimentation with this number, there may be a more optimal number the 1000.

- The parsing of the file is very simple, we simply call .Split(';') on each row and then pattern match over the resulting the array to unpack the relevant items. These are then loaded into the Commune type and stored in RavenDB using the sessions Store() method. As mentioned earlier these aren’t flushed to the DB until you call .SaveChanges().

And that about wraps it up, the data is in the DB and you can verify this using RavenDB’s administrative console:

The full code base can be found in the github repository for PicoMvc.

See My Stack Overflow Dev Days Talk

Robert Pickering — Thu, 08 Sep 2011 04:43:56 GMT

So Stack Overflow Dev Days has been cancelled. Obviously it’s a big disappointment to everyone involved, I thought the line up for the London event was great and I was looking forward to attending the conference as much as I was looking forward to speaking at it.

If it’s any compensation you can see me do this talk at skill matter as one of their in the brain sessions:

The Combinator Approach to Programming Domain Specific Languages with F#

Using a “combinator” approach to create internal Domain Specific Languages (DSLs) is something that has been popular in Haskell and the ML family of programming languages for quite some time. Much has been written about it in academic circles, yet this approach to creating DSLs has yet to become popular in main stream industrial programming. Now that F#, a member of the ML family of programing languages, is available out of the box in Visual Studio 2010, this means that these techniques are now much more accessible to programmers working in industry.

This talk will start by addressing the question of what is a combinator and show why combinators are a great way of building internal DSLs. It will then go on to show how this programming technique any be applied to many different problem domains, all of which are very relevant to the modern industrial developer. We’ll also look at some of the existing combinator libraries available for F# such as FParsec and FsCheck.

Please register on the talks pages and if that interests you have a look at my Beginning F# Workshop running on the same day.

Update: Some how forgot to mention that both the “In the Brain” session and the “Beginning F# Workshop” are on 1st November.

F#, RavenDB and PicoMvc – Creating an Autocomplete – Scenario and Project Setup

Robert Pickering — Mon, 05 Sep 2011 18:28:06 GMT

After a few philosophical blog posts, I decided it was time for something a bit more concrete. I’ve been playing around a bit with F# and some web stuff recently using both RavenDB and PicoMvc so I thought I’d share with you how to create an autocomplete drop down using these technologies.

Creating an autocomplete in a HTML form is fairly common these days and there’s a nice jQuery plugin that takes care of the UI side of things. So the heavy lifting that remains, although it’s not really that heavy, is loading the data into RavenDB then exposing a service that will return JSON records corresponding to the users searching.

In this scenario I’m going to create a drop down based on the French “Communes” an administrative area in France that’s roughly equivalent to the idea of a town. This is just because I have the data to hand.

The way we’re going to structure our project is:

Common contains the definition of our types that will be stored in RavenDB and will be referenced from LoadCommunes and Web, which will contain the ETL logic and the logic to drive the web pages respectively. The project WebHost is a C# “web project” it’s just there to hold the html parts of the project and make launching the web server for debugging easier.

So that the scenario and the project setup done, next time we’ll see some actual code when we look at the ETL. If you can’t wait that long the full code base is already available on github in the new examples directory of picomvc.

A quick caveated is that since writing this series I’ve read Ayende’s Modeling Reference Data in RavenDB, the approach we take here is a little different to the one he suggests, I’ll discuss alterative implementations at the end of the series.