So, first of all, the talks that contained new information (for me):
1) Getting started with Elm — Evan Czaplicki.
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.