Why I still prefer Eclipse to IntelliJ IDEA

Over the years, I've seen a trend of moving from Eclipse to IntelliJ IDEA. Last year, the usage of both was almost equal, but I feel the balance is slowly shifting toward IDEA.

IDEA is like the iPhone of IDEs - its users will tell you "Once you get used to it, you'll find it much easier to use", or "Why are you still using Eclipse?" or "IDEA is awesome, everyone should switch to IDEA", etc.

For the past 12 years I've mainly used Eclipse, but in some cases I used IDEA - when I was writing Scala, when I was writing Android, and recently - because Eclipse was not ready for the Java 9 release, I had to switch to IDEA after half a day of struggling until Eclipse finally had a working Java 9 version (with Maven and other things).

I always quickly go back to Eclipse. I still prefer it. Not just because I have internalized all the keyword combinations (which you can reuse in IDEA), but also because there are some things in IDEA that I feel are worse. Sure, IDEA has a lot of cool features like code improvement suggestions and it has effective plugins that can do practically anything. But I found some issues related to the more basic development workflow and experience. These "bullets" that cannot be sugarcoated are:

1. Projects are not automatically built (by default), so you end up with compile errors until you open a non-compiling file or run a build. Then turn on automatic builds and let the computer crawl. I know my computer needs an upgrade, but that's not the point - no "build on changes" was a huge "surprise" for me trying IDEA for the first time.

I recently complained on Twitter that this is "a feature". The argument seems to be that if you use refactoring, it shouldn't happen. However, there are dozens of cases where it happens. Refactoring by adding method parameters, changing parameter types, removing parameters (where the IDE can't infer which parameter to remove based on type), or by changing return types. Also, changes in Maven/Gradle dependencies may introduce compilation problems that you can't see. This is not a sane default at all, and I think performance issues are the only reason it's still the default. It makes the experience worse.

2. Only have one project per screen. Maybe those small companies with only greenfield projects exist. But you need a separate project at least occasionally - whether it's "experiments", or "tools", or whatever. Multi-module Maven projects (which IDEA handles well) are not enough. So every time you need to step out of your main project, you start another screen. Besides the bad usability, it's double the memory and double the pain.

3. Speaking of memory, the IDE seems to be more memory-intensive than Eclipse. I don't have representative benchmarks for this, but I know that my current 8 GB of RAM at home is too small for development, but I haven't changed it.

4. It feels less responsive and clunky. There's a tiny bit of lag, hard to tell, but "I feel it". I read somewhere that the IDE redraws screen elements excessively, so that might be why. Eclipse feels smoother (I know this isn't a good argument, but I don't have more precise data).

5. As smart as I am, the project has "unused methods" and "never assigned fields". Since I use Spring, these methods and fields are controller methods and autowired fields. Maybe some Spring plugin will take care of this, but Spring is not the only framework that uses reflection. Even getters and setters on POJOs will get unused warnings. What's wrong with these warnings? These warnings are depreciated. They don't mean anything now. Classes also don't have a "yellow" indicator, so you can't actually see the number of warnings. Eclipse is better at displaying warnings, and false positives are less common.

6. Call hierarchy is a bit worse. But since this is the most important IDE feature for me (along with refactoring), I must emphasize it. It will not give you the call hierarchy for default constructors that are not clearly defined. Also, what I have seen is that IDEA users do not often use the call hierarchy feature. I think before call hierarchy, "Find References" was also more obvious through the UI, so some IDEA users don't even know what call hierarchy is, but repeatedly "Find References". This is just one of the shortcomings of the IDE.

7. No search in the output console. Why do I have to copy the output and paste it into a text editor to search when I have an IDE? Wait, let me clarify, the console does have a search. But when I run the (Spring Boot) application, it outputs things in a panel at the bottom that is not the console, and there is no search.

8. CTRL + arrows skip whole words by default, instead of "camel case" words. This is configurable, but again a weird default. Almost everyone always wants to be able to traverse variables word by word (in camel case) instead of skipping the entire variable (method/class) name.

9. When I used it for Scala a few years ago, that project never actually compiled. But I guess that was more Scala's fault than the IDE.

If you say that, except for the first two, the rest are not major problems, I agree. But as the problems accumulate, these straws finally break the camel's back. So, I returned to Eclipse. Of course, you can also turn a blind eye to these problems, it is your freedom to choose.