This was my last day at JAOO. I was tired, but still looking forward to today’s speakers. It was hard to decide what to attend and what not to attend today. I just had to hope that I’ve chosen correctly.

The keynote today was held by Richard P. Gabriel and Guy L. Steele, Jr. It was… strange. Very, very strange. Bizarre, in fact. The two of them went through the history of programming languages in a colourful slideshow spiked with music and video clips and singing and ringing on cowbells. They didn’t talk but recited, like they were reading poems instead of giving a tech talk. Bizarre, just bizarre. I couldn’t quite decide if it were madness or genius. So I suppose it must be art.

Session 1: Five Considerations for Software Developers by Frank Buschmann and Kevlin Henney
I attended this session mostly because of Kevlin Henney. I listened to one of his talks last year and it was hugely entertaining, as well as insightful. This session wasn’t quite that entertaining, but it had a lot of good content. The five considerations were: Economy (strive for minimalistic solutions), visibility (your ideas should be visible in your code), spacing (keep separations between domain, services and infrastructure), symmetry (keep the code clean and balanced) and emergence (do not build too much explicit control in your code, let it emerge instead).

Session 2: LEGO Develops a new robotics platform WeDo
This session was a disappointment. It was not a presentation on robotics or WeDo or LEGO’s vision for robotics in the future, or much of anything, really. Most of all it was a presentation of LEGO as a business, and of LEGO’s business processes. As if the audience was a group of business managers, and the speaker was trying to sell stocks. I should have attended Kevlin’s second talk instead.

Session 3: Real-world Refactoring by Neal Ford
This was another session with a lot of content. It’s hard to summarise what he said in just a few sentences, but I’ll try anyway. First of all, he presented two principles to keep in mind when refactoring: The composed method (break down large methods into smaller well-named methods until it reads like a series of steps in an algorithm) and SLAP (keep the same level of abstraction in a method). Next, he gave us two things to be cautious about: Dependencies on third-party frameworks and spider web dependencies among our own classes. In addition, he talked about detecting duplication in our code with the tool cpd, avoiding duplication of code in tests, doing large refactoring on branches and doing ‘scary’ refactorings of brittle code. Lastly, he advised us to use code metric tools to discover when and where to use refactoring.

Session 4: Patterns of Internal DSLs by Martin Fowler
Martin Fowler is another of my favourite speakers. He always speaks loudly and clearly and I always feel as if I learn something when I’m reading one of his books or listening to him talk. This session was no different, although it was rather more technical than I had hoped for. He gave us several techniques for writing internal DSLs, but no pointers at all on when to use DSLs in the first place.

Session 5: Building DSLs with External Workbenches by Neal Ford
Neal Ford opened this session with one interesting observation: IDEs are slowly moving from working on text files to working directly on the abstract syntax trees instead. Thus, text becomes just one possible representation of the software, among other possibilities. But the rest of the talk concentrated on two different tools for creating DSLs: An Eclipse based tool called Xtext, and a tool created by JetBrains, the company behind the IntelliJ IDE, called MPS. Both tools enabled the user to create DSLs and the tools to work efficiently with the DSLs. Xtext, for example, will automatically generate a new Eclipse editor plug-in for the language, complete with syntax-aware colour coding and context-sensitive help.

Conclusion
Domain Specific Languages was hot topic this year. I think almost every speaker at JAOO mentioned them in some form or another. The most obvious use of DSLs I’ve seen is as a build language (Gant being an example of an internal DSL inside Groovy). But I would have liked to see some more (and more diverse) examples of using DSLs in real life projects.

Other hot topics included functional programming (emerging into the mainstream, both in the form of new languages such as F# and Scala, and as a heavy influence on the evolution of existing mainstream languages); dynamic languages (pretty well established in the mainstream by now, with representatives such as Ruby, Groovy and Python); parallel computing (mostly as a threat hanging over our heads, waiting to be overcome one way or another) and how best to utilize the internet in our applications (cloud-computing and rich internet applications).

In conclusion JAOO 2008 has been a wonderful conference. I’ve learned a lot, talked to a lot of very interesting persons and gotten a load of inspiration that will properly take me days, if not weeks or months, to process. I hope I’ll be able to attend next year too.

Popularity: 266 points