Tim Boudreau's Blog

Community: NetBeans Archives

Manila; Moderation done right; Breadcrumbs for NetBeans

My friend Geertjan and I just did NetBeans Day Manila, in the Philippines, followed by two days of plugin-writing training at the University of the Philippines. The students were wonderful and bright and motivated and it's always a joy to teach to people who are really interested in what you have to say.

There's a conversation going on on the mailing list for bloggers on this site - there's been a big issue with people posting comments that consist of 500 porn URLs and such. Back when we were little-bitty NetBeans-the-tiny-Czech-startup we had this solved on our mailing lists - 100% spam-free - a lot better than I can say for how things were after we joined Sun. The system was incredibly simple. My friend, and later, roommate for two years Karel Zatloukal, came up with this brilliant and blindingly obvious system - his becoming a manager was a huge loss to hackers everywhere. It's dead-simple:

• Any incoming message is delayed for 30 minutes
• There is a "hot-list" who get messages un-delayed
• Any "hot-list" member can bounce a message they deem to be spam

This seems like such an obvious solution. There are legitimate objections to this approach for mailing lists, although it worked well for us - the immediacy of conversation is reduced, because any incoming message will reach its recipients only a half-hour after it was sent. But for blog comments? It seems pretty ideal.

Anyway, I wanted to share that approach so that it would not be lost to history. It worked really, really well, and I highly recommend it. In our case it was a copy of majordomo hacked within an inch of its life, but the model is simple and easily repeated on any similar system. I feel like most moderation systems for mailing lists and blog posts are still stuck in the stone-age, and I've experienced vastly better almost ten years ago.

Lastly, at the booth in Manila last week, someone commented to me about a new "breadcrumb" feature in IDEA or Eclipse that they wished NetBeans had. I thought, gee, that would take about 20 minutes to implement, and set about doing it. Well, 20 minutes to get the rough draft. Another few hours to really make it useful. Geertjan already blogged about it (do a text search for "breadcrumb"). It's now available for NetBeans 6.0 and 6.1 on the plugin portal at this URL and should be available in the 6.0 and 6.1 built-in plugin managers soon.

Egads! An actual Swing Tree-Table!

When I canvassed folks who had done Swing tree-tables on our mailing lists, most of them were based on that article, as ours was. What I heard back varied between groans of pain and mad rabid howls of pain. There are a few things in that original tree table design that just don't work - not reliably, anyway. Sending events to an offscreen component as if it were on-screen and expecting it to behave sanely is just a really bad idea that happens to work if the look and feel is a subclass of BasicLookAndFeel, and other look and feel implementations have been tormented into supporting this abuse by all the evil Tree-Table implementations in the wild. But the bottom line is, a look-and-feel author would have to be slightly insane to code their TreeUI to behave as if it were a live component when it has no parent and obviously is not one. In other words, the fact that the JTree-as-cell-renderer design works at all is just an accident of how BasicLookAndFeel's TreeUI implementation was designed, which other look and feels inherited. Never mind trying to use said JTree as a cell renderer in a table (I once made a 400% performance improvement in our tired, tortured, hacked-up TreeTable just by having it translate the graphics context instead of repositioning - and thus causing a re-layout) is seriously abusing the component. Now try convincing said offscreen JTree that it has keyboard focus in order to get it to paint appropriately in its role as a cell renderer for another component. On all look and feels. On all platforms. Everywhere.

You see what I mean.

After doing that canvassing back in '04, it was obvious that Swing needed a real tree-table component. So I started to write one (and the layout cache classes JTree uses were very, very helpful - thanks, Scott!).

I started on it, got the basics working, and then moved back to the U.S., changed jobs and ended up travelling the world full-time teaching other people to write NetBeans modules - but it didn't leave time to finish up the Tree Table work. Thankfully, my former office-mate, David Strupl, picked up where I left off when he left Sun to work on Nokia's NetBeans RCP app for managing cellular telephone networks.

The really, really great news is: This week, Standa Aubrecht - who took over a bunch of the stuff when I left full-time development of NetBeans in '04 and amazed me with how quickly he was able to get going in a complex codebase - committed it into the main line of NetBeans sources yesterday. So anybody who gets a dev build of NetBeans as of today has a perfectly working Swing Tree Table component they can use (the class name is Outline - I borrowed the name from Apple's Cocoa library - it's a little less clunky than "tree table" but gets the point across). The JAR file is org.netbeans.swing.outline.jar. Usage is incredibly easy - you just provide a standard Swing TreeModel of whatever sort you like, and an additional RowModel that can be queried for the other columns contents, editability and so forth. And you never have to worry about cells painted half one color and half another because the tree-cell part got repainted after focus went to a popup menu. It actually works!

The real credit here goes to David and Standa for getting this thing production-worthy - I just was pissed-off enough at having a gargantuan list of unfixable bugs (well, fix it on one platform, break it on another, or leave it unfixed everywhere, or semi-fixed some places - pure evil if you hold the illusion that what we do is computer science) four years ago to get the ball rolling. They're the guys who delivered it.

I'm incredibly happy to see this finally be real and available not just to people writing NetBeans modules, but anybody doing GUI apps in Java. There has been a need for a real, reliable tree table component for Swing programmers for a long, long, long time. All hail David and Standa!

What technology evangelists really do for a living

BTW, the video editing and post-production was done by my good friend and music buddy Doug Finn (douglas dot finn at gmail). He is a supremely talented video editor, actor, director and musician. If you're looking for something like this, I highly recommend him.

A couple of other videos from this trip (less slickly edited, since it was me doing them not Doug) are visible at the bottom of this page on netbeans.tv.

The person I really feel for in the above video is Juan Daniel Perez, whose reward for helping organize our event in Cordoba was that five guys piled into his hotel room at 6:30 in the morning to use his shower :-)

See Java code the way javac sees it

Last spring I set about learning javac's Tree API (JSR 199) - NetBeans uses it internally as its parser for Java source code. It has a bit of a learning curve, and contains lots of this-tree and that-tree interfaces for different types of structures in Java source code. So to help me develop an intuitive understanding of what all of these classes map to, I wrote a tool - a standalone Swing app that lets you open a Java source file and then browse its AST.

I found it very useful, and still use it to figure out just how to hunt down a particular thing I want to find in source code. Hopefully it will inspire some others to play with javac as well. It requires JDK 6. You can download the JAR file here and just run it with java -jar.

