So I've been watching some more Devoxx talks on the Parleys live stream. Quick capture of my mood after seeing them: bored and disappointed. If you're a fanboy, don't read on. Though I do have some added and somewhat unrelated thoughts which follow.
The Android keynote didn't really say anything other than that you should be developing for mobile right now. The useful remarks were few and far between. As far as a keynote goes, this one didn't cut it.
Then the guys on the Cloud stuff. These barely scratched the surface of any of their three different topics. Why they couldn't work together to make one coherent presentation on platforms in the cloud I'll never know. One thing to remember though: forget about standardisation of platforms for the near future.
The JMS 2.0 talk basically showed that the next release should be called JMS 1.2 instead. For a 2.0 they should have some more guts to cut the cruft and try something better. Why can't we just send arbitraty (ok, Serializable) objects through JMS ? Why not take a look at the Actor programming model for sending and receiving messages between components ? In fact, a good actor model would totally negate the need for JMS.
Honestly, the JMS 2.0 talk was still the best one, but only because I grabbed on to two thoughts while I was listening to it. I'll try to describe them as best I can here.
First: annotations are being abused in Java. For one thing we are using them instead of interfaces. "You want to be a FooListener ? Just annotate some method with @Foo." No more FooListener interface. That's not a good thing, in my opinion, as you lose static type checking for one (the compiler won't complain if you don't annotate with @Foo). It also means you can only have one such method per class. Now, you might say that was true before as well, but there, at least, you had the option to use anonymous inner classes to overcome this limitation. The real solution would have been closures or first class methods, but we won't get these before Java 8. And at that time we will probably have to retrofit this best practice for callbacks and listeners once again...
Second thing I caught on to is that they're trying to make the JMS API nicer to use. Basically they want something which is easier to read/write than by making use of the different pieces offered by the API; do more in less lines of code. What they really want here is some kind of DSL, but as Java doesn't let you do that they will play with the API instead. What I realized is that they're trading off the quality/structure of their API in order to gain expressivity. I mean, the API is simple, and it doesn't take much to send a message through JMS. It's just that you have to do some boilerplating and juggling of objects. What is interesting is that in more flexible languages such as Groovy you can have the best of both worlds: a high-quality API and great expressiveness. These languages break the artificial bond you have in Java, where expressiveness is tied entirely to the API. I find this another great example of why DSLs make sense and why languages should support them.
Java was once revolutionary because it was doing bytecode and garbage collection. This was unheard of; in mainstream languages at least (*cough* Lisp *cough*). Now people looking at Groovy and similar languages are starting to see what expressiveness and DSLs can bring (*cough* Lisp *cough*). Either Java will have to get on board (which I don't see it doing in a timely manner), or it will become the next Cobol...
Well, if you have been watching Devoxx too, let me know what you guys think. Maybe all the cool stuff was shown in other sessions. :-)