Skip to main content

Java One Day 4

Posted by cayhorstmann on May 11, 2007 at 10:32 PM PDT

This is my last day as the intrepid reporter at Java One. The press
room, which had become my home away from home, was closed. Instead of
snarfing up the baked goods and looking for the secret stash of booze, I
chatted with lots of interesting folks in the halls of Moscone, attended a
couple of sessions, and pondered what it all meant.

The Toy Show

??? style="float: left; margin-right: 1em" />The morning keynote was the
traditional toy show, presented by James Gosling, with a show-and-tell of
nifty Java software and even niftier hardware that is driven by Java,
spanning the range from a meat scale with a Swing UI to an unmanned
helicopter that takes spectacular terrain images. You can watch it href="">here.

By the way, Sun is generously making the audio/video available at no
charge to anyone. The general sessions are on the web now, and the
technical presentations, including voice over, will be available in a
couple of weeks. If you need access to the slides immediately, run

wget -r --user=Developer --password=JavaOne07 ''

on Ubuntu. (Elliotte Harold
said it's --http-user and --http-password on Mac OS X.
If you don't have either of these fine operating systems, use href="">Cygwin.) Thanks to Neal Gafter for
pointing out that my Groovy script can simply be replaced by the
-r flag. (They say they'll turn the slide access off tonight, so
either get it now or wait two weeks).

The Web Framework Shootout

I went to the session that promised a three-way comparison of Rails,
Grails, and JSF+JPA with NetBeans. I had high hopes for this session when
we picked it. (I was on the selection committee—the first time that
Sun had outside people participate in the selection process.)
Unfortunately, I was not all that impressed with the actual presentation.
We all know that Rails and Grails produce a basic CRUD application, and
NetBeans can do the same thing. After all, how hard can it be to query the
database for tables and make a bunch of CRUD screens? And, more to the
point, so what? My users don't want an app that can update a
database table. Can I easily transmute that CRUD application into the
application that I really want, with login, a menu to the side, navigation
trails, etc. etc.? The presenter didn't address that issue at all.
Instead, he gave some performance data for the CRUD application.

Afterwards, I had a long discussion with href="">Pavel Buzek of NetBeans about the
pain points of using JSF. Here is my list:

  • Not enough decent components. (Pavel says that NetBeans 6 has the href="">Creator components, but
    I didn't see them in milestone 9.)
  • Touching too many files for mundane tasks such as navigation. (Pavel
    says that NetBeans 6 has the Creator navigation editor. That will help.
    Stupid me—I forgot to ask about message bundles.)
  • Unintuitive listeners for buttons and links in data tables. (That's
    the fault of JSF, not NetBeans, but maybe some tooling might paper it
  • No standard for templating or theming (shame on JSF—this works
    beautifully on ASP.NET). Soapbox: I remember when I first learned
    about JSF at a Java One way, way back when. href="">Amy Fowler presented the
    concept, and I asked whether we would get a tastefully designed widget
    set like in Swing. She said “of course”. But then href="">Craig McClanahan took over as
    spec lead, and the focus changed. JSF still has the potential of
    becoming “Swing for the Web”, but there would need to be
    some serious attention to look/feel, not just framework.
  • And of course, the href="">Stack
    Trace from Hell

Still, I see a lot of value in the components. I just can't get myself
excited about loops that generate tr and td tags, which
seems to be the level of sophistication that I get in Rails, Grails, or

Pavel pointed out that Rails developers swear by the incremental coding
cycle. They bring up a basic app, add a feature, test it immediately, add
another feature, test it, all without ever restarting the server. I was
dubious—after all, how long can it take to restart the server? But
then it hit me. It isn't the startup time of the server. It is the
mouse clicks that it takes to get back to the point of testing. Log in,
visit a bunch of screens until you get back to the screen that you are
working on. Ok, I do hate doing that over and over. I am not quite sure
what it means to incrementally change an app that has stuff stored in a
working session, but maybe it'll work out ok in most cases. I noticed that
I can actually change an app while I debug it, but I never tried that
either because I didn't want to think too hard what that meant. I'll have
to reconsider.

We talked about Creator and why programmers didn't embrace it in large
numbers. I felt trapped into a particular coding style that makes it
really hard to move your app into another environment. It isn't a bad
style, but it is idiosyncratic. Maybe if there was a JSF standard somewhat
like the emerging href="">JSR
296 for Swing, I'd buy into it. At any rate, it looks like the good
parts of Creator are making their way into NetBeans.

Finally, I felt this was my chance to kvetch about my single biggest
peeve with NetBeans: No workspaces. I have a dozen different Eclipse
workspaces (for books, open source, college courses, etc.). Each has a
separate set of coding conventions and libraries. Some of them contain a
single project, others contain hundreds. (The Core Java and Core JSF
workspaces have a project for every sample program.) Of course, a
corporate developer doesn't care so much, but consultants, book writers,
professors, etc. surely do, and they are in a position to convince lots of
folks to give NetBeans a try. If you want workspaces in NetBeans, add a
comment to this blog, and I'll make sure to let them know :-)


Martin Odersky gave a very nice introduction into href="">Scala. I was sorry to see how poorly
it was attended. Here is a language with a fresh perspective on so many
things that are an issue with Java: Good generics, closures, modules for
programming in the large, domain specific languages. Check it out and be
amazed at the work of true professionals in language design. When Gosling
designed Java, I felt that we got the best thinking on practical language
design at the time (ok, except for synchronized and labeled
breaks—perfection eludes even the href="">demigods).
Scala brings back that feeling, and it makes other languages that should
not be named (such as Groovy) look rather amateurish.

BTW, Martin referenced Guy Steele's classic (1998) talk href="Guy Steele talk Growing a Language OOPSLA 98">Growing a
Language. If you have never read it, check it out—it is great
fun, unlike some of the other links that I suggested solely to appear

On the way out, I ran into Brian Goetz, Josh Bloch, and Neal Gafter;
these are people who are much smarter than me, and they are paying
attention to Scala.

We had an animated discussion about closures, annotations, and
properties in the hallway. Something is likely to happen with all of these
in some future version of Java, but it looks as if that might be Java 8
rather than Java 7. I think that's ok. It is better to get some
experimental results and not rush into changes that one later regrets.
Neal thinks that it is possible to fix up the biggest issues with Java
generics by supporting reification. That would be a relief. He went on to
give his closures presentation which I had href="">already
seen at SJSU, so I went home for a much needed nap.

What does it all mean?

Here is my take on the 12th Java One. It wasn't the most exciting Java
One ever. The very first Java One was stunning. It was also a bit creepy.
The show was run in parallel with the venerable Software Development
conference. The SD exhibit hall was the usual freewheeling bunch of
booths, but all Java One booths had the same yellow/red/blue color scheme,
just like you'd imagine a trade show in North Korea.

The shows that introduced Java 2/EJB and Java 5/EJB 3 were very
exciting because there were such big platform changes. The shows that
focused on Java ME were particularly unremarkable—this may be my
parochial US perspective where the telco oligopolies won't let you deliver
your apps.

This show was somewhere in between. Four things impressed me:

1. The sleeper announcement was the completion of the open sourcing of
Java. This is a hugely important event that we will all appreciate when,
twenty years hence, we will still be laboring on in Java when other
proprietary systems have come and gone.

2. Tooling has come of age. It takes the NetBeans and Eclipse folks
months, not years, to bring us plugins for Ruby, Swing UI frameworks, etc.
etc. We yawn when we see another NetBeans demo. There was a time when we
all longingly looked at Microsoft's Visual Studio, but those days are

3. We have not reached the end of history with language design. Having
lots of scripting languages is not the answer.

??? style="float: left; margin-right: 1em" />4. The most important event in my
mind was Sun's renewed commitment to the desktop. Look at David Bock's href="">interview
with Bob Brewin. It is now apparent to the top brass at Sun that there
are serious issues, both with a dated look and feel and with internet
delivery. Java FX Script is a great step forward for look and feel, but
there remains an awful lot of mundane engineering work to get rid of
freezing browsers, incomprehensible certificates, and the dreaded spinning
coffee cup. I truly hope that Sun will follow through and fix these
problems the old fashioned way, with href="">blood,
toil, tears, and sweat.

Finally, I learned that reporting is hard. It is taking me a long time
to write these blogs. The folks who write real newspaper articles every
day, with all facts checked, on deadline, deserve great respect. I am glad
to relinquish my title of intrepid reporter until the next Java One and go
back to coding, teaching, book writing, and feeding the twins. Thanks Chi for feeding both of them while I got to enjoy Java One!