Do yourself a favour and try out Code for your next project.
But I would die before I switched away from Rider or Intellij. The auto suggestions, code smells, auto refactoring, ease of debugging, I could go on. It removes so much friction from developing that I feel like I have a hand tied behind my back when I move to anything else.
I often wonder if these people who recommend vscode as a "for everything" IDE have enough experience with the IDEs to know what they are missing by strong arming vscode into working for them.
It's a fine lightweight editor but if you want to refactor or do anything complex you want something like IDEA in your pocket. It comes pretty much "Batteries included" whereas you have to build your own IDE with VSCode which I don't have the time or effort for maintaining. I get that IDEs can look scary or seem bloated but once moving first to PHPStorm then IDEA I realized a lot of my "facts" about IDEs were either completely wrong and/or the heavier weight was actually worth it.
I'll be interested to see if JetBrain's new Fleet will eat into VS Code's market (it's a similar tool).
Also, both have 3rd party plug-ins but JetBrains seems to contain a lot more of the features I want as first class integrations whereas I generally have to find a plugin for VSCode and hope it's well maintained.
I will say that writing a VSCode plugin seems much easier than an IntelliJ plugin. So if you need that level of customization, VSCode might be the preferred tool.
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.
Even just using two fingered trackpad scrolling to move the view port is something I do almost everyday without thinking about it.
If you wanted to you could also highlight text, show balloon help, select windows and tab and interact with file explorers.
Of course you can do all that very quickly with keyboard shortcuts, which is what I mostly do, but they option of the mouse is still there.
A lot of developers looking for that VSCode experience are actually switching to Rider, even those who already have a Visual Studio license/MSDN via their employer. Ultimately Visual Studio is just a laggy, micro-stuttery, monolith, with a UI designed to create Forms for Visual Basic back in 1995. The x64 migration has helped, but it feels like a band-aid.
If you're doing Web Development in Asp.net Core in 2022 you don't really feel at home, not least of all because you may be using VSCode already to do TS/SASS/CSS/JS/etc.