Last week I’ve attended the CodeMesh conference. Some of the videos from that conference are available here; I haven’t watched them yet. I’ll talk about the talks I’ve seen personally.

So, first of all, the talks that contained new information (for me):

1) Getting started with Elm — Evan Czaplicki.

Evan works in Prezi, and, if I’m not mistaken, is developing Elm as part (or the whole?) of his job. Elm, in case you’re wondering, is a Haskell-like language that compiles to JavaScript. This time Evan was giving a tutorial, with full hands-on approach, making the class do some simple exercises, and so on. The most important message I’ve got from that tutorial is not to concentrate on advanced FRP stuff like streams, and keep things simple. Elm’s model is well-suited for that approach, and unless you have some very advanced problem, it should be alright.

2) Function-Passing, A New Model for Typed, Asynchronous and Distributed Programming — Heather Miller

That is Heather’s research project. As she admitted herself, it’s not clear whether it would have any practical applications. Nevertheless, it was interesting and original enough not to care too much about practice.

The idea, as I understand it, is to create a monad not in the category of types, as usual, but in a weaker category with types as objects and serialisable functions as morphisms. Then the real data could be kept on some remote nodes; “map” operation, for example, sends the function to that remote node, where it’s applied (lazily) to the data. “foldMap” (“bind”) function is a bit more complicated, as it involves creating a new closure on a remote node and transferring it to another node with the second portion of data; that way data can also be passed around from one node to another: inside a closure.


3) Transactions: Myths, Surprises and Opportunities — Martin Kleppmann

That was really interesting. I don’t know if database experts would find anything new in it, but for me it was new and alarming. I had no idea that things are that bad.

Martin was talking about different levels of isolation provided by transactions in various databases, and how they can result in database ending up in inconsistent state, despite every transaction preserving consistency. Apparently, only recently an approach emerged that can provide ironclad guarantees without sacrificing multithreadedness, and that approach seems to be the idea behind STM (Martin himself neither confirmed nor denied that last bit, saying he’s not familiar with STM; so, this link between those two is on me).


4) Depending on Types — Stephanie Weirich

That was nice. Stephanie demonstrated how one can use Haskell type system (not dependently-typed in a strict sense) to make RB-trees safe, providing guarantees that insertion algorithm does not indeed violate balance. She showed how Haskell code can closely resemble Agda proof.

But there was one other invariant that was not proved to be preserved by insertion algorithm: the fact that RB-trees are, in particular, search trees. That omission was, of course, deliberate, as incorporating ordering constraints is a much more complicated problem. We had a small discussion with Stephanie after the talk, and it seems that there are two approaches: one, following Conor McBride, provides really air-tight guarantees, but only with types that can be promoted to the type/kind level, while the second, based on the ideas of Oleg Kiselyov, works on arbitrary types, but is possible to accidentally circumvent.


5) CRDTs in Practice — Marc Shapiro, Nuno Preguiça

That one is a bit strange.

It involved creating data types and message protocols that can keep several copies of data, on separate nodes, in perfect sync. What bugs me is that it really reminded me of Operational Transformation, but Marc insisted that those two are radically different. For me, the jury’s out: I need to read more about CRDTs before making up my mind about that.


Now, let’s move on to the talks that didn’t provide much new information, but were nevertheless quite fun to watch.

1) The Road to Running Haskell at Facebook Scale — Jon Coens

It was a nice sales pitch for Haskell. But while it’s impressive that they use Haskell to handle millions of requests, I can’t help but wonder how far would they go without employing Simon Marlow. My guess — not quite far.


Fun comic on that subject.

2) Accidentally Concurrent — Evan Czaplicki

Evan again. This time he was talking about why mutability is bad and immutability is good. His take on that was that mutable variable is a sort of separate thread, and having mutable variables all over results in a complicated network of threads, each influencing each, and that mess is impossible to clean up. Which is true, but hardly new: even without concurrency abstraction it is quite clear that everything can influence everything through the use of mutable variables.


3) Keynote: Propositions as Types — Philip Wadler

Lambdaman (it makes sense in context) was talking about history, about formal definition(s) of algorithm, about Gödel, Church, Turing, and a lot of others, about Curry-Howard isomorphism and stuff like that. Lots of historical anecdotes and the general sense of humour made this quite entertaining.

4) Panel Discussion — Joe Armstrong, Don Syme, Bruce Tate, Josh Watzman, Tony Hoare


That was the last part of the conference. Guys who created their own, very popular programming languages, were talking about their inspirations, their achievements, and their mistakes.

Best of all, I think, was Tony Hoare, who recited his admittance of “1B$ mistake”, adding that, in retrospect, the estimate of “only 1B$ a year” seems a bit too optimistic.

Now, things that were OK, but not really interesting, let alone inspiring.

1) From Irrational Configuration System to Functional Data Store — Rob Martin

End-of-year report. We wanted to build this, we did. Nothing to take home from it. It doesn’t help that Rob’s mind seems to be poisoned by design patterns.


2) Coordination-Free Designs for Mobile Gaming — Christopher Meiklejohn

... I have to admit, I have no recollection of that talk.

3) Beyonds Lists: High Performance Data Structures — Phil Trelford

The better name would be “Data Structures 101”. OK, linked lists are not always perfect. Thanks, we know.


4) Into Production — Jamie Winsor

Another end-of-year report. Jamie’s talk was strangely entertaining (a bit), and I’m not sure why. Probably just the way he presents.

And the last part — thing that were disappointing (for me, as usual).

1) Building Web Services in Haskell! - Allele Dev

Another tutorial, which didn’t deserve the name “tutorial” — there was absolutely nothing that the audience could do for themselves, to make sure they’ve learned something; it was just a three-hour talk, focused on Haskell/Spock syntax.


2) Keynote: Grace Murray Hopper: The Original Pirate Hacker — Melissa Pierce

Better name would be “Grace Murray Hopper: A Potential Feminism Icon”. Melissa talked much more about difficulties that Hopper had to overcome as a woman, than about her real achievements. And while those difficulties were surely big and scary, I’m not really interested in hearing about them on a technology conference.

3) Keynote: Why Functional Programming Matters — John Hughes, Mary Sheeran

That left somewhat mixed impressions. It was another historic talk, about origins of functional programming, and while John was, as usual, great, easily competing with Wadler, Mary didn’t do the job nearly that good, while taking up much more time. As a result, it now seems like functional programming matters because we don’t know how many comparators are necessary to sort 32 values.


4) FRP and Functional Game Programming — Elise Huard

Unfortunately, that was, again, bad. There was no explanation of FRP, no indication of why is it really suitable for gaming, nothing. If you don’t know that stuff already, you won’t understand what it means when Elise says “signal”, and if you do — you don’t really need that talk.

5) My Little Pony — Darach Ennis, Sylvan Clebsch

That was supposed to be an introduction into the Pony programming language. But presenters were so impressed with their jokes that they took almost all of the time explaining the basic syntactic constructs (like “case”, for example), and found themselves without time to explain what makes Pony stand out, which seems to be it’s use of references.


Coincidentally, the tutorials I’ve seen on Pony seem to suffer from exactly the same problem.

So, 50% of the talks were either really interested or at least really fun, and I think that’s a great ratio. Kleppmann’s, Weirich’s, and Miller’s talks were easily the best for me.