Floyd is a
friendly guy, from Canada, formerly of theserverside.com, who is going
to launch his own site soon. It sounds quite good; I’m looking
forward to it and I’ll post about it when it is live.

Unfortunately I missed the first part of Floyd’s talk about trends
in Java, since I got locked in a bathroom. You’d think this would be
hilarious, but really it was just boring and mildly irritating. One
of the other guys called Bruno on his cell phone and after a short
wait maintenance physically removed the lock.

Floyd had many examples of AOP to present. I dislike AOP quite a
bit, since I think it violates the heuristic that says that it is
better to have local constructs be lexically signified. (There. I
put that in the most obscure and highfalutin way I could think of. Am
I pomo yet?)

I didn’t write down the examples but one idea was architectural
enforcement — where the AOP insertions can check that your code is
following some rule supplied by the framework. But see what I mean
here? It would be better to enforce these rules statically, using
compiler-level tools (perhaps in addition to dynamic checks if that is
really needed — though these too should, ideally, be done in a way
akin to verification).

About 15% of the audience planned to use AOP, and Floyd said this
was about what he found globally. Floyd is a gold mine of this sort
of information.

Dependency injection is a must-learn trend according to him. So
are annotations, everybody likes them. (C#’s influence on the
language is easily felt, but I suppose the web services guys would
have pushed for this regardless — look at xdoclet to see why.) I’m
probably going to use annotations for the next generation of GDirect,
for what it’s worth, as it is a natural fit. Floyd had a nice list of
known best practices for annotation use — most of these can be
thought up pretty easily, but it is smart to just distribute the
information like this, I think, to try to get good penetration of the
ideas early on.

He said that many shops are moving back to OO design and POJO
applications. I’m not really a J2EE type guy but I gather that this
is a change from how web applications are written today. The new
buzzword here is “domain driven design”, which really just means
“OO”. Buzzword proliferation is a disease and the UN ought to combat
it.

Scripting is a good “new” trend, with Groovy soaking up most of
the press gravy lately. Both NetBeans and Eclipse folks are
investigating scripting the IDE. Got Emacs? Though one nice thing is
that since the JRE provides a consistent platform, the scripting
language choices matter a lot less; you can pretty much write
scripting goo in any language you prefer.

“Domain specific languages” is also a new trend, just like it has
been for the last 10 years. “Software engineering” is the endless
renaming of existing ideas, and the history of it is largely the story
of IBM introducing the same ideas that it likes, over and over, with
different names each time, until they finally take hold.

Floyd also talked about Ruby on Rails (as did many here, mostly to
argue against it), and AJAX. (Ean pointed out that Project
Blackwood, which got little uptake, is really just AJAX for Java
applets. This seems like a cool thing to revive.) Running out of
time he mentioned “SOA” (service oriented architecture). I didn’t
know what this meant, but this
explanation seemed relatively clear.

To sum up he hit on something that was repeated a couple of times,
namely the importance of open source Java for emerging economies like
Brazil. “Emerging” is the official phrase — I heard it 2-3 times. I
think “developing” is reserved for poorer places.

I was glad to hear this from someone! There’s a quote I like
which goes something like: “Philosophy is the middle ground between
science and religion, open to attack from both sides”. This describes
work on gcj perfectly — the free software world and the Java world
are similarly unenchanted. The Brazilian Java community, though,
really gets what we’re about, and why we’re important, and this is why
I was so happy to come here to talk. The point here is, we have a lot
of free infrastructure below the JVM, and we have a lot of free
applications above the JVM — but that crucial middle layer is a
proprietary zone with all the attendant pitfalls. Our vision is to
change this, and we’re actually quite close to that.