3 November 2004

I've been attending OOPSLA for over a decade. It's become the place where I catch up with lots of friends and find out what they've been doing lately, and try to get a sense of where the OO community is going.

Before the beginning of the conference proper I attended a workshop on reappraising the GoF book, ten years after it came out. While the book is still essential reading for anyone in the OO space, there's much that could be done to modernize it (although sadly it appears that probably won't happen - at least by the GoF themselves).

We did a number of discussions around the what next theme, perhaps the most interesting one to report was an exercise in considering some to 'vote off the island'. People voted on the patterns to indicate which ones they felt needed deletion in the current form.

Four patterns were voted off. Factory Method (due to the confusion over what it means - the pattern is different to the more common usage of the term), Bridge, Flyweight, and Interpreter. Two patterns, Singleton and Chain of Responsibility, were split decisions.

I found the votes and discussions interesting. Of course it's hard to really consider this without looking at alternatives. I was surprised that Singleton got away with a split decision, considering how unpopular it's become amongst my friends. Most of the others were voted off because people felt they were sufficiently uncommon and that other patterns would probably take their place, sadly we didn't have time to consider new members.

Eclipse had a party (continuing the tradition of OTI and IBM) on Sunday night. However the room was far too small and so the only way you could enjoy it was to have roll under a steam roller first.

The opening keynote was by Rick Rashid of Microsoft Research. It was widely criticized because after a period of mildly interesting stuff from the labs, it launched into a product announcement that rapidly became a typical vapid product demo. I left after being treated to boxes being resized and put into groups - only to be told off by some friends for not walking out earlier. Among the most annoyed were the people from Microsoft who were very embarrassed at what they agreed was an inappropriate product pitch. I guess it's hard enough being the butt of everyone's jokes without this adding to it.

Being the supporting executive that I would like to be, I planned to attend my colleagues session on mock objects. But that plan was abandoned when I realized it clashed with NoNoPoMo - Notes on Notes on Postmodern Programming, the latest of the PoMo talks from Robert Biddle and James Noble. I caught their original Notes on PostModern Programming talk two years ago and usually describe it as academic speculation masquerading as performance art. This version continued the entertaining performance art thread but continued with drawing the links to how we think about building software. I'd seen James do his talk on the lego hypothesis at JAOO and this talk helped develop much of this theme.

My summary of the PoMo position is that programming has grown up the modern age, which has an underlying assumption of a grand narrative of progress and a liking for composing large structures out of smaller but similar structures to provide a unifying and coherent picture. But the notions of the modern age are being questioned in many places (particularly architecture and literature) by the idea of a new phase in human development which they call post-modernism. This introduces new themes, in particular a lack of any grand narrative and an acceptance of messy structures. The PoMo programming view is that this underlying current affects our view of programming - even if we don't consciously realize it. An aspect of this is how we are beginning to accept messy but useful systems - for example Perl, or the way that software parts integrate in any real software systems. A modernist viewpoint hates the messiness of these systems, but a PoMo considers them to be necessary feature of our world.

Alan Kay's Turing Lecture was a well-attended high note of the conference. The particular buzz was that this was to be a new talk - the wags joked it was Kay's first new talk in twenty years. The theme of the talk was the loss of the joy of discovery in the way we teach programming. In the sixties students were taught that nobody understood what you could and couldn't do with computers, which led to an explosion of creative ideas that were well summarized by showing a video demo of sketchpad. Now programming is more about learning rules about what we've done rather than encouraging people to push boundaries - and as a pattern author I'm more guilty of this than most.

Much of Kay's talk was about Squeak and Croquet. I heard a couple of Microsofties say that this was ironic after the criticism of Microsoft's demo that morning. I think the difference (other than that Squeak and Croquet are free) is that Kay used the tool to illustrate the ideas he was talking about. The tools were examples of the kinds of things you could do, rather than a statement of the art. They encouraged you to go further, either with them or in competition of them. As Brian Marick put it "in the Microsoft Research world, we're observers, consumers, secondary participants in an experience someone else has constructed for us. In Alan Kay's vision, we're actors in a world that's actively out there asking us to change it." My only nitpick here is that using Microsoft as the target here is only because they are the biggest - the whole industry reflects this problem - which is why Kay (the Orson Welles of software) has such an important point.

Steve McConnell opened up day two. His talk focused on the ten year gap between the first and second edition of his excellent book Code Complete. Brian Foote summed it up as a "litany of things I agreed with". My sum up would be that the industry has made real progress in this area during the last decade, despite the usual views of skies falling in around us.

Steve was on the same panel as me later on "Software Development: Math & Science or Arts & Crafts?". It was yet another examination of metaphors of software development, which is getting to be an annual theme at OOPSLA. These days I seem to be forming the view that the only good metaphor of software development is a dead one. I did my usual harangue about the problems of the software engineering metaphor and a particular shot at the manufacturing metaphor.

Attacking software-as-manufacturing was particularly timely since every OOPSLA attendee got a copy of Software Factories in their goody bag. I've been aware of this work for a while, and my instinctive allergy to this metaphor was only reinforced by the "we need industrialization" motivations. Dig deeper, however, and there are good ideas in here - particularly the approach of integrated DomainSpecificLanguage capabilities.

I missed half of Thursday's keynote of Amazon's web services - a talk which was much better than I expected. There were a lot of interesting things that people were doing based on Amazon's stuff and you have to take your hat off to Amazon for happily encouraging this by making the data easily and freely available. Doing so, of course, is not pure altruism - it also helps build Amazon's brand. For ages articles like this link to Amazon because it's become the de-facto point to link book references to. I do it because it's easy - even though I don't participate in their referrers scheme.

My second OOPSLA panel was on offshore development - I was invited based on Thoughtworks's experience with our Bangalore lab. However none of the questions were on the mechanics of making offshore development work, but instead they concentrated on the motivations and consequences of offshore development. What was clear is that there is still a palpable fear of what offshore development might lead to in the USA - but I still think much of this is based on the faulty manufacturing metaphor.

My last panel was the .NET vs Java shootout - but as I said the Canadians confiscated the guns at the border. I used the QuestionTimePanel format, which I've found useful to get panels more focused on reasonable discussion. I was concentrating too hard on chairing the panel to remember too much, so I'm glad there's an eweek report.

Two things that certainly struck me were a couple of Anders Hejlsberg's indicators of where he is currently thinking about C#. One is to deal with the infamous impedance mismatch between objects and relational databases. The other was moving towards type inference to combine the advantages of static and dynamic typing.