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.
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.
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.
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.
> 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.
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.
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.
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.
> 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.
> 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 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.
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.
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.
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.
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.
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.
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.
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.
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?
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.
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'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?
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
> 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
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!
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.
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?
> 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()
}
}
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
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.
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.
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.
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)
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 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.
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'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
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
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.
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.
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...
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.
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.
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.
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.
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.
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.
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.
I hit a file in Webstorm that literally freezes the app for 4 minutes while it analyzes the syntax. The same file in VScode was done within a couple of seconds. VSCode imo is definitively faster.
> 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 :)
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).
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.
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
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.
> 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)
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.
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.
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.
> 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.
>thanks in large part to the productivity of JS + Web renderer
Oh heavens no. I can't think of a single program written with "web technologies" that is in the same league of complexity as proper desktop applications. And IDEA is already enough of a resource hog; let's not make things worse!
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 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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
> 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?
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.
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.
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.
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.
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].
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.
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.
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.
412 comments
[ 2.1 ms ] story [ 303 ms ] threadAs 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.
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.
>>>>>>>>>>>>>>>>>>>
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 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.
https://github.com/intellij-rust/intellij-rust
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.
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.
[0] https://insights.stackoverflow.com/survey/2017#technology-_-...
[1] https://insights.stackoverflow.com/survey/2018#development-e...
[2] https://insights.stackoverflow.com/survey/2019#development-e...
Regardless, I find it remarkable that IntelliJ hasn't lost an inch of ground (it's even made modest gains) despite VSCode's explosion.
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.
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?
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.
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.
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.
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.
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.
Well that settles that, then.
Thanks for playing folks wrap up the site! We’re done here.
...no surprise, why would they waste their time on it? They give zero fruitcakes about Java.
Let’s just say, 3rd party plugins (like the redhat Java language support) are.... not of the same quality... as the Microsoft plugins.
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.
https://devblogs.microsoft.com/java/
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.
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)
The good old MS in action.
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.
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.
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 :)
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 suspect MS will be selling VSCode premium, as I mentioned elsewhere on this thread, they are already maintaining closed components.
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.
> 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.
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.
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].
[0] https://news.ycombinator.com/item?id=25719045
VS Code fails me for anything that isn't JS/TS in the worst way.
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.
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.
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?
It's still not perfect but my experience doesn't match that.
Android Studio could hang whole mac while "indexing" and often need to "reset caches and restart" while works just fine in VS Code.
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.
You do have to pay for Goland also.
I'm also using it for Rust, but it's missing CLion's powerful debugger UI - but I think that gdb is good enough :-)
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 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’m [redacted], I don’t mind that being public for a bit to avoid playing tag :)
I was pretty set with my Atom setup but it was clear that it is mostly EoL'd.
(and I'm aware that I still have less features than if I was using a full featured IDE, but I'm still very productive and also happy)
1: https://emacs-lsp.github.io/lsp-mode/
https://news.ycombinator.com/item?id=25719338
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.
Edit: typo
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.
However, for me VScode is always open, and I frequently open files with VScode from the terminal
Of course for single one off files I prefer to open in sublime because of how much faster it is.
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
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 think this is key - WHO knew that you could build out a billion dollar business from developer tools.
Edit: corrected autocorrect
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.
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.
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.
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).
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 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.
I did my learning by literally following the VS Code guide (the reference implementation) https://code.visualstudio.com/api/language-extensions/progra... and implementing each feature one by one.
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.
“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
Well that and use utf-8 string indexing (which is easier for every other language than javascript): https://github.com/microsoft/language-server-protocol/issues...
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.
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.
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!
https://youtrack.jetbrains.com/issue/IDEA-226455#focus=Comme...
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 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.
This is a direction jetbrains has been going in for a while. Have a look at the failed https://www.jetbrains.com/mps/
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 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:
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
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.
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.
So either [1] you buy IntelliJ Ultimate & get Java + other languages (PHP, Python, Ruby, etc except .NET and C++)
or [2] you buy the language specific IDE (cheaper) like PhpStorm, PyCharm, etc
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.
They're not just simple configuration changes from each other
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.
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.
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 use PyCharm and WebStorm daily, and CLion for Rust projects at the moment.
https://intellij-rust.github.io/2021/03/01/changelog-142.htm...
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
Or may be there are better ways to do so. Anyway just enable what you need.
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.
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...
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 are differences in default config, and sometimes the independent versions have a faster release tempo, but it's the same language code.
The IDE shell is the same, but in (for example) Rider there are features that are in Rider but not in IDEA.
Likewise RubyMine. I suspect WebStorm and PhpStorm, too.
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.
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.
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.
I prefer jetbrains like you, but some people like their apps to be really snappy.
The rest might be a tiny bit slower but it more than makes up for it with better UI/UX, code always feels a bit awkward
Doing the same in Jetbrains IDE is painful, but possible.
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 :)
I guess Webstorm doesn't exist in your book?
I'm pretty sure the reason is that you might want to use the same ide for backend and frontend (e.g. GoLand, PyStorm,...)
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.
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).
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.
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.
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)
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.
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.
Can you give me an example of what you mean?
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.
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.
who said difficult?
training wheels are not difficukt to use, but that's not how biking actually works.
> I have yet to find any IDE that performs as well as IntelliJ et al.
fortunately, there are different kinds of people.
Oh heavens no. I can't think of a single program written with "web technologies" that is in the same league of complexity as proper desktop applications. And IDEA is already enough of a resource hog; let's not make things worse!
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
I could theoretically host an IDE on a workstation and develop from anywhere with a browser.
Unfortunately it's not ideal yet - remote editor wouldn't let me touch files not owned by session user (even when I could sudo) and similar issues.
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.
[1]: https://github.com/cdr/code-server [2]: https://marketplace.visualstudio.com/items?itemName=ms-vscod...
Ref: https://code.visualstudio.com/docs/remote/containers
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.
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.
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.
I’ve tried to move to vs code several times as I like using the “default” (same reason I use Ubuntu) but webstorm is just better IMO.
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>.
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.
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.
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.
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?
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.
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?
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.
LSP needs to make 2 major improvements in order to to get wider adoption:
- Improve package/runtime support detection (Go modules, npm, virtualenvs, etc). IntelliJ shines here.
- 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.
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.
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 :)
But this may be a recent improvement, I only work on Python sporadically. My next wish for IDEA's Python plugin is Poetry support.
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.
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.
that's unheard :o
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.
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].
[1]: https://en.wikipedia.org/wiki/Don%27t_repeat_yourself
[2]: https://en.wikipedia.org/wiki/Unix_philosophy
[3]: https://www.youtube.com/watch?v=WxyyJyB_Ssc
[4]: https://petevilter.me/post/datalog-typechecking/
[5]: https://arxiv.org/pdf/2004.03082.pdf
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.
Btw I am pretty impressed with Quick fix and autocomplete functionality for VS code. It's IMHO pretty great for text editor.
- 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.
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.