I attended NetBeans Day yesterday, which started with a presentation on Looking Glass. Of course, Looking Glass has nothing to do with NetBeans and it was merely a way for Sun to showcase their technology, even though Hideya did mention NetBeans for twenty seconds at the beginning of his presentation (“we use NetBeans for development”).

Looking Glass looks as good now as it did one year ago, and just as useless. I thought by now we had established that 3D desktops are very hard to use on a 2D screen, but it’s a lesson Sun just doesn’t seem to want to learn. What really worries me is that I didn’t even see anything new compared to last year, but the most troubling part was that even the demo person was sometimes confused during the show, picking the wrong titlebar or looking for his own windows.

Don’t get me wrong: Looking Glass is a good technology and I hope Sun keeps working on it, but please don’t try to sell it as the Next Big Thing in desktops and usability, because it’s neither of these.

Rick Ross was next, and after his usual diatribe on how big JavaLobby (the name, not just the Web site) is, he proceeded on giving his usual presentation on communities and how important IDE’s are.

Next came Jonathan Schwartz, unshaved and unprepared, but winging it with ease. I am a bit tired of his propaganda spiel but I have to give him credit: he always looks and sounds good on stage, so it’s always entertaining to listen to him as long as you can wade through the Sun party line hammering.

And finally, the NetBeans demo started.

The first twenty minutes were spent demonstrating the editor, with features such as “turning all words to uppercase and back to lower case with just three keys” and “extracting a method” or “splitting an editor”. The entire demo was just a painful rehash of every single feature that every IDE (or even text editors) on the planet already has.

If you are trying to win over an entire crowd devoted to Eclipse and IDEA (which was pretty much the case based on the various questions and conversations around me as the NetBeans demo was unfolding), you need to do better than “we do the same as the competition”. You need to show what you do different and what you do better. And of course, emphasize what you do that nobody else does (more on this below).

You also need to show how using the IDE on a daily basis feels: how do you navigate through your sources? Through your projects? How do you locate a class? How fast do you solve compilation errors? How the windows and the GUI fits together, etc…

The staging of the demo was also horrible: one person was manipulating and another one was talking. “So now we are going to talk about… [look at the big screen] … [look at coworker, exchange a few hushed words] ah right! Code completion!”. Do you really need to have two people on stage telling each other what to do? And I’ll gloss over the fact that the speaker started the demo by asking how many people read his blog… Seriously. You can’t find a better way to embarrass yourself in public (and a hint to the speaker: check your logs).

Throughout the demo, the presenter was asked quite a few questions by the audience, and most of the time, he would just dismiss them and say “I don’t know, I’m just the presenter, I didn’t develop this thing”. Well, if you can’t answer the questions, you shouldn’t be on stage in the first place and you are guaranteed that it’s a frustrated crowed that will walk out of your presentation, not a wowed one.

Next came a profiler demo (a lot of graphics but no real demonstration of solving a hard problem, and not much that I haven’t seen in OptimizeIt or JProfiler). Followed by… a JXTA demo. Yes, seriously. JXTA. Now there’s a differentiating factor, alright. You can be sure that nobody besides Sun will ever show this.

But the real reason why I was there was for Matisse.

I have worked with GUI builders since the early 90’s (yes, you read that right, circa 1990) and by now, I have a pretty good idea on what makes a good builder.

The demo was unfortunately very mundane: creation of a search dialog in a few clicks and drag and drops. The automatic line up and visual cues are nice, but the demo failed to address the real hard questions, which are:

  • What does the generated code look like?. The audience asked several times for this and eventually, the demo person relented. The code looks pretty big but doesn’t seem too bad.
  • How tweakable is it? Not surprisingly, the code has big warning comments saying “you shouldn’t modify this or that portion”. There is a very elegant way to generate code and still make it easy for users to add their own logic that won’t be erased by reverse engineering: ask user to instantiate subclasses of the code you generate.
  • What is the layout manager? Can it be changed? It’s called NaturalLayoutManager. It’s not part of Swing, it’s a brand new one, and they are talking to the Swing team to have it part of the JDK, which should happen in late 2006.
  • Can you reuse your GUI’s ? This is by far the most ignored feature in GUI builders of all times, and the reason why they are so little used in general. Here is the deal: creating a nice GUI is just the beginning. Very often, I create windows with abstract methods and even abstract widgets in them. Then I want to be able to subclass them and alter them slightly (“I want the exact same UI but with a checkbox instead of a text field here”). Sometimes, I also want to build part of my GUI dynamically, and I can’t do that in the builder because I don’t know yet what widgets will be in this area. No builder has ever understood this problem and as a result, I have always ended up writing all my UI’s by hand. You just can’t take OO practices away from developers, they will hate you for that.
  • How does code binding and reverse engineering work? No idea on how Matisse works there, there was no demo on callbacks or code insertion.

There are also very important features that still don’t seem to be implemented yet: JUnit plug-in, Subvsersion support and, more importantly, global search. This is a feature I couldn’t do without, and I’m not just talking about text searches through a project, but also Java searches (“all places where this method is overridden”, etc…).

Now I have to say there is at least one thing that I liked in this entire presentation: the collaboration plug-in. With this, you can have one of your coworkers see what you are seeing and even take over your editing or compiling. This is very neat and I hope that Eclipse and IntelliJ will follow suit and implement it as well.

But for all the rest, the demo was a very poor illustration of all the hard work the NetBeans team has been putting into their product this past year. They deserve much better.