Impressions from the SPLASH 2011 conference
I have been to a number of IT-related conferences, but they have all been industry/practitioners events, usually the Microsoft PDC:s etc. These conferences are good and focused on delivering knowledge that you can take home and use today. However I really wanted to try out one of the more academic conferences and see what I could pick up there. The OOPSLA conference is something that I have heard of over the years so I decided that was probably a good bet (see http://splashcon.org/history/ for a couple of the "big things" that has originated there) . For various reasons it has changed name to SPLASH (a very convoluted acronym that stands for Systems, Programming, Languages and Applications: Software for Humanity). I soon found out that acronyms is something of an addiction in the academic world, I quickly got lost among FOOL, PLATEAU, FREECO, AGERE etc, etc...
Since this conference covered so much, I will not try to cover everything but just give a very broad overview and point out some points of interest.
Theme 2 - parallelism, concurrency, multi-core, many-core...
I cannot remember how many times I heard "The free lunch is over" referring to Herb Sutters classic article http://www.gotw.ca/publications/concurrency-ddj.htm . Everyone was experimenting with various approaches for taking advantage of many-core architectures, improving the parallelism of serial programs, improving synchronization mechanisms etc.
Speculative execution "in the large": You know about todays CPU:s using speculative execution to improve performance, but now there are experiments with using many-core architectures to automatically execute various permutations of your code in parallell and simply pick the version that finishes first.
Another thing that was really interesting was a concept that David Ungar from IBM talked about. Forget about trying to ensure the correctness of your code with synchronization - it is just too expensive. Instead accept that your code will be wrong some times and try to implement recovery strategies. I am a proponent of eventual consistency for the sake of performance, but giving up on the notion of correctness? Maybe in a few, well defined cases, yes - but I have a hard time convincing myself that correctness can be a secondary concern.
Theme 3 - Java and the JVM
Maybe not as much of a theme as the other two, but almost every time there was a talk about introducing new language features or modifying runtime behavior, the JVM (and sometimes Java) was the subject being experimented on. For example one talk was about using asynchronous assertions - basically breaking out asserts in your Java program and running them on one or more separate threads. Implemented by doing some brain-surgery on the JVM.
I talked to a couple of the presenters and it seems to be the general view that the current JVM implementations are really outstanding examples of good software engineering. However the Java language was generally not held in high regard.
Academic conference indeed...
...but also a lot of pragmatic views
My favourite talks:
- "How to handle 1 000 000 daily users without using a cache" by Jesper Richter-Reichhelm from WOOGA
Described the challenging road from a traditional three-layered database approach, to doing both horizontal and vertical partitioning of data, to moving to an hybrid solution with in-memory NoSql as well as traditional SQL database. All in the name of performance and scalability.
- "Erlang - The Road Movie" by Kresten Krab Thorup from Trifork
Contrasting the object-oriented view that "everyone" in the software industry has today with the agent-approach of Erlang, this was a real eye-opener for me. The object-based paradigm is so dominant that it is hard to even see that there are alternatives. Erlang is the next language that I will learn. Period.
Sorry - I could not find the slides for these presentations available online...
[Update - slides for "Erlang the Road Movie" available here http://www.slideshare.net/drkrab/erlang-the-road-movie-gotocph-2011-keynote ]