It runs very well on my 16GB RAM. I find a lot of the speed is in internet and hard drive speed. It opens up a full project in 3 seconds with a SSD, assuming there aren't too many dependencies.

I was also forced to buy an SSD to make my life easier, but lets be honest, SSDs are still quite expensive on price per GB on first world countries, let alone the rest of the globe.

Same regarding RAM, I know of companies that a standard developer machine is 8 GB, while everyone else gets 4 GB.

Getting something like 16 GB is unthinkable unless that is a business related change request.

So basically making the life miserable for those developers.

you're right - SSD makes a big difference too.

Try it with something non-trivial. SSD here as well, the difference between Android Studio and VSCode is night and day.

I dont think you could rightly compare the two. One is a full IDE the other isn't.

Visual Studio (not code) is the most smooth actual-IDE I've used, by a wide margin.

The whole damn thing just uses only one thread for UI, how is that smooth?

Mostly in context of text editing/auto completion hints. With e.g. intellij there's enough choppiness/delay in typing and completion to really put me off.

Have you tried the new versions with Zero Latency Typing? As the name implies, they managed to basically eliminate all latency on typing, even beating apps like notepad++ and emacs on latency. It's switched on by default in the current release.

https://pavelfatin.com/typing-with-pleasure/#windows

Was that before or after Visual Studio became a bloated pig?

I use VSCode as a full-blown IDE for Rust(including jump to def) and it works great for that.

Jump to def is like the minimum thing of a IDE

Well, there's also a debugger, source control, syntax highlighting and intellisense.

Looks like an IDE to me.

Pretty primitive compared to what IntelliJ actually does, which for Java (and typed JS, Scala, Kotlin, etc) is full source code indexing and understanding of the type hierarchy.

That means "Find Usages", "Jump to Implementors/Overriders", "Show Substypes", etc all work correctly. When you ask for code completion, it's far above what IntelliSense does. IntelliJ will actually understand all of the variables and types that are reachable in scope, as well as those that are reachable by calling methods or accessing fields on those types two or three levels down. This is not the same as just examining what's reachable via 'this' or what's to the left of the '.' character.

https://www.jetbrains.com/help/idea/auto-completing-code.htm...

The autocompletions are also ranked and sorted properly most of the time. Think of it as the difference between a shitty search engine and one that shows the most probable autocompletions first. Even Eclipse IMHO is pretty bad at this, and will often try to suggest meaningless classes somewhere on my classpath that I'm obviously not going to use, including internal sun.* implementations.

IntelliJ's refactoring and code analysis is also far above what XCode and VSC do. I've been using IntelliJ since the first version, and to me XCode and VSC aren't much of a step above Emacs as an IDE.

Syntax Highlighting, VCS integration, Debugger, and Jump to Symbol Definition are table stakes that even basic text editors have.

Erm, VSCode does all of that for Rust via RLS and the Language Server Protocol[1]. Heck, VSCode does even better than Android Studio because the pick common words in the source file as part of their auto completion. Things like comments, untyped parameters(ints, etc) all work much better in VSCode.

I'll agree that for Java VSCode isn't up to par yet but for many other languages it's easily at an equal level.

[1] https://github.com/Microsoft/language-server-protocol

VS code gets full intellisense for e.g. C# (omnisharp), and many of the implemented language servers do real-deal source code indexing.

https://github.com/rust-lang-nursery/rls for rust

This is a matter of opinion, but language-specific navigation, searching, and refactoring is where I'd draw the line between an editor an an IDE. VS Code may not be there yet, but they're improving quickly and I think it's only a matter of time.

Better search ranking seems like a feature that could easily be added (though it has to be done for each language).

I'm happy to see competition in this space. The end user might not see it, but IntelliJ internals are pretty horrible from a plugin developer's point of view and haven't improved in many years. Moving language smarts to editor-independent servers (with VS Code's Language Server Protocol) seems like the right architectural move.

While I agree that IJ's internals are spaghetti, the VS LSP isn't quite the same, or at least, it appears to me, it does not offer the richness of IJ.

Consider that IntelliJ can syntax color and autocomplete multiple language grammars at once, e.g.

String aJavaString = "<someHtml onFoo='someJs.style=\"color: red\"; var regex = new Regex(\"someRegex\");'">

Does VS's language server protocol handle the ability to deal with nested language grammars each with nested contexts?

My issue is false negatives: IntelliJ usually just "works", especially with Java, it's near perfection and almost never gives a wrong completion. I've never encountered another IDE whose code understanding was as complete. Even a 2-3% false completion rate is super annoying.

Plus, the refactoring, structural search, and callstack analysis stuff is beyond reproach. Can VS tell me all possible reaching expressions to a given method? I've used that before to figure out what kinds of subtypes or nullability a given parameter has, but it requires global code understanding.

I feel like the kind of functionality that grok style code indexing provides is just the baseline, and what's important is what's built on top of it. VSC has a long way to go to reach IJ in that regard.

Looks like they just added nested languages in the latest version: https://code.visualstudio.com/updates/v1_17#_language-suppor...

While agree that IntelliJ is pretty great the Android Studio implementation of it is nowhere near perfect. I've had false lints, incorrect flags and a whole class of issues where intellisense goes wrong.