Thursday, July 28, 2016

Comparison of Java IDEs

Why use an IDE?
If you're writing Java programs, you are without a doubt using a Java IDE of some sort. The way that Java runs, that is, using managed bytecode on a virtual machine means that the compilation step is a bit more rigorous than a call to gcc as you would do for a C source file. In any given Java program, you go through so many steps to compile and run the bytecote that it's nearly nonsensical to use the language without an IDE.

Additionally, the language's complex foundation (meaning, it's extensive standard library, OO model, and verbose nature) make it even more perfect of a fit for a language to use along with an IDE. So, you can't be too informed about what IDE is good for you.

Personal IDE Ranking
Quickly, here are the IDE's that I've used and most like for Java development:

#1 - IntelliJ

#2 - Eclipse

#3 - Netbeans

These are the basic Java IDE's. For a more in-depth look, check out this list here.

Strengths and Weaknesses

IntelliJ, Jetbrain's Java IDE, has become the de-facto Java IDE in the industry. As a matter of fact, many of Jetbrain's products are used all across the software industry (most famously, their Resharper plugin for the Visual Studio ecosystem).

Its strength lies in a very strong out-of-the box experience with heaps of features missing from the other two popular Java IDE's. Some of these features include:

Out-of-the-box experimental technologies

With Netbeans or Eclipse, you can feasibly use technologies such as groovy and maven. With Eclipse, you can integrate Scala, Clojure, kotlin, etc. into the IDE with the use of addons. However, IntelliJ IDE comes with support for these supplemental JVM languages out of the box. Support includes first-party support, syntax highlighting, code completion, etc. They are first class members of the IntelliJ ecosystem.

Unbelievable code completion and Linting

IntelliJ's code completion is good. Creepily good. It will never fail to resolve the name of some class's methods, if it's your class or some other library's class. It supports sensible completion for the newest of Java features, such as generating lambdas.

Speaking of lambdas, IntelliJ's linting process will often tell you to replace lines of code. It will automatically transform uncessary loops into lambda calls to tidy up your source, or report sources of possible error as you write them.

Stellar Android support
Android Studio, the de-facto IDE for creating Android programs at the moment, is based on IntelliJ. So, in order to install Android Studio, you need only install one plugin for this IDE, retaining all of your other settings you have within it.

The Android plugin includes a drag-and-drop GUI designer, cached emulation for fast in-pc testing of android apps, and the same great code completion that it has for all java source files, which is even more important for Android.

Unlike some other IDE's which support Android, IntelliJ's XML editing leaves almost nothing to be desired.

Next-level debugging
To emphasize just how good the built-in debugger in IntelliJ is, understand that I am no stranger to debugging, inside and outside of IDE's. I've been mucking around with debuggers since it meant crawling through assembly outputs to identify your issue. In that time, I have never come across an IDE as featureful and powerful as IntelliJ's. The debugger is my personal favorite feature of this IDE.

Breakpoints support more feature's than a lot of other IDE's.
You can choose to sleep  just the thread where the breakpoint is set, or the entire thing. You can choose to not even suspend execution on your breakpoints. And, most importantly, you can set a condition for the breakpoint to break on. Even cooler is the fact that the condition line supports code completion.

The debugging process itself is just as featureful as the breakpoints are. It supports all the standard features that a debugger should have, such as "Step Into", "Step out", "Step Over", etc. But it also has some advanced features like "Drop Frame" (for recursive functions), and "Force Step" for situations resistant to debugging... which, surpirsingly, do come up from time to time for some reason or another.

As you debug, the values of local variables are displayed alongside of your code as gray text.

As is the case with many IDE's, IntelliJ supports evaluating expressions at any point during the debugging process.

Integrated VCS management
IntelliJ has top-notch VCS integration. You can pull changes, push changes, edit commit logs, and even apply patches from diff to your project directly.

A feature that, for me, sums up the type of IDE IntelliJ is is "Create gist"
When I saw that the context menu had an option to paste to gist, I was excited. Partly because it makes it easier to ask for help via IRC, but mostly because it shows the type of IDE that IntelliJ is. It is truly the frontrunner in keeping up with the latest in the software industry.

