I've just come back from Devoxx 09 in Antwerp, Belgium, a conference that will probably become known as the one in which closures sneaked back in to Java 7.
Whilst I didn't feel any particular urge to return for the day 3, there was more than enough interesting material, both technical and abstract, in the first two days for me to chew on. Here some thoughts and comments on my personal "slice" of Devoxx.

Andrew's agenda

What I saw (and, for the curious, what I missed)¹:

Wed

• Keynote: Java, the Platform for the Future
• Keynote: Java EE 6 and GlassFish V3: Evolution of a Platform
• Agile Mythbusters
• The Concurrency Revolution
• Traditional Programming Models: Stone Knives and Bearskins in the Google Age
• Keeping Your Options Open, Even if the Cloud is Not
• Distributed Programming the Google Way

Thu

• Keynote: Do we really know how to develop software?
• Keynote: Filling The Professionalism Gap
• The not so dark art of Performance Tuning
• Google Appengine Java - Groovy baby
• Traditional Programming Models: Stone Knives and Bearskins in the Google Age
• Using BTrace and DTrace to Instrument and Analyse Java Applications
• Performance for the performance-shy

That announcement

Yes, it's somewhat ironic that I missed the big announcement of the conference: that closures may sneak in to Java 7 after all. In fact, I had decided to forego Mark's talk in the moderately firm belief that there wasn't going to be anything in it he hadn't presented elsewhere or blogged about before. So much for instinct.
Needless to say, news filtered through pretty soon, though, and of course almost everybody has an opinion about this unexpected (to say the least) development.

Some samples² of what they might look like

