I recently attended the QCon London conference, and I have to say that there were a number of really interesting and thought-provoking talks.
I very much enjoyed Bart De Smet’s talk on “LINQ, take two”. This talk consisted of some observations on the current state of LINQ. In particular, the speaker pointed out that you don’t need to use interfaces when implementing LINQ as this forces the implementation of error raising methods corresponding to functionality that you don’t provide, which leads to completions in Visual Studio which aren’t really of value. Instead you can use the way that the compiler uses syntactic transforms and straightforward overloading to make it easier to use statement completion on queries for your own provider. The talk then moved on to IQbservable interface and later on to the scheduling of the execution of the LINQ query as the third dimension of query execution. This was the last talk of the conference and it overran by 15 minutes, but it was well worth attending.
“Webmachine: A practical executable model of HTTP” was really interesting from two angles. First it talked about something that was implemented in Erlang. This meant we got to see a small amount of Erlang code, and the implementation had a functional programming flavour with no global state and no mutable shared state. The main point of the talk was that this was a way to do REST correctly. Webmachine is an implementation of the state machine that governs HTTP requests. From this point of view it is interesting in itself, as it highlights some of the corner cases of the specification that are not often seem. The idea behind Webmachine is that this state machine calls out of user defined functions at various points. These functions can change the interaction by returning the appropriate values.
The presenter showed how easy it was to write a simple REST server. The defaults have been chosen to make this easy, and the user defined functions are passed the appropriate arguments, so that if the bodies only depend on the parameters, it is really easy to ensure that the server behaves as it ought.
Webmachine has been ported to a number of languages, and I’m sure it will make its way to other languages in the near future.
“Advanced Reflection” was a talk by JB Evain that highlighted the use of the Cecil library. This is a library for manipulating .NET assemblies. It provides an object model over the assemblies, allowing them to be modified and re-saved. The talk emphasised the use of the library for Aspect Oriented programming – one main example was adding checks to the prologue of functions to check for null parameters.
The current implementation allows a method’s code to be modified at the IL level, and the presenter talked about his future hopes of decompiling the IL into expression trees and allowing the modification at this level.
Cecil (and associated utility libraries) is a really useful tool which we have used at work for reading and adjusting assemblies.
Node.js is very scalable due to its use of the operating system to queue the work. A single thread means that there isn’t the memory overhead of many blocked threads, and performance is good as there is little context switching or scheduling overhead. Load balancing happens at the level of having multiple Node.js instances instead of at the threadpool level.
On the Wednesday, I attended two talks on The Java track. “Java’s youthful maturity” talked about the soon to be released version of Java, emphasising the new VM support for dynamic languages via the invokedynamic bytecode. There was also discussion of some concurrency support via the ForkJoin classes which support the ForkJoin pattern. During this discussion we got to see the new lambda syntax in Java, and a potential mechanism for extending existing classes. This latter facility adds default implementations into existing classes to support backwards compatibility.
“The future of Java EE” was very much about getting Java to work better with the cloud. During the talk the presenter used the glassfish application server to deploy an application into the cloud.
I also attended an “Introduction to iOS development” which was a quick tour of the iOS platform and it’s development tools. The introduction to Objective-C was really good, though as I’m a fan of Smalltalk it was easier to grasp the + and – to denote class and instance methods and the parameter syntax. The presenter gave brief guidelines for when an HTML5 application should be written in preference to a native application.
Both days also had relatively interesting keynote presentations, and the conference was really worthwhile.