The source code is available in NetBeans CVS under contrib/SyntaxTreeNavigator (everything was reorganized for the recent migration to Mercurial, and I haven't figured out where it is in the new source structure yet).Update (3/31/08): I've set up a java.net project for the source code, syntaxtreebrowser.dev.java.net. It is pending approval but it should be publicly visible in a few days.

Caveats: (updated 2/29/07)

1. To use the application, you will need javac on your classpath. If you are running Apple's JDK 1.6 it already is. For other platforms you may need to run with -Xbootclasspath/p:/PATH/TO/javac.jar (may be in tools.jar).
2. This application uses the com.sun.source.tree API from javac. If you are not running Sun's javac, this package will probably not be there.

I have updated the JAR file to produce better diagnostic information, and added a source zip file.

What if we built Java code with...Java?

So he created the Gosling project. It's pretty embryonic - and I think some of the file and resource classes could be replaced by straight usage of things like javax.tools.FileObject, but it has a nice simplicity. Here's the constructor for Gosling's own build to build itself. It has a similar feel to what Jon did in designing Wicket's APIs:

    public GoslingProject() {
        final Folder root = new Folder("/Projects/gosling/workspace/gosling");
        final Folder source = root.folder("src");
        final Folder lib = root.folder("lib");
        final Folder target = root.folder("target");
        add(new JavaApplicationBuilder() {
            @Override
            protected Set getDependencies() {
                final ResourceDescriptorSet dependencies = new ResourceDescriptorSet();
                dependencies.add(Apache.apache.wicket.core.development.resources());
                dependencies.add(Apache.apache.wicket.extensions.development.resources());
                return dependencies;
            }

            @Override
            protected Set getJars() {
                return lib.nestedJars();
            }

            @Override
            protected Folder getSourceFolder() {
                return source;
            }

            @Override
            protected Folder getTargetFolder() {
                return target;
            }
        });
}

I mean, the appeal of things like Ant is that many things are built in a pretty similar way; Maven is even more "my way or the highway" in that regard. I use (and sometimes like) both of them. And in theory an Ant XML script (xml script - now there's an oxymoron) is human readable - although I challenge anyone to make heads or tails of this in ten minutes. It certainly beats Make and tab vs. space madness. There's an argument that it's toolable - that a tool can analyze an Ant script. This seems to me to be a red-herring if you do a design like Wicket or Gosling use - where you know that the entire state you need to analyze is going to be set up in the constructor of a known class of a known type. The Javac Tree API may not be for the faint of heart, but analyzing the closure of a constructor is perfectly doable.

My point is that Ant doesn't really deliver the clarity it promised except in the most trivial of cases. You could have at least as much clarity with plain-old Java code - you just need to start from a good design so the code can speak for itself. And a design where all targets will be added to the build in the constructor is pretty darned clear. Isn't one of the things the agile crowd talks about a lot letting code speak for itself?

Not to mention that running javac in-process ought to be blazingly fast. And that such a project could import and call existing Ant tasks to do things with a thin adapter layer - so anybody's custom tasks or missing functionality could be handled leveraging stuff that's already out there.

It seems like a pretty nice idea to me.

NetBeans Editor Demo video

To the person who posted it - if you can send me a .wav file of the audio, I'd be happy to clean out the ambient noise and make the soundtrack much easier to understand - I was a sound engineer in a former life...

The NetBeans South American Tour Wraps Up

On Saturday, after our five hours of NetBeans talks, I was scheduled to do a talk at Natal Java Day, at 9:40AM. I awoke to blazing sunlight coming through the window of my hotel room. My mental clock that judges such things told me it looked like 9 or 10AM. Oh, crap, I thought - I slept through my talk! So I power up the laptop. It says it is 5:45AM. So I call the reception desk. Yes, it really is 5:45AM. Natal is in the tropics - quite close to the equator. Sunrise happens very fast, and it is full light very early.

We spent Sunday cruising around the dunes of Natal in a dune buggy, with a driver who offered us the options of a tour with emotion, or a tour without emotion. We realized what with emotion means the first time we went down a near-vertical grade. There were various stops to zip down ropes at high speed into a lake and other such madness. Actually, I'd recommend this sort of tour (maybe with slightly less emotion when it comes to the driving) to anyone with kids - it's very kid-friendly.

I'm taking some vacation now, which has given me time to work on one of my Friday-afternoon-projects, a persistence framework for Wicket that makes writing database-aware applications really trivial. I'll be contributing it to Wicket Stuff sometime in the next week or two - so a blog containing some actual Java code is coming, I promise :-)

Meanwhile, some photos from our travels...

Cows on the beach - who knew?

A fisherman in Natal, Brazil

Street vendor in Natal, Brazil

Can you find the computer programmers in this picture?

Florianopolis, Brazil - one of my favorite places on earth!

The NetBeans Latin American Tour - Starting Week Three

In Buenos Aires, 90% of the airline pilots were grounded for not having had sufficient vacation to comply with safety regulations. So our flight to Cordoba was cancelled.

The next option was to take an overnight bus. So we went to do a little tourism shopping in the afternoon before the bus, and got back to pick up at our bags at the hotel and go the short distance to the bus station for our 6:30pm bus at 6pm (we had already bought tickets).

Well, the thing we didn't know is that it is impossible to get a taxi in Buenos Aires in less than 20 minutes at 6pm on a work-day. So we end up hauling bags and boxes of cd's and backpacks several blocks, trying to find a more major street to get a cab - and I end up begging a busboy at a Sheraton hotel to help us get a taxi ahora to the airport, in extremely broken and forgotten Spanish.

(Spanish is a challenge - after three years of Russian and five and a half years speaking Czech daily, actually constructing a sentence is nearly impossible - in Fortaleza, a security guard questioned what I was doing there, and I replied "Yo soy [spanish] paletrante [portuguese] na treti patro [czech]").

So we pile into a taxi at the Sheraton, but we need more than one taxi. And there is no other taxi. So Bruno and I go ahead to the bus station, leaving Mauricio and Tim Jacobson to find another taxi while we try to stall the bus. We succeed in delaying the bus, though it did not make us popular with the driver, and finally the guys arrive and off we go.

We get into Cordoba at about 5AM. So we get our vast pile of boxes and bags and head for the taxi stand, and get in two taxis. The driver tells us the address of our hotel does not exist and he's never heard of it. So we start driving to try to find some hotel, and Alvaro goes into the first one we find and asks them where our real hotel is. They tell us it is in another town 50km away. So we drive around Cordoba with two taxi drivers, trying to find a hotel we can actually get a room at at 6 in the morning. Eventually we make a phone call, and it's suggested we call a guy from the local users group who is helping us. So at 6:30AM all five of us pile into his hotel room, shower, eat breakfast...and then it's off to the university for the first five hours of talks of the day. We had a very good crowd for the morning in Cordoba, very knowledgable about Java, so I skipped my intro to Java talk and went straight to NetBeans. There were some oohs and aahs when demoing code templates and instant rename, and the audience was really attentive. It's always fun to do a talk with people who are really into what you're talking about. Cordoba is a beautiful city, and it is spring here, so the trees are in bloom. One of the professors from the university we talked at took us on a tour of the city the day after, which is where most of the photos in this blog came from. It's definitely a city I would love to visit with more than 48 hours to get to know it - there's a lot here!

Hallway in the oldest university in the Americas

I've got a bunch of ideas for NetBeans module projects percolating, that I've been thinking about on this trip. As usual, the question is what to prioritize (like I don't have enough projects!). What do you think:

• Support for developing things to extends Project Wonderland
• Something to make it easy for students to submit a project for a class just by right clicking a NetBeans project, with an SPI for plugging in whatever talks to the backend, so people can do what they want

Wall of a cathedral in Cordoba, Argentina

Jack - one of Bruno's wonderful puppets, who loves OpenSolaris

Now this is art!

Not quite what it is advertised as...

But definitely an unusual sensation, as Bruno discovered

The NetBeans South America Tour, week 1.5

The turnout has been excellent in all of the cities we have visited, and we are having a lot of fun meeting local Java developers and users groups. Some of the highlights:

• Playing soccer with the Montevideo JUG members - put a bunch of Brazilians, Argintines and Uruguayans at a table for lunch together, and the topic will inevitably turn to soccer. This ended in the Uruguayans challenging the rest of us to a game of soccer that night - so we all rented a soccer court on the beach, and well, two days later walking down stairs is still a bit painful.
• Three big guys in the world's smallest taxi - Taxis in Montevideo are divided by a wall and very thick glass, and that wall is very close to the back seat. Put me, Bruno Souza and Mauricio Leal in the back of one, along with bags and laptops, and, well, it's a fun ride (photo below).
• Chinchulin - as my friend Fernanda delicately put it, it is a cow's intestine, with its natural contents grilled. You can see it in the photo with all the meat below (the puffy looking things are cow lymph glands). What does not kill you makes you strong...
• Muqueca de Camarao - an incredibly delicious dish made with dende oil, which you can only get in the area around the city of Salvador in Brazil (photo below)
• NetBeans wire-art - we paid a jewelery-maker in a street market to bend the word NetBeans into a piece of wire (photo below)
• Sumo Wrestling Robots - I missed this personally, but next to our Solaris talk the other night in Montevideo was a room full of robots programmed by students to sumo-wrestle. That's tough competition for an operating system talk, no matter how good.

Our makeshift translation rig is working out quite well - the announcements mention than anyone who wants simultaneous translation should bring a walkman or other FM radio. We have a small FM transmitter, and a microphone preamplified through a laptop. It really works. Bruno and Mauricio are the true heros, as they both do their own talks and also translate for us gringos. That adds up to about 10 hours of talking a day!

We are currently in Buenos Aires, Argentina, where we did a talk at a university this morning, and the Solaris talks are happening now - I skipped out to an Italian restaurant where I could catch up on email and write this. Tomorrow on to Cordoba, and then Santiago, Chile. At this point we're really hitting our stride, with the talks and the timing of them tuned pretty well. If anyone wants to hone their speaking abilities and put a fine shine on a presentation, I highly recommend doing it every day for weeks on end on 2-4 hours sleep. I'm really not complaining - this is a great trip!

So we are flying to Cordoba tomorrow, and we have just learned that 90% of the pilots for the Argentine airline are on forced vacation as of today, for working too many hours above safety regulations. So most flights are cancelled, and we need to be doing a talk there at 8AM day after tomorrow. And that is the airline we are flying tomorrow. So tomorrow will be an interesting day - we are considering renting a car and doing an eight hour road trip across Argentina, or going by bus, or finding another airline (which surely everyone else is also trying to do). More will be revealed...

NetBeans: The Flan

Lunch in Montevideo (the fluffy looking things are cow lymph nodes)

I need more coffee if you want me to talk for five hours

Mauricio, Bruno and 1/10 of me, in the world's smallest taxi

Moqueca de Camaraoes - quite possibly the best food on earth

Trash collection in Montevideo

NetBeans Goes to South America!

I drove the NetBeans Mobile to its destination last week, arrived in Massachusetts on Thursday; unloaded it all day Friday, and flew to Brazil on Saturday. A steady diet of vast quantities of barbecue (the death-by-meat approach to dining), tiny cups of super-sweet coffee and Guaraná soda is keeping me vertical.

We began yesterday in São José do Rio Preto, with a crowd of 102 for five hours covering an intro to Java, Open Source and NetBeans. It's fun doing an intro-to-Java talk - a nice change from what I'm usually doing, and some of the students have some programming experience but not necessarily Java. So I get to go into the history of programming, languages, computer science, how programming languages have evolved, what Objects are, why there is equals() and hashCode(). Believe it or not, it's a fun topic.

Waiting at the airport I think I hit on a useful metaphor if you want to explain what multi-threading in programming is, to someone new to it: You get off an airplane. You are one thread of execution. The folks taking your bag off the plane and loading it on the conveyer belt are another thread of execution. Ideally they get done at the same time, and you walk up and your bag is there. Sometimes no; so the threading constructs in Java allow you to handle those cases.

I like teaching through metaphor - my grandfather had my wiring up circuits when I was four years old, and he used metaphor heavily: think of the electricity in the wire as water running through a pipe - current and voltage mapping to water pressure and how much water comes out - and a four year old can understand it (with a demonstration or two at the kitchen sink if needed). It's necessarily imprecise, but it gives people a handle to grab onto. So when I'm teaching or presenting, I really just try to channel my grandfather and ask myself how he would have explained things.

As I write this, we are getting ready to land in São Paulo, to connect and fly to Brasilia. The sheer expanse of São Paulo is astounding - I'm looking at tall buildings like twigs stretching out to the horizon. Alas in my high-speed moving and unpacking chaos, I forgot to pack my good camera - so I'll either borrow one, or go luddite and try to find a good used SLR.

We'll spend the afternoon doing the NetBeans road-show there, and then it's on to Fortaleza this evening. And I hope to learn a little Portuguese this time around - with a month in Brazil there is no excuse not to. My seven years of Spanish, 19 years neglected and buried under Russian and Czech ought to help a little if I can dredge it up!

Our schedule for the trip:

• October 29: São José do Rio Preto, Brazil
• October 30: Brasilia, Brazil
• October 31: Fortaleza, Brazil
• November 1: Salvador, Brazil
• November 5: Montevideo, Uruguay
• November 7: Buenos Aires, Argentina
• November 9: Cordoba, Argentina
• November 12: Santiago, Chile
• November 14: Florianopolis, Brazil
• November 16: Natal, Brazil
• November 19: Porto Alegre, Brazil

The view from the restaurant in Congonhas airport - doesn't really show the scale of the city, but can give an idea of what the buildings look like

The Return of the NetBeansMobile

I owe a huge thanks to the folks at Jantz Auto in Kenosha, Wisconsin who put a new engine in it over the last month - and were kind enough to notice that the clutch was shot and that they had new-old parts for it, and so threw in a new clutch at no charge. She's running like a champ!

Unfortunately I likely won't be able to do any stops along the way for this part of the trip - I need to make good time, get back to Massachusetts, drop the truck off (probably without time to unload it) and get on a plane for Brazil for a university tour we're doing there. But I haven't forgotten the folks from the Ann Arbor and Albany JUGs - Albany is easy, since I'll be living in Northampton, MA; and we'll figure something out for a visit to Ann Arbor down the road too.

It's sunny and warm and a perfect day for driving, so, back to the road!

The NetBeansMobile goes on Hiatus

The NetBeans Mobile is half way across the U.S.

I bought some Gatorade and nuts at the truck stop yesterday (the dinner of champions!). Two guys wearing turbans entered the store at about the time I brought my items to the counter. The woman selling me the things said, "You know it still scares me when I see people who look like that. And I'm not a racist person". I said "Well, I suppose we have the news to blame for that". I mean, what do you say? There are no racist people. There are people who have learned to fear something. That can happen through first-hand experience, or through the media, or through any variety of indoctrination. But the bottom line is, I can meet the person whose grandfather killed my grandfather, and I will never know that fact unless somebody told me it - and if they told me it, it was probably them looking out for their personal gain via what I might do because I knew that "fact". There are no age-old conflicts. There are no "These people have been fighting for 6000 years, it's unstoppable" conflicts. That's a lie. All of that is just manipulation - people turning easily available knobs on other people. This is basic: There are no 6000 year conflicts because there is nobody who has been alive for 6000 years. Period. These conflicts need to be refreshed and renewed with each generation, and the appalling thing is that there are people who have no reservations about doing that. Slobodan Milosevich exploded the Balkans into a war with the phrase "No one will beat you again." As a species, as a whole, we need to get more media-savvy fast. This stuff is not going to slow down.

Human beings are a product of biology. We are vulnerable. The environment we were built for is not the one we are in. The essence of evil is exploiting those vulnerabilities for gain without regard for the multitude of consequences.

Anyway, this is a longer and less focused blog than I'd planned writing. The NetBeans Mobile is doing well, and I'm looking forward to meeting the Java Users Group in Madison, Wisconsin on Tuesday, and the folks in Milwaukee on Wednesday.

And I'm a little creeped out by people thinking I must be a skinhead. I'm just going bald in a big way and every other alternative I've seen looked pretty embarrassing.
-Tim

The NetBeansMobile update

Meanwhile, the NetBeansMobile is inspiring commentary:

• Dion compares my little labor of love with Adobe's tour bus
• Roman points out that this is apples and oranges
• David points out that what we need is a NetBeans aircraft. He suggests an Airbus, but since Boeing is building on the NetBeans Platform, we know where our loyalties lie

I've set up a twitter account for updates from the road - their wap interface plays very nicely with my phone.

Rick Ross and his gang over at DZone have graciously offered to spring for pizza for JUGs I visit. Thanks Rick!

The NetBeansMobile - coming to a city near you?

I'll also have a video camera along, if I can cajole anyone into being interviewed - hopefully we'll end up with some content for netbeans.tv, which is looking quite slick. How did this weirdness come to be? Well, I never planned to live in California forever, and I'm originally from Western Massachusetts. So with a let-up in the travel schedule for work, now was the time. So I bought this giant 1984 GMC truck for $1000, and spent the last two weeks fixing it up (I will never sand and paint a big truck by hand again!). I told my colleagues about it, and David Botterill suggested that I should put NetBeans signs on it, load it up with a GPS. And the rest was history, or is becoming history...

Getting all of this stuff to work together has been interesting. I'm using my tired old PowerBook to run everything (having just sent off my MacBook for a new screen - don't swat flies on your keyboard with a baseball cap. Bad things can happen.). So what all it does is:

• A Garmin G18 gps (basically a wart with a USB cable - no built in UI, it just talks to the computer) is used to record tracking data
• gpsbabel talks to it and writes the data out to a GoogleMaps compatible .kml file.
• A little Logitech webcam takes pictures
• isightcapture is the command-line utility that takes the pictures
• The computer is online via the internet connection from my BlackBerry Pearl phone
. Actually this part is currently the weak link, as getting the laptop online again via bluetooth after it has disconnected once is still eluding me
• Every so many pictures, it will rsync the photos and kml file up to the server
• On the server, a one-page wicket app is running, which periodically notices if new files have appeared, and serves them in what will hopefully be a usable ui

Places I could use some help
If anybody out there has experience with gpsbabel, I'd love to find a way to get it to spit out a single kml file and exit - I've only gotten this working in tracking mode, where it polls once every second and generates files too big for GoogleMaps (but not for GoogleEarth). Any pointers appreciated.

There seem to be a number of hacks, commercial products, etc. out there for hooking up a BlackBerry to a mac. Bluetooth is preferable, as if it's via USB, well, that's probably more reliable, but then I can't use it as a phone :-(

I'll post more info and pics when the graphics are on it tomorrow. As I said, if I'm going to be passing near you, let me know - just post something right here. Maybe we can set up a NetBeans demo or you can do something fun on camera or we can just have lunch.

Generate a NetBeans module for your library or JavaBeans in one Ant task

This afternoon I got an email from Mikael Grev about the tool, and asking if there was an Ant task. I'd planned to do one but hadn't gotten around to it. This afternoon I finally did.

It can still benefit from some prettification, but it's ready to try. You can download it here.

Easy way to use it: The first time, just run the GUI using java -jar beans2nbm.jar and point it at the files for the library you'd like to bundle into a NetBeans module. At the end of the wizard, on the summary page, it will show all the necessary Ant code to replicate what it just did (and include the text you entered in the wizard). Just tweak the paths to be relative to your build script and paste it there.

For examples, the Quick Color Chooser and Wizard projects are now set up with build scripts to use the task. Here is the ColorChooser build script.

Please try it - comments and feedback are most welcome! And many thanks to Mikael for the suggestion!

For convenience, here is a sample target:

    <target name="nbm" description="Generate a NetBeans Module" 
        depends="jar,release-javadoc">

        <taskdef classpath="lib/beans2nbm.jar" 
            classname="beans2nbm.ant.GenNbmTask" 
            name="nbm"/>
          <zip zipfile="dist/colorchooser-src.zip">
              <fileset dir="src">

                  <exclude name="**/CVS"/>
              </fileset>
          </zip>
        
        <nbm destFolder="dist" 
            destFileName="net-java-dev-colorchooser.nbm" 
            description="A color chooser" 
            version="1.1" 
            homepage="http://colorchooser.dev.java.net"

            codeName="net.java.dev.colorchooser" 
            jarFileName="dist/colorchooser.jar" 
            author="Tim Boudreau" 
            displayName="Color Chooser" 
            license="CDDL"
            docsJar="www/release/colorchooser-javadoc.zip"

            sourceJar="dist/colorchooser-src.zip"
            minJDK="1.4"/>
    </target>

Mobile Bay, Mobile, Alabama

How to replace the selection model in the NetBeans Platform

First, let's go over how NetBeans defines selection. The selection is a Lookup. That's basically a bag-o-stuff owned (by default) by whatever component has focus. So, an Action in a toolbar or menu that should be enabled is written to be sensitive to the presence or absence of some Java type in the selection lookup (the Lookup returned buy Utilities.actionsGlobalContext()). For example, a Save All action which can save one or more files (or whatever) listens on the global context for one or more SaveCookies. If there is at least one, the action is enabled, if not, it's disabled.

Let me back up a bit...a Lookup is like a Map, where the keys are Class objects and the value for any Class key is a Collection of zero or more instances of that class. A lot of lookup-like APIs use Strings for keys (think JNDI - when you realize that could have been done in a type-safe way and wasn't, it seems kind of grotesque and depressing, doesn't it? A Lookup may be a magic bag-o-stuff, but it's a type-safe magic bag-o-stuff - I want all the help the compiler can give me!); Lookup is nicer in that you have type-safety - if I call Map.get ("foo"), I have no idea what I will get back - the compiler cannot help me; if I call Lookup.lookup (MyObject.class), I know I'm getting back instances of MyObject.

By default, in NetBeans, the Lookup you get back from Utilities.actionsGlobalContext() is provided by the window system implementation. It tracks which logical window has focus, and proxies that window's Lookup. It provides a central point for listening for selection changes without the code interested in selection changes having to care that there even is a window system that is causing the changes - an object that cares about selection simply subscribes to changes in the presence or absence of some Java type in the global selection - the fact that the global selection, by default, is the Lookup that belongs to the focused logical window, and when focus moves to a different logical window, appropriate changes are fired (so if you're listening for a Customer object and the focus moves from a window that does have one to one that doesn't have one, a change is fired to tell you a Customer object disappeared from the global selection, your code doesn't have to care why that happened), is immaterial to things interested in selection. Selection is completely divorced from the UI that happens to provide it.

For some applications, that's not what you want. I discovered this when working on the Imagine project - this is an image editor. There are palettes that display attributes of the image being edited. It would be very disconcerting if the component that shows all of the individual layers that make up the currently edited image suddenly disappeared when you clicked the tool palette to select a different tool - the image you are editing hasn't changed.

I spent the last couple of days here in New Orleans working with some folks with a similar problem - they are building a CRM application on the NetBeans Platform, and the appropriate context for actions and palettes is the selected Customer - it doesn't matter which window has focus.

Fortunately, in NetBeans, if you want a different selection management model, it's easy. The Lookup that is returned by Utilities.actionsGlobalContext() is what determines the enablement of context sensitive actions. You can completely replace it by implementing org.openide.util.ContextGlobalProvider and placing your implementation of that interface in the default lookup. Here's an example.

public final class Ctx implements ContextGlobalProvider {
    private final InstanceContent content = new InstanceContent();
    private final Lookup lkp = new AbstractLookup (content);
    public Lookup getLookup() {
        return lkp;
    }
}

public void setContent (Collection c) {
    ic.set (c, null);
}

public void setCustomer (Customer customer) {
     Customer old = lkp.lookup (Customer.class);
     if (((old == null) != (customer == null)) || (customer != null && !customer.equals(old))) {
          ic.remove (old);
          if (customer != null) {
               ic.add (customer);
          }
     }
}

Then you have the question of event model; in the case of the CRM app, there are a bunch of UI pieces that display the address, etc. of a customer. Different user roles will see different attributes. There are two ways to solve this: First is the Swing-like way, where you can add property change listeners to a Customer object, and the UI that cares about it can listen for changes. But this introduces boatloads of bookkeeping, because probably Address, etc. objects all ought to have listeners, and pretty soon you are drowning in potential memory leaks and objects listening to each other. Particularly in this case, where the Customer object arrived from a web service and its object-identity is determined by its database id.

So we can simply make the model more granular - object identity remains the same, but we need to update all UI's showing an attribute of a customer when it changes. Since we control the selection model, we can simply remove the current customer and re-add it. Slightly less efficient, but one line of code and a thousand trips through a heap-dump averted - just remove old and re-add it, regardless if it equals() the incoming object or not. Unbeautiful, perhaps, but eminently practical and a world of listener-leaks is avoided.

The point here isn't so much that the above is good or bad, but that if you're writing an application on the NetBeans Platform, you can create whatever selection model makes sense for your application.

The final step is to register the custom implementation of ContextGlobalProvider in the default lookup. The default lookup is just the Java Extension Mechanism which has been around since JDK 1.3 (JDK 6's ServiceLoader, while painfully limited, does the same thing as the default lookup) - you include a flat file in your JAR in META-INF/services. That file's name is the name of the interface it is installing an instance of - in this case, its name is org.openide.util.ContextGlobalProvider. Its content looks like this:

#-org.netbeans.modules.openide.windows.GlobalActionContextImpl
net.java.dev.imagine.Ctx

While all of this may take a moment to digest, the important fact is that the NetBeans Platform and window system are not married to the NetBeans IDE's notion of what is selection context - you can customize how selection works to your heart's content.

Poetic commit messages

User: jglick
Date: 2006/10/25 15:33:26

Modified:
   contrib/docbook/src/org/netbeans/modules/docbook/Processor.java
   contrib/docbook/nbproject/project.xml
   contrib/docbook/manifest.mf

Log:
 Load Saxon reflectively. Otherwise it is used as the IDE's default XSLT processor and all hell breaks loose. Well, maybe not, but small but scary denizens of hell start to creep out. 

NetBeans Workshop @ OOPSLA 06

We hope to provide an interesting day of activity - bring interesting design problems! If you plan to attend

Send email to Tim dot Boudreau at Sun dot Com if you can attend.

More info is available on the OOPSLA web site.

For a taste of some of the sorts of things we may touch on, have a look at Jarda's recent API Fest in Prague.

NetBeans Day Seattle - Tomorrow 1PM

When: Wednesday September 6, 2006
Where:McCaw Hall at Seattle Center
Registration
Agenda
Sun Tech Days Seattle

I will also be doing a talk on Monday, for SeaJUG members and anyone else who cares to show up, on the NetBeans Platform, NetBeans APIs. Pizza will be provided. Email Charles dot Ditzel at Sun dot Com to sign up - he is graciously organizing it.
When: Monday, 11 September 2006
Where: Bellefield at 1150 114th Ave SE       Bellevue, WA

It's good to be back in Seattle - it's one of my favorite cities! (no the picture above was not taken here :-))

"Fishbowl Debate" at NetBeans Day Seattle

I was talking with friend and colleague Simon Phipps, who suggested the "fishbowl debate" format for it. How this works, more or less:

• You have a table with 6 chairs onstage (well, ideally it's done in the round, but in Seattle the chairs will be bolted down)
• At any time 5 people are seated, discussing a topic of interest to all of them
• One chair is always empty; when someone in the audience hears something they strongly feel they have something to say about, they get up and go sit in the sixth chair; at that point one person who was already seated gets up and takes a seat back in the audience

The idea is to have an group-driven discussion driven by people who really care about the topic.

For the record, the topic will not be "why is NetBeans great" or something like that :-) One theme that seems worth pursuing is "What takes too much time when you're writing code"; I can think of others, but what's more important is that you think of the themes/topics - if you've got ideas for topics you really care about, feel free to suggest them below.

Probably 3-4 themes will do the trick for a one-hour event, so we don't even need that many. What I'm most concerned about right now is making it a fun and interesting time for all.

Thoughts?

A really bare-bones platform

It's a pretty cool example of just what you can do with the NetBeans platform. The crack-cocaine of coding for NetBeans is the module system - the fact that you can have public classes that are public only within their own JAR, so you can design really clean, well-separated APIs. And it comes with a Manifesto - what's not to love about that?

We'll probably use DVBCentral as part of our workshop at OOPSLA 2006 in Portland, Oregon this October.

This little fellow was crossing the sidewalk early the other morning when I interrupted him (her?) to pose for the camera

NetBeans Modules for HTML Authoring

If you have a development build of NetBeans, you can get any of these from the development build update center off the Tools menu. They are:

• HTML Projects - support for opening a directory of HTML files as a NetBeans project. By default it automatically recognizes directories named public_html and www as projects; with the New Project wizard you can just create a new HTML project over any other directory you have that contains HTML. The directories are simply remembered - nothing will be written into those directories disk to mark them as a project, and HTML projects have no settings - so there's no risk of adding project metadata into directories that might live on a web server.

  It provides a flattened logical view of all HTML files it finds, by HTML title. It will scan every subdirectory of the directory you choose, so you probably don't want to do this on the root of your hard drive (although it will do it in batches on a background thread, so if you really want to you can...).

  

• Generic Navigator - this started as an HTML-specific Navigator panel, but it wasn't much more work to make it not specific to any particular file type. You can define named regular expressions and associate them with any file type, and the results will show up as list items in the Navigator, and you can select which regular expression to use.
  

  It has a customizer for adding and editing regular expressions, which also lets you test and preview matches:

  

• Folder To HTML - very often in a tutorial I need to show a directory tree and say something like "You should now have the following files on disk:" followed by a directory tree listing. Doing this stuff by hand as nested HTML list items is truly tedious. The Folder2Html module simply adds an action to all filesystem folders in NetBeans, Dump Folder as HTML. It will simply walk the directory tree and send the appropriate HTML to the output window, where you can copy/paste it into a tutorial. It includes some space and formatting for adding descriptions, e.g.
  • src/
    • syntaxtreenavigator/
      • IntrospectionTreeNode.java Tree node with children for all methods of the passed object
      • SyntaxTreeVisualizer.java Main frame
      • V.java Tree node for one element in a syntax tree
      • ViewPanel.java Inner panel

All of the above (click image for full size)

Addendum: For users of 5.0 and 5.5, here are NBM files for the modules. Simply download them to some folder, open Tools | Update Center and choose Install Manually Downloaded Modules and select them all and continue through the wizard to install them.

• Folder To Html
• Generic Navigator
• HTML Projects

Oh, the wonders of the tech press...

First, WebLogic won an award as the "best visual java component". Now, the only problem with that is, WebLogic isn't one. Then, Oracle JDeveloper won the "best mobile development toolkit". The only problem there is that Oracle actually has no mobile tools.

I'm really not sure whether to laugh or cry.

It would be nice if I could say something alarming like, "the foxes are guarding the chicken coop." But it's more like the turkeys are guarding the chicken coop.

The next time you hear anything is "award winning," contemplate how astonishingly little that actually means.

Oh, and I'm running to be Miss America. Surely if we all band together and place a few ads, we'll be able to get past the gender issue. I'm taking contributions...and if I really, really have to I'll shave...

NetBeans' portability matters

With NetBeans, exactly the same bits run on any platform with a 1.4 or greater JVM - there's no native code to worry about. You can take the zip distribution, just unzip it on any machine with a modern JDK and there you go.

And more importantly, working with a J2EE project requires no configuration, no additional downloads - it just works out of the box, which Charles also points out.

I thought I'd never see the day...

What a lovely thing to read over my first cup of coffee on a Tuesday (de-facto Monday - yesterday was a holiday in the U.S.) morning. It's going to be a good week :-)

NetBeans in Budapest

Budapest is lovely...

It was my first time in Budapest since backpacking through there in the summer of 1998, and I was back to do a presentation at a Java developer event - along with Martin "the mobility guy" Ryzl, and Petr Jiricka, Mr. Web Tools who drove down from Prague to talk.

Martin Ryzl demos Mobility in Budapest

Martin is an interesting guy - in 1999, we (NetBeans the tiny Czech company) had just been acquired by Sun, and he'd written this really cool plugin for KJava. We were in New York for the long defunct Java Business Expo conference - it was my first time back in the U.S. after moving to Prague. So, this KJava module was an amazing thing to demo - write some code, press F9 and it deploys to your Palm Pilot, and there's your code. There was just one hitch: He had written it on his own time, and we weren't supposed to be demoing it. So we had to demo it only when his management wasn't around so he wouldn't get in trouble.

Eventually it was clear nobody was going to stop Martin from writing mobile development tools on NetBeans (I'm not sure why anyone ever wanted to stop him), and so the Mobility pack was born. Today Martin manages the mobility development team (a sad loss to development, but he's a good guy to work with).

Austin Powers, ahem, Jirka Prazak (foreground, center) and Martin hijacked a table to do demos during lunch

Petr Jiricka did his talk about Web and J2EE support in NetBeans, including demoing the new Struts support in 5.0. It's pretty amazing stuff. Makes me almost want to do server-side development, which I haven't done in years (as long as I can do it as NetBeans plugins...hmm, now there's a neat tutorial idea...).

Petr Jiricka likes cake

Anyway, I said something about a new tutorial, and I'm spewing trivia. On Wednesday, post-plane-flight-from-California, I wrote a pretty cool app based on NetBeans to demo the next day at the event in Budapest. The coolest thing is that it really looks and feels like its own application - and it took an hour to write. It's a cute little paint program.

So having nothing to do on Friday but catch up on email, I spent the day turning it into a tutorial. The draft version is online here. Reviews and feedback appreciated - I hope to write up several more in the next couple of months.

In that vein, I spent the 26 hour train ride from Budapest to Grenoble, France, turning the app from that tutorial into a slightly-insanely decoupled demo. So, coming soon: Photoshop in Netbeans. The painting window is a plugin. The tools palette is a plugin. The layers window is a plugin. The brushes are plugins. The color fills are plugins. All any of them know about each other is a single, small, shared API module. Be very scared...

Here in Grenoble, I'm working with Sun's Real Time Java team on tools for that. There are some truly fascinating problems in this space - difficult, challenging, fun to have. And a great bunch of extremely smart guys working on them.

Would you trust these guys with your JVM?

Grenoble is also, as always, lovely.

Follow-mode for NetBeans?

Is that a thing anybody wants?

I've written some (admittedly crude) patches that do the very basics; doing it right would be considerably more work (lots of little things like making sure you can't have two selections, eliminating duplicated decorations, etc.).

Somebody asked for a screen shot of the usages tree view - that's it on the left (sorry about the resolution, I haven't got anything decent for picture editing for windows on my laptop).

