More contentious is that this is the fate that awaits C. Bob was at pains to point out that he isn't gunning for C and gave us a recap of his programming career from punchcards on the PDP-8 through to his first usage of C in the late 1970's. The presentation style was fun, though there was a little controversy.
The first nail in C's coffin was C++. It gave us strong typing, modularity and the wonders of templates, but importantly it still gave developers the chance to see the metal. If you worked hard enough, you could still reason about what was going on in the underlying machine. You can still see the metal, though it's a little fuzzy.
Next Java showed us that we don't need to see the raw metal, we can have an idealised machine running on a machine. You don't need to see the raw metal at all, have a look at the JVM instead! Looking back, it does seem that the world had gone bonkers at this point. Instead of running on a machine, we'll run on a software simulation of a machine, running on a machine. Eh?
Now the final nail (and a familiar theme for the conference) the multi core revolution. Now we need radically new views of the hardware to take full advantage of it.
I agreed with most of the keynote. C is never going to fully go away, but it's going to be needed by a smaller and smaller percentage of people. The presentation style was fun, but a little intense when you are nursing a hangover!
Next I went to Kevlin Henney's talk on "Functional Programming you already know". There's been a lot of hype generally about functional programming, but we've been practicing these concepts for years anyway (I think you could replace functional programming with any of the patterns and practises that have been hyped and still be on safe ground e.g. dependency injection).
There were some examples of first class functions from the C language e.g.
qsort, function composition (UNIX pipes) and declarative (SQL). There were also some great sound bites too:
code generation - do the wrong thing faster!
lock is the anti-fast pattern
There was lots of historical content too. It's always suprisinging to read notes from the 1970's and hear that it still sounds fresh and new today. For example Alan Kay's explanation of what object orientation really means.
After this I went to a C++ talk about generic libraries by Andrew Sutton. Firstly I found that he has the perfect job, researching how to make the perfect data structure and algorithms library. Unfortunately he has to use C++! The Origin libraries are the playground for this experimentation.
I learnt a lot of new things about C++ concepts. A concept is the both the syntactic meaning of a type (e.g. the operands) and the semantic (the behaviour of those operations). I was very interested in the axiom part of concepts which provides a series of relationships that any I implementation of the concept must obey. For example, you can specify that the equality concept should be transitive, reflexive and symmetric. I will be interested to see how verifiability evolves in C++ as it certainly doesn't seem like a natural extension for a language as wart-ridden as C++.
Then as a C# / Java / Haskell programmer, it was clear that my next session should be the C++ 11 pub quiz. This was a well run session about just how complicated C++ is. Even with compiler writers, language specification contributors and so on, no one managed to understand all the code. Compiler bugs were found and changes in behaviour over different versions were also observed. C++ might still be close to the metal, but I don't think there is a person on earth with the necessary mental acuity to see through the complexity!