ECOOP day 1

The first day of the conference was probably the most interesting to me and there was loads of good stuff. It all started with the invited talk by Joe Armstrong about Erlang. Apparently he is quite well known as an opponent of OO programming, so was a bit of an odd choice, but a good one. He was an excellent speaker and the talk was not actually very confrontational. He expounded a lot of good design ideas and concepts and evangelised a bit for Erlang (which seems pretty hot right now in PL circles). He has a real thing against mutable state, which, I guess, in its shared incarnation with concurrency around, is fair. I liked the idea that you don't catch expcetions, but let the process fail, but I'm not entirely convinced you can do this in real life, since other processes are going to have to catch the mess at some point. The other controversial point (according to me) is that we 'natively' understand concurrency, but not OO. I think the opposite is true, I think objects and classes are pretty natural, but that we function very sequentially. We only really notice what other people (processes) are doing when we interact occasionaly. But I think this is even more reason to like something like Erlang which really concentrates on concurrency.

The invited talk was also good beccause it seemed to capture a few of the big 'feels' of the conference - that concurrency is hard and fertile ground for research, and that we might be reaching the limits of OO research (although I don't think I agree with the latter, I do with the former).

The first proper talk was on gradual typing, a great idea that is getting some attention recently in various guises, this is another iterative development in the field. The idea is to be able to safely combine dynamically and statically typed program fragments (and some kind of grey area between the two). I really think this is the way forward for programming languages, especially as type systems get more complex.

Next up (in my notes) is Werner again, this time talking about extending universe type systems with generics. This is the continuation of the work at FOOL that I describe below. Surfice to say I like it a lot and its worth reading.

Possibly the most controversial talk of the conference was on object identity and relation types. The authors propose special classes called relations where the equals and hashcode methods are automatically supplied by the compiler by comparing fields marked 'key'. This was the first step towards some kind of heap/database project. A few members of the audience disliked the use of the term object identity in such a context, but I think this is a pretty petty objection, changing things for the better is what we are meant to be doing. I kind of liked this, it addresses a long standing problem (the subtyping/equals mismatch) and does it nice and simply. However, the extra syntax and machinary seems a lot of effort for what is really a fairly small problem.

To round off the day was the panel discussion, discussing the future for OO programming languages. Martin Odersky and Gilad Bracha gave the most interesting and animated opening talks, but the rest of the discussion was a bit too restrained. Popular points were about concurrency and the (allegedly) growing division between expert and casual programmers. Whether reflection was essential for OO programming seemed to get people excited too.