And another new NetBeans plug-in...

Having the flu gave me plenty of time to code this weekend...so, here is a module that does that.

There are some bells and whistles still to be added - like using wildcard imports if the number of imports from a single package exceeds some threshold number. But still, right now it should do what a lot of people have been asking for:

• Sort imports
• Break up groups of imports with newlines
• Replace FQNs in source with simple class names and add imports for them
• Replace wildcard import statements with explicit imports of all classes that are actually used

Probably eventually this functionality should be merged with Fix Imports in NetBeans, but I figured I could make some people happy by writing a small module that does that now.

Sate yourself with pleasure...read the NetBeans developer FAQ...

As I mentioned above, I've been feverishly growing the NetBeans Developer FAQ for plugin authors - have a look, edit, delete, whack away - it's a Wiki.

In the meantime, I can thank Judith Lillienfeld for finding these wonderful cashews with even more wonderful packaging in the supermarket here:

I'm not sure which I love more, the slogan

or the ominous yet pleasing sounding warning

Everybody, be on the lookout for the tasty. Alas, I'll be sauntering back to California soon.

More Navigator fixes, the road from St. Petersburg to Beijing

Nevsky Prospect in St. Petersburg at sunset

Saturday, my friend Martin Ryzl, the original author of, and current manager of the development team for the NetBeans Mobility Pack and I flew from St. Petersburg to Beijing. It was the first trip for both of us to both cities. Particularly interesting was when the plane did a 180 degree turn in the middle of the runway (there are three sets of wheels, two under the wings and one in the middle - reverse the directions of the wing sets and pivot) - it was a disconcerting moment when we suddenly seemed to be executing an impossibly tight turn on the runway for our stop in Novosibirsk.

