It amazes me that people put up with the gigabytes of RAM and full cores it takes to use Jetbrains products when VSCode/Vim/emacs can do 99% of what Jetbrains IDEs can do with LSP at a fraction of the power consumed. I guess fleet is Jetbrains acknowledging this shortcoming, but paying for current products that are marginally better than free and open source seems crazy to me.
If I need a Java program I install IDEA. It has support for all the java frameworks, supports all the build tools, can connect to a database and show me the data inside of it.
If I code C/C++ i install CLion and do the same, with an amazing debugger etc.
When I install VSCode I got nothing. I got a glorified text editor and that's it. I first need to install what feels like thousands of plugins, only for half of those to not work, then install fifty more because I forgot I even needed those until I did.
Or to put it more simply: I don't want a text editor, I want an IDE.
If someday someone can give me a download link for a VSCode release that has all the necessary plugins for a certain language already preinstalled and does not require me to install anymore or care about how/why this stuff works then I will give it a try.
But for now I will switch with my IDE. It might not be as FOSS as other stuff, but it is more comfortable to use, enables me to be productive and it just works. That's what matters to me
As a Python/Typescript developer I switched to IDEA from VS Code and never looked back. Debugging, code sense, full GUIs for test coverage - everything works right out of the box without tweaks or addons. Is IDEA's RAM usage massively higher, and if you starve it of RAM, does it lag obnoxiously? Of course. But I'm lucky to have a workstation that can handle it. If you do too, it's worth trying out.
Did you even try VSCode or are you just making things up? The official docs link you to a build of VSCode with Java extensions preinstalled, exactly what you’re asking for, calling the Coding Pack for Java: https://code.visualstudio.com/docs/java/java-tutorial
The OBE is much much nicer in IDEA - it figured out what I was doing (when I didn’t even know) and worked fine out of the box with Java8.
VSCode got into some loop where it demands Java 11 for highlighting code but then explodes on a Java 8 project and I’ll be arsed if I’m going to spend time debugging what’s wrong
I do use vscode for config files and other “quick load” things - it’s beating BBEdit there.
I'm the same way about jvm languages, but for ruby I use RubyMine as a text editor. The navigation is a bit more powerful than text search but could also get by with only the fast searching. The main reason for the choice is familiarity.
Oh and as mentioned in another comment the git conflict resolution is stellar.
I'm the same way about jvm languages, but for ruby I use RubyMine as a text editor. The navigation is a bit more powerful than text search but could also get by with only the fast searching. The main reason for the choice is familiarity.
I've used VSCode for Go and TypeScript/JavaScript for years. I recently tried switching to IDEA, and the difference is just stunning.
The Go support in VSCode relies on Gopls, which is a buggy mess. It frequently just stops working. It also lacks most refactorings (and no refactor preview). The Go debugger integration is okay, but Jetbrains' is miles better.
IDEA has tons of features that makes VSCode feels positively stone age:
* The "find/replace" across files has a result view with live editing.
* "Find implementations".
* Lightning fast search across many projects in one window.
* Symbol search, also lightning fast, across many projects.
* Extensive refactoring tools. Not just things like "extract method", but also linter-driven ones like removing an unused function argument, or fixing an identifier's spelling (updates all uses).
* Git support is tons better, including things like "Compare with..." allowing instant diffing against a branch or revision.
* Diff view is much nicer. It's also "live", like many things in IDEA; if you compare two files, the diff view updates when the files are change.
* GitHub integration where you can, for example, create, view, comment on, etc. pull requests within the IDE.
* Unlike VSCode, the experience out of the box is much more complete. I only had to install a few plugins (Prettier, my favourite colour theme, etc.).
I don't mind the extra gigs of RAM when the experience is so much better.
I don't like that it's not open source. But IDEA is a classic case of commercial software being vastly more mature than open source counterparts.
> * Extensive refactoring tools. Not just things like "extract method", but also linter-driven ones like removing an unused function argument, or fixing an identifier's spelling (updates all uses).
The latter is "Rename symbol", which VSCode supports for anything it has language support for, and which works across files where the language support includes that. The former is often suggested as a quick fix with VSCodes linter support. Neither is foreign to VSCode.
> Git support is tons better, including things like "Compare with..." allowing instant diffing against a branch or revision.
This is very much available for VSCode. Yes, it takes a plugin (GitLens and GitGraph are the two I use, the latter for history/branch visualizations and conducting operations from the visualization.)
> Diff view is much nicer. It's also "live", like many things in IDEA; if you compare two files, the diff view updates when the files are change.
Again, there's a plugin for that. (The one I use is just called "Diff", but the array of different Diff plugins for different preferences available for VSCode is...enormous.)
> GitHub integration where you can, for example, create, view, comment on, etc. pull requests within the IDE.
VSCode has this. I mean, sure, like almost everything else it is via plugins (the official GitHub Repositories plugin and the official GitHub Pull Requests and Issues plugin.)
> I don't like that it's not open source. But IDEA is a classic case of commercial software being vastly more mature than open source counterparts.
From your description, it seems mostly to be a classic case of an IDE having a better OOB experience for the set of functions it is intended to support than an extensible editor before considering plugins for the latter, rather than being "vastly more mature".
You cherry-picked a few things where VSCode has some extension support, but I can assure you that the differences are huge.
> The latter is "Rename symbol",
No, I'm talking about linter warnings providing smart fixes, which overall are not provided by the Go plugin, and is a mixed bag with other languages. GoLand has tons of fixes for things like unused arguments, inconsistent receiver names, incorrect spelling, and so on. And the fixes are previewed before they are applied.
But let's look at "Rename symbol". As an example of how primitive VSCode is, consider this in Go. If the rename doesn't work — for example, because it results in a conflict with an existing name in some file — it will just abort; it's all or nothing. GoLand, meanwhile, allows you to inspect the refactor preview and tweak the places where there are problems, before you apply the whole thing.
VSCode also has no awareness of implementations. If you try to rename, in IDEA, a method implemented from an interface, it will suggest altering all implementations, including the interface it came from. IDEA even goes further and will pick up strings that look related, such as in mocks, debug strings, comments, and so on.
> [Git support]
I have used GitLens, but the experience is vastly inferior to IDEA's. With GitLens, you have to compare the entire working tree (by selecting both versions to compare), which gets shown as a (not live!) snapshot in the left sidebar. You then have to click the file to compare. In IDEA, you simply select "Compare with Branch...", "Compare with Revision..." or any of the many other comparison methods, and you get the diff for the current file.
I also vastly prefer IDEA's diff UI, which can collapse unchanged portions (like classic UNIX diff). And while VSCode aligns the files strictly by inserting gaps, IDEA will cleverly align the code with visual markers, which I find much more readable. (IDEA has a toggle for the VSCode mode, of course. It also supports unified diffing as a toggle.)
I guess the GitHub PR extension has similar functionality as IDEA's, but the UI is primitive in comparison.
Some of your points are very true, but you should perhaps give a second try to VsCode because most of the features you describe are now available in VsCode or available in very common and popular VsCode extensions.
You need to install these extensions but that's the way it is designed, and a small JSON file is enough to have the extensions recommended in a given project.
> most of the features you describe are now available in VsCode or available in very common and popular VsCode extensions.
The question is: which extensions are those? And do they work?
With IDEA all this is just bundled. And you reach for extra extensions for, well, extra stuff that's no core functionality. With VS Code I've found it's a glorified text editor that you have make work, maybe, and unreliably.
It millions of man-hours of development to get VS Code even remotely near what JetBrains has been doing well for over a decade, and that's being very generous in judgement. How much money was wasted trying to get Electron to not perform super shitty?
Jetbrains software has its issues but it handles and has handled nearly every language I throw it save dotnet. And I grew up on big chunky IDEs and that is what I know and like. Vim is cool (I use it for more basic tasks) but lobbing molotovs like that only furthers pointless holy wars.
It still performs super shitty - I can get azure data studio to choke on 25 rows of data if its large enough. Anyone who says "vs code is faster" is in such a weird place to me.
The difference, at least with Vim and Emacs is the time it takes or time one can spend getting it all setup to do all the nice things the Jetbrains products just do out of the box.
I think the last time I fully revamped my Neovim setup I spent upwards of 40 hours learning, tweaking, and plugin shopping. And that was before Neovim shipped with it's own LSP so it was CoC. Now I'd probably spend however many hours converting my config over to the new setup.
The Jetbrains stuff just worked. I tweaked a small handful of settings and was good to go.
I'm generally allergic to anything Java, and desktop apps written in Java tend to scare me off. But I'm glad I got over that bias, because I've been pretty happy with CLion.
> VSCode/Vim/emacs can do 99% of what Jetbrains IDEs can do with LSP at a fraction of the power consumed
I've never experienced a comparable editing, inspections and refactoring experience with these LSP-based editors to what I get from JetBrains' tooling. It's absolutely not 99% :)
They really aren't comparable; IDEA is far ahead in profiling, refactoring, inspections, Git history integration, and probably a bunch of other things too that I haven't yet bothered to learn about.
You clearly don't know what IntelliJ offers. I've been paying a high price for their tools for years now, and will not stop. My colleagues are often on VSCode so i've forced myself to use it and learn it so i could help them when they struggle, especially junior people.
The difference is night and day. VSCode is a light code editor. IntelliJ is a rich IDE.
The database tool in IntelliJ is better than all other specialized DB software i've tried last year when i did a market study to try and find a good DB tool. That tool is hardly even advertised and is like 1 button out of 100 buttons in the IDE. The diff tool is another example of top of the industry software rivaling stuff like Beyond Compare.
Bottomline is you seem to not have dug into it before sharing your judgment of it with people who have
I’ve tried VSCode, Sublime, Vim, Eclipse, and IntelliJ for both Java and Python development. I’m more productive with IntelliJ for both (though Python is only more productive if I’m also extensively using type hints). Eclipse was the second best, but it had enough rough spots and slowness than IntelliJ still handily beat it out. The marginal productivity gain is probably in the tens of hours throughout a year, which makes it more than worthwhile for my company to pay the $99 for it.
I use Sublime for other coding where it’s fewer files (and Vim for quick text editing in consoles) and I’m quite happy with it as long as I don’t have to do any refactoring. VSCode is too slow for me in comparison and I kept running into bugs with extensions when I tried it a year ago or so.
You’ve already had a lot of comments to the same effect…
But I certainly don’t mind my developer tools taking more power since that’s what I’m using my computer for. When it comes to things like Slack/Teams, where that is not the primary function of my workstation (and, by it’s nature needs to be running on everyones computer) I get more annoyed at wasted resources.
Those are secondary functions of my computer.
Web browsing, instant messaging, email. These things should be as lean as possible to get out of the way of my real work, wether that’s after effects or photoshop or visual studio (the fat one).
> But I certainly don’t mind my developer tools taking more power since that’s what I’m using my computer for
If you are okay with being chained to a power outlet, sure. I often find myself needing to be on battery power, and applications gulping electricity is frustrating at best.
(I don't use the visual design tools you listed regularly, just writing / editing code and poking API endpoints, so maybe that has much to do as well).
And how is running an electron instance better than running the JVM? Also, intellij does actually have a battery saver mode which provides less intelligent autocomplete.
And just for your information, the JVM is the most power efficient managed language out there. With a somewhat saner heap size than the default the GC is very seldom run.
VSCode isn't the only alternative to Intellij. Sublime and VIM and emacs are also options, though I suspect emacs is probably a power hog- I haven't really invested a lot of time in learning to use it, though.
None of them are IDEs. Of course putting out a terminal text buffer doesn’t take much resources.
And yeah I know there are countless plugins for vim, emacs, etc. but when you are at even half of what intellij can do, it will be instable and full of bugs. Also, resource consumption does go up considerably even then.
Not from scratch if I can help it. Incremental compilation is fantastic.
As with complexity, there is necessary and accidental (or lazy) power consumption. I stick to tools that are lighter on power when I am able to.
Running unit / integration tests is probably my biggest drain right now, and unfortunately (to collect coverage and ensure no unintended consequences) I end up running the entire suite probably more than is ideal.
As others have mentioned, your experience seems to be drastically different from theirs. Maybe it depends on what languages you use and what features you need?
To me, IntelliJ is to Vscode as Vscode is to a plain editor without IDE features. The amount of additional value it brings is large, the level of polish compared to vscode is extreme.
It costs money and needs more resources. The licensing costs are recouped in a day or two thanks to increased productivity. The beefy workstation I use takes maybe ten days to be worth it (and Firefox likes all that extra RAM as well). And then you get an extra 20-30% more productivity for the other 350 days of the year. Feels like a no-brainer to me.
Besides what the other commenters have said, I have 32GB RAM. If Firefox or IntelliJ don't use it, nothing else will. I'd rather have the applications I live in utilise as much memory to make the experience faster and better, than to have unused RAM be wasted. IntelliJ is far superior over VS Code, VIM, etc. IntelliJ is batteries included, whereas VS Code, VIM, and most other editors require additional configurations. Some configurations I've seen have required hours and hours of set up and integration. With IntelliJ on the other hand, it just works. I click run on the main function, and it asks me for the compiler/runtime config the first time round, and afterwards it just fully works. Even running tests is as simply as clicking run from there on.
Some language servers (e.g. PyRight) also regularly consume 2GB RAM for me when using Emacs. Also, for some languages, their IDEs are just way ahead of the competition (e.g. Java). Even for e.g. Rust CLion works really well.
(I probably use Emacs and JetBrains products 50/50. I prefer the keybindings of Doom Emacs, but prefer the JetBrains IDEs for actual development. E.g. refactoring is a lot easier.)
I'd almost forgotten that a lot of the (n)vim language servers require Node.js. The first time I tried CoC it was over an ssh session to a small VPS I had.
I started up Neovim with the new config, and promptly had my ssh session hang. It took me a little bit to figure out that I'd maxed out the 256MB of RAM on my little VPS and hard locked it. Had to get a bigger VPS to actually run my editor.
There are a few languages I won't touch without an IDE: Java and C#. For Java I use IntelliJ and I don't write C# at all anymore. Otherwise, I use Vim. VSCode is a complete non-starter for me. I glanced at it a long while back and quickly concluded it wasn't going to give me an editor experience I would enjoy. In particular around "windows" to view files/sections of a file. Something that IntelliJ also doesn't do a good job of, but it does provide a huge advantage for Java code.
you can write concise Java, and don't need to use Spring or similar. even then (and arguably especially then), Java IDEs (intellij, netbeans, eclipse) are a huge win since they natively speak the strong static typing and AST, allowing you to refactor much more aggressively than you otherwise could
netbeans is my personal favorite - you can throw (at least, on low end hardware) 50ish large interconnected codebases at it (microservices, libraries, frameworks, etc) and it can find usages / change signatures / rename across all of them with almost perfect results (reflection, serialization and unsafe usages are the only places i've seen them miss). intellij isn't quite as seamless for that many projects, but the code understanding is similar
Sometimes good enough defaults are really good enough.
There definitely was a time in my career (admittedly before VSCode and some of the other cool new kids on the editor block even existed) where I obsessed over vim plugins and macros and themes - but these days I love that consistent out of the box experience, too. Plus the IDEA has DataGrip embedded, and I love having a good database client right alongside the code I'm looking at.
As I've gotten older my whole philosophy with tech has shifted towards not letting the perfect be the enemy of the good, editors/IDEs included.
VSCode has also the problem that sometimes plugins work, and sometimes they just don't. Live Share for example logs me out at random times, cannot connect, or cannot find files on the remote computer. The same kind of inconsistencies appear in the Angular plugin which sometimes finds definitions, sometimes it doesn't; it's basically roulette if I can use the jump to definition or find references functions today.
With JetBrains' products I get everything out of one hand and it just works. The IDE gets out of my way and I can focus on developing. If something doesn't work I can create an issue and it will be taken seriously.
The 1% VSCode/Vim/emacs doesn't do is exactly why I use IntelliJ and PyCharm. Refactoring, code analysis and debugger integration is lightyears ahead of the competition in my experience.
It's up to you to decide if Jetbrains' stack is right for you or not. For many simple projects, it's really not worth the hassle. Just because you don't use the extra features doesn't mean nobody else does.
I am inside and it is.. not that interesting to be honest. Not bad, but it is pretty much a cleared up intellij with much less functionality and an eclipse-like left pane where you can have non-project folders as well.
Regarding the much less functionality, the run button is not really configurable by much so more complicated projects can’t really be worked on yet. But I’ve just updated the package so I’m talking about a somewhat dated version.
Is this some definition of % with an implicit divide by 10, because VSCode can't even do 1/10th of what IDEA can do for Java or Kotlin, and in basic operations like VCS, Diffing, debugging, profiling, refactoring, find/replace, code analysis, auto-generation, etc it's lightyears better.
Maybe for dynamic languages, it might not be as powerful, I'm not a heavy user of IDEA for JS or Python (but WebCharm and PyCharm do seem very good), but I will say, the Typescript support in IDEA seems very good.
Writing code and what comes with it is the one potentially resource intensive thing I do at work. It's not like I'd be gaming at the same time. I don't really care if my programming environment takes up a few gigabytes of my 16 or 32 gigs of available memory. That's why I have it, no? Perhaps that "1%" difference is something that makes my daily work a lot nicer?
I‘d argue that one should not compare editors to IDEs as they are not comparable. I was using VIM professionally (i.e. at work) for many years until CLion showed up. Sure enough I could get around in VIM using many LLVM tools such as clang-rename, clang-format, clang-analyzer etc. but an IDE is doing much more (of rather is capable of) than editing text efficiently.
Thank you -- the best parts of JetBrains' tools are brilliant, magical almost, but they are let down -- almost completely -- by the performance problems and stalling, and given that their target market is programmers (who are an opinionated and impatient lot), one would think that they would pay attention to such performance/responsiveness matters.
It is mostly due to them using an old GC algorithm instead of the default that comes with JDK 11 (what they use). Changing to G1GC with a slightly higher heap size makes quite a difference.
I don't care much about RAM tbh and CPU usage is fine. If it were faster, that'd be great. But what I get is great extensions, language support, debugger, etc.
When I've been forced to use vscode I'm pretty shocked at how weak the experience is.
This sound a bit like "I don't understand why people use planes to travel on land, I do well with my bike or my car" Sure and I'm glad we all have the choice to choose what fit our needs.
