Why Did VSCode Win?

The first push for making Language Server mandatory part of language tooling. Working with TypeScript and now with Rust using VSCode is basically one of the best developer experiences I've had, especially compared to having to wrangle Kotlin with JetBrains IDEs.

And the plugin ecosystem + declarative configuration makes it really good to personalize.

I’ve used both Atom and VSCode, and personally I’ve always liked VSCode much more.

My experience with Atom was that it was a stereotypical “Electron” app in all the bad ways. It was very slow to start and the text editor was laggy; the UI was way too spacey and it was hard to find things and I just didn’t like it; and there were lots of bugs.

VSCode is also implemented in Electron and it has bugs and UI quirks, especially with extensions. But it launches almost instantly, text editing is almost instant (even if extensions are slow thanks to some sort of priority threading), the UI is clear and compact, it has more key combinations. Once Microsoft introduced the LSP I think it was over.

Marketing is key, Microsoft marketed VSCode to Python programmers and others. It was written into tutorials to use VSCode as an IDE.

Richard Stallman wants me to use eMacs. Microsoft wants me to use VSCode.

I just want to see Visual Studio for Linux.

It won because most developers don't know any better.

The main reason is Language Server which allows you to quickly bolt on some simple autocomplete+refactoring functionality for almost any language. And this is already a magnitude better than what was available for most languages in most editors. Even if it's a tiny percent of what an IDE like Intellij IDEA is capable of.

I may hate IDEA's sluggishness, but the insane amount of tools at my disposal trumps anything VS Code offers even for the officially supported languages.

It doesn’t suck. Almost everything else sucks.

It was 'literally' designed to win. Microsoft Visual Studio branding is much stronger than 'Atom'.

As part of their new form of 'Embrace, Extend and Extinguish' strategy after acquiring GitHub, a significant part of the ecosystem of cool plugins, services like live share, etc are exclusively focused and supported on VSCode which is a further form of lock-in and pushes out editors like Atom.

After the acquisition, Microsoft was maintaining both Atom and VSCode and one of them had to go and they knew it had to be Atom; unsurprisingly.

My observations and experiences. Used VSCode from 2014.

1. Attracted Nodejs and then Python initially.

2. Fast enough

3. Good extension architecture and extensive extension ecosystem (hey look a new EEE)

4. LSP integration

There are technical and political reasons. Among the technical were that Atom was the first app built on the Electron framework. On the political side, I think a significant reason was the fact that Microsoft bought GitHub.

Money/time. Microsoft dumped a ton of effort into doing a good job.

Web platform is a great tool, that allows rapid development with very fast results.

Extensibility. With JS under the hood & a plugin system, people were able to create tons and tons of value ontop of the base system very quickly. This was the promise of tools like Eclipse for a long time, but development was cumbersome & heavyweight. Some of the win here is again that the web platform is already extremely well known and popular. Some of it is more refined architectural tastes. But creating new value in vscode was easy, in a way it's never been before. The existing capabilities are themselves great examples. There's many more examples too. https://code.visualstudio.com/api/extension-guides/overview

Lack of competition. VSCode aside the market hasn't changed much in a decade. Not a lot had changed.

Light & fast. Starts stupid quick, runs stupid quick.

Targets the important stuff. Fantastic for webdev, great debugging, linting experiences. Well integrated & capable IDE.

Liveshare. Holy shit, liveshare. I've spent dozens of hours trying to figure out how to collaborate with coworkers & friends in the past. Floobits, a random assortment of odd other projects... nothing compares to how quick & easy & simple it was connecting to someone else. And being able to then just navigate the project, or follow them, or follow someone else. By compare, Atom's TeleType offered... almost nothing. Barely better than coding over zoom.

I was going to make a guess & say that a huge advantage was that VSCode won because it was a late mover, because we got way better at tech, & much more is within reach. I was doing some searching around to understand what tech (beyond Electron) it's built with, and found this neat interview[1] with longtime dev Benjamin Pasero that goes deep into the history. Evidently it's from 2011?! Holy shit; didn't know that. One of the first TypeScript projects out there. This mainly reinforces that it's just been a product of a lot of time & money. VSCode itself has a number of other vscode sub-dependencies, but off the bat, I'm not seeing a ton of other high-value big-ticket libraries they've leveraged to do their thing.

One other win is just having a well-defined UI architecture, that provides a reasonable backbone/structure to develop around: https://code.visualstudio.com/api/ux-guidelines/overview

Language Server Protocol sealed the deal, as a way to "interface" with any given language.

[1] https://www.git-tower.com/blog/developing-for-the-desktop-vs...

win what?

i'm not using it, it lost?