For the Novosibirsk to Beijing leg, I bug-fixed and growled and cursed at my laptop, while Martin glowingly showed me one after another another cool thing his guys had implemented in Mobility, that he hadn't had a chance to try before, but could include in his demo - for example, a stack trace from KVM only gives you a bytecode offset; NetBeans will now reverse engineer a real stack trace for you by reading the class file. You can now edit guarded blocks in the editor. Mobility just keeps getting cooler.

Martin Ryzl in the cavernous hall of Sun's temporary digs in St. Petersburg

The plane flight was productive. In a recent blog I listed some interesting line switches that affect the behavior of the Navigator component in NetBeans. A couple people pointed out that some of them were no longer working in NetBeans 5.0. Plane flights are a great time to get things working, so now they all are. A quick recap (with some new ones):

• nb.navigator.singleclick - one click to navigate between methods instead of double clicking
• navigator.string.abbrevs - strategically omit characters from method names to keep from needing a horizontal scrollbar (far from perfect, but handy)
• nb.navigator.relatedItems - highlight all callers of the selected method/field (currently infrequent false positives, working on it)
• nb.navigator.decorate - show overriding method names in bold, final stuff in italic. The performance problems with this feature seem to be much better in 5.0 trunk builds - might even be viable to turn on by default - we'll see
• nb.navigator.noscroll - Having Navigator scroll when the caret moves can be distracting; this disables auto scrolling. Works best if you dock Navigator to the right of the editor so it has a lot of height - for most java files, all methods will be displayed, and horizontal real estate is less critical than vertical screen real estate.
• nb.navigator.reordering - Allow (in natural sort mode only - right click and choose it from the menu) you to drag and drop methods to reorder them in your sources

