Earlier quoted context omitted.
There's no comparison between using VSCode and IntelliJ for Java development
There's Eclipse too. It was almost always the better IDE for pure Java development. IntelliJ was always heavier and buggier whenever I tried using it.
Features I still miss:
- Real incremental compilation. Real as in, lift your finger and it's ready to run before you manage to hit the key-combination that actually launches the test. Intellij under the best of circumstances does not get closer than five to ten seconds (full seconds). Eclipse could run the same test dozens of time in the same time span. It was that fast.
- An IDE that does not lie about the compilation state of my project. Intellij is perpetually confused about this. It will tell me everything is fine when it is not. And the opposite. I can never trust it until I do a full rebuild. Which is slow. Eclipse was much more consistent with this. Make typo, everything goes red instantly. Fix the typo, the red disappears. It mostly stayed consistent throughout a working day. Occasionally it would need a little nudge and then it would fix itself and get back to being super responsive. Typically when messing with dependencies.
Those two are connected of course.
Intellij is two orders of magnitudes slower than Eclipse for this. That's a 100x. I'm talking ms vs. ten seconds plus. I could make a case for 3 orders of magnitudes for some things. I deal with scenarios every day where it needs half a minute (or worse) to boil the oceans where I know from a decade plus of experience that Eclipse would have caught up nearly instantly and it would not have slowed me down.
Unfortunately, Intellij would have to be redesigned from the ground up to get close to this level of performance. It's simply designed wrong to ever get that good. The fact that it relies on gradle (or maven) to do a lot of things means it's going to be bottleneck. Eclipse had a real incremental compiler properly integrated into the IDE and a good enough integration with maven that it could import classpath dependencies from there without needing to run it all the time.
It even did partial compilation when part of your code was wrong/broken (e.g. because you had not finished typing yet). It would still be able to run the non broken parts of it. And it would accurately tell which parts were broken. Intellij freaks out if that happens and quite often needs to be restarted to get rid of all the red squiggly lines for phantom problems. It will spawn lots of errors that aren't errors until you fix the actual error. There's a reason it has synchronize buttons, invalidate caches, and other functionality to force it to re-assess the state of things: it loses track of this all the time. Their issue tracker is full of issues related to this. People have been reporting them for decades (just in case somebody unhelpfully suggests I create an issue for this).
So, yes, I miss that. Kotlin particularly is a pain in the ass. As much as I like the language, I really hate it's compiler speed (or lack thereof).