Lately I have read a lot of IDE discussions about IntelliJ IDEA. I've only ever heard good things about it and was curious how it compares to NetBeans 6.0, which is nearing beta. The main plus points that I hear over and over about IDEA are its code editor, refactoring capabilities, and performance. Everyone knows that IDEA is way ahead of other IDEs in refactoring so I didn't look at it. Instead, I compared features that I personally find useful in NetBeans, and also some areas of NetBeans that could use improvement. I downloaded IntelliJ IDEA 7.0 milestone 1 (a dev build) and NetBeans 6.0 milestone 10. I'm running these on Ubuntu Linux 7.04 with JDK 1.6.0. This was the first time I have ever tried IDEA.

The first thing that shocked me was how fast IDEA started up and was ready for use. When I tried again several days later I was not as impressed because it seemed to take a lot longer. Maybe the first time I tried IDEA the JVM was already loaded, but not the second time? Also the second time it was examining project files that I had created the first time I tried IDEA. IDEA takes 15 seconds to load and be usable, and NetBeans 6.0 takes 30 seconds. I do this only once per day so load time isn't a big deal for me.

Next I created a new web project in IDEA. I really did not like the (seemingly) 15 screen wizard asking me all kinds of questions such as which directory to put source files in, which for compiled classes, which for resource files, etc... I had to do a lot of reading and decision making. I much prefer NetBeans 6.0's new project wizards. It asks more than one question per screen, and makes a lot of default decisions for me. I like the consistency of these default decisions (such as paths). However, I think it is powerful that IDEA is flexible enough to accommodate any directory structure. This can be useful when working with code written in other IDEs or text editors. NetBeans has a “New Project With Existing Sources” project type. I have not tried it and don't know how flexible it is. IDEA has “Import from Eclipse...”, “Import from Jbuilder...”. The NetBeans 6 help file talks about using the update center to add the Eclipse and Jbuilder project import functionality. Update Center has been renamed to Plugins Manager, and I don't see these plugins. Maybe they will be coming in the future?

Once I had a web project created in IDEA I double clicked on the web.xml deployment descriptor. What I saw next shocked me. I saw... raw XML!!!! I also see raw XML for ejb-jar.xml, sun-web.xml, persistence.xml, and probably other deployment descriptors. I couldn't believe the IDE of IDEs doesn't have visual deployment descriptor editors like NetBeans, Jdeveloper, WebSphere Studio and other IDEs. Some developers may argue that editing these deployment descriptors is easy, especially with the code completion. Well, until you have used visual deployment descriptor editors you have no IDEA (pun intended :). Why are there visual editors for JSF and Struts navigation cases, but not other deployment descriptors?

The next thing I wanted to try was the infamous code editor. Using the web.xml file, I started to type the name of some elements that I know it uses. I was very impressed by the instantaneous responsiveness of the code completion. I'm used to a short delay, maybe half a second or so before code completion opens. In IDEA, it seemed like it came up as my fingers were still pressing the CTRL-SPACE combination. Next I created a Java source file and tried some more code completion. Again I was blown away with how fast it was. I found that anything I pressed or clicked in IDEA had an instantaneous response. Very nice. I used to think IDEA users were over exaggerating when saying that Eclipse and NetBeans are sooooo slow. If I got used to this kind of performance, I would probably say the same about the other IDEs. However, I don't think you can say NetBeans 6 is slow anymore.

One of the major new features of NetBeans 6 is a complete re-write of the code editor. The new editor uses the JDK 6.0 compiler APIs to access the Abstract Syntax Tree which is extremely fast, and provides every minute detail about everything to the code editor.