./netbeans -J-Dsome.line.switch=true

People who know me know I have a perverse love of non sequiturs and mistranslations - even to the point of writing software that generates its very own non-sequiturs (almost a decade ago, but it still works...as well as it ever did). While my all time favorites come from an English menu in Warsaw, fascinating sayings in English abound. The following can hardly be called a mistranslation - this ATM machine is perfectly succinct and to-the-point:

Led Zeppelin meets ATM - who knew?

The food here has been fascinating and wonderful - particularly something called "Chrysanthemum water with honey" was wonderfully refreshing after a dehydrating international flight.

I have no idea what these folks do, but it sounds interesting:

So far so good.

NetBeans tweaks you've probably never heard of

Just for fun, the other day I patched Boolean.getBoolean() to find out just what was actually still in use (now, how many people do that for fun?). As with anything undocumented and unsupported, caveat emptor - nothing is guaranteed to work or keep working in the future. But here are some useful ones. First, how to use them:

• Try it out - run NetBeans with -J-D and the argument on the command line, i.e. nb.exe -J-Dnb.tabnames.html=true
• If you like it, add it to your netbeans.conf - you can find netbeans.conf in the etc/ subdirectory of your install (make a backup, and if you have changes you like, keep a copy somewhere else to reuse if you install a new version)

