I write Java software. I used to use and recommend NetBeans, but recently Eclipse has taken the lead. There's a pre-release version of NetBeans that might press that lead.

Early on there were really only two FOSS Java IDEs; NetBeans, backed by Sun and friends, and Eclipse, backed by IBM and friends. NetBeans took an early lead, but like a teenager racing a toddler, Eclipse surpassed the NetBeans promise quickly. I still have a soft spot for NetBeans, so every time they have a new release, I give it a hopeful try.

Some things I really like about NetBeans include the fact that it's pure, raw Java; all Java and nothing but Java. Their interface is written using the Java Swing classes, and all of the included tools are pure Java, too. Because of this, the exact same package works on all of the Java-enabled platforms; Windows, LINUX, Solaris, and Mac all work the same, allowing for the differences in the operating environments, of course. Try it; download the tar.gz version, open it (use gzip/tar on everything but Windows, or newer WinZip on Windows) and extract everything somewhere and fire it up. If you've got an up-to-date JRE, it works. No install, no other requirements, nothing, just NetBeans.

Additionally, NetBeans has a fairly decent GUI development tool. Layout Swing applications and applets in no time, no fuss, no muss. Sure, the older versions added some comments and noted some blocks of code that the GUI tool "owned," but that's a small price to pay and beats the pants out of the trial-and-error methods otherwise requried.

NetBeans also had integrated tools like Ant and Tomcat to help make standard builds and test them right in the IDE. Eclipse now has those integrated, too, but not at first (like I said, it overtook fast).

Both platforms have CVS capabilities. Both can work with other application servers. Both have helpful tidbits like JavaDoc and autocomplete, but in these Eclipse starts really taking the lead.

Eclipse really rocked the house with its refactoring tools. Its autocomplete (and related auto-suggest) works faster and more completely. Due to working with Eclipse more, the keyboard shortcuts are on the tip of my fingers, like formatting code, organizing imports, and fast-finding classes and methods. Alas, these in-the-program shortcuts vary from platform to platform; on Windows formatting is control+shift+f, while on LINUX it's escape then shift+f.

There's a new NetBeans out, and it brings a whole new tool to the table. Three of them, actually. Integrated graphic interfaces for BEPL, UML, and XML. The WSAD (IBM's for money) version of Eclipse has a graphical XML editor, but not otherwise.

I've only started tinkering, but the UML diagramming is way cool. It's completely integrated, and allows alteration of code to automatically alter the model, and vice-versa. It has a reverse engineer tool that takes an existing set of Java code and creates a UML model set. It does class diagrams, dependencies, sequence, state, and all the good ones.

I did run into a few Exceptions (big "e" as in program fault, not little "e" as in concession or compromise) when I tried to change the name of a package that the classes were in as I tinkered (I named it "Sample" instead of the more acceptable "sample"). I blame Windows for that, though, as the case-insensitive nature of the file system probably didn't jibe well with the rename--in fact, when I renamed it from "Sample" to "ample" and then back to "sample" it performed much better. I wouldn't expect the same file system interference on any other platform.

The program is more robust, too. I didn't mention that. One of the things I liked about NetBeans originally that I didn't about Eclipse was it's true Java nature; mentioned that already. The alternative, as used by Eclipse, uses proprietary graphics and a native executable to enhance performance. This is handy, I'll admit, when you have to sit at the monitor and make the changes all day long, but it rubbed me the wrong way some time ago. The new NetBeans, either through more efficient programming, improvements to the JDK or virtual machine, or something in the middle, is much more responsive, and borders on the speed of the native-compiled Eclipse.

I do still have a fondness for the auto-complete Eclipse offers. The ability to type few of the many characters in the class names and hit control+space to get the completion is very handy. It's much better at predicting what you may need, especially in a parameter list. Additionallly, when declaring variables, as in "type name = new type()", Eclipse rocks with its friendly name suggestion. Generally accepted Java development would look like

Iterator iterator = collection.iterator();

Note the name of the variable (iterator) is the same as the type (Iterator), but with a lower-case first character. You can see from this one line that we expect the right-hand operation to be happening to the "collection" variable, which by the same code standard we can infer is of the type "Collection." In Eclipse, after typing the space after "Iterator" the auto-suggest would give us "iterator" just by hitting control+space. I must do this a hundred times a day. Saves me a lot of time and error. NetBeans doesn't do this.

I suppose I could be a good FOSS user and develop the stuff myself, contributing to the cause...

I'll have more as I continue to play.