email article printer friendly

Product Review: IntelliJ IDEA
A powerful and flexible IDE, but watch out—it's slow.
by David Thielen

Posted April 29, 2003

Like most developers, I'm slow to change the tools I use. But when a friend of mine suggested IntelliJ IDEA, I tried it—and loved it. IntelliJ IDEA is a powerful IDE that can provide help when you want it and stay out of your way when you need that. However, over time, you'll find that you want more and more of its assistance.

A major selling point is its flexibility. IntelliJ IDEA is designed to assist you in the way you want to work. For example, you can use IntelliJ IDEA to build your code, or you can use Ant through IntelliJ IDEA. If you use Ant, you can still have IntelliJ IDEA build files for you and place them where Ant would.

The editor is brilliant. It finds any errors (and warnings) in your code and will prompt you about them if you wish. (It does have a problem with var ++.) This includes warnings on variables assigned but never referenced and incorrect param names in your javadoc comments (I had several of those). These warnings unobtrusively stay out of your way and/or each kind can be turned off.

Its automatic templates are very smart. Type itco<TAB> and it creates the code to iterate through the first container it can find before that line in your code. It's more than just a macro expansion, although it has those, too.

At first I thought that the refactoring was a complete waste—until I used it. There is no Save As command in the editor, for good reason. When you want to create a class similar to an existing one, you use the Copy refactor command. It asks for the class to copy and the new class name and package. It then creates the new class, renaming that class wherever appropriate, and placing it in the correct directory.

Another refactor command can remove a variable from a method everywhere the method is called. IntelliJ IDEA has about 20 refactorings, and although I haven't used all of them, the ones I have used are not only timesavers, but they help you to avoid creating new bugs.

The debugger is great and it has two very nice, extra features. First, you can set classes that should be displayed using toString in the debugger, giving you a great display if you implement toString in your classes for debugging. Second, it will evaluate any java expression in the context of your current breakpoint, which can be useful at certain points in the debug process.

Figure 1.

This "being one with Java" extends throughout the program. For example, along with a normal find, you can do a find on a method in a class and it will find that method call, ignoring all other text that matches the method name.

IntelliJ IDEA's three biggest problems are that it's slow, it's slow, and it's s-l-o-o-w. Forget it if you don't have at least a 1GHz system, and you really need at least a 1.5GHz system. Even then, it makes you hesitate.

Second, it only sort of pays attention to standards. You can set the keymap to "visual studio," but it's not the Visual Studio keymap. It's about 85 percent the Visual Studio keymap and 15 percent different. This can throw you until you realize that it's off and you add the rest yourself. Same with the code formatting. You can tell IntelliJ IDEA to format your code and you can adjust the format you use. But the default format is not the Sun recommended format. It's close, but not exact.

Finally, it does not have true undo/redo. Instead, it's like the undo in Word or Visual Studio. If you are used to the undo in a program such as Codewright, you will miss it. (The undo in Codewright undoes the previous key or menu command. If you did a PageDown, it will do a PageUp.)

Other little things bothered me, but these fall into the category of individual preference. The #1 problem is performance, so make sure you try it first and make your own decision about whether its responsiveness matches your work style.

About the Author
David Thielen has been programming and managing programmers for 20 years, mainly for startups. His Web page is at .