OOPSLA again, lots of conference and all sorts of ideas. It's impossible to do a proper write-up of this conference - there's too much for any one human to attend, let alone take in. So these are scattered thoughts.
It was nice to see the return of Jonathon Edwards and the Subtext project in the Onward! track. Subtext is one of the the most fascinating ideas about a development environment that I've run across, and also one what is difficult to describe (go to the site and watch the videos). Like Language Workbenches, it avoids using text as source, preferring an abstract representation that's projected for editing. However, unlike general purpose workbenches it is a specific language environment with a particular emphasis on showing both code and example executions simultaneously. I like it because it is so different and is an example of the kind of very different programming environment that language workbenches are striving for.
Since it was in the same session, I also caught the X10 session that described a research language specifically at concurrency. With the growing emphasis on multicore processors and the view that this leads to a fundamental change in software towards concurrency, it's important to think about how concurrency can be handled in a way that mortals (ie people other than Doug Lea) can handle. I have no idea whether X10's approach is correct, after all I'm a muppet when it comes to concurrency, but language based approaches to the problem seems interesting. (I'd better mention Erlang before the reproachful emails begin.) While I'm on the topic of concurrency I should mention my far too brief chat with Doug Lea. He commented that multi-threaded Java these days far outperforms C, due to the memory management and a garbage collector. If I recall correctly he said "only 12 times faster than C means you haven't started optimizing".
I caught a few interesting developments on the refactoring front. Frank Tip's been working on using type inference techniques to help implement refactorings. He was also involved on a paper that uses refactorings to automatically migrate client code on a library change - in this case removing the old Java 1.0 collection classes. I talked about this with John Brant and Don Roberts, and they said they've been doing this kind of migration for quite a while. Most of it is migrating between Smalltalk implementations (not a trivial problem) but also some cross-language migrations. Sadly none of this has been written up yet, although they did mention their key tool for this work is SmaCC. In another corridor chat Jennitta Andrea observed that in teams she was working with she noticed that refactoring tools changed they way people thought about the chunks of programming.
My colleague Ivan Moore and Nat Pryce ran the Scrapheap Challenge. The idea is to give out a problem and let people have 90 minutes to build a solution by downloading bits of software off the internet and gluing them together. Essentially it's an exploration of PostModernProgramming. It was a small workshop, probably a good idea given the fact that it was one of the first times it was done. It seems like an idea that would work well for other conferences: active, different and interesting.
Brian Foote's talk on a history of dynamic language development got a large audience, after all he has one of the best joke/minute averages in software. Amongst the one-liners ('Java is Diet Cobol', 'XML is lisp with [devil's] horns') my attention was caught by his request to spend some of the proceeds of Moore's law on better self-monitoring of systems, so we can more easily find and fix the inevitable problems that we get when we deploy software. Just because you think you can prove that the opposition can't score a goal is no reason to not play a good goalkeeper.
Mary Beth Rosson had a keynote suggesting that we think about ditching our notion of 'users' and thinking instead about 'use-developers': people who build their own tools such as mail filters and spreadsheets. These use-developers require a different approach to thinking about usability and features. These use-developers need better tools (hello Language Workbenches) and better practices that incorporate much of what we've learned about software development.
Amongst all this I was taken by her mention of a teaching system based on Alice where children were introduced to a simulation that included a flaw and were asked to fix it. Should more teaching be done this way? Ask students to fix a program with a bug; or in a more tricky vein to refactor an ugly program that works correctly.
I won't say much about my own talk, other than the best bit was probably Brian Foote's introduction.
I missed the evening party at San Diego Zoo to attend a BOF on Grady Booch's effort to create a Handbook of Software Architecture. His aim is to look at a whole mass of different software systems and provide a brief overview of their architecture. The resulting tome will provide lots of examples for people to learn from. It's a huge and necessary effort. There are masses of lessons learned in systems that have spent time in production; we don't learn enough from them.
OOPSLA's a funny conference. At the beginning I was very struck by the difference between it and RubyConf. RubyConf is the young conference, focused and confident. Like any adolescent it knows everything and refuses to believe that anything is impossible. OOPSLA is the flabby middle-aged conference with no guiding purpose any more - after all objects have (at least on the surface) won their quest to be the dominant decomposition of software. So there's no longer any reason to advocate objects and push them on the unwilling software development community. We're all OOers now.
So my opening conversation on the first night was to moan that OOPSLA hadn't disbanded in 2000 - we've won - goodbye. After all wasn't the fact that I was giving a keynote proof of how low OOPSLA had sunk? Yet as the conference went on I found myself enjoying it more and more. More than anything OOPSLA is a community, and although advocating OO is old hat, the people in that community move on to plenty of other interesting things. OOPSLA is a chance to catch up on all this stuff.
How this works for someone new I'm not so sure. There was an item in the conference bulletin from someone complaining about the OOPSLA in-clique. I suspect that's a necessary consequence of a long running conference community. This is the chance for friends to catch up, so they spend a lot of time together. I hope that newcomers find the side-effects to be fun, but I suspect OOPSLA can never avoid the in-crowd effect. I don't think other long-running conferences do either.
(All quotes are from memory and thus approximate.)
Dynamic types are stronger than static types, as they don't flee the field at runtime.
-- Brian Foote
Eclipse has a 'guess the button' user interface.
-- James Noble
Static types give me the same feeling of safety as the announcement that my seat cushion can be used as a floatation device.
-- Don Roberts