There's no comparison between using VSCode and IntelliJ for Java development
IntelliJ was always heavier and buggier whenever I tried using it.
Google switched from Eclipse to IntelliJ for Android Studio mostly because everyone hated how heavy and buggy Eclipse was.
Eclipse's Java core is by far the best of all Java IDEs: refactoring, auto-complete, editing, etc. IntelliJ had earlier support for Maven and Gradle, but it was always a less-polished IDE experience using Swing vs Eclipse's native windowing toolkit.
Eclipse's ability to debug and run a single failing unit test were massive as well. IntelliJ was always hit or miss as to whether it would allow you to run a subset.
IntelliJ refactorings also were a lot less smart IMO - often trying to refactor unrelated comments and sometimes code that was unrelated but happened to be named the same thing.
I don't mean to sound rude here, but that just sounds like nonsense to me. How are you supposed to run code that won't compile? Does eclipse just generate random bytecodes for the party that doesn't compile?
> debug and run a single failing unit test
I'm not sure where the issue is for you, but this has always been available since I have used IntelliJ, going back 15 years.
https://www.eclipse.org/jdt/core/
> An incremental Java compiler. Implemented as an Eclipse builder, it is based on technology evolved from VisualAge for Java compiler. In particular, it allows to run and debug code which still contains unresolved errors.
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).
Pros and Cons, but my experience spending hours or even days solving IDE classpath hell in large projects is a huge annoyance to me, especially when the same issues don't actually exist in the 'real' build. So much that I'm willing to pay a few more seconds for every task/build initiation in large projects if that's the cost of having an accurate representation of the classpath in the IDE.
I also really enjoy Kotlin, but find the weird configuration and versions of the kotlin sdk bleeding between the IDE, build tool (gradle) and actual dependencies to be a source of confusion. This is especially true when building/publishing gradle plugins written in kotlin.