Here we go. Unless otherwise noted, all of these are boolean, and most are defaulted to false - so you want to specify -J-Dsome.flag=true to use them.

Settings for Screen Real Estate Fanatics

• nb.tabnames.html - Instead of displaying a * beside the name of a modified file, and "[read-only]", on editor tabs, use bold for modified and italic for read-only.
• netbeans.winsys.statusLine.in.menuBar - Instead of having a statusbar at the bottom of the screen, make it part of the menu bar (won't work on Mac OS in current 4.2 builds, since they now use the screen menu bar)
• netbeans.small.main.window - This did a lot on the 3.5 windowing system; something is still checking it, but I didn't find out what. Related to statusline-in-menubar, for making size smaller
• nb.cellrenderer.fixedheight - This is an integer in pixels, i.e. -J-Dnb.cellrenderer.fixedheight=12 - Set a fixed height for cells in all tree/list/table views. You can make the more cluttered this way (less space between items), which, if you want to fit the maximum info on screen possible, is desirable.

Settings that affect the Navigator component

Some of these are features that I wrote into the original navigator module which are disabled either for performance or aesthetic reasons. The highlighting stuff

• nb.navigator.singleclick - In list views, such as the class members view, clicking once on a method/field/etc. name will scroll the editor there (ala IDEA)
• navigator.string.abbrevs - Shorten names of methods that won't fit, rather than use a horizontal scrollbar. It selectively omits characters using a weighting algorithm - the results are readable for the same reason we know what all those ads for Genric Vigara are talking about.
• nb.navigator.decorate - This one will cause some performance issues - once they're solved, it will probably be on by default. Boldface any methods that override methods in the parent class, italicize final methods, show native methods in blue, deprecated methods with strikethrough
• nb.navigator.no.related.items=false plus nb.navigator.relatedItems=true - (both of them) - Poor man's Find Usages - Whenever you put the caret in the editor inside a method or field definition/body, Navigator will highlight all of the methods in that same class which call the method/use the field where the caret is. This seems not to be working in today's build, but should work in 4.1.

And, one switch you definitely won't want to use in daily, but which is briefly amusing: nb.tabcontrol.fx.gratuitous - causes switching tabs to do all sorts of funky transparency/scaling/sliding stuff to make the new tab come up. It is, as the line switch says, gratuitous - and more importantly, whether and how it works, and if it's slow or performs well depends way too much on the vagaries of the operating system, the graphics card driver, etc. for it ever to be useful in production. But it's cute.

Remember, caveat emptor. Enjoy...

When engineers (sort-of) read licenses - a cautionary tale

...the download requires me to accept a non-open-source license that severely restricts what I'm allowed to do. I've heard Sun claim that Netbeans is open source, but that doesn't seem to be true.

So I went to the NetBeans download page, to see what he was talking about. And took a look at the license, and said to myself..."Whoa...this is a major screw-up!" Here was, indeed, this rather scary legal text. It didn't look like an open source license to me either. But it's what you agree to when you download NetBeans builds. Did I scroll down and go through the whole thing with a fine toothed comb? Nope. Neither did anybody else - that's the cautionary part of this tale.

The license text he's referring to is this. It's actually the same text you agree to when you download the JDK. And indeed, it doesn't look anything like an open source license. And I wrote to Elliotte, to mention that,

• I know for a fact that that license agreement is only intended to apply to libraries like javac and JavaHelp that NetBeans links to at runtime, not NetBeans itself, and
• It's the same license agreement that you agree to when you download the JDK, so how could someone be okay with agreeing to that for the JDK but have a huge problem with the same license when it comes to some libraries their IDE uses?

The license agreement is a bit of legal boilerplate. It is the result of a bunch of folks like me complaining that everything you download from Sun had its own unique, slightly different license agreement, and why couldn't we just have a generic agreement for most things and simplify everything. It worked. It got simplified. And it actually was done correctly, as you'll see below. But the document is written so perfectly backwards for an open source site that it's almost impossible to tell that. It definitely means I should be careful what I wish for. Correct doesn't necessarily mean human-readable.

In the meantime, Weiqi Gao picked up on what Elliotte had written, and repeated it, but his blog restated it as fact, saying flatly that NetBeans isn't open source. And that's the danger of this sort of thing - misinformation spreads, and nobody necessarily goes back and checks it. And we were all, myself included, not reading the whole thing. It just smelled bad, and we all said, "Yup, smells bad."

But the license text doesn't look like an open source license at all. In fact it isn't one. How in the world could that be kosher? I asked our legal folks about it, and they replied, in essence, "What's wrong with it? The license specifically mentions what it covers."

How could a lawyer think that it's perfectly clear that this agreement only applies to the libraries that are linked to by NetBeans, and I and everyone else would see something completely different? I put on my thinking cap, and tried to think like a lawyer for a minute. It hurt like hell and I took my thinking cap off. The answer is really an impedance mismatch in the kind of reasoning an engineer uses when he or she says "Let's see how this software is licensed," and the reasoning of a lawyer thinking about a legal agreement. If you're a lawyer, you look for the holes first. So I went back and really read it this time. For the missing piece of the puzzle, you have to scroll way down to section 6, which says:

Sun supports and benefits from the global community of open source developers, and thanks the community for its important contributions and open standards-based technology, which Sun has adopted into many of its products.

Please note that portions of Software may be provided with notices and open source licenses from such communities and third parties that govern the use of those portions, and any licenses granted hereunder do not alter any rights and obligations you may have under such open source licenses, however, the disclaimer of warranty and limitation of liability provisions in this Agreement will apply to all Software in this distribution.

So, here it is in a nutshell: When you download NetBeans, you click through a license. That license says "This license covers everything except the parts that are covered by open source licenses." Which, in this case, happens to be...all of NetBeans. For a lawyer, it is perfectly clear because it says it doesn't supercede the open source stuff - how could anyone read it and not figure that out?

For an engineer downloading software, the first thing you look for isn't what the license says it doesn't cover - and probably nobody expects a license agreement to say "This agreement doesn't apply to a bunch of stuff, and by the way, one of the things it doesn't apply to is the product you're downloading."

The agreement is, as I mentioned, boilerplate. It was created for closed-source software that uses open source components. It applies equally well to both, but I can't blame anyone for misunderstanding it - I did. And it's totally non-intuitive to find that on an open-source project's download page.

To be fair, I'm not saying that Elliotte is now perfectly happy about the agreement - we exchanged some emails, and it's clear he doesn't really like the agreement as it applies to Java either. At the same time, one of the things he objects to is the indemnity clause (4e) - we exchanged some emails about that, and do you know what? Neither of us noticed that that section is about redistributing libraries that are part of Java (i.e. the JDK, or JavaHelp, for example). So we were both talking nonsense to each other.

Also to be fair, there are people who will object to the very fact that NetBeans links to libraries that are not open source, even though they are all either parts of the JDK or Java standards like JavaHelp or JMI - even though they are under the same license as Java itself.

So let this be a cautionary tale about what happens when engineers read - or especially, skim - legal agreements. I had a lengthy, and ultimately useless (my fault) conversation about the indemnity clause, because neither of us had noticed that it doesn't apply to NetBeans users. The rumor could have taken on a life of its own and done quite a bit of harm (and nobody here was trying to do harm) - it was already repeated once. It wouldn't have been true, but that doesn't matter with rumors.

Richard Feynman once wrote about his experience reviewing science textbooks for the state of California in the 50s. It turned out that the book the group gave the highest marks to consisted entirely of blank pages. The publisher couldn't get it done on time, but the law required they submit a book by the deadline. And the reviewers gave it high marks because nobody had actually opened it. It's incredibly easy for debates to get wildly off the mark, especially when they involve texts that a lot of people don't enjoy reading anyway - like (unfortunately) a science textbook...or a software license.

Anyway, there's a happy ending here: I don't like that legal agreement either. There's no click through license on other open source projects when I download them. Why should NetBeans have to have one? Well, we get our wish. The click through license on the download page will be deleted. Let me repeat that, loudly:

For those who downloaded NetBeans, there's no need to delete it or download it again - as I hope I've made clear, your copy of NetBeans is covered under the SPL - it always was. But I'm very happy to see this confusing and unnecessary piece of legalese go.

So, thank you, Elliott and Weiqi, for helping to make that happen.

Now perhaps I'll get to spend some time coding.

This work is licensed under a Creative Commons License.