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.
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.
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.
>>>>>>>>>>>>>>>>>>>
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.
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.
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.