Unfortunate, because it had (has?) a great Swing and UML editor, built-in for free.
Maybe I'm wrong and it's awesome now, but I haven't used it for a while in favor of Eclipse, and now, IntelliJ. This graph illustrates the IDE popularity between Intellij and Netbeans. IntelliJ became preferred over Netbeans about mid 2014.
Netbeans was really great, maybe still is, but the noise jetbrains made with the astroturfing advertizing has jetbrains dominating everything.
IMHO Netbeans was ahead of idea in many ways. But since they didn't buy commenteers to hype their product it's pretty much nowhere, at least I don't know anyone who uses it.
I'm someone who has regularly recommends Jetbrains software (including IntelliJ and Resharper) to others in comments, and now I'm wondering if they forgot to send me my check.
I am using it now because the team is using it, but cant figure out in which way it is supposed to be better then Eclipse. It looks somehow better, but it seems strictly inferior in terms of what it does for me.
I find both mysteriously stop working on a project for a while so I keep them both.
Eclipse has far better refactoring. IntelliJ refactors text files that are not Java and can easily break stuff when eclipse refactors are always safe. IntelliJ updates text strings but it's not always correct in doing so, é. G. A comment that says "_don't_ use a.b.C" might get refactored.
In eclipse you can often safley "code backwards" i.e. break an API and then fix all the red dots, usually with auto fix options. IntelliJ misses a lot of necessary fixes until you compile. That can add hours of work to a big change.
Incremental and partial Java compilation. Partial compilation is the notion that partially compiled software is still usable and something you can debug or introspect on. The IDE compiles while you type, it will detect syntax problems and as soon as you fix them they go away. Error markers in intellij are nowhere near as fast and you can't trust their presence or absence to be correct either.
Intellij does that a little bit of incremental compilation. They half integrated the eclipse Java compiler at some point but they never really made using it a thing. Most projects just hand off compilatio to Gradle or maven, which means you lose a lot of time waiting for that and dealing with various caches in intellij and gradle/maven getting out of sync with each other. The process for fixing that generally involves boiling the oceans and running the CPU at 400% for a few minutes.
Eclipse compiles two orders of magnitudes faster when you have it properly setup. I'm not exaggerating. It's really good at this. Intellij users have never seen this level of performance. I've tried to explain it a few times to users that insisted they had intellij configured just right. The minimum execution for a unit test after a 1 character code change is the key benchmark for this. Run a test, change something trivial, run it again. If that takes more than half a second and has a noticeable delay, it's not fast. Eclipse user to be closer to 50-100ms. Even on a (now) ten year old laptop. With intellij, it's closer to 3-5 seconds. They have improved things over the years but it never got even close to that level of performance.
Thanks, that sounds very cool. As you say, intellij basically hands this off to gradle or maven. Does Eclipse interpret those natively or do you have to reproduce your maven build in the Eclipse gui?
Compilation of everything, how it shows compile errors and warnings. I see them in tree, in list, easily and quickly all of them. All of them for whole project at once and trustworthy. Less bogus warnings and contraproductive suggestions.
I never needed to fiddle with "command line shortener" ridiculousness in Eclipse.
Better code navigation and discovery. Eclipse always finds everything, every called and callee to depth. Same with inheritance. Even where Idea has same views, for some reason they hide it and only former Eclipse users stumble on it.
Actually safe refactorings. Idea occasionally "refactors" by creating bugs.
I had some cases where Idea simply formats code wrong. And it was impossible to configure to formát it right.
Also, Eclipse compile by default. It is ridiculous to have to remember to press shortcut to compile in modern IDE. I know it is configurable, but still ridiculous default.
Elipse keeps a complete Java representation of the source code in memory, (not the classes) that's why it can find compile errors before saving.
This comes at the cost of lost of RAM, some projects are just too big for eclipse so IntelliJ is your only option.
But that eclipse model can be used for lots of cool tricks, you have access to it in the plugin API, so for example you can enforce coding standards before even saving code.
I would argue that if a project can't fit into Eclipse with 32 GB RAM then perhaps the code base has become too large to manage and ought to be split into separate projects with dependencies.
Eclipse immediately tells you what is broken when you change an api. IntelliJ does not.
You can't stop IntelliJ from saving work. I like to kick of a build, and work on some new stuff while it's going on without saving until the build completes. That workflow is impossible in IntelliJ.
You have to down tools, for a long build with lots of tests that can make IntelliJ slower over all. IntelliJ generally more responsive for most work, but that's because it's not using Java's type system to find errors as you work, errors are deferred, which often means they take longer over all to fix.
It just takes two check boxes to uncheck to disable that in IntelliJ. I agree it is disturbing that it is a default at first. But it is at least configurable.
Eclipse shows me all errors in whole project at once. This is biggest one. The hierarchy and callers hierarchy always work, I can rely on them way more then in Idea where they sometimes miss things.
Much much better full text search. I can search through multiple projects. Not just root.