I used to think VS Code was going to be a threat to JetBrains IDEs considering how fast its iterative development was (thanks in large part to the productivity of JS + Web renderer) but its never seems to quite be able to reach the feature-set, polish & intelligence of JetBrains IDEs.
Every IDE function appears to be better implemented in JetBrains, whether it's Code Analysis, Refactoring, Navigation, Running/Debugging, Running Tests, adding new files, git integration or contextual functionality like adding package references etc. Everything is just better in JetBrains.
I see VS Code as an ubiquitous smart editor platform with zillions of plugins that's half way between a glorified text editor and an IDE which I use a lot for quick dev changes, quickly searching a folder, front-end UI development, trying out new languages or writing docs. But if I have to start a long dev session I turn to JetBrains which I find far more productive.
Part of it feels like it comes from a different development philosophy.
Vscode is a "text editor" or a "code editor". Usually this means that it's fairly lightweight, supports every language under the sun, is highly configurable and extensible, but doesn't have a lot of very in-depth features, and also partially relies on third-party extensions for deeper functionality.
Jetbrains on the other hand works on IDEs built for one specific language explicitly. Consider CLion for C, it's only a couple of years old!
They put a lot of resources into supporting a language and all its relevant workflows. Phpstorm for instance has built-in support for three different standalone code quality checkers, composer (package manager) support, deep language understanding with highlighting, warning, errors, refactorings, generators etc, doc comments, code formatting, support for different testing frameworks, a built-in debugger, etcetcetc...
While that's great, you shouldn't go edit python code in Phpstorm. It supports syntax highlighting and maybe a couple of other small features, but that's it!
In short, code editors usually cast a really wide net with a lot of configurability and extensibility, while (jetbrains) IDEs tend to go really deep on a single language or workflow, with less extensibility, and deep configurability within the supported language itself.
I wonder if you have had the chance to use a Jetbrains IDE with a professional license. Doing so gives you access to more or less the content of all the other "flavors" as plugins (it's basically all IntelliJ underneath).
For example, I've been using PyCharm for both our python backend _and_ our React + Typescript frontend, all in the same project window, with the same features regarding syntax, linting, refactoring, tests, debugging, etc.
I have. IntelliJ ultimate edition still has fewer features for PHP specifically than Phpstorm.
Presumably not because it actually has fewer features, but because "the debugger" now has 150 options instead of like 5.
Also, these super-featured IDEs still won't support languages that Jetbrains doesn't have a specific IDE for. For instance, Delphi. Sure they'll support syntax highlighting somehow, and there might be one plugin.
VSCode probably has 20+ search results if you look up Delphi
As someone who used to develop in Delphi for my day job, but has been mostly out of the loop for the last ~10 years, this really got me curious: do people actually use VSCode for Delphi? I mean, Delphi already comes with an IDE, including a GUI ("Forms") designer - that was its killer feature back in the nineties, that you could slap together a GUI app as quickly as in good ol' Visual Basic, but backed by a compiled language. Maybe the text editor is better in VSCode, but still I imagine it's pretty hard to deliver the same experience as with the "native" Delphi IDE? So I can understand that JetBrains doesn't see a huge market for that (unless they could become the official Delphi IDE, like they did with Android Studio).
I have current Delphi project with heavy GUI. I'd be out of my mind to use VS Code for it. I use VS code for scripting stuff where it more or less shines (JS, Bash scripts etc). Same for C++ - Visual Studio/QT Creator and CLion fill my needs way better than VS Code can ever do.
No clue, I just picked a random not super mainstream language as an example.
I'm sure vscode is terrible for Delphi, but I'm willing to bet that the experience (with whatever third party plugins exist) will be better than any jetbrains product.
I did not try that myself, but I think that you can switch enabled plugins with a simple text file. So you should be able to write simple BAT files to launch Idea for different sets of plugins if you need to.
Or may be there are better ways to do so. Anyway just enable what you need.
Just 5row money at the problem and configure your machine with more memory. Docker for Mac already eats a ton so I’m not sure there aren’t other good reasons to do so.
I've been using it for the last 3 years. At first it was slow, and running out of memory (it was in-process in Visual Studio, which is limited to 32-bits), but now that they've moved a lot to out-of-process it's much better!
I don’t know what version you use but Visual Studio 2019 is so full of bugs that it crashes multiple times a day or I simply restart it as some features such as codelens simply stop working and it becomes cumbersome to find references. Im sure they’d get their s__t together in the next version but so far I’m stuck with a crappy IDE. I’ve had a similar VS experience in the past and while it works it’s okay when I can upgrade i am super reluctant to do so. Yes, MS does push half baked versions quite often
For example I used to just own Idea Ultimate and use the language plugins, but the workflows were always inferior to using the dedicated IDE for that language.
So I now have the full JetBrains suite and use a mix of Rider, CLion, PyCharm Pro, AppCode etc...
Yeah, I basically use IDEA as Rubymine instead of using Rubymine. It's a fantastic polyglot IDE, and for my uses it supports all the latest Ruby + Javascript workflows.
There is most certainly a lot baked into the language-specific editors that isn’t in IDEA proper.
That said, the fact that they all share IDEA’s gubbins makes it massively easier to jump between languages and frameworks for small jobs than I ever thought would be possible.
Having a set of tailored environments that also share keybindings and most common features makes for a fantastic (and really under-appreciated) value proposition.
There just isn’t a C#/.NET plugin for IDEA that replicates the Rider functionality, though. Same with CLion and AppCode. They do ship Ruby and Python and PHP plugins. The JavaScript/web dev stuff is baked into all of their IDEs.
Which means IDEA does not contain all the features of the individual IDEs.
The thing is, I’m confident in saying the plugins don’t replicate 100% of the feature set of PhpStorm or WebStorm either, but I’d defer to someone from JetBrains who has first hand experience.
If you're confident, what features don't they have?
I subscribe to all their products so I can verify this :) I'm not sure why they don't have C# or C plugins but my guess is that it's because there's enough extra work in those IDEs that they want more money for them. Rider contains the ReSharper backend, which is a completely different application from IntelliJ.
Turns out 99% of my work is in something like Java, Python, or JS. Once you include other JVM languages, C++, PHP, and Ruby, IDEA's coverage is huge. They even have C#, Objective C, and Switft offerings, but there's something to be said for staying in those ecosystems.
One thing to note is that you can use IntelliJ and install the official plugins for each language. For example you can bring the WebStorm functionality to IntelliJ, or install the database plugin to get an embedded Datagrip window. (Which is really neat because you can then get SQL syntax highlighting and such based on your actual DB)
IntelliJ ultimate is the main IDE. Everything else is a version of IntelliJ that has been configured for a specific language. IntelliJ should, theoretically, be able to behave like any of the sub-IDEs, but the reverse is not true.
The simplified setup for modules in the language-specific IDEs alone makes them worth it IMO. It’s great that the plugins in IntelliJ cover basically everything but CLion, AppCode and Rider - but if I’m working on Python, JavaScript, PHP or doing database work I’ll still fire up Pycharm, WebStorm, PHPStorm and DataGrip respectively because there’s less overhead getting my project imported (and DataGrip is more useful as a standalone DBA tool because I open it and all of my connections are right there).
Given the individual license cost difference between IntelliJ Ultimate and the All Products Pack is minimal it’s worth it, especially given it’s cheaper than IntelliJ + CLion separately.
Even just using the correct language terms is helpful. IntelliJ modules contain packages, because that's how Java works, which makes it super confusing when your modules are python packages and its subunit (called package in the UI) is a python module.
Yeah by the time you need two IDEs you might as well just get the suite.
It also worked out well for me because I bought Ultimate on sale, and the suite was discounted for existing owners. So it's really been good savings. Regardless, given the time savings the IDEs give me, they pay themselves off pretty quickly.
As much as that is true, I have a license for all of them and always use a few of them instead of the main IDE: CLion, Goland and Rider being the ones that are really much better for their respective domains because they are so different.
That didn’t used to be the case. You used to be able to add the Python plugin to the free IDEA ide and that would give you java + pycharm - but only the free tier features of pycharm.
However, if you used the paid IDEA, adding the Python plugin gave you full PyCharm capabilities EXCEPT that IDEA was always based on version N of the core IDE platform where PyCharm was based on N+1 version, i.e. the smaller pycharm IDE sometimes had some newer platform features than the IDEA ide which led to occasional differences between IDEA + Python plugin vs PyCharm.
I switched to VSCode last year and let my licence lapse for Intellij so things may have changed.
What i will say, despite having moved to VSCode and being entirely happy - Intellij is the better platform. It’s the difference between 80% and 99% though, and the VSCode 80% is good enough. If i went back to full time dev, i would buy another jetbrains licence.
Intellij allows you to install pretty much most of the features from all the other jetbrains IDEs as plugins. Additionally most of their IDE's have the ability to code in several other languages seperate from the core experience. Almost all of their IDE's can for example integrate with the javascript ecosystem.
I think you're making a mistake here. Essentially behind the scenes there's one jetbrains IDE. This IDE is a single platform that can take plugins and code in any language and be customizable to your hearts content.
ON the surface however Jetbrains doesn't exactly release this IDE to the public. They deliver different configurations and different defaults on TOP of this IDE, then they lock it down a little and ship each one of these profiles under a different name. All these IDE's are basically different bundles of plugins running on the exact same core platform.
That's why CLion is only a couple years old and still really good. It's because all Jetbrains needed to develop was a plugin and shove it into an existing ecosystem.
This is no different then Vscode when you think about it. Both are coding platforms that can be plugged with new features, it's just that jetbrains locks some of this customization down and sells their IDEs with bundles of plugins that offers a better core experience.
What makes Jetbrains better is this focused and higher quality bundle of features that feels cohesive. What makes jetbrains worse is that this central platform they're developing for is bloated. Everything is slow, takes forever and can lock up.
If Jetbrains just did something to speed up the platform then pretty much IMO it beats anything Vscode has to offer.
A faster/lighter JetBrains IDE would beat everything in VSCode... except for price. CLion and WebStorm and PhpStorm cost money, there's no dedicated Rust IDE yet, and you have to pay money for CLion or (IntelliJ Ultimate) (not Community) to debug Rust programs.
There is already a Light Mode version of IntelliJ designed to compete with Sublime Text and maybe VS Code. It's not entirely obvious that it exists and they need to market it way better, but if you run "idea whatever.txt" from the CLI and the IDE isn't already open, you'll open in light mode. It starts nearly instantly because it's not loading all the plugins and project infrastructure.
And still, it's really cheap if you consider the amount of work you have to put into configuring other products like VS Code where you end up with an inferior experience. I think it pays off.
For a professional, jetbrains basically pays for itself within a day of starting to use it (in my opinion). I know a lot of people prefer VS code, but I frankly cannot imagine why.
> Almost all of their IDE's can for example integrate with the javascript ecosystem.
That’s mainly because they don’t have a Javascript specific editor. I cannot even syntax highlight groovy files in PhpStorm, even though I’m paying for the full pack.
But I think that is literally my only gripe with Jetbrains :)
The plugin infrastructure for VS Code along with excellent first party support for JS/TS has helped it grow very fast. But in languages other than TS the mishmash of plugins of varying quality really degrade the experience. The opinionated approach and strong first party support just makes Jet Brains product much cleaner. I use both a lot.
Indeed, I haven't used VS Code a lot but my few experiences with it were largely figuring out which of the available plugins for a particular function was the "right" one, with all of them sitting at various levels of "working". The IntelliJ, Sublime, and heck even TextMate 2 plugin experience is cleaner in that regard.
I use both. IntelliJ being a paid personal subscription. I like both. But VsCode excels in their remote editing capabilities. Sometimes I work on code that will only compile on a Linux and I am on a Mac. It is not just remote debugging - the whole environment including language server works flawlessly via remote while making you feel like local development.
It is good for two good IDEs to survive. I don’t want one of them to win. There is room for two.
I only wish the opensource development model of plugins (for both IntelliJ and VsCode) doesn’t come to bite us one day with a rogue developer inserting malware. The whole review/reputation system should be like Apple App Store
VS Code Remote Containers is another cool feature. You can develop inside any Docker container locally. This could essentially mirror whatever image you have deployed into Kubernetes, GKE, GCS, etc.
I still mostly just SSH onto a workstation for any of my personal work, but every month or two I'll check out the latest batch of self-hosted remote IDEs. My favorite by far (with caveats -- a few of your favorite extensions have licensing issues, and the mobile UI is garbage) is a fork of VS Code designed for doing exactly that. Check out https://github.com/cdr/code-server.
I went this route with code-server[1]. But later decided against it because some shortcuts don't work in the browser. Also installing and managing code-server on those VMs had started becoming a chore.
I am using remote-ssh instead. Hassle-free and works like charm.
Can't comment on sudo issue because I mostly log in using root.
I think that sounds about right. I see vs code as a jack-of-all-trades, master-of-none type of tool. if I want to try something in a new language or just edit some text real quick (I find vs code has better than average support for weird text encodings) but keep a familiar ui, I go with vs code. if I'm going to be doing some more in-depth work, I'll spend the time to learn a purpose-built tool. I mostly write c++ for windows, and I find vs code can't really compete with its big brother (bloated as it is) here.
This sums it up for me. For languages with a dedicated Jetbrains IDE (Java, Ruby, Python, etc) Jetbrains will be better experience hands down.
For everything that doesn’t have the premium experience, I find that just using plugins isn’t as effective.
For example, the experience of using IDEA with the Elixir plugin hasn’t been great despite a lot of development. It seems like it constantly loses the proper SDK if I jump between projects.
The VS Code experience has been a lot better for Elixir though. Just works. The moment Jetbrains releases a dedicated Elixir IDE I’d jump for it though.
I agree. Intellij ultimate is the best polyglot work environment I've ever used. The primary project I work on has Java, kotlin, groovy, python, typescript, js, shell scripts, dockerfiles, various configuration files, etc. Intellij Ultimate handles them all equally well as the more specific language flavors in my experience.
Not sure how many devs code in a single language these days. I go back/forth between Go, Dart, and C++ every day, so using one IDE like VSCode (with the familiar features from extensions to shortcuts to snippets) is a big help.
I do have to maintain libraries in several languages, basically every JetBrains IDE has built-in first-class support for JS/TypeScript + all popular Web file formats irrespective of whatever backend language you're developing in.
For C#, F# & VB I use Rider.
For Dart, Java & Kotlin I use Android Studio, but if I need to do a lot of development with Java/Kotlin I'll bounce to IDEA.
For TypeScript/JS npm projects I use VS Code for small changes, but bounce to WebStorm for longer sessions.
For the Swift package I use Xcode for development & VS Code for git, update docs & run publish scripts. Unfortunately ran into issues trying to build my project with AppCode.
For all other languages (used to develop project templates & packages for https://gist.cafe) I'll use VS Code, but that's mainly because I don't have the IDE installed. If I had to spend more than a couple of days working on a language that JetBrains offers a dedicated IDE for I'll most likely be installing & trying that out, before falling back to VS Code (JetBrains All Products Pack + Unified Toolbox Updates makes this effortless & feasible).
Jetbrains provides plugins for Intellij that support almost every other language they have a "dedicated IDE" for. That's what I do and it supports almost every language I throw at it. The exceptions that I know of are Rider and parts of Android Studio
I don’t since you end up with either complex configuration to surface language specific tasks. Having well thought out defaults, tools, etc by separating them out into different IDEs allows for ease of use you couldn’t get with one IDE to rule them all approach. Yes, they sell different IDEs that share a large core but I think the incentives are well aligned for sustainable business focused on developer satisfaction.
Nah. Would have to disagree on this front. These should still work. After all each language/runtime is defined by some underlying template (for example in Visual Studio - .vcxproj for C++, .csproj for C# in .NET, etc.). I don't see reason all of this to work under one Umbreall IDE, even if I have to pay more for it - I'd rather pay for it, than the bundle I'm getting now.
if you use intelliJ ultimate edition you have official plusing for all languages for ex: I work on golang, scala, python and JS using intellij ultimate.
A somewhat radical rephrasing would be that the IDEA products occupy the space that used to be held by Borland IDE or something like Quick Basic whereas VSCode seems more like an Emacs for the javascript age. (which I find surprisingly fitting, considering how according to The good Parts javascript is just a scheme with curlies)
I agree, I'm a long term IntelliJ polyglot, and I watch people in pair programming or video call refactor in VSCode and I feel sorry for them. Stuff goes sideways badly with dynamic languages, worse, they don't have a grip on it.
Simple stuff like code formatting and structure of files isn't well respected by vscoders <I find>.
IntelliJ got a bad wrap I guess because it all started with Java. I'm glad I had a short gig in Java to discover IntelliJ back then. I really think their software, although getting quite complex now, and the plugins can be a little sketch, is the best IDE out there <unless you're a vim nerd who swears by vim and will die on a sword for it>.
The almost perfect Vim support is why I pay for JetBrains’ AppCode over xCode. Second I simply don’t think I’d be able to code both Java and Swift without having a similar workflow between IDEs. To me the development experience makes the difference between loving or hating the work.
Jetbrains IDEs performance is so abysmal I quickly get annoyed and move to something else. Same with XCode.
I find VSCode to be the most feature rich editor whose speed I can tolerate.
VSCode is by no means ideal in terms of resource consumptions or startup speed but the community picked up VSCode for the golden path in the languages I code with (rust, node.js, frontend js) and using other lighter editors is a significant downgrade.
Sublime was incredibly promising but it's not enough feature wise for my experience.
I'd literally throw money into a native and more performant/lightweight VSCode.
NB: IDEA performance is improved drastically by giving it more memory. Basically every time someone complains about perf issues with IDEA it's because their heap limit is too low. It can be configured via the help menu.
One of the unfortunate (or fortunate?) design decisions in IDEA is that there's an explicit and user configurable tradeoff between performance and memory usage, but the defaults are far too low. And if it's too low only the most very recent versions can detect this and tell you what to do about it.
There are several projects attempting to develop a native smart editor. For Mac users there is Nova (https://nova.app/) and for the Vim crowd there is Onivim (https://onivim.io/).
I have used neither of them but I find them intriguing, especially when I wait for my VSCode cursor to catch up with my typing.
I switched from VSCode to CLion (IDEA variant) and its Rust plugin because... well... it actually works for complex C++ code. VSCode requires a restart every 10 minutes while working with a moderately complex C++ code base with some complex template logic.
Since I switched I've really come to like the polish and completeness of the thing. I have confidence that it will actually work, and it almost always does. It's fatter than VSCode in some ways (especially RAM) but that's what 16G or more of RAM on a laptop is for.
Even with plugins, VsCode feels like a text editor + syntax highlighter for single files. Jetbrains feels like a project-first language introspection tool. It knows how the languages (Python, Typescript, Rust etc) work, how their functions, data structures, modules etc interact.
JetBrains IDEs are more thorough, kind of Apple like vertical integration while VS Code is more like Windows: hack everything together.
From a experimental standpoint I highly prefer VS Code, since writing add-ons for JetBrain was too complicated for me in an affordable time. VS Code shines here.
I think that this flexibility really is a different beast. For example, workflow optimization is becoming a thing in software development. In my department, I turned VS Code into a somewhat low-code editor for Web development. This could not have been achieved using JetBrains.
There are plenty of quirks when you aren't coloring in the lines in Jetbrains, though. Formatting with Rubocop on save in Rubymine is nearly impossible to do successfully in my attempts.
in my experience Intellij looks better if you have coded in Inttellij first (especially Java) and then moved to othet tools.
Intellij offers a lot of custom behaviours that IMO programmers start coding the "Intellij way" (let's call it Intellij muscle memory for lack of a better definition) on the other hand going from vi to Emacs to Sublime to VSCode is less of a problem and people tend to honestly judge strength and weaknesses of each one.
For example magit is so good (for me) that until the magit plugin for VSCode came out I kept an instance of Emacs running only to interact with the git repository.
Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.
BTW the java plugin bundle for VSCode replicates 95% of the features of Intellij, except for some formatting styles and a few of the refactoring facilities that I could not reproduce, I switched from Intellij to VSCode without looking back.
There's even a keyboard bindings plugin for VSCode that perfectly maps IJ keyboard shortcuts.
If only the VSCode java ecosystem was refined as it is today 2 years ago when the project I am working on started, I would have never even downloaded Intellij.
If I had an euro for every time I had to "Invalidate cache and restart" on Intellij to make it recognize some trivial change, I would be rich now.
Having said that: they are different products for different targets.
Intellij has a huge advantage in corporate environments where conformity, uniformity and easily replacing team members are paramount, VSCode is an highly customizable code editor that fits a different use case where each member of the team prefers to customize the working experience as much as possible.
> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.
Disagree. I use it all the time. It's sooo nice to have the different changelists. Easy to make changes that I don't want to accidentally commit by putting them on a different changelist (like pointing to a different database). And it can be split even in the same file, much more easily to commit parts like this than using git -p.
> BTW the java plugin bundle for VSCode replicates 95% of the features of Intellij,
If you only look at the textual java code, perhaps. But it lacks the awareness of the rest of the java ecosystem that Intellij provides.
Something Java accidentally did was be impossible to code without an IDE, in part because of its type system. People wrote really good IDEs for it, aided by the type system. At some point, they realized they could use what they learned and adapt the IDE to other languages.
At least most of our java program is written by us. Compared to visual studio (not vs code) where a wizard will generate thousands of lines of config no one dares to touch again or know how to modify.
It wasn’t accidental. JavaBeans were explicitly designed for “wiring up”
UIs in IDEs and are the reason the horrible getters/setters are ubiquitous in Java.
It’s also why NetBeans was a part of Java for so long (is it still?)
The main reason I started using IDEs was automatic imports. Funnily enough, when I went from VSCode to GoLand, one of the things I miss is the import management, which is better in VSCode. But for everything else, especially refactoring, GoLand is better.
> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.
You're going to have to explain that one to me. I don't know what part of `ctrl+k`, comment, `ctrl+enter` to commit is difficult. Keeps my hands on the keyboard and head in the code. Time to push? `ctrl+shift+k`. Update? `ctrl+t`.
I have yet to find any IDE that performs as well as IntelliJ et al.
I had the exact same feeling arriving into projects using PyCharm: somehow I could feel PyCharm's influence over the code and ignorance of the non-IDEA tools (e.g. makefile/isort/black, which are usually superior/easier to use than the mouse oriented interface of PyCharm). I even use a phrase for the way they are developed: PyCharm oriented development.
VSCode is better at first, unless you need to work with Python 2.7, where it fails completely: there is no good lsp for it (intellisense fails), and working this problem around by downgrading to ctags does not work either.
The best I can say about them is that both has decent multi cursor implementation.
> in my experience Intellij looks better if you have coded in Inttellij first (especially Java) and then moved to othet tools.
I have started with notepad and moved through vi, Eclipse, VSCode and then IntelliJ. Out of these I used Eclipse and IntelliJ for Java and IntelliJ wins hands down when it comes to the quality of the features, atleast for Java.
> Intellij offers a lot of custom behaviours that IMO programmers start coding the "Intellij way" (let's call it Intellij muscle memory for lack of a better definition) on the other hand going from vi to Emacs to Sublime to VSCode is less of a problem and people tend to honestly judge strength and weaknesses of each one.
Since I didn't start with IntelliJ, I didn't have any baggage of muscle memory etc but the ease of refactoring and the quality of autocomplete/suggestions of refactoring takes it beyond an editor to almost a companion. It doesn't nag and you are free to ignore its suggestions but hell those are pretty good suggestions. I use a few keyboard shortcuts like jumping to definition and checking usage so I don't have any keyboard focused attachment to IntelliJ. Infact I use vi keybindings in both VSCode and IntelliJ.
> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.
IntelliJ's git integration is definitely not barely useable and not counter intuitive either (I started with command line git and then worked on IntelliJ). The only gripe I have is that occasionally I want to create a branch from a tag and I need to do that from the command line. Everything else works seamlessly.
> If I had an euro for every time I had to "Invalidate cache and restart" on Intellij to make it recognize some trivial change, I would be rich now.
I've had to do invalidate cache and restart about 2 times in last two years so while it is not a great use of my time when I have to do it, its not a big bother considering it is rare for me.
> Intellij has a huge advantage in corporate environments where conformity, uniformity and easily replacing team members are paramount, VSCode is an highly customizable code editor that fits a different use case where each member of the team prefers to customize the working experience as much as possible.
In my team, the average period folks have been with the firm is 3 years so easily replacing people is not a priority (because they are not leaving left, right and center). Also, I'm not even sure if that makes any difference, because its not like we are coding style nazis carrying out IntelliJ dictated formatting (we use Sonarlint for linting and only expect people to code in a manner that is easy to understand and maintain). Almost all team members have used Eclipse / VSCode and atleast for Java, after they used IntelliJ, they haven't gone back to either.
> Almost all team members have used Eclipse / VSCode and atleast for Java, after they used IntelliJ, they haven't gone back to either.
I was also using it because my team was using it and it holds value to share a screen and watch the same thing or when debugging an issue replicating the same exact steps, having different tools can make it harder.
My point is that when you have a stable setup any setup is good if it's good for you, Intellij is better on some things but worse on other that I personally value more
the git integration for example, which works backwards compared to how git works: stage/commit/push
in Intellij I am presented with all the tracked files already staged, the commit message box is already filled with the last one, files are showed as a tree instead of the classic list with paths and I have to look for untracked files that are collapsed by default.
Magit is much simpler and intuitive IMO.
> I've had to do invalidate cache and restart about 2 times in last two years so while it is not a great use of my time when I have to do it, its not a big bother considering it is rare for me.
I wish it was like that for me.
Or probably I am simply doing something wrong but no amount of Google fu helped me to avoid the issue, the only thing that works is pushing the damned "invalidate and restart" button (and sometimes running mvn idea:idea from the command line, but I gather it is obsolete and not actively supported anymore)
I don’t really see IntelliJ and VSCode as competitors. VSCode competes with atom and other full-featured text editors (vim, emacs) ... its got great adoption amongst the newer generation of programmers that think those editors are old school and user hostile.
VSCodes Java, Python, and Golang support is miles behind IntelliJ.
FWIW, on my team at Microsoft where we write a lot of Go, theres a 50/50 split between IntelliJ/GoLand devs and VS Code devs and more people have switched to IntelliJ from VS Code than vice versa.
Interestingly, as an emacs user, I am really rooting for the success of VSCode. The existence of the Language Server Protocol means that I have a horse in this race. Emacs users that use the same language server as VSCode users directly benefit from this relationship. So even though VSCode is competing with Emacs for market share, it is very much collaborating with Emacs (and other text editors that use LSP) in making language features comprehensive for everybody.
It's more complicated. Microsoft waits until everybody adopts LSP for, say, Python, and then slowly moves to a proprietary language server, explicitly forbidding its use outside VSCode:
I think the textbook (i.e., The Innovator's Dilemma) model for a disruptive technology is specifically one that starts out looking like it only competes in a different (typically lower-value) market, right until it's eating your lunch.
I used to work together with someone who didn‘t catch basic errors in VueJs and Symfony projects in VSCode because (idk) somehow it can‘t do it or some plugin is missing.
On the other side there‘s me with PHPStorm and WebStorm with full project inspection support and detailed analysis about code available at a glance.
Maybe I just don‘t know how to do that in VSCode but VSCode does not feel like an IDE but rather a Notepad++ on steroids to me. Sure, you can do the job in it but that‘s not the reason I pay a lot of money to JetBrains each year.
It's likely a missing plugin. As an avid VSCode user I would liken the difference of VSCode and IntelliJ IDEs with the difference between an unfurnished apartment and a fully furnished apartment.
With the latter you skip setting up your environment and just start doing your thing. The former is more barebones in this regard. It lets you build your own IDE from plugins and a ton of configuration options.
As someone who likes to have one app for everything code related (from Markdown to the programming languages I use, to config files and to LaTeX) I like to "bring my own furniture" for the unique combination of needs I have.
Thus it makes perfect sense to me that VSCode is regularly underestimated regarding its IDE capabilities. Stock VSCode is indeed just "Notepad++ on steroids". You have to invest some time to build it up into a fully fledged IDE.
Interesting. I have used IntelliJ for Java for as long as I can remember and can't imagine using anything else. For JS and Go I use VSCode. I wonder if it's just what I started with and am used to. I've tried to use Intellij a couple of times for Go, but end up back on VSCode.
I dont know how you’re productive with VS Code and Go... I watch my coworkers live code with it sometimes and they are struggling. The lang server crashes constantly and stuff like autoimports or code complete barely works. I sometimes want to scream while watching them struggle.
I've read about those issues, and used to get them occasionally, but haven't really had them in a long time. Maybe my projects aren't large enough to cause any issues?
Same pretty much the same for JetBrains stuff. Constant screaming about how to configure their autoformatter compatible to prettifier for specific settings. Not supporting required configs out of the box. And build and IDE often live in completely different worlds. For example, project moodel at gradle and at IDEA is completely different and IDEA one is much more limited. And so on.
Android Studio could hang whole mac while "indexing" and often need to "reset caches and restart" while works just fine in VS Code.
> Constant screaming about how to configure their autoformatter compatible to prettifier for specific setting.
Assuming you mean “prettier” rather than prettifier (which a cursory Google did not show up as being a popular thing), the way to do this is to add a prettier config block to a package.json or a .prettierrc file, and then click “yes” when the IDE asks you “use code format based on prettier config”.
I did this not more than 10 minutes before writing this comment, on whatever the latest (shipping) version of IDEA available with whatever version of prettier came from `npm install` this morning - may save you a few mins next time the IDE is screaming at you.
I think only recently did the gopls become turned on by default for the Go plugin for VS Code. I've been using it for years and have never had any major issues.
The quality is really getting better but it is my experience that you still have to restart the language server (or the integration?) multiple times per hour on any non-trivial project. It is frustrating but it also becomes a habit to quickly reach out to that shortcut in case completion, formatting or intellisense randomly stops working.
It is hard to complain about free tools though. For a Free tool, VSCode, gopls and the Go extensions are great.
If you want more stability, polish and features, pay the $8/month for Goland?
I'm the same way. Java/Kotlin in IDEA, front-end (js/ts/css) in VSCode, and Go can be either but usually VSCode. I don't really want/need more than what VSCode provides for it.
For Ruby, I'm lost without RubyMine--I work on a huge codebase and lean on the superfast search (with default "*.rb, !*test*" files) a lot, usually restricted to a project subfolder.
I'm really glad they renamed Gogland to GoLand--gland is weird (unless maybe I'm doing Monads in Haskell or something).
I work on a large rails codebase as well but within a docker container doing emulation because ARM. How does RubyMine perform then? Last time I tried it felt sluggish.
Do you mean the search itself or other parts? Quite possible that I've become accustomed to the parts that are slower being used to IDEA. e.g. I accept the 'indexing' operation sometimes on startup or the now rare garbage collection pauses.
I love Goland, and it's honestly one of the products that I very much like to pay for. You can eventually pay a one time fee and use it forever (without updates).
I'm also using it for Rust, but it's missing CLion's powerful debugger UI - but I think that gdb is good enough :-)
If you have IntelliJ ultimate, Goland is installable via the Go plugin for free. I use IntelliJ for go/js/python using their plugins and they work as well as the native apps (pycharm, webstorm, goland). Although it is a bit tougher to configure because you treat things more as modules.
In the past five years or so I haven't bumped into anyone who would use Atom. When Atom came out, it picked up some steam, but I'd say VS Code has already won that race by far.
Ex MS employee (and former intern).
Somewhat new to Go (and using VSCode full time) - but it's the language of choice for my job right now. Go seems to be popular in backend apps (non windows mostly) where concurrency and performance are important. The tooling around go for performance profiling and optimization are rather good IMO, and quite friendly if you are accustomed to Unix style CLI tools.
I do agree with the other comments that the language server is buggy but it works quite well when it works. I may be a bit bias when dealing with tooling since I came from Xcode where workflow breaking bugs was the norm.
I haven’t tried the Java integration but based on using VSCode for TypeScript I could imagine feature parity. VSCode is so good that it makes me concerned Microsoft is just using it to eat at JetBrains until they up and start charging for it in the future. Not sure how else to see it.
So VSCode is very, very good for TypeScript. Hell, I'm pretty sure VSCode itself is written in TypeScript!
But that does not carry over to all languages. When working on web apps with a Java backend, I still prefer Idea because it's better for Java and close enough for TypeScript so it comes out ahead over all.
My experience is the opposite with VSCode and TS, actually.
It becomes obvious that Jetbrains understands MSFT's own language (TS) better than VSCode the moment you actually need real IDE-like features (such as refactors) to work.
It does. All languages are basically the same. They parse to ASTs that you can manipulate programmatically. If those ASTs are strongly typed, you can safely perform refractors. What makes IntelliJ good is the base framework JetBrains uses, the same one they use in WebStorm, PyCharm, etc. VSCode is that same thing: an adaptable base and I’m sure making it on par for Java if it isn’t already will happened is only a matter of time if they invest.
Absolutely not, there are many, many language-specific things that an IDE does beyond code hints.
Microsoft doesn't seem to be investing that much, if anything, on languages other than JS/TS; it is delegating all on the OSS community through plugins. And while some of the plugins are really good, in my experience they don't even come close to the native capabilities of Jetbrains products.
This is what Microsoft does. Their #1 thing is being in the market even if the product is bad. They’re delegating now, but wait until they’ve established their foothold, leveled up the core framework. Then they’re going to stop delegating one language after another.
Extend: have a plugin system that everyone can contribute to (sounds like eclipse or IntelliJ CE) and even make money off of. Plugins don't have to be free.
Extinguish: make your own plugins with full refactoring support etc. for the languages you see most actively used (everyone uses it for Go and Python now? Make a good enough plugin for that. Nobody uses it for Erlang anyway? Leave it to the community)
It remains to be seen whether they will find this economical when they are not making any direct revenue on the product.
I understand that VSCode is part of a grand strategic plan that goes beyond revenue, but I seriously doubt that they'd be willing to internally maintain the absolute truckload of code that would ensue from getting to feature parity with Jetbrains on languages like Java or Python. I'd wager at some point the quality would derail, or someone would pull the plug altogether on such a cost sink.
And that's one of the things I love about Jetbrains products. I'm actually delighted to pay for a product that I use every day for ~8 hours and which I think is extremely well-designed, knowing that the money is going to a company of craftsmen who do that, and only that.
Once you've killed off the competition, a lot of other things don't really matter much any more. From the money perspective, it's a well known strategy to loose money to kill off the competition. It's just about who has the deeper pockets/better stomach for it. Microsoft has traditionally been able to do it and I have no doubts that they would still have the stomach for it. I don't know if their pockets are still as deep as they used to be. Windows (and Office etc.) used to be so dominant and such a cash cow that it enabled a lot of the other strategies, but then again they also had to get Windows to that point first. The landscape looks a bit different nowadays I'd wager, given Apple's and Google's footholds on mobile but then again, I wasn't really old enough back in the day, to really compare from my own experience, what the landscape looked like back then with Apple, Amiga, Atari, SGI, Sun etc. in the mix.
> A short read and should give enough examples and descriptions of the strategy
I know about it and don't need a Wikipedia link to enlighten me, thank you.
In my comment I questioned your application of that theory to reality by raising concerns about the cost/benefit analysis from a Microsoft perspective.
I don't think you're accurately scoping the undertaking of getting VSCode to feature-parity with Jetbrains products in Java, Python, etc., nor the potential benefit for Microsoft. My contention is that the gap between Jetbrains and VSCode outside of JavaScript/TypeScript is massive, and that while VSCode is strategically important to Microsoft, they don't have the incentives to even try to extinguish Jetbrains.
But instead of addressing any of the concerns in my original comment, you've just pretty much gone on your own unrelated tirade.
Also, Microsoft ultimately lost the browser wars and many of the similar crusades that they undertook in the 90s and early 2000s, so maybe they've learned a few things along the ways.
Wow, I seriously underestimated the way this written communication could be misunderstood. Especially how anyone could possibly read it as a 'tirade'. And not everyone knows about EEE, especially nowadays but fair enough as to how a link to explain some of it might upset someone that does. That said I really thought that you weren't aware of some of what they had done and how much it would have cost them.
We have a difference in opinion it seems on how much money we think Microsoft might be willing to pay for it and other items as well. That's fair enough. How any of that is a tirade is honestly quite nebulous to me but I probably won't be able to change your mind, even if I tell you that it wasn't written by the furiously typing mad dog you probably imagined.
Let's structure it, so you see how I thought I was addressing things:
> truckload of code
I.e. costs a lot of money: "it's a well known strategy to loose money to kill off the competition"
> pull the plug altogether on such a cost sink
Addressed in "Microsoft has traditionally been able to do it and I have no doubts that they would still have the stomach for it"
> feature parity with Jetbrains on languages like Java or Python
The rest that starts with "I don't know if their pockets are still as deep as they used to be." and which also includes "The landscape looks a bit different nowadays I'd wager" is basically me acknowledging that your opinion is different on this than mine and that I can see that potentially their cost/benefit analysis would lean towards your interpretation. They are trying to cover the Java side well enough with the Redhat maintained plugin. If Redhat does a good enough job to take customers away from Jetbrains that plays into Microsoft's strategy without spending a lot of cash on it. Brilliant.
It's an evolving thing too and as you point out in your reply here, MS did loose the browser wars eventually. The market changes all the time through technology breakthroughs for example and people are actively working against EEE tactics too. I for one am glad that MS lost the browser wars and to address one thing that I did not comment on (on purpose because I was concerned with the EEE discussion and not whether or not one or both of us like JetBrains):
> I'm actually delighted to pay for a product that I use every day for ~8 hours
I absolutely agree that IntelliJ is awesome and I don't want to miss it or use anything else. I don't even use vscode for FE code, unlike most of our FE developers. I'm traditionally a BE guy but have no qualms about doing FE work as long as you don't make me do pixel perfect reproductions of designs in CSS :)
Good point. I don't think that necessarily matters too much though. You obviously can't just give everything away and not have a strategy to make money at all.
That said, giving something away can still make you money or ensure that your competition does not make money either. This comes down to being a large enough entity to support that strategy, which I personally think Microsoft still is.
If I'm Microsoft, I can give away a "base IDE", enlist volunteers and other companies that can even make a buck themselves for quite some time (and spend some money myself) to kill two birds with one stone.
1) I can bind developers to my platform. From the 2019 annual shareholders report: "Beyond GitHub, we are investing to build the most complete toolchain for developers — independent of language, framework, or cloud. Visual Studio and Visual Studio Code are now the most popular code-editing tools in the world. And TypeScript is one of the fastest-growing programming languages."
2) Where I deem necessary use it to kill off competition by driving them out of business. For quite a few companies, the price point of the IDE that their developers use is important i.e. the choice that companies give their employee is: Use vscode or IntelliJ Community Edition (or something else that's free but we're not paying) and it's very hard to explain developer productivity increases to the bean counters.
I agree. Particularly with the first point. One of VSCode's big strengths is it runs on the web as well - it's easy to see it becoming a fully integrated cloud IDE (whether you run it in Electron or your browser), and then MS can sell VSCode Premium for $2/mo to integrate it with your corporate login etc.
It’s incredible how it runs on the web. CodeSandbox is an awesome tool because it’s the same thing you use on your desktop (if you use VSCode). Just the other day I saw some post here wondering why you can’t “code in the browser” and uh, you can! Just go to CodeSandbox.
I suspect MS will be selling VSCode premium, as I mentioned elsewhere on this thread, they are already maintaining closed components.
If you ever get a chance to work on something with JetBrains developers (I got to when I was on the Java 8 JSR), you will find them to be some of the best out there. Their Java support was always ahead of javac for the new features we were specifying.
Another important point: JetBrains have long experience of competing against well funded free competitors. In fact they have grown in an environment where there have always been such products: first NetBeans, then Eclipse, now VS Code. Subsidising IDEs has been a common tactic for a long time, VS Code is nothing new. The story is always the same: such IDEs grow quickly for a while because their price is zero, but eventually after the project has become a "success" the parent corporation gets tired of sinking money into it and the executives lose interest. With weakening internal support, the projects get steadily destaffed. Eventually the project may go off the rails by e.g. deciding to rewrite from scratch.
Meanwhile JB survive the assault, continue to invest in their core product (which have been incrementally evolved for decades and were never rewritten from scratch), and come out the stronger party. They cannot lose interest or make self-destructive decisions because the IDEs are their core revenue stream.
This argument is a compelling case for JetBrains and I hope it proves out.
> They cannot lose interest or make self-destructive decisions because the IDEs are their core revenue stream.
But this can be said about Microsoft as well. IDEs are not the core of their revenue stream, but they're near the core, because "developers, developers, developers, developers" is still true. They're a software company, they make operating systems, a cloud platform, and hardware. They need to provide developer tooling. If IDEs aren't their core revenue, they're certainly near the core. If Microsoft hasn't been making money on IDEs lately, they have in the past, they see other people are, and they're certainly going to try and get back to that if they can.
That argument is true for Visual Studio. Not VS Code, which is Microsoft's "rewrite moment". Visual Studio is targeted at Windows apps, which you have to pay Microsoft to use. VS Code is targeted at web apps, which people run on Linux. The revenue impact is highly indirect: it's not like people will write more web apps than before now VS Code exists, somehow benefiting Azure.
They could try to do a reverse JetBrains and introduce an enhanced for-pay version. Supposedly they're already starting to do that with Python support, it seems. But starting commercial and going free is a lot easier than starting free and going commercial, in terms of user loyalty.
> but I seriously doubt that they'd be willing to internally maintain the absolute truckload of code that would ensue from getting to feature parity with Jetbrains on languages like Java or Python
Why would you doubt this? Microsoft is huge compared to JetBrains and revenue opportunities of code editors have been clearly demonstrated since the 80s. Microsoft sold how many billions of dollars of Visual Studio in the 90s? Plus the red flags are already popping up: Microsoft is already not open sourcing Python language tooling [0].
Sure, but Microsoft also has Visual Studio. If they start heavily investing in VSCode for C#, C++, then they're going to be cannibalising Visual Studio. And for what?
I think they're going to phase out Visual Studio. They like VSCode because it's an Electron app that runs on any platform and even in the browser. Microsoft isn't just a Windows company anymore, and VSCode is their future editor.
The language server is a really small part of an IDE, though. IDEA has soo many Java specific features I use every day (like maven, spring and other tools, debugger, hot reloading, profiling etc), and other non-language specific stuff like db viewer.
It’s possible they lack vision and focus for this thing, such that they go out and do “Java support” without making it good or caring about it.
On the other hand, we’re talking about Microsoft. If you lived in the 90s, I find it hard to imagine how you can see Microsoft in any other light. I know: different times, different leadership. But still: it seems possible that they’ve got a huge vision for this and want to do the equivalent of Internet Explorer 1 and 2 just to be out in the market, so they can come back and do versions 3 and 4 as their position has become entrenched.
I think it’s less that and more that Microsoft is leveraging Redhat’s focus on Java. They have built a good editor and plug-in environment, then engage organizations stronger in other tech and have them build support.
Reality check, Microsoft is a Java vendor nowadays, after having bought jClarity, has a seat at OpenJDK table, official Java blog in English and Chinese on MSDN, and Java is the only plaform that has biggest parity with .NET features on Azure.
Python is not a strongly typed language and renaming variables in such a language is a minefield. I've used PyCharm and WebStorm and never felt comfortable using their variable rename facilities for Python and Javascript. If they do it better than rope then that's good, but you need to write those languages in a very specific if you want IDE renamings to succeed. IMO, that rope fails silently might be viewed as more of a feature than a bug :). Anyway, I'm sure it will be improved.
I think VSCode is really good, but even when I was only writing JS I ended up preferring WebStorm. I like its refactoring tools and command palette better, and I also prefer its "batteries-included" rather than "plugin-first" approach (although I do have a few plugins on JetBrains products always, such as Vim, there are significantly fewer than in VSCode)
Anecdotally, I know other devs in the same situation. You wouldn't pry WebStorm from their cold dead hands, even with an excellent free offering like VSCode. But I also know some who don't understand why you would pay for WebStorm when VSCode is free, which is reasonable (though if they took WS for a spin, they might change their minds).
Now that I write mostly Python and JS there is no contest at all. I get all the JS/TS goodies, plus absolutely amazing Python features.
Like GP is saying, I don't think JetBrains and VSCode even compete that much. Maybe VSCode will capture a good part of the JS world - which is huge of course - but I think WebStorm will maintain a decent foothold there no matter what, and I think JetBrains will remain very strong in other languages.
I feel like we are kind of ignoring how Visual Studio plays into this, do we really expect Microsoft to replace it with VS Code? I feel like Visual Studio Pro/Ent is more of a competition with other paid IDEs and VS Code won’t be, perhaps somewhat so it isn’t positioned to eat Visual Studio?
I've been programming with various IDEs and text editors for over 30 years. In my formative programming years (1990s) I relied heavily on Borland and Microsoft IDEs. In the 2000s it was a combination of Visual Studio (C/C++/C#) and various editors (PHP, HTML/CSS/JS). In the 2010s I started working across multiple languages: C#, Java, Python, Ruby, Elixir, Scala, JavaScript (also dabbled with Lisp, Go, and Rust); using various tools: Visual Studio, JetBrains IDEs, VS Code, Atom, Sublime, Vim, and even Emacs.
My opinion: JetBrains IDEs beat every single other IDE/editor hands down (Visual Studio -- not Code -- comes close). The level of integration and polish is unmatched. I use PyCharm on a daily basis at work and the level of productivity I get out if it is far beyond what I get from any other IDE/editor. I've been developing a hobby kernel recently using C, and initially used VSCode; it was OK. Then I thought I'd give JetBrains CLion a try and I never looked back. I happily paid for license and it's been a well spent investment.
I had the same experience, used Visual Studio for C++, and years after C#, and Eclipse for Java projects. When JetBrains came along it really shined.
I tried VS Code a couple of years ago for a few months for some scripting languages, it really is not bad, however JB IDEs are better for Java, Python, Ruby,.. even for frontend development - support for Angular and React is great.
I bought the "all products pack" for individuals - it something like 15 bucks per month - for me it would be silly not to use it.
I pay (personally) for the entire Jetbrains tool set. They are damn good. And I guess to be fair, I haven't given a lot of time to VSCode, but TBH: I find that Sublime and IntelliJ cover the spectrum for me (which is Scala, Java, Kotlin, Python, C, Go and Typescript all with git support)
I'm not super exploratory, because it always seems that I have a project due in two weeks, but given that I have pickd up two of the BEAM languages, but am always lagging on learning Ruby and Haskell. These days - I'm starting to wonder about the utility of learning another language, other than re-learning Smalltalk out of nostalgia.
The only reason I use VS Code is when I want to quickly check a file or create a PoC. PyCharm or CLion are just too slow and frustrating, but for bigger projects there is no better option than those, despite being awfully slow.
On what platform are you using these IDEs? I use CLion daily and it is very fast on my Linux machine with a Ryzen 3700X CPU.
(I have heard complaints that the JetBrains IDEs are much slower on Macs, which also corresponds with my limited experience of using their IDEs on a Mac.)
I think it’s less about the platform and more about the size of the code to index. Text editors are about as fast in a repo with 30,000 files as in a repo with 3. IDEs can take a few minutes to do the indexing necessary to support their code intelligence on bigger repos.
I never really realised this, but IntelliJ feels almost instant on my fedora workstation whereas there is a certain sluggishness on Mac in the ui. Resizing panels, context menus, the terminals.
There’s more too bootstrap so the IDE is slower. Plus setting the project up properly and so on. It’s not as simple as typing ‘$ code <dir>‘ and starting to write as the editor pops up instantly. People’s definition of fast and instant are different. There’s absolutely no way an IDE can start faster than a text editor, otherwise text editors wouldn’t exist.
Don't get me wrong, I still consider VS to be an extremely powerful IDE. I think it's the best IDE for .NET development, and maybe C++. It also has the best debugger, period. But when it comes to supporting multiple languages, it lacks the consistency, extensions, and integration that JetBrains IDEs enjoy. Admittedly, I haven't used it professionally in about 5 years, so many things may have changed.
There's also something I can't express about productivity when I'm using a JetBrains IDE. I remember over a decade ago when I added ReSharper as a plugin to VS and all of a sudden I felt the IDE come to life, with a level of assists I haven't seen in VS proper. Of course VS has caught up now, but ReSharper was way ahead of it in those days.
It's also clear that MS is focusing their efforts with VS on cloud integration (VS Online, Azure, etc), rather than sweating the little details that make you even more productive day-to-day. That's probably why they let VS Code eat the bottom of the market, knowing that MS shops will still pay for MSDN subscriptions.
Thank you for your answer. VS has indeed changed a lot, especially in the "ReSharper" department. My only qualm would be the performance (startup, loading solutions etc). JetBrains might be better there too.
> Meanwhile, JetBrains seems to be staying afloat mostly thanks to hard work and sheer luck.
I don't think they keep ahead simply by hard work and sheer luck. Once you look under the hood at Intellij it's clear that they have significant architectural advantages.
While VS Code is a text editor that uses LSPs to provide refactoring and navigation, Intellij is a refactoring engine with a good text editor on the front. Under the hood Intellij is a structured editor operating on abstract syntax trees. ("psi nodes" in Jetbrain's parlance.)
The hard part of creating an LSP is providing things like refactoring and navigation support, and these are exactly the things that IntelliJ provides for its language plugins. To achieve a given level of refactoring and navigation support an LSP developer needs to expend significantly more effort than a jetbrains plugin developer.
From my vantage point Jetbains doesn't seem to be staying ahead by hard work and luck as much as by an intelligent architecture and design that allows them to produce high-level, high-value features with less effort.
IntelliJ runs its language plugins in-process, using object oriented APIs. VS Code runs language plugins out-of-process with an RPC protocol to the backend.
The latter has some advantages if you want to re-use the language's "native" compiler, assuming there is one. However, this isn't quite as useful as it sounds. Compilers parse text into ASTs and do transformations on them, yes, but, they are not IDEs and the needs of an interactive "presentation compiler" are very different to the needs of a batch-oriented normal compiler. The OP's article overlooks this: it just blithely assumes that building an IDE on top of the regular compiler is always better than writing a dedicated IDE support from scratch. The truth is more nuanced.
Meanwhile, the costs of going out-of-process with RPC are enormous. Beyond the obvious performance, bandwidth, memory overhead and latency problems, the Language Server Protocol spec is 100 pages long and still growing. Despite being a protocol and thus theoretically language neutral, in reality it's a JS/TypeScript API. In fact the protocol is so much a JavaScript API that there's no direct way to represent it in a conventionally typed language: for example the Response.result field is totally dynamically typed and can be anything at all.
Worse, because LSP is just a protocol, there's no platform to help you implement it. IntelliJ platform is full of classes you can compose, subclass or use to simplify the task of writing plugins. VSCode is not like that.
My take with VS Code is that their support of development container and ssh is the best and it's a killer feature.
My ultimate goal for quite sometime now was to pack all my development dependencies inside containers or cloud-init files to keep my host bare-bone and have reproducible/shareable setups anywhere anytime.
Before I was an Emacs fan. I tried multiple combination of Emacs, Tramp and containers but it failed: there always was a package that didn't played well and kept looking for stuff at the wrong location. After a while, I was fed up to make low-level fixes in random packages. I also tried weird setup with Nix for the same exact bad result.
It just worked. The experience was flawless. In a matter of second, it blew the competition away like nothing.
Nowadays, I cannot live happier: I clone the repo i need to work. It comes with a development Dockerfile. VS Code starts the container and everything is there for working. If I need a beefier host, I spin up a cloud VM with cloud-init and 5 minute later the setup is ready without any manual intervention. Any extension I tried in marketplace worked.
In my opinion, the Emacs/Vim communities clearly missed a golden opportunity for a more larger adoption.
I desperately wanted VS Code's remote development functionality in IDEA, and was keeping track of their remote development feature in YouTrack. When CodeWithMe was released, I was sorely disappointed.
All I wanted was my code to run anywhere, and my local machine to be the IDE.
mutagen.io ended up being my answer. After learning how it worked, I got it set up and it works really well. I'm mostly doing PHP development these days, and have a LAMP stack running as docker containers on a server.
The sync is nearly instant (99% of the time), the rare conflicts are easily resolved, and of course debugging still works.
The only thing I'm missing is collaborative editing, which I still have to jump over to VS Code to do. I haven't tried out two people using `mutagen sync` on the same instance of code, but that could be a really interesting solution if it works.
An editor agnostic solution to collaborative/pair coding would be really fantastic.
I've spoken to some Jetbrains employees and it seems their vision of remote development is nothing like what VSCode does. No matter how much I explain they just don't seem to understand the advantages of being able to host the IDE in a docker container/remote system. "Docker isn't supposed to be used for that, you deploy to a container, not develop inside one" they say.
As for the conflicts, I chose the option of one way sync, with everything being overwritten by what's on my local machine if there's a conflict. Works like a charm, since the remote machine will only ever produce build artifacts and run them, which I don't need to sync back to my machine.
Jetbrains Projector seems to be their solution. It runs the IDE on the server, and renders the GUI in a browser. Seems experimental so far, I'm running it at home and it's surprisingly far along but still ... Kludgey? A great POC.
I agree 100% that being able to work on a project that actually lives on a remote server, or on Windows subsystem for Linux, or in a container, is a killer feature. It's really awesome. It still wasn't enough to tear me away from GoLand though. I hope JetBrains implements something similar, I think they may have done so already in a limited way for certain languages, but it's not on VS Code's level if I recall correctly.
In my opinion, the Emacs/Vim communities clearly missed a golden opportunity for a more larger adoption.
They just copy their init.el/vimrc to the server, Emacs/Vim users have been able to do this (coding on remote environments without all the kludges) since forever ;) and personally, I find it superior to vscoce's remote plugin since your editor and tools sit on the same machine.
For GUI editors, I agree that vscode's remote development extension is a killer feature and nothing can't match it today.
> They just copy their init.el/vimrc to the server, Emacs/Vim users have been able to do this (coding on remote environments without all the kludges) since forever ;) and personally, I find it superior to vscoce's remote plugin since your editor and tools sit on the same machine.
Unfortunately this doesn't work well if your connection has a high latency though, which I think is what VScode does really well.
did you ever try this? or is this just something which you think should be it's distinguishing feature?
Asking mainly because I think this is cool, but the whole setup (lots of random binaries in the server) is not so different to an AppImage of emacs+xpra (if you could do tha) and the times I tried, the thing was _very_ picky about connection losses/timeouts...
Yes, I did try this and although I don't particularly need remote editing, the fact that it took me less than 2 minutes to setup a remote editor with auto-complete and other IDE features was pretty amazing.
Fully agree. Also, if you need to debug your code that runs in kubernetes pods, VS Code also smokes other IDEs. In my case, not only the API calls are forwarded from the cluster to my debugging session but I can also consume during debugging some Kubernetes services by using their DNS names. Just awesome.
I'm the same - editing remote code is required - full stop.
Of course, VS goes further.. But all I really needed was remote projects with intellisense. Remote debugging, git, and everything else are just bonus.
I run my editor on my desktop, and expect to be able to work on whatever remote server I need to.
> The key technology here is probably the Language Server Protocol
I've been working on an LSP implementation lately, and I have to say so far the reality falls short of the promise. I feel like what LSP should be is a clear, simple interface for implementing IDE-like features for any language, but my experience is that it is incredibly arcane and difficult to use.
The main issue is the documentation. It has a high-level intro about what LSP is, which is basically marketing, and then it has some sort-of details about (maybe) all the interfaces supported by LSP. But I was sorely lacking that "middle" documentation about how to practically get set up and do things. I had to piece a lot of things together through blog posts, and reverse engineering mature LSP implementations like rust-analyzer. And the documentation you do have of the individual interfaces is kind of weird. Like LSP is a JSON-RPC protocol, but documentation of the objects involved is all C# code, which is never really explained. And many of the concepts, like what a 'code lens' is, what properties it has, and how it would appear in an editor are never explained, so you just have to look up VSCode documentation to figure out what any of this means.
I feel like LSP is sold as a general framework for IDE-independence, but working with it feels a lot more like you've just given access to some of the internal API's in VSCode via JSON-RPC, and other editors have just adapted to this.
LSP is a great concept, but I can imagine if you really approached this problem from scratch, you could probably reach a much better, more sensible result.
As someone who wrote an LSP implementing server 2 years ago (when the documentation was even less complete), I can't really relate to this.
As far as I know, the LSP specification only accepts PRs once there is a reference implementation. So you can literally just run VS Code with verbose logging turned on for the reference language server and inspect the communications.
You simply return an object following the interface and features magically work. It's wonderful. I added the "Outline" feature in VS Code, and the similar feature to show all symbols in a file in vim in about 2 hours.
> And many of the concepts, like what a 'code lens' is, what properties it has, and how it would appear in an editor are never explained=
Well, no, because they're not specified. How vim displays a code lens might be very different to how VS code does.
> As far as I know, the LSP specification only accepts PRs once there is a reference implementation. So you can literally just run VS Code with verbose logging turned on for the reference language server and inspect the communications.
“You have to run VSCode to reach a working understanding” seems like a pretty far cry from the stated goal of the project of decoupling the language features from the code editor to me
Most of this post is just speculation like "I seriously doubt it will work well in an average cafe though" without much substance. Either test it or report on it, or at least discuss its shortcomings based on some technical merits. And frankly I don't care how well it works on "spotty café wifi". If the wifi sucks I wouldn't sit there and work anyway.
As for the language server protocol, nothing stops IDEA from doing the same. But while technically cool, it really doesn't matter as long as my programming language of choice works. I don't care how it works. In my anecdotal example, the community made Elm plugin for IDEA was even for a long time miles ahead of the one for VSC.
> Most of this post is just speculation like "I seriously doubt it will work well in an average cafe though"
Meh. I don't think that's his main point. The two advantages of vscode he points out are:
- browsers, and by extension Electron, are the best funded cross-platform GUI
- vscode offloads language support to compilers (or other third-party tools) via LSP (Language Server Protocol)
Electron apps are... slow craps. But it seems to be a problem of implementation, as vscode is slick and fast. In my own anecdotic experience, faster than IDEA.
As for LSP, you don't care how it works, since it works now. But will it support as many languages as vscode in the future?
Sure, that's speculation, but he gives a sound argument: it offloads the burden of maintaining the language integration to the community at large (or even to the language team itself). By creating a LSP server, you add support for vscode, vim, emacs, or even... Intellij. Hard to pass.
LSP support on Intellij is a community plugin, far from first-class experience. And if it does become first-class, why then would people choose it over vscode? If both are LSP based, vscode is faster, free, and extensible in the most widely used language.
And here's something less speculative, editor usage from stackoverflow surveys:
- 2017[0] -> vscode 24.0% intellij 23%
- 2018[1] -> vscode 34.9% intellij 24.9%
- 2019[2] -> vscode 50.7% intellij 25.4%
Disclaimer: I don't think LSP is great, yet. Most of the servers are still rough around the edges, but as an emacs user, I have big hopes for them.
It's important to note that IntelliJ is not Jetbrains' only product. PyCharm has seen a very significant growth during this period too (7.7% -> 13.4%), although PHPStorm has decreased (11.6% -> 7.6%).
Regardless, I find it remarkable that IntelliJ hasn't lost an inch of ground (it's even made modest gains) despite VSCode's explosion.
And you also have to see that they're just special purpuse branded IntelliJs that you can buy for less money.
We have had licenses for WebStorm, PyCharm and IntelliJ Ultimate depending on what the Dev in question was doing in his job. So some of that market share/use is hidden.
Why is it an advantage being Electron? If anything, IDEA is also cross-platform. As for speed, VSC is faster as a text editor, but not that much faster for IDE stuff if you try to use it as that. Even slower some times, maybe LSP incurs some overhead IntelliJ don't have to do.
While I get the point of LSP, as I wrote in another comment an IDE is much more than understanding the AST of the language and providing autocomplete.
I don't get your point about usage. What is it supposed to show? Even though VsCode is growing fast, JetBrains products are also growing and thus has a merit to them?
Usage is important, has all editors live and die by their community. Intellij is less dependant on them, as they develop their most important features themselves, but third-party plug-ins are still mandatory nowadays.
That's my take, anyways. I'm biased as I personally wouldn't use Intellij if not for the community that made Emacs mode plugins for it. I also tend to costumize more than your average programmer.
But tooling becomes broader and more complex year after year (too complex, maybe), so I don't see in the futur any company being self sustained on that front.
One of the things that baffles me is the rust-Lang support.
Rust-lang has an official dual-licensed MIT/Apache language server protocol implementation (RLS) under active development. In my view it’s currently a better experience than the custom IntelliJ one.
Instead of collaborating though I see IntelliJ continuing on the path of their custom implementation. Every week RLS gives an update on their progress and so does IntelliJ on their rust plugin, but it just seems like so much duplicates effort.
Besides Typescript, I haven't seen any language server do better in syntax completion and introspection better than the JetBrains equivalent. They probably don't want to work on it because 1. If they write their own they can make it work to exactly what they need, and 2. They would probably not leverage as much working on the OSS version as they'd lose by open sourcing and doing the bulk of the work on what makes them money. That might sound cold but it is not unreasonable.
JetBrains have always developed their own language analyzers from what I've seen. I would bet they have a clear API between a language analyzer and their suite of refactoring and code navigation tools, and it would probably end up being similar to work to support that API through an open source variant VS building their own.
Not to mention, JetBrains typically are at the forefront of IDE support for a language, they start working on it before there are any open source tools around to base work off of. Even with mature languages like C#, the JetBrains C# language backend predates Rosslyn by a good decade I think.
No, the goals of an IDE-oriented compiler are largely different from the goals of a bulk code compiler. They can / will share substantial amounts of code though. Quoting a developer:
>>>>>>>>>>>>>>>>>>>
Aleksey Kladov: The limitations here are not specific to the Rust language, but a general for command line vs IDE compiler.
The main thing is that the command line (or batch) compiler is primarily optimized for throughput (compiling N thousands lines of code per second), while an IDE compiler is optimized for latency (showing correct completion variants in M milliseconds after user typed new fragment of code). As usual with throughput vs latency, these two goals require pretty different optimizations (and even high-level architectures). In general, it's hard to retrofit low latency requirement on a compiler which was developed solely with big throughput in mind.
Another thing is difference in handling invalid code. A traditional compiler front-end is usually organized as a progression of phases, where each phase takes an unstructured input, checks the input for validity, and, if it is indeed valid, adds more structure on top. Specifically, an error in an early phase (like parsing) usually means that the latter phase (like type checking) is not run for this bit of code at all. In other words, "correct code" is a happy case, and everything else can be treated as an error condition. In contrast, in IDE code is always broken, because the user constantly modifies it. As soon as the code is valid, the job of IDE ends and the job of the batch compiler begins. So, an IDE-oriented compiler should accommodate an incomplete and broken code, and provide IDE features, like completion, for such code.
I use both VSC and CLion, and CLion is a much better experience for Rust IMHO. I know the IntrlliJ only plugin is kind of lacking versus the CLion feature with regards to debugging, but overall I find CLions support to be miles ahead of rust analyzer for stability, speed and ease of use.
A few years ago I contributed to an Intellij plugin with significantly less resources than the rust one. What became clear there was that external tools are glitchy, laggy, frequently crash, and don't quite match Intellij's model of things, native Intellij support will likely always be better.
There is nothing inherently wrong with solving a problem multiple ways. While it's usually good for smaller players in a space to work together, I'm always happy to see others that trod their own path. They can make different choices/tradeoffs, and learn from each other. This usually leads to better outcomes for both of their user bases.
> Instead of collaborating though I see IntelliJ continuing on the path of their custom implementation.
I haven't checked in a while, but RLS was sub-par for a long time (feature- and latencywise). Tight integration has its benefits if you can afford it (and apparently they can). So I guess as soon as they can get the same properties from RLS as from their own implementation they'd switch. But if it meant having to rewrite a lot of stuff that suddenly also becomes available to competitors that seems like a dumb move.
I can think of multiple reasons they may prefer doing it themselves: Differentiation, if they just reuse the same thing everyone else does, they will have no moat or extra features. Or maybe because the language server protocol cannot handle everything IDEA normally provides, so they will have to run some kind of parser etc. on their end anyway. Or that interfacing with an external tool can be buggy or have weird boundaries making certain features harder to implement.
> And frankly I don't care how well it works on "spotty café wifi". If the wifi sucks I wouldn't sit there and work anyway.
Obviously the author cares about it. It’s basically an article from a personal blog, what makes you think that the author should write for your own use instead of theirs?
They are sharing their thoughts on the topic, and that’s it.
I don't believe that there's anything preventing VS Code from getting features like refactoring at the level of JetBrains at a fundamental level. One time I wrote an IntelliJ plugin that exposes an LSP server so Emacs could run Jetbrains' refactorings remotely, as a glimpse into such an ideal.
And at a philosophical level, I would imagine that having those IDE features in VS Code at Jetbrains' level of polish would be viewed as beneficial to everyone involved.
The issue is that on one hand you have an entire salaried dev organization whose sole purpose is to create the best IDE possible, and on the other you have a scattered array of open source devs who only work on the polish as much as they have free time. LSP simply came too late to the party. Everything we like about IntelliJ is now both battle-tested from thousands of man-hours of development and also impractical to architect as a separate language server. The more people that use a hypothetical JetBrains-developed language server, the less editor market share they retain.
Another hypothesis I have is that since some language servers are supported officially by the people who develop the language itself, their time becomes split between working on the language and maintaining the LSP support. Any extra time spent on one separate project takes away from the other.
This whole argument that VS code takes over seems to be assuming the Language Server Protocol and Electron is a vastly superior ecosystem. I haven't seen any evidence of this being true. It's probably an improvement over the older Visual Studio ecosystem, though.
Sure seems like this argument is just another version of, "Well, it's Java, so it's enterprise/corporate/boring".
They're both open source ecosystems, and that's great. And I'd rather work with the JetBrains or VS Code ecosystems, then say, Eclipse, even though all of them are open source. (I haven't met many Android devs yearning for the Eclipse-based Android development environment.)
The language server protocol is diametrically opposite to the way that IntelliJ works. For each language, IntelliJ builds its own internal representation (PSI) of the source code. There are a lot of language specific things, but there are also a lot of commonalities between languages.
I have no idea how you would morph (say) IntelliJ's Java support to use a LSP without basically throwing everything away and starting over.
Caveat: I never worked at Jetbrains, but I did work for two years supporting Android Studio and IntelliJ at Google, which involved a lot of work in its internals.
I'm not really arguing that the JetBrains ecosystem is equivalent, or necessarily better, than the LSP approach. It's just that this article seemed to base the existence of the LSP as some evidence that JetBrains' approaches with MPS, etc, are "corporate enterprise bloatware", which will be displaced by VS Code.
I just haven't any evidence that the LSP is creating a disruption, which is what the article is asserting.
Right now, it seems like you still have Microsoft as the main driver of the VS Code ecosystem with a few other contributors, and JetBrains really drives a lot of its ecosystem, with a few contributors. Not really seeing much of a difference, and, it doesn't seem like the products or business of JetBrains is significantly challenged by VS Code.
I mean, I haven't heard anything like Google deciding that VS Code will replace Android Studio, right? If the LSP was a true disruptor, I'd think that after a few years, that would be true. I'm sure eventually there will be more and better support for Android development in VS Code, but that probably won't displace Android Studio much.
Yeah, I didn't mean to say that Eclipse "wasn't" open source, just that these other ecosystems are also. It's not like you have a choice between "Eclipse and commercial".
> Meanwhile, JetBrains seems to be staying afloat mostly thanks to hard work and sheer luck.
Or, just maybe, their products are excellent.
This piece is interesting but is is not more than an opinion piece. There is very little in there that actually compares the two products. Feature-wise or how the developer experience is.
It would be interesting to read an objective comparison. Does any site/magazine review developer products?
I use VSCode for 95 percent of my development and I couldn’t be happier. I use IntelliJ for the other 5 percent (which is just Groovy scripting for a particular product).
For the way I work, it fits very well.
- I write nearly exclusively a mixture of CPP and Typescript. Particularly in projects which mix these languages (and for Typescript as a whole), I have not found anything better.
- I use the remote SSH feature heavily. I have a bottom of the range MacBook Pro but I use a reserved t3a.xlarge instance in AWS for all my development. It’s blazingly fast and I know that if my laptop was to explode I could be working again in 5 minutes (which is important to me being self employed)
- Any software that I ship to clients I ship with a container configuration. Even if they do not use VSCode themselves, if they have a problem they can spin up my exact development environment and run tests, step through debug etc.
- GitHub settings sync seems quite useful although I have not needed to use it yet.
However, VSCode weak points:
— Terraform support is awful. Hashicorp seem to have completely broken the related plugins since they took over maintenance of them.
- The CPP debugging experience is not as rich as full Visual Studio (which is fair enough). I occasionally miss things like the memory window.
I use IntelliJ daily. I think when LSP gets there VSCode can catch up and fill the IDE gap, but until then it doesn't come close to IntelliJ in terms of functionality (though sometimes the perf of IJ makes me want to switch but it has been feeling a lot better on the M1).
LSP needs to make 2 major improvements in order to to get wider adoption:
- Create one bundled cross-language LSP container or something that all the editors out there can use. Currently its a mess to configure and run all the language servers and what not. This leads to a broken half-assed end-user experience.
Once #2 happens, I think the whole editor ecosystem will feel a lot better for all the editors. Everyone is poorly reinventing the wheel right now.
This is interesting to me and makes me question what I missed on setting up JetBrains products. I moved away from them because of their lack of support for standard tooling like eslint and pep8. It felt like JetBrains editors wanted me to set up lint rules by their spec and I had to set it up in their editor configs.
I’ve always been able to add the VSC plugin for a language and everything just works. With JetBrains it felt like the first thing I was gonna have to do on every project on every one of my computers was set up a bunch of custom scripts to do really basic stuff.
To be clear, I really am questioning what I missed, not the parent. Everyone here says Jetbrains is more convenient and I felt like my first task was always 3 hours of setting it up.
> I moved away from them because of their lack of support for standard tooling like eslint and pep8.
Sounds like something went wrong. These both get auto configured for me. I even get correct completion suggestions to disable the rules inline or at the file level for both eslint and pep8. The only thing I’ve had difficulty with is Prettier but that was improved recently. Email is in the bio if you need any help :)
Huh, how long ago was that? I've been recently using the Python plugin in IDEA while fixing up a rather important script, and it's very good at a) telling me when I'm doing bad PEP8 things, and then adding PEP8 compliant formatting when I tell it to autoformat and b) highlighting type hint mismatches.
But this may be a recent improvement, I only work on Python sporadically. My next wish for IDEA's Python plugin is Poetry support.
Outside of the JVM space, I share the complete opposite sentiment. Go and Rust support in the past few months (close to a year at this stage) have been vastly better with LSP than with intellij (or the more specific products). Rust-analyzer literally just works for me with the vscode rust-analyzer plugin (intellij wouldn't work after a few minutes of googling etc, not a great experience) and I've consistently seen Goland be outperformed in OOTB experience by gopls, as a highly active member in Go online communities catering to helping many new developers.
This comment doesn't make much sense. LSP is just a protocol, implementing package detection is the responsibility of the language server.
The second thing you're asking about sounds more like a unified LSP client which is totally possible. It would actually be pretty easy. VSCode could actually improve this a lot since language clients are mostly boilerplate.
All that said I think you're undervaluing what LSP/DAP actually gets you. It's a language agnostic API for PL tools, which includes compilers and virtual machines. All you need to be able to do is parse JSON and you can begin writing a reactive compiler that integrates into any code editor.
We know how LSP works...Run a few of their implementations for various languages and send me a script. I have, it’s not easy. Running the LSP server set for a polyglot programming environment is really hard.
Not having read the article, I think the main difference is that IDEA as a traditional IDE is a monolith, while VSCode interestingly and somewhat unexpectedly integrates a lot of different tools. With LSP, the VSCode team created something quite interesting. And the most interesting aspect is that an LSP server can be accessed from many other editors. I personally have grown to like VSCode. While I previously switched between eclipse and vim, I now use mostly VSCode, RStudio (which I still prefer for R code due to some details), and VIM, mostly for maintaining todo lists and my markdown wiki.
According to Jetbrains' own surveys, VS Code is indeed growing in popularity - from 7% of Python developers in 2017, to 29% in 2020, while Pycharm remained at about 33%:
I am wondering a bit what is meant here by “disruption”. As I see the situation, some people seem to believe that as professionals we don’t necessarily have to use “the best tools available” and if you can save a little by getting “almost as good (after some tinkering)” it’s more than acceptable.
My view is that if “a real IDE” (I use quotes as this is subjective and said in a bit of a tongue-in-cheek manner) gives you even 3% performance boost, it’s well worth paying 100 euro per year especially if you are making tens of thousands using it.
Overall though this “IDEA vs VS Code” situation is interesting because it reveals something about cultural situation in the developers’ community.
I hate to work with JetBrain tools. Whatever machine I am using them on, they feel sluggish and bloated. Starting an editor takes ages and often it is unresponsive or you can feel the delay between character appearing on the screen and your key press. Absolutely dreadful.
That being said I still use them, because nothing can quite compare despite these awful flaws.
I also use VS Code but only because there is almost no delay between typing `code .` and having an editor ready to type stuff in. It's perfect for quick "sketches" or if you want to check an odd file here and there, but if you want to work on a larger code base, the experience falls short (e.g. navigation between files, searching)
With that in mind, there is still a big gaping market hole when it comes to IDEs - create an editor with JetBrains feature set plus make it as fast as VS Code or Sublime and you'll be a winner.
One more thing I cannot understand is that literally every editor's search functionality is more or less useless for bigger projects - simple thing like "and" and "or" operators for keywords are yet to be found. Sure some allows you to use regexp, but that is a pain and not how people are used to searching when using e.g. google or github.
The link seems to be dead but here's my thought anyway.
People in this thread mentioned brilliant factors among those IDE/editors, but the 2 cents I want to add is their difference is related to the way they work, or how people work on them.
VSCode: LSP reflects the mentality of VSCode - it's extensible, it's working but it usually doesn't offer first-class experiences. It usually aims to serve the intersection or the common part of languages first, then the specific language.
The idea is very akin to Emacs, in which the community tries to find the abstraction of functionality, and then people can work on different implementations at the same time - there's Helm for completion, and Flycheck for checking in the first place, then there's a whole bunch of implementations. The good is it solves the m*n problem, but the bad is the experience is not good as tailored for specific languages. Actually, one specific struggle in the Emacs community right now is choosing between LSP and language-specific plugins.
Intellij: It is on the other side of the spectrum. It's polished, feels pragmatic for major languages they're targeting. Unlike LSP and VSCode, It was aimed to be the best Java IDE, and it did it. Now you can see the inheritance panel for a lot of languages that don't even really care about inheritance.
So IMO it's like Conway's law. The key difference between VSCode and Intellij is because of the way they work - VSCode was built on community, and Microsoft is more like a facilitator. While IntelliJ is driven by a single company, and the plugins and communities are supplement features.
In my opinion, one killer feature of VSCode is the ability to connect to WSL, remote server and Docker container. As someone mainly developing on WSL2, I use this feature everyday. I only use Idea when I need to use Java or Kotlin, because its language support is really good.
> or Kotlin, because its language support is really good.
I've been using Kotlin for about a year now at work. I feel that "IDEA has good Kotlin support" isn't quite the right way to say it. It's become clear to me that the language is explicitly designed to be read and written in IDEA. Receivers (changing `this` per-scope) and `it` (to a lesser degree) are really poor syntax features to read in plaintext. But IDEA automatically adds the plaintext for you so you don't notice.
Genius business move by JetBrains. Get some corporations hooked on some sugar on top of Java, and now they have to pay that fat license forever.
Or, less cynically, it's time we moved beyond designing languages for the lowest common denominator in editors. Sure I should be able to make tweaks in notepad, but I'm totally fine with that being the less happy path.
That's not exactly what I'm complaining about though.
The syntax features I mention only make any sense period within IDEA. But it's just a syntax feature. The value-add is very low! But it's pervasive in Kotlin. That creates the lock-in. In fact, pumping IDEA's seeming value is those features' biggest impact on the average Kotlin developer.
The majority of the valuable code I've written in my life has been Haskell. I do just use emacs, but I heavily use ghci (free and flexible) to aid my understanding.
But most of that Haskell was conceived while I was doing the dishes. So far, my Kotlin has been too tbh.
So IDEA isn't solving the actual critical path of software problem solving. Kotlin and IDEA are sugar for the masses. Nothing more. And I'm pretty sure they know what they're doing when they aren't drunk on their kool-aid.
I happen to disagree with you both that syntax is irrelevant and that receiver scopes are "just syntax".
I think whether you care strongly about syntax is just personal preference. For example, I prefer Elixir to Erlang, TypeScript to JavaScript, and Kotlin to Java even though they could be/are implemented by transforming source code to source code.
On receiver scopes specifically, they make simple DSLs very easy to implement. Arguably needing a DSl is a symptom of design flaws, but Android has a lot of those so receiver scopes makes Android programming a lot nicer.
Edit: I would call this more than syntactic sugar:
interface MyScope {
fun frob()
}
fun foobar(content: MyScope.() -> Unit) {
let scope = MyScopeImpl()
scope.apply(content)
scope.getResultInternal()
}
fun user() {
foobar {
frob()
}
}
There is also projector and "code with me", but they still have some work to do before they reach feature parity in that regard. At least they are working on it.
I agree with this; I bought the professional license of PyCharm on the basis of its "remote development" functionality which I assumed would meet the (admitted) easy "it just works" standards of everything else in Idea.
It never worked, not even close and I ended up dumping it and returning to VS Code because the remote stuff (particularly to linux VMs and containers) was a deal-breaker.
Real missed opportunity I thought, it had been a long-standing bug when I looked into it, and very very oversold as functionality present in the professional version.
I've seen this being mentioned in other comments, and besides WSL2, I've used PyCharm (a close relative to IDEA) connected to containers, Vagrant and plain VMs for years. I suppose the rest of the IntelliJ products have the same support, and WSL2 being rolled out, obviously?
Speaking as a corporate programmer working from home indefinitely, I'd kill for IDEA Viewer. My laptop can't have code on it, so I'm forced to remote desktop to my workstation to use IntelliJ and CLion remotely, which is a middling experience at best. A light protocol for synchronizing the frontend with the IDE backend would be excellent.
You can look at my profile and various papers we've published about why code on laptops is both hard technically and draw your own conclusions beyond that.
As an aside, I also use IntelliJ on my own projects for Rust. The Rust LSP is getting there, but nothing beats IntelliJ Rust yet, and that's been my experience across the suite. JetBrains tackles the hardest 20% of the problems (like partial compilation and indexing) and executes extremely well.
It has some semi-minor issues still (e.g. resizing panes, last I tried it, would only move a few pixels before losing the "drag"), and it's not as efficient as VSCode (which is a pretty high bar, to be fair), but there is a "Projector" for many of their IDEs: https://medium.com/swlh/how-to-run-android-studio-on-any-dev...
It's not quite good enough on my bandwidth to make me switch from VSCode for remote work, but it's pretty close. And the day it is, I will be thrilled to abandon VSCode's horrible Go plugins.
> remote desktop to my workstation to use IntelliJ and CLion remotely, which is a middling experience at best.
i had to do this for a while. Genuinely awful experience over the citrix thing and best possible connection situation.
> As an aside, I also use IntelliJ on my own projects for Rust. The Rust LSP is getting there, but nothing beats IntelliJ Rust yet,
Thanks for saying this. I'm trying to pivot to using rust for a greenfield project. Just gave up on the emacs rust set up as it was tremendously frustrating to use
Offtopic: I can't seem to resolve this website through CloudFlare's DNS servers, what's going on here? Are they blocking Cloudflare's resolvers? Is there something wrong with Cloudflare? What is going on here?
In my experience, IDEA is just better in the things it does well and just worse in the things it doesn't. Without spending days searching for extensions and configurations, Jetbrains' products beat Code every time when it comes to Java and the related ecosystem. When it comes to C/C++, Clion is one of the best IDEs there are, and VS code can only get close through extensions and a buttload of JSON.
For frontend, both suck equally as much, but that's just because modern development has turned into a Javascript mess and frontend developers seem to make it their personal mission to change up and replace the entire ecosystem every five years. No IDE can keep up with such an ecosystem without becoming janky and unpredictable.
The language server feature of Code makes it excellent for languages that weren't originally included in the product. For example, Clion has Rust support, but that support comes nowhere near what VS Code can do with the Rust Analyzer addon. Other languages have similar problems with Jetbrains' products; the language server for Code makes it integrate with other languages so well that the two barely even compete.
But, for most of the work I do, the advantages of VS Code seem irrelevant to me. If you develop in a quirky or brand new language, use WSL2 (because you can't or won't use normal Linux) or if you're writing C# code on and for Windows, then it makes sense to use Code, but I just don't see a lot of people with these problems.
The biggest advantage of VS Code I can see is that through its addons, it gets to become fully-featured for free. You might argue that it's open source as well, but as far as I know there's still functionality that Microsoft has hidden away (C# debugging) in open source builds due to licensing issues. In my opinion the pricing on Jetbrains' tools is pretty good; the tools have increased my productivity enough that I'm more than willing to invest in these tools.
Until four months ago I used PHPStorm although I haven't typed a line of PHP code in at least 4 years. Since all my coding is with TypeScript I decided to switch to VSCode and not renew my Idea subscription.
The only feature I miss is the local history. It is nice to be able to aggressively hash out code to solve a complicated problem and revert to the state 1 minute, 5 minutes, or 20 minutes ago or at least look at the diff.
When I juggle between vim, sublime, VS Code and PHPStorm/IDEA. I tend to come back to IDEA for any project bigger than a few files since the after the indexing the refactor, code analysis, search and auto import functionality is so reliable that I just love the ease of use. I still have the free education license and a company license so I am not sure whether I’d pay for JetBrains out of my own pocket but difference in the tooling is night and day, it’s much more robust and quicker to get stuff done than VS Code in my experience
For typed languages like Java and Kotlin there is really no competition. IntelliJ is just clearly above every other IDE. For dynamic languages advantages are less clear, but still there. Every time I tried to use VsCode for longer periods of time on my JS/TS projects, I would stumble on many small bugs and problems, usually with extensions that I would loose the nerve and just get back to Webstorm.
It did, and millions of Android developers use Android Studio, which is of course also part of the IntelliJ family. So I'm sure that and the (financial?) relationship with Google has also helped a crazy amount with making the whole platform better.
I read somewhere that Jetbrains is valued a billion dollars these days. With zero investor funding. This is a very very serious business with smart leadership.
It is valued more than that, 2/3 of the founders are billionaires now. What I love about their story is they basically just made a great product that developers are willing to pay for and everyone else eventually died.
I almost use always vscode via it's ssh remote development feature. In my experience this thing is flawless and indistinguishable from local development. It's hardly believable how good they've made it.
The idea vs. code is something i don't buy. Each has its use cases. Idea has great tools for android development, it's just tightly geared towards that, which is especially good for someone that is not a main android developer and need to those extra wheels. While vscode is my go to editor for everything else, including java ee.
That depends on the person using it, there isn't a fix list provided by the devs of vscode. For me it's some of the following:
It can be a remote workstation you'd otherwise have to RDP into it. Sometimes RDP is annoying due to network conditions. Via vscode this works great, even at the worse case scenarios of connection drops. Mind you, it's not just source code editing, but debugging, local server management during iterative development. Experience is just like if it was local. Can have multiple projects (directories) opened at the time via a single vscode instance, or multiple instances of vscode running different projects (or modules of the same project) all connected to the same ssh target.
It can be a local container filled with tons of prerequisites/deps, like application server runtimes, support files, all that stuff that i don't necessary want (or need) to pollute my host just because of that one thing right now i will be working on. I just destroy that container when i don't need it, or do anything with it without fear of consequences on the main host. Another case would be a container that perfectly mimics final production environment with all its config.
Whether accurate or not, my personal perception of IDEA vs. Code is that IDEA wants to own my development workspace while Code just works with whatever files I've decided to check in.
It's a real shock when I occasionally try an IntelliJ product and it just swallows up my entire project repo and injects lots of magic.
There's absolutely pros and cons to both. And I don't see them as competing for the same class of editor.
I guess it's kind of IDE vs. Text editor. Though Code certainly looks more like an IDE every month.
Mmm... Feels more like a loss leader than a technical disruption.
Don’t get more wrong; look at Teams, it clearly works to offer a low/zero cost inferior product that is integrated into existing products, so fair call.
...but all that technical stuff? Oh come on; the jetbrains products are better, at basically everything; the only reason more people dont use them is that you have to actually pay for them.
Sure, vscode starts more quickly on a low end machine when you have no plugins installed, but the quality of plugins varies wildly and so does the memory use / speed of vscode when you have them installed.
...and the tools it offers for most languages is simply... inferior; there simply no other way to describe the support for Java, kotlin, go, rust, python, c#.
So... you know, in some ways it does feel like a disruption going on, but not because of technical reasons; Microsoft is just playing the “we have lots of money” card.
I pay subscription for everything but 99% of time use VS Code. Why? Remote execution for huge typescript project - i moved it to separate mac mini and performance (i can open 5 VS Code without slowing anything at all)
Language support in VSCode for Go breaks in unexpected ways after every update of Go, VSCode or any plugin involved. gopls has not helped at all so far.
Golang or IntelliJ with the Go plugin just work. I have been trying to use Code instead of IDEA for 3 years and it is just not worth it. VSCode startup also is not as fast anymore, so that USP is gone as well.
Debugging features are not even comparable, the difference is day and night.
I tried fixing it again and again but never in my whole journey has there been a moment where everything just works, just as Goland did since it became stable.
It is cheaper to use IDEA Ultimate instead of wasting a few minutes every day fighting with my IDE.
Oh and i want to add that VSCode actually created a lot of damage for me.
There were multiple instances where i practiced a live coding session for some talk or other a day before and after arriving to the venue Code language support just broke for some reason or other. This happened like 50% of the time. One time if destroyed a lot of the session because it just automatically did nonsensical imports during my live coding!
Funny that the LSP wanted to give IDEs a way to move fast, by getting its info directly from the compiler and then slow compiling languages like Rust built another tool (the analyzer) to make IDEs fast again.
My switch away from WebStorm was with the rise of compile-to-js languages. I asked myself, do I get more from a new language than a fully fledged IDE with JS-only support? And I choose to go Sublime and then VSCode.
In a fast moving industry there is simply no way I'm going to wait for an IDE vendor to implement everything I want to use.
> Funny that the LSP wanted to give IDEs a way to move fast, by getting its info directly from the compiler and then slow compiling languages like Rust built another tool (the analyzer) to make IDEs fast again.
I don't think that was the main goal. The main goal was giving a standardised protocol for implementing language support in IDEs, so instead of needing n * m implementations for n IDEs and m languages, only m implementations are required. The idea that you could use the language's compiler to implement this was only a bonus (and it's not a very good one in practise: the requirements on parsing and analysing code as it's being edited are very different from when compiling. That's the core reason for rust-analyser taking over from RLS. Without the LSP concept you could just as well build the compiler as a library into whatever plugin architechture you had).
LSP is a huge deal and ought to allow all kinds of new editing tools to empower users with the kind of things we used to get scoffed at by Visual Studio users for living without. Vim is now as "full featured" as VSC and I have some bet winnings to collect.
> the kind of things we used to get scoffed at by Visual Studio users for living without.
Needing to buy thirdparty addons to get basic refactoring tools? Because for a very long time that was the VS experience, it was incredibly bare-bones compared to the equivalent Java IDEs.
No offense; I couldn't care less about Java personally. I just mean Intellisense (at all) was this hammer I kept getting hit with. IntelliJ too. I just kept on with vim+google and now the playing field is level. And I'm still getting more work done and paying less.
Why are desktop Java apps are always so slow? Applications written in other languages (C#, C++, etc.) are much much faster. Even VS Code, written in JavaScript is faster... I tried hundreds of applications and this was always the case and not just with certain applications.
It's not really Java as a programming langage, you can have light and fast Java code, nor the JVM, it's a pretty fast virtual machine that is just very memory hungry by default. In my opinion it's the community and the philosophy around Java. It's usually a bit over engineered and performances are not taken into account very often. Take eclipse as an example, from a software design point of view it's great and a very advanced. You can for example play with the eclipse modeling framework and it's in another league compared to VS code plug-ins.
However the end user doesn't really care about the beauty of the Eclipse meta meta model and think more about why it takes so long to start or why it uses to much memory compared to notepad++.
Also while Vscode is written in typescript/javascript, it uses V8 for the javascript VM which is very fast.
Web Browsers are built on multithreaded rendering - Paint, Layout and Main threads. It works really well, but on legacy or native everything is done on the single main thread and everything is jammed into 16ms of a single thread.
For example why iOS is so fast? It renders everything in separate process. (This is why Flutter will always be a garbage by reimplementing this in main thread).
I bet it just too much and too old to rewrite to new shiny things.
My best analogy for this is to think of Java as like a truck and other languages as like vans (C++) or motor scooters (python, etc). Past a critical threshold Java has absolutely amazing performance (sits in same league as C/C++) but if you imagine driving a large truck around town ... you are constantly starting and stopping, turning into alley ways etc - a truck is not going to do too well. But if you actually have to deliver 50 tons of goods, good luck on the scooter. And a well designed Java app can behave like a scooter but its not the default setting because most people in enterprise settings have truck-like problems.
However the slowness of Java on the desktop is a bit overblown by people's past experience I think .... improvements to garbage collection and hotspot optimisation, and elimination of applets have certainly made a big difference to the type of stalls that used to make people say these things.
VS Code is fantastic and I'd rather use it over something like Eclipse, but as a very happy jetbrains recurring subscriber, when my subscription comes up for renewal I can't think of anything that gives me so much productivity for such a relative pittance of cash.
I still had it installed for quick edits until I found out about Panic's Nova and then uninstalled it and paid for that - the look and feel, and responsiveness of a native application just can't be beat.
The author frames this as a contest between two architectures: either spend a lot of effort building custom developer tools, or repurpose the compiler as a server for multiple clients. Both approaches have their tradeoffs: the first, as the author mentions, violates DRY [1]. The second violates the Unix philosophy [2].
However, there is a third way. Both developer tools and compilers can be seen as special cases of a much simpler and more general pattern known as a graph database [3, 4, 5].
This is the same for me, Sublime 4 is faster and more polished than VSCode and Intellji is more feature packed
Personally I switch between Sublime Text 4 and Intellji depending on the task, VSCode in my opinion isn't outstanding in either performance, polish or features
Maybe Emac 28's speed increase will change the landscape a bit
I’ve actually happily reinstalled Sublime Text after almost a decade due to this.
VS code has been relegated to a text editor with my work changing from mostly JS to mostly C++, and `code X` or opening up a JSON file is just slow enough for a little internal groan to come out.
Certainly not XCode levels of groan, but slow enough to move me anyways.
I found IntelliJ IDEA about 7 years ago. Before that, I had used a number of different editors/IDE's for polyglot development.
I honestly really started to enjoy developing again. Intellij let's me focus on the problems I'm trying to solve. It does a ton to help remove the boilerplate of programming. The things that I really use it most for:
- 1. quick fixes. Automatically adds imports and cleans up code with a key command
- 2. reformatting. I just reflexively reformat everything as I go
- 3. show parameters. Cmd P shows me what I need to call functions
- 4. find usages. Jumping through code is so fast and easy
- 5. syntax highlighting. So many options. But the ones I use most are showing issues as I type, and clicking on a variable and it highlights its usages
There are probably more that I'm forgetting I use.
But I also bought the pro license for myself and happily renew every year. A lot of the features and upgrades I don't even use - they are for languages that other people use. But I am happy to support the product and get features that I do use.
> GitHub is now a MS property, so in the future VS Code is expected to be more and more integrated into GitHub. That pretty much catches all the young and hip audience in a MS owned behavior loop. Which certainly shows some very competent strategic planning.
And so, it baffles me even more that AWS weren't in the conversation to acquire GitHub (or if they were, that they failed to acquire them). Seems like a huge miss to me.
> Meanwhile, JetBrains seems to be staying afloat mostly thanks to hard work and sheer luck.
Setting aside their colossal IDE efforts for a minute, Kotlin and the ecosystem JetBrain's building alone shows their level of competence. Truly amazing to put in so much effort while also making the business work. I mean, in a world of F/OSS languages, frameworks, and IDEs this is no mean feat.
Yeah or Google. They stopped Google Code (or whatever it was) to move it all to GitHub; I just assumed they'd then buy GitHub. Felt like a much more natural home for it.
I'll just keep using Eclipse over here in the corner :-)
I guess its a case of sunk investment, but having got to the point of understanding top to bottom how Eclipse works I find that it still beats everything else in terms of presenting me with a completely comprehensive framework for developing at a high level of complexity across multiple languages and environments. Every time I move to another tool I find them better on the surface but missing these deeper features that enable dealing with super complex infrastructure across many projects in many languages.
I used to be an Eclipse zealot. I clung to it even as my co-workers moved to IntelliJ. When I finally made the jump, I found it a huge boost to productivity and stability. I needed for a while on one project to run Eclipse to be able to use an IBM plugin for their rules engine and it was painful how much slower and crash-prone Eclipse was.
A lot is in the framework level features: I have workspaces set up with combinations of projects configured as dependencies for each other. The perspectives feature allows me to then have specific window configurations for each, and the working sets lets me zero in on a particular subset of projects and files for what I'm working on. The incremental compilation that crosses project boundaries then means I can, for example, jump into something in library, refactor it, immediately (like, less than a second) have all the errors across all the projects across multiple languages show up from this change ... and nearly as easily execute all the unit tests.
I have projects where pieces are written in PHP, python, Java, Groovy and Javascript and these can all be open at once and do things like, set breakpoints in each step of a flow that executes across them all and follow a process end to end to inspect where it is going wrong.
It may well be this is somehow all possible in IntelliJ but the times I have tried it out I couldn't work out how to do anything as sophisticated as what I routinely do in Eclipse. It could barely highlight the errors in one project correctly without launching Gradle, let alone propagate that downstream to all the dependencies.
The examples the author uses to make the case that Idea is getting "fatter" and "more corporate" are actually things VS Code has too:
"What bothers me about JetBrains is the fact that they seem to be playing along. Judging by the talks on their recent conference, IDEA goes more elephantine, more corporate, more complex. (...) In this regard I will mention two announcements: the CodeWithMe technology and a lightweight "IDEA viewer" product. CodeWithMe allows one IDEA instance to run another instance remotely to allow for collaborative work. Even the color scheme and the shortcuts are provided by the master instance, if I understood that correctly. That is very Java and very corporate, no doubt. The IDEA viewer is another step in the same direction: let the IDE run somewhere else, maybe on a server, and let people use a lightweight client "on a laptop in a cafe". I seriously doubt it will work well in an average cafe though. Their WiFi tends to be unreliable. Given this degree of dependence of the client machine, spotty WiFi will cause a developer to smash his laptop against the coffee machine."
Talk about underming your own case.
CodeWithMe is what VS Code calls "Live Share" and "IDEA viewer" is what VS Code calls "Visual Studio Code Remote Development" (the SSH part), and has been available since forever in Emacs too.
I've been using this to develop in CLion running on a beefy remote Linux server from my Mac. Overall it works quite well, with just a few teething issues.
I don't think it's in it yet. Those are 2 features the author says IntelliJ announced (for the future). Although the first (Code With Me) is already available.
This started with eclipse vs intellij. Eclipse was free and okay. Intellij was paid and polished to hell.
Then vscode came along. Again it's great but not polished. Mishmash of plug-ins that may be supported and may do what you want.
To be fair. Intellij needs to refactor their ui. It is not great. By default ugly. And material ui is not officially supported and buggy.
The reality is yes they go for corporate because idk why but developers refuse to pay for an ide license. By hell developers earn a ton thry could afford one.
I spent nearly 1 year with VS code before paying for Jetbrains for good. The time I wasted with VS Code and all its configurations from different plugins in json format can't justify the time I lost with IDEs.
Not to mention, Pycharm, PHPStorm, GoLand, Clion,Webstorm etc all have consistent UI and shortcuts. You learn one and it's quick to pick other ones.
Yes I still use vim for console coding sometimes, but Jetbrains is where I got most of my productivity these days.
You should only compare by specific language/stack. Not as a whole. For Java I’d use IDEA. For JS maybe I’d go with vscode.
For Rust I also used IDEA and preferred it over the vscode rust setup. However, didn’t check as of late, maybe vscode rust experience because better now.
I mostly write JavaScript/TypeScript (with a little Go in my freetime) and I switched from Webstorm to VSCode in December. Things I miss from Webstorm/Intellij:
- Test runner
- visual diff tool (gitlens isn't quite good enough)
I've been thinking about what I'd miss from VSCode if I switched back and I cant' really come up with anything other than I really love https://shadesofpurple.pro/.
So why did I switch? Basically everybody is using VSCode on screencasts, at work, etc. for TypeScript and JavaScript and I wanted to see what the fuss was about. It's not better, and I don't really understand why it's popularity.
My opinion: JetBrains IDEs beat every single other IDE/editor hands down (Visual Studio -- not Code -- comes close). The level of integration and polish is unmatched. I happily paid for license and it's been a well spent investment.
Curious about people who switched to something like Webstorm from VS Code. I've tried it for Typescript development and didnt find much of a difference. I can say webstorm has better , more clean ui for Git, but that's it. Certainly issue was that I could only try it shortly on simple project. Would love it here about some more example from other where to see the differences.
Btw I am pretty impressed with Quick fix and autocomplete functionality for VS code. It's IMHO pretty great for text editor.
Right now I'm primarily using PyCharm, but I made the switch from VSCode to Webstorm a few years back. Here's what I liked better:
- The refactoring keyboard shortcuts and facilities (moving functions from one file to another, UX for renaming, etc.)
- I found code introspection and autocomplete to be more accurate
- I perceived WebStorm to run better on my machine. The initial load time was longer, but after that the latency of different actions seemed better (again, this was just my perception, on my machine).
- Preferred how many things came installed by default on WS vs having to install plugins on VSCode.
- The Live Templates feature was better than the equivalent code snippets feature.
- The command palette felt more intuitive, I could find things that occurred to me much easier than in VSCode's equivalent.
- The git UX which you mention
Those are a few things that come to mind. VSCode may have significantly improved in these dimensions over time - I wouldn't know because I only use for writing markdown and sometimes to compare my working code base with another code base in a second window.
> That situation may catch the IDEA family between a rock and a hard place: it has to outdo compilers
CLion (the C/C++ variant of the JetBrains IDE family) introduced built-in support for the clangd language server in 2018. It's not perfect (https://youtrack.jetbrains.com/issues?q=clangd), but they improve the integration with every release. I leave it turned on by default now.
At the end of the day JetBrains doesn't own a whole cloud office suite that can finance and price dump their competition in the IDE market. They can fight against Microsoft, but US corporate consolidation will make sure that their competitor can just give out "good enough" product for free and destroy their revenue source.
They'll either go out of business or get bought out by another corporate conglomerate and their products released for free.
I have had VS Code load the wrong version of a file. I’m not sure whether it’s loading an older cached version or loading a file with the same name from another folder. The first time this happened and I couldn’t resolve it, I put away VS Code for a couple of years. I tried VS Code again after forgetting all about why I deleted it. I got burned by the same problem. You can navigate right to the file you want to open, and it opens something else.
I use VSCode for most JS work now, but largely prefer Webstorm for big codebases, and wouldn't dream of using anything but PyCharm for python. PHPstorm is a no-brainer unless you're still debugging by using print statements. IntelliJ and Android Studio made me not hate Java anymore. I forgot about GoLand, but haven't encountered an occasion where I felt I needed more tools. When that time comes, I know where I'll go.
I'm having paralysis analysis with VS Code, and trying to choose which plugins to use now. Curation is key, when there tens, if not hundredths of thousands of stars for plugins seemingly doing the same thing.
I have only one wish for JetBrains IDE - can we have one singular one with everything in it, not CLion for C++, and then Dart working on most, but Flutter only in some, or Java, or C#, etc.
I see Jetbrains' role first as a curator of a near flawless collection of plugins for a given purpose.
I'm not surprised the set of plugins is different for each use case. I don't need a Java IDE with CMake plugins, so I don't care if latest CMake plugin conflicts with the Maven plugin (as an example). I'm not _sure_ this is the motivation for per-language products, but I strongly suspect it is.
Another difference is leveraging container orchestration tools (compose on the low end or k8s on the high end) to manage your dev+ environments. The editor used to take a big role in managing that but now I don't want that because I need the dev environment to be highly reproducible and a full environment is usually pretty complex with multiple apps and one or more datastores.
IDEs like IDEA and Visual Studio give me perfect tool for a perfect learning experience: As a hobbyist I'm extremely picky about what I want to learn. For exmaple, when I'm learning C++ and game programming, I'm not interested at all at the inner workings of Git or Makefile or whatever that is not relevant at the moment.
I need something that I can sit down, install some libraries on, config a bit within, and then it works to some extent that I can start coding and with one click it can compile and run. I also need intellisense out of box for a better coding experience. Debugging experience should also be pleasant without installing anything. Of course it's a bonus point if there is a plugin system and I can potentially write my own.
I tried Vim and realized that:
- It will take many months to reach the same comfort of an IDE out of box.
- I'm reaching 40 and don't have many months to live, so wasting any for anything not in my target list should be a sin.
- I probably won't code professionally for my life so it's OK not to learn a lot of things (e.g. I only Git with myself)
- If somehow coding becomes my profession I should be able to use the same IDE for work as well.
- My coding skill is too low to make any advertised productivity increase of the Vim/Emacs people looks insignificant comparing to the time I nheed to debug some trivial errors.
Thus I dropped any learning towards Vim/Emacs/VSCode. However if I want to pick up one of them it's going to be Emacs because I really like its note taking facilities.
I have no doubt that IDEA is probably more "professional" but I find VS Code is more my preference because of the open source nature of it. I know it has it's warts but it's in a whole different league than IDEA products. However to each his own, I have made a living with open source and that has colored my perceptions of products.
IntelliJ IDEA's Powershell support (via plugin¹) is very poor. Both VSCode (predictably) and Atom are superior. It is the one reason why I keep VSCode around.
I am new to Rust, and started first with VSCode, and I never managed to make plugin work properly. Again, an experienced user will be able to fix the problem, but I am not.
what about Intellij with Rust plugin? Install plugin, start coding. Done.
And I can't imagine doing Java in anything else than Intellij (have tried Eclipse at some point)
I've used both extensively, and for me it boils down to whether I am using Typescript or not, as the code hints for Typescript are much better in VS Code. I've also noticed VS Code suffers less performance degradation with some projects.
In general, for Java and Python, Intellij is much more polished and functional.
The great advantage of a Jetbrains IDE is the solid integration of all the components for a particular language. Bolting together extensions in VS Code has never gotten me close to the efficiency of a dedicated IDE from Jetbrains. I use both for their strengths and always have an instance of both running.
The debate seems similar to some language comparison like JavaScript vs Go. There is a place for each - IDE and a Code Editor, Interpreted and Compiled - and for every problem - big corporate project, small open source repo you should just use the appropriate tool.
Unfortunately, for a "light-weight" text editor, VS Code is very power hungry, especially if you have more than a few plugins. Yes IDEA is not much better but you get far more for your watts.
This! I have been trying to switch to VS Code for dotnet core projects, wanting to ditch Visual Studio. It's clear that Microsoft is - willingly? - keeping VS Code an arm and a leg away from being close to Visual Studio. Refactoring is a hit and miss, the language server will randomly need kicking, code completion is at times outright trying to sabotage you - inserting random classes - and the whole experience makes impossible to consider switching to it.
And even their poster child language, Typescript, is handled by the code editor in a manner that's borderline unusable. If you ever used WebStorm the inability of VS Code to autocomplete with types defined in the same project is mind boggling.
All this said I still reach for it a lot, until I have to stare at a red file with an error on a line that's no longer there until you restart the whole thing and question my sanity.
The original text has been deleted. Here is the copy:
===============================
Reflections on IDEA vs VS Code
The story of IDEA vs VS Code is a story of low-end disruption, straight from the textbook. There is an emergent competitior that is not yet feature-rich but it is not elephantine yet and its technology has an unique advantage. The key technology here is probably the Language Server Protocol; it offloads programming language related smarts directly to the compiler (typically), thus relieving the IDE from supporting a hundred programming languages with all their warts and twists. As the compiler is the ultimate authority on the matters of language, that seems like a wise move: reusing instead of reimplementing. The other technology is Electron and, by extension, a browser engine based GUI. Given how much money was put into browsers, that is probably the most mature multiplatform GUI framework in existence.
That situation may catch the IDEA family between a rock and a hard place: it has to outdo compilers on one side and browser engines on the other side. Specifically, in their primary line of business. Which may easily become an unwinnable bet.
So far it looked like textbook low-end disruption, except for one thing: the disruptor is an old fat incumbent while the disrupted party is a (relatively) young emergent competitor. That is the funny part. Clearly, the MS leadership has read the book.
What bothers me about JetBrains is the fact that they seem to be playing along. Judging by the talks on their recent conference, IDEA goes more elephantine, more corporate, more complex. That is easy to understand: a corporate user pays a lot. But, that is the classic low-end disrupted trajectory that leads to the very same corner where IBM DB2 sits. They will retain some deep pocketed customers, but all the interesting things will be happening somewhere else.
In this regard I will mention two announcements: the CodeWithMe technology and a lightweight "IDEA viewer" product. CodeWithMe allows one IDEA instance to run another instance remotely to allow for collaborative work. Even the color scheme and the shortcuts are provided by the master instance, if I understood that correctly. That is very Java and very corporate, no doubt. The IDEA viewer is another step in the same direction: let the IDE run somewhere else, maybe on a server, and let people use a lightweight client "on a laptop in a cafe". I seriously doubt it will work well in an average cafe though. Their WiFi tends to be unreliable. Given this degree of dependence of the client machine, spotty WiFi will cause a developer to smash his laptop against the coffee machine. Then, the developer will have to pay for both. I experienced similar issues with JetBrains YouTrack in the past: it was an awesome issue tracker, unless you use a poor connection or the server is too far away. Then, it was unnerving. So I assume, that will be stress-free on a wired connection only. Whether the developer is using a laptop or a workstation is of secondary importance then: it is wired. Still, that feature fits some corporate behavior patterns, so it may entrench IDEA better in that environment.
In addition to the rock and the hard place, IDEA seems to be caught in one more aspect. GitHub is now a MS property, so in the future VS Code is expected to be more and more integrated into GitHub. That pretty much catches all the young and hip audience in a MS owned behavior loop. Which certainly shows some very competent strategic planning. Meanwhile, JetBrains seems to be staying afloat mostly thanks to hard work and sheer luck.
I personally don't mind it. I probably would have taken issue with it if there were no user themes, but the ability to dress it up in my favorite Nord colors has assuaged my concerns.
Critique of the post:
The belief that LSP are implemented in the compiler is mostly plain wrong. They might or might not be maintained by the same team as the language team but are almost always a separate library that interface through the compiler through APIs. Yes compiler have became much more queryable.
Intellij has had a technology similar to LSP (and much more complete) a decade before it's "invention" and do leverage compiler APIs.
Which btw allow intellij to support LSP (apparently) https://plugins.jetbrains.com/plugin/10209-lsp-support
The only point here is:
Vscode has better and earlier support for niche technologies
This does not at all outweight the tremendous gap between vscode support for non-niche technologies versus the excellence of intellij support of non-niche technologies, it's two different worlds comparing them is proof of pure ignorance.
The point on code with Me is nonsensical, vscode (and atom before through teletype) supported real time pair programming before, jetbrains is here playing catch-up (for once)
However the point on Electron enabling better rendering performance is actually true, skia is just the fastest 2D renderer to exists and it's time for people to understand that objectively on this aspect native gui toolkits are obscolete.
This is why JetBrains has made skia bindings for Java and develop jetpack compose for desktop which Wil enable them to reuse the chromium rendering engine (skia) for Intellij IDEs while allowing their frontend to be in jvm languages (which are multiple time faster than js)
However I believe that skia alone isn't enough and a lot of engineering effort must be made to match the chromium rendering performance (cf the various flutter performance issues(yes Ionic has faster rendering))
One must understand that adding more features does not equal making intellij slower, given enough engineering resources. Actually intellij IDEs are quite fast nowadays and it improve regularly.
Regarding the github.com argument for Microsoft:
It's simple, intellij has perfect support for github, you can create pull request from the IDE and the only remaining improvements to make should not make a huge difference.
> Actually intellij IDEs are quite fast nowadays and it improve regularly.
I want what you're having.
I've been actually trying DataGrip these past weeks and even though I only used it lightly and I'm on a pretty decent computer, it's terribly sluggish. Is there a magic option to make it run faster?
I'm very much in the same boat. VS Code isn't the fastest editor around, but it still runs without putting up a fight on my older machines. I even used it on my x201 from more than a decade ago, which happily darts around VS Code while PyCharm feels really sluggish.
Don't know about datagrip, I was speaking for Idea and webstorm anyway they are mostly the same codebase.
You can increase the available ram to intellij in the settings (under the help section if I remember correctly)
My old thinkpad was really slow with Idea because my RAM would easily overflow and therefore spam swap usage.
The secret sauce is to go for 16GB of ram, any developer deserve it.
Also if you feel adventurous, by going to the EAP release channel you will get optimization earlier (at the cost of some rare additional bugs)
Also always be up to date by using the jetbrains Toolbox and checking download update automatically.
If you turn mitigation=off on your Linux you will get better perf in general at the price of enabling an extremely hard and slow security threat.
I already happen to run an EAP and Linux without mitigations (they're less bad on AMD CPUs anyway). I guess I'll try increasing the heap, but I hope it doesn't need 16 GB for itself.
I have been using JetBrains IDEs for about a decade, after having used emacs for nearly two decades. I have never felt that JetBrains was slow, but I hear that a lot here.
I'm curious what situations people are finding JetBrains' speed to be impacting usability.
Sometimes I just want to read code with highlighting. I want to open the project and search for some text in all the files.
I don't want to wait for IntelliJ to take 30 seconds to open.
This idea assumes that one I am familiar with grep and vim or nano and two that I was using my terminal already. Which can be true or wrong. But, the discussion is not about whats the best way for searching for text in a file set. I am just talking about whats the use case in which I prefer VSCode over IntelliJ.
Using Windows, comparing different Jetbrains products to VS Code, I personally experience for example a constant input lag in the terminal (Powershell) emulator (?) on Jetbrains IDEs.
IntelliJ user here. Both on Windows (personal) and Mac OS (work).
I never understood why people use the terminals built into their IDE. Can you explain the use case for this? Genuine question.
I do certain stuff via the command line and other stuff via the IDE. But switching between windows and just using the native tool for its own job seems the most natural to me. Is there some sort of awesome integration or something that I'm missing out on?
That seems to intuitively make sense as a want, if I consider the fact that many other devs tell me that they never want to leave their IDE, even just to open a PR or whatever.
Is this windowing support somehow superior to using regular windowing and shortcuts? I ask because I personally find that getting used to a new set of shortcuts takes considerable time and creates frustration when you mix em up. I switched to IntelliJ from eclipse and wanted to learn IntelliJ native shortcuts instead of using eclipse settings. There's something to be said for everyone to 'speak the same language' when interacting and helping each other.
Anyhow back to windowing, I personally like to just have whatever application I use to be open full screen (minus any menu bars, docks etc). and having the same set of shortcuts to interact with any window (CMD-TAB or CMD-~ works the same on all of them - substitute CTRL-TAB for Windows) is awesome. Similarly I know some people use a tiling window manager and I would gather that it would even be beneficial if each internal window in IntelliJ could be detached and arranged by that window manager (sort of like Photoshop/Gimp does on Mac) using its own shortcuts.
An example in frustration for me is the debugger in Chrome. The times I've closed the Chrome tab because I wanted to close the open file (which looks like a tab to me) with CMD+TAB is staggering ;)
Caveat: I might be biased by seeing people awkwardly click around to find the right internal window and then the terminal or other tool is way too small to be useful if you ask me.
Another 'integration' into IDEs that I don't understand is the source control. They also in many cases rename functions which makes for awkward conversations. Though they seem to learn e.g. people have an easier time now to find the function in IntelliJ if I ask the to show me the 'git blame' as it's called "Annotate with git blame" now. Whether a current employer gives me Windows, Linux or Mac OS, I work on Java and have IntelliJ or do whatever else, using command line git and gitk and Kdiff3 will always look and behave the same.
I've never quite figured out the advantage to these integrations, either. The only "terminal" that I use occasionally in an editor is BBEdit's "Shell worksheet", which is actually just a plain text document that will send the current line to a shell when you press ^Enter and paste the output into the document starting at the following line. (This is equivalent to Emacs's Shell mode; I don't think I've seen it in other editors.) And I only use that in cases where I want to capture terminal output and do stuff with it in a text editor because, hey, it's right there.
And, so far I've never found a source control integration that I really like more than using command line git or, on specific occasions, standalone git GUI clients.
Curious how often you start your IDE? For me it's at most once every few days.
But then, I use Eclipse which has amazing multi-project support so there is nearly never a need to restart to switch contexts - its just choosing a different working set ...
Hot buzz without much substance. You propose hipster driven development. Ignore lessons from the past and repeat all mistakes and deficiencies in super shiny alphabet soup of technology. Look at node.js ecosystem to see where this leads to.
IDEA is fast once it starts up. It's not supposed to be used as Notepad (or Vim).
HN deserve better content than this, while the topic is interesting there are too much errors, unadjusted logical quantifiers and omissions to make this biased writing worth a read.
It's also posted by some anonymous throwaway account that was registered on GitHub three days ago. JetBrains deserves more respect than this. They're not threatened. They're a rising star. They're making tons of money when the rest of the industry thought there wasn't any money to be had in tools anymore. I love them because speaking as a long time Emacs user, JetBrains makes the only IDEs I've seen that simulates Emacs well enough that I can feel comfortable using it. Java is a real pleasure to work with thanks to them and I don't see that changing anytime soon. If they had support for make and assembler then I'd use it while working on cosmopolitan libc too.
I used IDEA once and it failed to parse or validate my Java code because it lacked the same understanding of generics as javac. So I would be developing my codebase with various red marks everywhere and no confidence in the code navigation tools such as "find all references". Seems IDEA is overrated to me. But I know webdevs have other use cases like automatic CI or whatever and not the slightest desire to be able to statically analyze code. To be fair I stopped using Java since then as I could not ever fully learn all the edge cases, and corners like generics edge cases and JMM have about 3 people in the world who actually talk about them.
FWIW Eclipse and NetBeans also broke in other places in my code base too (all related to generics), so maybe just Java developers have no idea how those weird parts of the spec surrounding generics, type inference, and capture conversion work.
I tried VS Code to analyze some Go code and it just downloaded a bunch of ghetto stuff from random people's githubs and ran their build scripts or whatever. It broke of course and I gave up as I was new to Go and didn't want to dig into "why thing here wants this version of this and that". Currently using 30 day trial of Goland, which at least works out of the box. This is after trying ctags and cscope after realizing they are basically glorified grep.
Every IDE function appears to be better implemented in JetBrains, whether it's Code Analysis, Refactoring, Navigation, Running/Debugging, Running Tests, adding new files, git integration or contextual functionality like adding package references etc. Everything is just better in JetBrains.
I see VS Code as an ubiquitous smart editor platform with zillions of plugins that's half way between a glorified text editor and an IDE which I use a lot for quick dev changes, quickly searching a folder, front-end UI development, trying out new languages or writing docs. But if I have to start a long dev session I turn to JetBrains which I find far more productive.