I spent two days last week at CodeMesh in London. This was a thoroughly entertaining conference, with two keynotes and six talks on each of the two days. There was an additional tutorial day on the day before the main conference but I didn’t go to that.
It’s hard to put my finger on exactly what CodeMesh is. It is tagged as the alternative programming conference, but what does that mean? From my point of view, it took ideas that are starting to make there way into the mainstream, say functional-first programming, immutable data, data as streams and lightweight processes as a means of handling failure, and showing how they have been used successfully and why they may be useful in the future. It was very interesting conference which pushed a lot of ideas. Lots of the talks were good quality, and there were talks that ranged from industrial use of the ideas to talks of a more academic nature. The language emphasis was on languages like Erlang, Haskell, Scala and Clojure, most of which mix functional ideas into a more standard OO setting.
Some of the slides are available on the individual speaker’s page, and the videos will come online over the coming months. Hence most of what I write below comes from memory a couple of days after the conference, so some of the information is a little sparse.
Day one started with a keynote on Going Reactive. This really set the scene for the conference. The world is moving to multi-core scalable reliable applications, and this demands access to many ideas that were present in languages like Erlang (which wree designed for this use case). The talk pushed the Actor model (and the Akka framework), pointing out that we need to embrace failure by basing these new distributed system on failure domains (such as lightweight processes). The talk was informative and exciting.
I followed this with Snake Bitten, Bruce Tate’s thesis being that a language is popular often because it solves one particular issue (say deployment as in the case of Java) with complete disregard for the other dimensions (such as correctness, learnability or elegance). This was just the type of things us functional programmers wanted to hear,
Apache CouchDB Internals was next and I was hoping to get lots of information about the internals of CouchDB. Unfortunately, it didn’t live up to my hopes.
Cliff Click’s talk on An Api For Distributed Computing was informative, stressing as it did that the way to handle large datasets is to split them in-memory across multiple nodes, and then to run the map-reduce inside these nodes, keeping inter-node communication down to a minimum. The Api for these large vectors is implemented in Java.
End to end Reactive Programming at Netflix was really just an introduction to Reactive programming. The talk was really good, but I didn’t learn anything more than I’ve seen before – certainly nothing was mentioned about the deployment of this technology at Netflix.
Erjang – With the JVM under the hood was the best talk of the conference. It discussed how the speaker has written a system that takes the Erlang BEAM bytecode format and converts it to run on the JVM. It talked about the implementation, giving examples of the translation of various functions and also showed that the JVM is able to run such code very efficiently, with the only problem being the scheduling of the lightweight processes (IRC the usual Erlang VM is single threaded with the scheduler swapping lightweight processes after a certain number of instructions).
Day two started with another keynote, 50 Shades of Green, which started out with a discussion of the Sapir-Whorf hypothesis and then moved on to the richness of expression in programming languages. Along the way we got to see demonstrations of macros inside the Elixir language.
Meta-programming in Logic Programming was an interesting talk on writing a meta-interpreter and using it to prevent a non-terminating tree search. I’d seen these kinds of things in meta-circular Lisp interpreters in the past, but never seen them applied to logic languages. It was interesting to see miniKanren, a logic programming language embedded into Scheme, and there was a good discussion of how these ideas had been used to allow one of the speakers to define a type checker using straightforward declarative logic rules, and then using meta-interpretation to get more information about the type errors that where found in programs [really I guess we were seeing how a DSL could be interpreted in multiple ways where the semantics of the DSL were implemented in the semantics of the original logic program]
Idris: Programming with dependent types was a great introduction to dependent types by a lively speaker. He started with the standard vectors with length type examples, and then used the theorem proving side of dependent types to get the Idris system to write the code. There was a little discussion of using dependent types to track effects, and he showed that we had a real programming language here, by showing a basic implementation of space invaders. Dependent types are something I will be reading about a lot more.
Akka in heterogeneous environments was the speaker writing a Scala frontend (using Akka) which communicated with a C++ vision processing library using RabbitMQ. It emphasised how easy it was to write actor code in Scala (running on the JVM).
Practicing at the cutting edge. Martin talked through his job history and discussed how performance has changed over the years. For today’s truly high performance systems, all data needs to be in memory to avoid the massive overhead of going to the disk. Indeed, he stated that a processor to processor message can be achieved in 10 microseconds, so often it is quicker to get data from another processor’s memory, than having to go to the disc to fetch information from the data set. Equally, rather than transactionally writing to a disc, some systems write multiple in-memory copies to other nodes, which then write to disc at some later point. With enough replication, persistent changes are effectively guaranteed. An interesting talk, though it wasn’t clear how close to these high performance boundaries usual applications are running.
A very interesting conference with lots of interesting talks. Well worth attending!