Eclipse, NetBeans, and IntelliJ: Assessing the Survivors of the Java IDE Wars

Installation
Under Windows, IDEA provides a regular EXE installer. Under Linux, the installation is much more Spartan, consisting of a single TAR.GZ file. Upon extracting the contents, you have to manually change to the "bin" subdirectory and execute "./idea.sh". It fails if you do not have the $JDK_HOME variable set up correctly, preferably in your .bashrc file as follows, for example:


JDK_HOME=/home/jacek/Dev/Java/JDK/jdk1.6.0_01
export JDK_HOME
JAVA_HOME=/home/jacek/Dev/Java/JDK/jdk1.6.0_01
export JAVA_HOME

export PATH=$JAVA_HOME/bin:$PATH

Unfortunately, JetBrains does not provide a standard .deb or RPM file for any of the major Linux distributions. Therefore, the installation does not integrate into the desktop very well (e.g., no desktop shortcuts or K Menu entries are created). Worse, double clicking on the "bin/idea.sh" file from the Konqueror file manager did not work either (it was returning an error about JAVA_HOME not being set up, even though it was actually set up correctly). The only option that seemed to work was to drop to command line and execute "./idea.sh" manually. The IDEA installation experience under Linux needs some serious polish. It was the weakest of the three tested IDEs.

General Features
Just like NetBeans, IDEA comes with a very flexible layout, providing the ability to dock/pin/float panels in a variety of configurations. However, it didn't seem quite as smooth and configurable as the NetBeans windowing system (which IMHO is the one to beat).

However, this is a minor gripe in light of the outstanding IDEA editor, which has long been regarded as its crown jewel. The editor is fast, with complex context-sensitive color highlighting, hints, and suggestion pop-ups—not to mention an impressive array of refactoring options. The IDEA editor is any hardcore coder's dream. The more time I spent in it, the more little touches I found that made programming that much more efficient. I'm sure I barely explored all of its functionality during the limited time I had for reviewing. (See Figure 4 for a sample of IDEA's editor and its advanced coloring/syntax highlighting.)

Figure 4. IDEA Editor in Action

Swing Development
IDEA provides a fairly powerful GUI editor. It doesn't quite live up to NetBeans Matisse's, but it arguably is the next best thing. In particular, its support for JGoodies Forms (arguably the best layout manager available prior to GroupLayout) places it well ahead of those that are still stuck on GridBagLayout (like Eclipse's Visual Editor).

Interestingly, IDEA keeps the generated UI layout in a separate ".form" file (similar to NetBeans), but it does not generate the corresponding Swing code by default. It gets generated only during compilation via a proprietary GUI compiler (which can also be packaged as a separate Ant task). If you prefer to have the IDE-generated code directly in your .java file, you have to enable it via an option (which in my opinion is the preferable approach, since I would prefer not to have all of my UI code hidden and available only after running a IDE-specific code-generation mechanism).

JSP/Struts Development
Struts support in IDEA is nothing short of outstanding. In a fine example of the sort of attention to detail that IDEA is known for, it can even download all the required Struts libraries for you! Not only does it automatically set up all the configuration files (including Tiles and Validator), but it also provides a dedicated Struts panel called simply Struts Assistant, which provides graphical editors and productivity wizards for all Struts configuration files, including tiles-config.xml and validation.xml.

IDEA has no visual editor for JSP/HTML pages, but the regular IDEA JSP/HTML editor is superb even without a visual component. The support for embedded JavaScript (with full code completion!) especially will be a godsend to anyone dealing with large amounts of DHTML or AJAX code. As another example of the type of attention to detail others can only dream of, the JavaScript editor comes with support for browser-specific elements (IE, Mozilla, and Opera), as well as popular AJAX frameworks such as Dojo, Bindows, and Prototype. (See Figure 5 and Figure 6 for samples of IDEA's Struts support.)

Figure 5. IDEA Struts Web Application Setup

Figure 6. IDEA Struts Assistant

For hardcore, cutting-edge Web 2.0 development, IDEA delivers full-blown support for GWT (Google Web Toolkit) as one of its core features. I find that very impressive, especially considering how new GWT is (but since it is sponsored by Google, the odds are it will be a winner and it's good to see IDEA supporting it so early).

JSF Development
Just like its Struts counterpart, the JSF project options are an exercise in flexibility: you can choose which JSF version (1.0, 1.1, or 1.2) and implementation (JSF RI or Apache MyFaces) you're going to use, and then IDEA can even download the required libraries for you (and it displays productivity hints while downloading the JARs—now that's attention to detail). NetBeans team take note: this is exactly the kind of broad support for all popular open-source frameworks or implementations (instead of just Sun-sponsored ones) that is missing in your IDE. Also, the JSF module provides out-of-the-box support for JBoss Seam, which by all accounts seems to be on the way to becoming the standard framework for JSF development (similar to the way Struts was for JSP). This is further proof that IntelliJ is well aware of cutting-edge development in the Java web world.

Refactoring seemed fully JSF-aware (e.g., moving a managed bean to a different package properly updated faces-config.xml). (See Figure 7 and Figure 8 for samples of IDEA JSF support.)

Figure 7. IDEA JSF New Web Application Setup

Figure 8. IDEA JSF Configuration

Enterprise Development
IDEA provides thorough support for the J2EE specifications. More importantly, it provides full-blown support for EJB 3.0 and JPA, although not quite as well as NetBeans yet (which automatically adds entries for the JPA provider in the persistence unit and generates code for named queries on all entity fields, something that I found missing in IDEA after getting used to it in NetBeans 5.5). IDEA does come with the option to view the ER Diagram for a JPA Persistence Unit, but unfortunately this seems available only in an EJB module. When using JPA in a regular web module, I was not able to invoke the ER Diagram option. Aside from this minor gripe, IDEA's overall J2EE/Java EE 5 support is top notch. It even offers an upgrade path from J2EE to the annotations-based approach of Java EE 5!

As far as application servers go, IDEA provides deployment plugins for all the major players, namely WebLogic, WebSphere, JBoss, Geronimo, and Glassfish.

For unit testing, it supports JUnit4 and provides an integrated tool for measuring code coverage as well.