As biased as I may be for this IDE, I truly feel that IntelliJ doesn't have anything wrong with it as far as the software itself is concerned. I've used this IDE for a bit over one year, at one point for a pretty major project (hundreds of thousands of lines of source, 100+ files). In that year, it has never crashed for me, or behaved in a way that it would not allow me to accomplish my work.

The IDE itself, or some addon, always had whatever feature I was looking for in the Java IDE.

The only problem with the product, in my opinion, is the fact that the non-community edition (which has features that do make it worth it) costs quite a bit of money, and the subscription doesn't particularly make sense. In addition, Jetbrains products are not Open Source or Free, so you can't modify them if you do need to integrate deeply with the IDE, fix some bug, or just see how it's running.

Eclipse, for many years, was considered the "professional" Java development environment. Interestingly, Eclipse is as much a plugin framework as it is a desktop environment. Behind Firefox, it is the second most extensible desktop application ever created. Quite literally, "eclipse" is just a plugin framework that has a lot of good Java editing addons pre-installed. Or C++ editing addons. Or brainfuck editing addons. Or, really, anything you can conceive.

Extensibility within Eclipse is no joke. It gives you the tools to fine-tune everything about the IDE. You can transform the IDE to do anything you want to. It has very good "official" addons for it, such as Android, C++, and Java. On top of that, there are tens of thousands of community plugins, which can turn Eclipse from a Java development environment to, say, a Lisp environment, a Ruby environment, a D environment, or a development environment for just about any language imaginable.

It's rather easy to create a plugin for Eclipse. You do so with plain Java and XML, and you're able to install plugins that you make yourself to fine tune anything about Eclipse that you would like.

Featureful Project management
Eclipse, would like to make sure that it has every possible use-case covered. The user should barely have to do anything with setting their project up manually. This includes things like inheritance and interface implementation. Take a look at the "New Class" dialog box:

This makes it very simple for somebody new to Java to generate a ton of code. Or, if you're extending a large class or implementing a large interface, it streamlines the experience by quite a bit.

Like IntelliJ, Eclipse supports code completion very well (not quite as well as IntelliJ, mind you). It supports debugging, but, once again, not as well as IntelliJ can debug.

However, one key advantage that Eclipse has over IntelliJ is the fact that it is Open Source and completely free to use. You can edit it, or add one plugin to the tens of thousands that already exist. 

If you're a programming multiglot, you should seriously consider Eclipse, since it could become your environemnt for all of your programming languages if you choose for it too. However, if you're looking to purely write Java programs, IntelliJ may be the better option.

Eclipse has quite a few weaknesses. As it is so extensible, you will often get the feeling that the IDE is "held together with duct tape", as I heard my professor say about Eclipse. 

It uses something called "Perspectives" to display information to the user. These perspectives are essentially windows, and Eclipse is the window manager. That leads to odd behavior like this: 
where you may have to resize your IDE to fit the entire Eclipse window, since the IDE features are themselves plugins. This is a good display of just how truly extensible Eclipse is, however, it's a bit cumbersome to work with if all you're looking to do is edit some Java.

The fact that Eclipse is so extensible also makes the memory usage quite high, even by Java program standards. This is not a problem on most systems, but on slower computer the overhead of being so extensible can really slow things down.

Unlike IntelliJ, there is no baked-in support for version control. However, there are many git / subversion plugins available in the Eclipse repositories to fit these needs.


Netbeans is another traditional Java IDE, like IntelliJ. It's been around for years, and is the default Java IDE (meaning, that Oracle develops it and bundles it with their Java downloads). Despite Oracle having control over Netbeans, the IDE is completely open source.

And, although it is most comparable to IntelliJ, it shares some similarities with Eclipse, including its numerous addons. However, most of the features that you would end up using Netbeans for are pre-installed.

Something can be said about Netbeans that cannot be said about Eclipse. It's dead-simple. It's a traditional editor, reminiscent of code::blocks and the like. Its RAM usage tends to be quite low, and the learning curve for Netbeans is high, making it a great instructional or introductory IDE.

When you create a Java project, it will create a default package and the main class automatically. Unlike IntelliJ and Eclipse, you are ready to execute your java program the second you create it.