Collections.sort(strings, #(String a, String b) a.length() - b.length());
Collections.sort(strings, #(String a, String b) { return a.length() - b.length(); });

@Shared int clickCount = 0;
button.addActionListener(#(ActionEvent e) { clickCount++; });

What's buzzing

With Sun and Adobe "premium partners" of the event, it was hardly surprising to come across quite a number of JavaFX and Flex talks. Oracle's entry into the fray was slightly more intriguing, focussing as they did on new features in the upcoming WebLogic releases.

Needless to say, that was slightly more enterprisey than one is used at developer conferences; I personally was intrigued to see them starting to get interested in the deployment space with an initial offering that makes it possible to create virtual machine images from configured systems.
From what I saw, there are still some important concepts missing there (which, naturally, we at XebiaLabs are trying to address with Deployit), but it's interesting to see the middleware vendors beginning to pay attention to this.

Sponsors aside, the conference's main threads, as far as I could see, were the "usual suspects" of concurrency, OSGi, Cloud and Scala. Of these, concurrency/distributed programming and OSGi seem to be gaining a little more enterprise traction (in terms of the number of people who actually appear to be using them for real projects); Scala and Cloud remain things to be "interested in" and "play with", but still retain a slightly experimental flavour.

I can't say, though, that I came across anything that hasn't been around the conference block for at least a year. No real surprises, in other words.

Highlights

Most Professionally Thought-Provoking

Joint award here to Ivar Jacobson and Uncle Bob, both of whom presented a rather critical view of the current state of the software development industry and made some thought-provoking remarks.

The main gist of Ivar's talk was that software engineering as a discipline lacks any kind of solid theoretical foundation, lurching from (methodological) fad to fad rather than developing a cumulative body of best practice knowledge.

His approach to avoiding what he considers as a recurring tendency to throw out the baby out with the bathwater is to break methodologies such as Agile down into sets of practices. In this framework, these constitute the "atomic" entities, and supposedly make it easier to identify common features of different methodologies and incrementally improve them.

Whether the Iterative practice in e.g. Scrum is really the same as Iterative in a different methodology, or whether processes are really just "bags" of practices to which you can add others without disturbing some inherent balance, are questions left unanswered.

In any case, Ivar has drummed up a bunch of Thought Leaders and is issuing the following call to action, to which all developers are apparently invited to contribute.

By contrast, Uncle Bob's talk focussed less on the process and more on the technical side of software engineering. His central tenet: developers need to learn to behave more like skilled professionals. Which to him means, amongst other things:

• Learning to say no (how often have you heard a doctor say: "Fff, it'll be tough, but we'll try and get your liver done by tomorrow?")
• Demanding a right to a technical career path that suitably recognizes
  accumulated skill and experience (rather than forcing developers to become managers to progress)
• Always aiming for a "professionally ethical" level of code quality (independent of business value)

It intrigued me to note that the attitudes that Bob was referring to are most commonly found in guild-like professions (such as law or medicine), whose practices are usually based more on experience and tradition than hard science. But let's keep the "software development: craft or science?" debate for some convivial pub session, shall we?

Most Technically Thought-Provoking

Looking back on it as a whole, Cameron Purdy's talk was no more or less than a well-delivered, knowledgable presentation on the benefits of event-driven architectures. The observation he used as an introduction, however, I found fascinating: simply learning to program is bad for scalability.

The argument goes a little bit like this: in almost all the languages you might learn as a beginning programmer, you can write something like:

  int total = 0;
  int i = 10;
  addToTotal(i);
  // now total = 10
  i = 20;
  addToTotal(i);
  // now total = 30

Trival. But hidden amongst our "natural" interpretation of what code will do are the following expectations:

• the statements will be executed
• the statements will be executed in the order written
• the statements will be executed exactly once

Cameron's point is that, if you consider distributed systems, these requirements - guaranteed execution, global ordering and exactly once processing - are just about the most stringent, and hence costly, expectations one can have.

Systems which are fault-tolerant, free of race conditions and idempotent have a much better chance of scaling and distributing well, and one of these reasons this is hard is because it goes so deeply against the grain of the intuitive picture of how programs run that are ingrained right from the first line of code we write.

Best Technical Content

Trust Google to put together the talk with the most varied range of "cool stuff". Gregor Hohpe gave a very engaging presentation on MapReduce, Bigtable, Sawzall and others, interspersed with mentions of things like Bloom filters and other interesting theoretical concepts.

The common theme here was definitely trading off functionality for scalability, with the conclusion that we can often get away with much less functionality than one might expect. Sawzall, for instance, does lightning-fast distributed aggregations, but, being history-less (you only see the current row), can't even do duplicate checks.

So what do you do if you discover that the engineers over at the Mountain View chocolate factory have sacrificed even the tiny little bit of functionality you need? Can you hand back a bit of that Bigtable scalability for multi-row locks, or are you straight back to Oracle 11g?

Well, it appears that Google does have a transactional engine on top of Bigtable, after all. But that's certainly not open source!

Best Presentation

The prize for sheer viewing pleasure goes to Doug Tidwell's talk on SimpleCloud. Humourous, slickly presented, with a good mix of examples and concepts served in manageable chunks, I certainly enjoyed this one. Including a recurring joke (in this case, Adam Koford's set of HTTP response code illustrations isn't a new idea, of course, but this one was actually topical and funny.

In terms of the content, SimpleCloud looks like a pretty decent cloud API. Quite how useful a PHP library can be for Java developers remains to be seen; if you're looking for a powerful, concurrent Java cloud library with support for lots of cloud providers try jclouds³.

Lowlights

Most Annoying Trait

To presenters from North America, a polite request: if at all possible, please remove jokes or other references to intrinsically North American popular culture.
Having to sit through a five-minute explanation of who a particular character in an American sitcom in the 70s was, or what the point of a certain gameshow was, isn't a great start for a presentation that was supposed to begin with a quick joke and then get on to the topic the audience is actually interested in.
Thank you.

Biggest Disappointment

Working for a company that is widely known for its Agile expertise, I was looking forward to Scott Ambler's promise of investigating some of the myths and rumours surrounding Agile to the scrutiny of cold, hard statistics.
What we got, however, was a lightning dash through the self-reported results of a number of surveys, without so much as a hint of analysis or further explanation.

Whilst it's certainly not uninteresting to learn that more than 50% of Agile teams do in fact do some up-front design, what I would very much like to know is whether up-front design actually leads to more successful projects! Suffice it to say that my colleague and I left the hall with many questions and few, if any, answers, and that's not taking into account the confusing presentation of many of the numbers.

A note on Performance Talks

As you might have guessed from my conference agenda, I'm quite interested in all this concurrency and performance stuff (it probably wouldn't surprise you either to learn that I'm also trying to help with Multiverse, a Java STM implementation). But after this round I think I'll be skipping performance tuning presentations for a while.

Not that Kirk's or Holly's presentations were bad or even boring, they were simply going over the same basic "performance tuning 101" stuff that is talked about every year, at every conference.

Now, these sessions are usually packed, so there certainly still seems to be plenty of demand for learning how to get a thread or heap dump or how to write a JMeter test plan.

Naturally, I understand that, because performance tuning is so specific to the application at hand, it's difficult to give more than general information and guidance. But at the end of one of these sessions I always feel I've hardly scratched the surface of these experts' knowledge of application performance.

What I would love to attend, for instance, is session during which I could simply watch these performance experts at work, attacking the problem of tuning a real application "from scratch".
The point would not be to see to what extent the application could be speeded up - in fact, that would be completely irrelevant. But I think there would be a lot to learn from seeing how a performance tuning professional goes about such a task in practice: where to start measuring, what tools to use, how initial hypotheses are formed etc.

But of course it's also not realistic to expect people to give away the "trade secrets" that allow them to earn a living just like that.

Oh, and to all the JVM vendors out there: please consider coming up with some standardized formats for profiling information! It's such a pity to watch demonstrations of really useful-looking tools (such as IBM's Health Center) only to discover they can't work with the data produced by the JVM your client is using.

Quote of the conference

The rumour that Mark had come up with the new closure proposal syntax on the plane over to Belgium certainly caused a few chuckles. My favourite, though, was a remark attributed to Larry Ellison, who in response to possible demands from the EU to sell off mySQL is supposed to have said: "The 'my' in 'mySQL' means Larry's SQL.".

A final note

Hats off again to the Devoxx team. Content seems to be more or less on a par with JavaOne, and yet the attendance fee is still roughly €1000 less than almost all other conferences.

It's not perfect, of course: the wireless connection is just as continuously unavailable as elsewhere, and the food-loving Belgians are unlikely to consider the catering the pinnacle of Belgian culinary tradition. But after all, for €1000 you could eat and drink yourself pretty silly in Antwerp's many good restaurants and bars, and still have enough left over for some lightning-fast internet.

For me, still the European conference to beat.

Tags: conference, devoxx
Filed under Java | 1 Comment »