The Java compiler (as do most compilers) parses source code into an intermediary representation, which is structured as a tree. Each node in this data structure (called an Abstract Syntax Tree) represents a code element: a class, method, statement, block, identifier, operator, literal, etc. Though code processing tools usually manipulate programs as ASTs, many use a simple parser that produces only a basic tree. The “full” AST produced by a complete compiler like javac, which is capable of semantic analysis and code generation, will contain very detailed and reliable information about each node. For example, the node for an identifier holds not only its name but also its type and its ”definite assignment” status (whether the identifier is guaranteed to be initialized at a given point); it can even hold its statically-calculated value (when applicable). Tools that work on top of a full AST are much more powerful and reliable. The difference won’t be noticeable for a simple selection feature, but it may be very significant for more sophisticated functionality like refactorings.

When I try code completion in NetBeans 6.0, I am equally impressed. I've read some IDEA users say that it is still slow but I have not experienced that myself. I can see a significant improvement over NetBeans 5.5's code editor.

Earlier I said that I wasn't going to be talking about refactorings. I lied. I want to talk about NetBeans 6.0's new refactoring engine called Jackpot. It is a language-independent refactoring API that will allow implementing refactorings for code other than common .java sources (e.g., XML or JSF files). The new API also allows Java refactorings to precisely update dependent non-Java elements. This should make the current refactorings safer and easier to use. Jackpot is actually a comprehensive framework for general code understanding and manipulation. You can use it as a replacement or foundation for several kinds of features: refactoring support, advanced searching and browsing, quality inspection, macro-like automation of complex editing tasks, and more.

Because Jackpot – like the new editor – relies on javac’s source analysis engine, it’s able to fully attribute all types in the processed code. This includes the most complex cases, like inferred generic types. Other code analysis tools often resort to heuristics that approximate types but might fail to calculate types for some expressions.

Jackpot also has a query language used to write the refactorings. The refactorings you find in NetBeans 6 are actually Jackpot scripts. I believe that one day Sun or the community will create Jackpot scripts that will match IDEA's refactoring capabilities.

Now back to IDEA. Here are some other features I liked:

• When creating a new JSF web project I could choose between Sun's reference implementation or Apache MyFaces. I would usually choose Sun's RI but when working with some app servers, you have to use MyFaces. I think some of the JSF component libraries also rely on MyFaces.
• Built in support for Spring and Hibernate. I'll bet NetBeans doesn't have these built in by default because Sun is pushing Java EE. There are a couple of plugins for Spring and Hibernate, though I'm not sure how good they are. I've never seen anyone use them or talk about using them.
• IDEA supports the following app servers: Tomcat, Geronimo, WebLogic, WebSphere, Jboss, Glassfish/Sun App Server. NetBeans supports those too, with the exception of Geronimo and WebSphere.
• IDEA has support for exploded deployments. I don't think NetBeans supports this.
• IDEA has many Analysis features built in such as code metrics, test coverage, the equivalent of checkstyle and findbugs (I think), etc... NetBeans has some plugins to do these, but I doubt the work in NetBeans 6 and they are not built-in.
• This one is a negative point. To get a profiler for IDEA you need to spend another $500+. NetBeans comes with a powerful and performant profiler built in.

I've read complaints from developers who say their 10,000 – 20,000 file projects make NetBeans extremely slow. I don't know if they were using NetBeans 5.5 or 6.0 but I do know that performance is a major priority in 6.0. There is a performance tiger team that moves from module to module to speed up problem areas. Milestone 10 was the last milestone in NetBeans 6. It is now feature complete. The work from now until final release in November 2007 will be bug fixes and performance improvements.

I admit that I did not do an exhaustive review of IDEA. I only scratched the surface but did answer the burning questions I had about it. To really experience IDEA I need to spend a few weeks full time with it, take the time to learn the keyboard shortcuts, and refactoring features. Those who love IDEA say that once you make the effort to learn it, you will never look back at any other IDE. I think I would be happy working with IDEA if I had to. I haven't worked on mega projects in Java yet so have not encountered limitations in NetBeans. NetBeans has all of the features I need and I don't find it slow. I won't be switching -- at least not until I can give NetBeans 6.0 final release a chance.