Enterprise Support
When you think of Oracle, you think "Enterprise", and Netbeans has features that back this up. It has features, such as allowing you to automatically Globalize your applications with international strings. It allows you to do most things you may need to do in Java through the IDE in pre-defined ways as well. Inheritance, encapsulation, code formatting, comment generation, etc. 

Code Completion
Netbeans has powerful code completion, but it falls short of both Eclipse and IntelliJ. It can automatically fix issues from the context menu, but it won't provide this option as well as Eclipse or IntelliJ does, and it will mostly be able to fix warnings and errors only; it won't improve already working code like IntelliJ. 

The downside with the code completion is that many times it incorrectly assumes what you want. If you put the line import javax.swing.UIManaer; where you actually want javax.swing.UIManager, it will suggest that you create a new local package called javax.swing.UIManaer and write the class yourself.

VCS support
Netbeans has support for all of the major Version Control systems out of the box, including mercurial, git, and subversion. This is one clear advantage it has got over Eclipse, however, the VCS integration doesn't offer all of the features that IntelliJ's does.

Multi-Project support
Netbeans has my favorite multi-project support out of any IDE. It lets you quickly zip back and forth between various projects from the project browser. 
Netbeans is, in my opinion, the weakest of all the 3 major Java IDE's. It will allow a beginner to get started in Java, but it lacks  so many features that Eclipse and IntelliJ have that it's not worth trying to work around it. The linting is non-existant. The code completion doesn't work 100% of the time. The interface is surprisingly error-prone in contrast with Eclipse, which, since everything is a perspective, you may imagine that it would have a lot of errors.

I stopped using Eclipse a few versions ago, but at one point it crashed and refused to open the project I was working on again. I recall this happening twice during one semester of a java course, which means that it may be common with the IDE. At the time, we were just working with classes for educational purposes. That is, no external libraries or unit tests, which may increase the chances of it crashing.

Other Java IDE's
The only other Java IDE that I have experience with is BlueJ, which I have nothing good to say about. The interface is built around the idea that a problem that literally does not exist should be solved (that using user-defined classes is too difficult). It provides syntax highlighting and rudimentary code completion / debugging / unit test generation, but that is literally all. It isn't worth it to look into BlueJ unless you're going to do so for the novelty of the experience.

Here, I will list the scores for some goals you may have for your Java IDE.

Eclipse - 10
IntelliJ - 8
Netbeans - 5

IntelliJ - 9
Eclipse - 7
Netbeans - 4

Code Completion
IntelliJ - 8
Eclipse - 6
Netbeans - 5

Code Generation
Eclipse - 9
IntelliJ - 8
Netbeans - 4

IntelliJ - 10
Eclipse - 5
Netbeans - 3

Unit Tests
IntelliJ - 8
Eclipse - 6
Netbeans - 4

Version Control
IntelliJ - 8
Netbeans - 7
Eclipse - 2 (must be used via addon)

Open Source
Eclipse - 10
Netbeans - 5
IntelliJ - 1

IntelliJ - 10
Eclipse - 8
Netbeans - 4

HTML, CSS, Javascript
IntelliJ - 9
Eclipse - 9
Netbeans - 3

Kotlin, Scala, Clojure
IntelliJ - 10
Eclipse - 9
Netbeans - 0

Learning Curve
Netbeans - 8
IntelliJ - 7
Eclipse - 5

IntelliJ: 96 / 215
Eclipse: 67 / 215
Netbeans: 52 / 215

You should use IntelliJ if...
You just straight-up want to edit Java source. You don't need insane amounts of extensibility or the ease and official support of using Netbeans. Additionally, if you're going to be working with Android, you want IntelliJ.

You should use Eclipse if...
You need an open-source IDE that is as extensible as it is deep. If your project using many languages and technologies, Eclipse may also be the best bet for you.

You should use Netbeans if...
You are just starting out in the world of Java, or, for some reason, you're not comfortable with IntelliJ or Eclipse. If you are an instructor, you may also want to use Netbeans for your students.

You should use BlueJ if...
You have a mental defect, but don't want it to get in the way of your programming fun.

Hopefully this article helped you make your choice. Good luck!

No comments:

Post a Comment