The Era of Visual Studio Code | Hacker News Reader

The Era of Visual Studio Code

blog.robenkleene.com

647 pointsrobenkleene672 comments

I find this post along with the comments in "A Picture of Java in 2020" https://news.ycombinator.com/item?id=24551390 to be incongruous with my experience as a professional developer.

My first couple of years writing software I used Vim, then VSCode, then worked in a Java shop and was forced to use IntelliJ. I didn't like it at first, but now after a couple of years I cannot see how I lived without it.

The idea that VSCode is the future doesn't seem right to me. JetBrains products allow you to do so much out of the box, without installing a million plugins that may or may not work. In IntelliJ I can write a half baked statement like `new Foo()`, and then Alt + Enter my way to it being `foo = new Foo();` as a private member variable of the class in no time. If you take time to set up configuration it becomes even more powerful. Even these basics are more difficult in VSCode.

To me the future is IntelliJ for Java and all other languages should seek to have such a nicely integrated experience with an IDE.

I am not even sure I could write Java from scratch in Vim - its really that I'm using IntelliJ, not writing Java. Is this bad? In some pure sense, sure, you are further from the language. But I don't care because I can write and edit code some multiple faster than if I was in VSCode.

From my experience out of the box you get poor performance and you have to spend a lot of time figuring out how to change configuration to improve it as knowledge is scattered in many places and not always up to date. Then it still likes to stall from time to time or sometimes doesn't register key presses properly. It's a poor user experience, but even worse is that alternatives are often worse. I wish there was an editor with low latency, smart search, some proper file system database, so it doesn't take ages to open a directory and built in VCS support, that works quicker than manually issuing commands in a terminal.

I think the success of VSCode is because you can easily open it in your current directory from the terminal and it will show you your folder etc. without having to setup a project first and that you are ready to type you code quickly after opening. If I had to open PyCharm every time I want to try some Python in a new directory, I would probably start questioning my life choices. Before VSCode I would just use nano or Sublime.

JetBrains products _are_ pretty much the best. I think Android Studio + Kotlin is the best, most impressive IDE experience I've ever had. Mostly because Android Development in general is kinda hard, and Android Studio cleans it all up so nicely for you. It really outshines XCode in this regard.

I've never used CLion but I really want to.

That being said, I think it's clear that VSCode is, and will remain, dominant.

First: its free.

Second: it's simpler.

That alone is enough to make any product dominant. The fact that's it free, simple, and pretty much just works is pretty stunning.

VSCode for Unity Game Development kinda shocks me how you can literally install the IDE while the game is running and successfully attach a debugger. It's pretty wild how reliable it is.

I'm not a VSCode fan boy. I find that it lags on my PC sometimes. I kinda hate the "notifications" that it pops up with. And I don't like the auto update mechanism or the Welcome screen, but overall VSCode (or Codium) is clearly the next level of IDE.

I think Microsoft is going to build some really wild stuff on top of VSCode and Github.

I think there gonna come up with way to leverage the amount of data they can mine out of github repos to write code for you.

I'm pretty sure that's a big reason why they bought github.

Well, I think you're right about performance being a problem, but I have 64 GiB and a 4790k and an NVMe SSD. It's like half a percentage of my pre-tax income and was even less when I bought it.

I don't need efficiency. I need something that, given fuel, gives me power. And as someone who has donated to vim, was an early backer of neovim's bountysource, and loves his terminal: vim is my ion drive, IntelliJ and friends are my conventional rocket.

(disclaimer: I am an IntelliJ fanboy)

> From my experience out of the box you get poor performance and you have to spend a lot of time figuring out how to change configuration to improve it as knowledge is scattered in many places and not always up to date.

I don't know if you are talking about IntelliJ or VCS, but IntelliJ can quickly start an empty project. And you don't to spend time to figure out how things work. I mean, there is literally no entry barrier for a bare bone project.

> I wish there was an editor with low latency, smart search, some proper file system database

You are describing an IDE here. Smart search and a proper file system database, it means operating not on a collection of text files but on a project and a code tree, which is the main difference between IDE and Editor.

> I think the success of VSCode is because you can easily open it in your current directory from the terminal and it will show you your folder etc.

IntelliJ is adding this functionality slowly: https://blog.jetbrains.com/idea/2020/04/lightedit-mode/ It's not on par with opening a folder in VCS, but it's a matter of time until the close the gap if they choose to.

I see them as complementary. VS Code shines if you’re jumping between independent codebases for distinct projects, and startup time matters.

But my startup monorepo I keep loaded in IntelliJ for days at a time and have never looked back. For the 1% of time it’s laggy due to a JVM GC or background indexing, the other 99% of the time it’s immensely productive to have e.g. full-stack debug breakpoints that Just Work, well-designed customizable gutters, integrated linting, and more.

IntelliJ isn't really the IDE for dicking around with ideas. Projects or not, it's just too fat. I am an IntelliJ diehard myself and I usually have a copy of Sublime Text open as well, usually to use it as a scratch space, to peek at logs or somesuch, or for playing with code that isn't quite yet in a runnable state.

As someone who uses all three of the editors you named, I think that each serves a pretty different purpose in practice. Each aspires to be the be-all, end-all editor/IDE, but that's just unrealistic to me.

For me, I use VIM all day, every day at work (C++), because while it doesn't have the full IDE experience out of the box, it's close enough, and can be brought much closer with various plugins and knowledgeable adjustments. I've stuck with it because "it just works" and I'm use to it. A previous colleague was a big VIM evangelist, so got a running start from him, and now I've tweaked it enough that it works well for me.

VSCode is my general purpose text editor at home. If I'm writing markdown, or fixing some script, or I just need to see what's in that file, I'll use VSCode. It is the obvious, far superior replacement for Notepad, and has plenty of niceties to make it that much easier to use.

But if I'm building something with a lot of moving parts in one of its supported languages, I'll use IntelliJ. I don't often write Java these days, but PyCharm is just a reskin for Python and I think it's great. It does so much junk for you, and it makes testing and debugging so easy. It does trip up my muscle-memory occasionally, but for the most part it's a powerful tool that's great at what it does.

I used to use Intellij for everything (and I'm not even a Java dev). It is indeed very nice and comes with so much out-of-box around languages and popular libraries. However, Intellij is _sooo_ very slow to load and edit with. This is more tolerable if you work on one project. But in the past couple years, I've had to work on many smaller projects, and loading up Intellij for multiple projects meant gigs of RAM disappearing, along with that sluggish start time wait for each project and slow editing.

I really loved Intellij and I wish it could be made to run more efficient. VSCode fills the niche of "loads fast, moving around code is fast, and I can have many instances open at once without crushing my computer"

I guess it depends on the type of project you're working on, but I think these tools still serve separate use cases.

Fancy IDEs are lubricants for high-friction languages. If a language is already low-friction, there won't be much benefit to be gained from an IDE, as even a plain text editor will already get you near to optimal productivity in said language.

Personally, I'd rather use a plain-old "code editor" (with at most syntax highlighting, but no snippets, let alone autocomplete), in part because doing so will actively steer me away from languages that weren't designed with the User Experience of writing them in mind.

Imagine if there was a hammer that was so badly-balanced that—despite being not too hard to lift—you needed to be wearing a powered exoskeleton to accurately hold and swing it. That'd be a bad hammer, right? Hammers are hand-tools; it's an expectation that they'll work when used "manually", i.e. with raw human capability alone.

Programming languages are hand-tools as well, in an essential sense. Like mathematics, the "interface" through which we manipulate a codebase is plain, raw text — sequences of symbols. We humans understand source code by reading it with our eyes; and then we write or modify it by editing it the same as any other text. We can do the whole thing on paper, or a blackboard, or even purely in our mind's eye. That's kind of the idea behind having a source code representation of a program in the first place, divorced from a machine code representation — to give us humans a formalism we can intuitively handle. A programming language is something you can think in.

Seen through that lens, a programming language that requires the cybernetic prosthesis of an IDE to read and write it fluidly, is a bad programming language. You don't have an IDE loaded in your head. So how will you think in it? (Usually: by thinking in a vague pseudocode instead; or even, by thinking in a different language than the one you're writing in. Obviously, this is going to be lower-productivity than coming up with a mental model of the problem that can be directly typed into a computer.)

(Before anyone makes a supposition about my language biases: both "complex" and "simple" language designs can be inherently high-friction due to their design choices. Scheme has very little syntax, but it's also high-friction, in that it's easy to get lost in a sea of parens unless your editor helps you along with a feature like Emacs' paren minor-mode. Most modern code editors do have something like that, but it's still a form of lubrication to overcome a point of friction in the syntax; one that some of Scheme's linguistic siblings—e.g. Clojure—avoid by increasing syntax.)

While editors like IntelliJ are definitely more polished out of the box, something that may not be apparent is that internally they are all standardizing on tooling and protocols put in place by VS Code in the last few years.

Language toolchains are now expected to provide IDE-specific features on their own (by implementing a language server), and so IDEs themselves don't need to focus on making the language better. So the biggest sell of IntelliJ, reSharper etc. won't be relevant for too much longer, since every editor can (or will be able to) e.g. understand Java and provide basic fixes and refactorings.

Other replies have expanded on this quite a bit, so I'll just add my 2 cents:

When using a strongly typed, object-oriented language like Java or C#, Jetbrains tooling, namely the intellisense and refactoring is well-worth the cost.

However I'll still spin up VSCode for most all other languages since the tooling advantage diminishes when using a loosely-typed language like JS or Python.

Also consider that VSCode is free compared to Jetbrains, and the tooling is "good enough" for most cases. Even the C# tooling is passable with the right plugins.

I write Java in vim all day and it's fine. I'm also one of the top code contributors in my org by any metric (LoC submitted, bugs fixed, tech debt reduced, etc.) And everyone else uses IntelliJ.

You devote time to learning your tools and improve the efficiency of the parts that matter, and the tool itself becomes mostly background.

> To me the future is IntelliJ for Java and all other languages should seek to have such a nicely integrated experience with an IDE.

If you think Java + IntelliJ is well-integrated, you should try C# + VS, C# + Resharper.

I am not joking or being facetious - modern C# IDE support is on another level.

And I don't even like C#.

I tried out vscode for python now that I started a new job. I'm on linux for what it's worth. The experience has been massively frustrating coming from pycharm. First I installed the open source version, and found that microsoft publishes plugins that are programmed not to work with the open source version. They don't tell you this, rather, the plugin throws exceptions that some API is missing. I tried out the official version, and instead of whining about not being supported, it now just crashes intermittently. I gave up less than three days in.

I found configuration of code to be pretty annoying as well. Either you write json, having to google for things like how to format keyboard commands, or use their (subjectively) ugly configuration page.

The fact that I can't detach the terminal from the code window without some weird workaround was also something I couldn't come to terms with. I'm back in pycharm again.

> JetBrains products allow you to do so much out of the box

It's all nice and shiny until it takes several minutes to index your whole project structure. Then you can only hate it a little bit more every time you start it.

VSCode is not bloated (for now) with millions of options, I can add extensions and/or disable them whenever I need without losing performance or even creating my own ones without too much effort.

> I am not even sure I could write Java from scratch in Vim - its really that I'm using IntelliJ, not writing Java. Is this bad?

What I see here is the IDE being powerful to make up for a lack of power in the language. Is that bad? Maybe.

I tend to think it's bad because tooling usually does less for making code easy to read than it does for making code easy to write. Furthermore, one of the few characteristics that seems to consistently predict defect rates is codebase size.

On the other hand, increased abstraction can also require more effort to read, and you'll get a lot more resistance in most projects to switching languages than you would to you switching your editor.

I agree, I used VSCode for Python programming, until I found Pycharm is better. I also used it for Go programming, but later found Goland to be better.

But what confuses me is that the article always references it as a "Text Editor", not an IDE. As a text editor it might be the best, but as far as I am concerned, I just don't need "standalone" text editor. I don't have usage for it. I use IDE for programming, and as far as writing text goes, I need that only for writing notes or software documentation, and for that I use Drafts app, Roam Research, or Google Docs.

But I am curious to learn how people use VSCode as a "text editor".

I'll add to your Java anecdote: JetBrains editors appear to be the most sophisticated across multiple languages. PyCharm is a pleasure to use with Python, Rust, and Typescript. Perks include catching errors on its own (eg before compile in Rust or TS, and don't even need to run Python's type checker), auto-complete, and refactoring. In comparison, VsCode appears to only understand these languages at a surface/syntax level.

I don't like this situation: I wish there were more competition, but it appears one company has the edge at present. I use VsCode for one-off files, since Jetbrains isn't a good fit for these.

Intellij is always too buggy and slow for me. Things it helps you with - it's a language verbosity problem. Ideally you should just use better language.

And they also stopped bringing any more advanced features, like refactoring from null to Optional for example, or reversing template method.

If we're talking about java specifically vscode and vim would just use eclipse language server which can do most of the things intellij can like refactorings and snippets. And for other languages like python ms language server is even better than pycharm for example.

I can't stand writing C#/Java in VSCode and I can't stand writing anything but them in Intellij/Rider personally. It's a trade off between speed and feature set.

I'm glad it's one I can decide to make when and where I want to.

Hopefully one day a full featured IDE will be as fast as I want, but until then I'll be switching between VSCode and JetBrains products depending on what I'm doing.

My personal gripe with intellij is how unintuitive the shortcuts are and how much clicking is the default way of operating.

intelligent completion is something like cmd+mayus+space. "find usages" is cmd + f7 (which in osx means cmd + fn+ f7). The "open" dialog for opening a project doesn't even have a default shortcut, it's mouse based and will open a second dialog asking if you want a new window or just reusing the current one. CMd+mayus+f for global search wont work if my focus is on the integrated terminal, I have to click out of it.

I feel like I'm learning to play piano placing my hand in weird chord shapes constantly, and half those things launch an ui pane or menu that I practically need to navigate by clicking even if they sometimes technically allow some kind of keyboard interaction.

It's not like I'm an extreme vim+dvorak user obsessed with having everything in the home row at one button press, but a bit of thought into priorizing shortcuts and placing the common ones in comfy places would go a looong way.

> JetBrains products allow you to do so much out of the box, without installing a million plugins that may or may not work.

The problem is that all I need is 2 or 3 plugins. If all I need is a golf cart I don't care that your Lamborghini is amphibious and can fly to the far side of the moon

People have written the same hype driven articles about Sublime, Atom and even IntelliJ. The same articles will continue to be written for whatever comes next. Just use whatever you feel makes you most productive. Having tried VSCode I ended up sticking with PyCharm/Goland.

I think the fairer comparison is with Visual Studio 2019, not Visual Studio Code. Visual Studio Code is free, making it highly attractive for a larger audience. The pricing for IntelliJ is not accessible: https://www.jetbrains.com/idea/buy/#personal?billing=yearly

I've also used IDEs that are highly optimized for Java and .NET. I agree it's great for the use case I had.

I have had the same experience. VS Code looks like a fine lightweight text editor plus a marketplace of plugins with variable degree of maturity and interoperability whereas IntelliJ is a mature and polished IDE.

All IntelliJ lacks is two things: 1. Being a lightweight editor with syntax highlighting which IIUC they are / have already built 2. Remote development where the IDE is just the front end running on, say, a laptop and the computation runs on a remote work station

> The idea that VSCode is the future doesn't seem right to me.

VS Code is the future of editors, not IDEs or all developing. There will always this two sides which live from the box and those who build their own box. And for the later VS Code is nowadays one of the best road to walk.

> JetBrains products allow you to do so much out of the box,

It's also very limited on where you can work with it. It works for the handful most popular languages they support, but what if you get a bit more exotic? What if need something non-programming, like markdown, rst or plantuml? What if I am not satisfied with a certain feature in the IDEs editor or workflow?

If your Box is not supporting it, you need to customize it, and there JetBrains is just not as good as editors like VS Code, vim, emacs.. And VS Code even goes to great lengths to gain the IDE-state of having everything out of the box.

IntelliJ is a much better experience than VSCode. Without leaving the IDE you can: edit (with autocompletion), static analysis, debug, test, code coverage, version control, profile. All using JetBrains official plugins.

It also integrates with databases, Docker, etc.

I've switched between IDE's and "lighter" editors like Sublime Text and VS Code so many times now (and I can't get used to vim and co, I'm too young I guess lol).

IDE's helped me so much writing Java code; refactorings, autocomplete, code generation etc are features that never became as good in 'lighter' editors.

Then the JS era appeared, and IDE's couldn't really do much with it - in part due to its unstructured setup, lack of importing code, lack of namespaces. Autocomplete and jump-to-definition was non-existent. I switched to Sublime Text for web work, and relied heavily on the powerful and fast global search and cmd+p navigation for a good while.

Over time, things changed; JS got modules, JS got types (or type inference) through projects like Flow and Typescript, and JS got richer with e.g. JSX. Still mainly used VS Code (by then) for front-end though; heavier editors didn't seem to offer enough added value to warrant the switch.

But every time I did back-end work I would switch back to a proper IDE. Java / JVM languages are things I never did in a lightweight editor. Go (which I use as a back-end language currently) support was rough for a good while in both editors and IDEs, but it's getting there.

In my current job, I handle four languages over two projects; there's the legacy project, PHP and JS / Dojo, and the new one, Go and TS / React. I've fully switched to using an IDE again; intellij's JS / TS support is good enough, and honestly for the legacy codebase I need it. The codebase is nearly 10 years old, and the 'hip' editors simply don't support PHP 5 or 13.000 line spaghetti messes. But intellij does; I configured it for PHP 5.2 specifically (so if I use the shorthand array syntax it flags it up) and ES5, it struggles a bit but it can make sense of the huge files, and it helps me a lot in making sense of it. It's a safety net that the codebase and language itself doesn't give me.

VS Code and co wouldn't come close.

Anyway I still switch to VS Code from time to time for one-off tasks, quick edits, formatting, etc.

I'm using IDEA and VSCode in conjunction (for Kotlin and Typescript respectively) and I find them equal in power. Maybe I'm not a power user, but I reached a point where they even look the same (more or less).

There are 2 minor differences I experience very often: VCCode is blazingly fast compared to IDEA, and VSCode has much more quality plugins than IDEA (at least for those things that interest me).

I'd compare VSCode to Emacs in a sense that the architecture is really simple (all you have is functions that do something) which makes VSCode more appealing to prospective plugin developers.

I'd even go so far as to say that to me VSCode becomes the new Emacs.

> without installing a million plugins

Perhaps that is because of the very narrow focus on what IntelliJ does and the functionality of plugins is part of the core system of IntelliJ.

In my view, VSCode is a platform. It's unfortunate that they chose to use Node (its slow) but otherwise, its a great platform to develop extensions for.

For someone just getting into programming, it offers a great stepping stone and it can handle medium sized projects quite well.

Agree. I am now working on a project that includes development in Android, Java server side, Swift, Xamarin, Unity (c#). By using Intellij products namely AndroidStudio, Idea, AppCode & Rider - I have a unified experience which makes development so much easier, and fun! Only con might be the price - but I would not know as its all payed by the corporate I work for - with their IntelliJ licensing server.

It's remote server support over ssh is seamless. It's pretty amazing it took this long to get to this point. Pity it gobbles so much memory.

> In IntelliJ I can write a half baked statement like `new Foo()`, and then Alt + Enter my way to it being `foo = new Foo();` as a private member variable of the class in no time

This will be in VS Code one day, except when it's there it will be for all languages (some neural code completion engine) and do much more.

My experience of IntelliJ is that it looks nice but it is very complex and offers little compared to Eclipse. For professional reasons I had to learn Eclipse, and now I see that IntelliJ gives a more polished product. But when I need to relearn all that I had with Eclipse, I don't see the point.

I’m going to save this comment for many years down the line. I don’t agree with your sentiment (having also used VIM and Rider, but happy right now with VSCode), so it’s a sort of personal check-in I can have with my thoughts sometime near 2030.

I agree that JetBrains products tend to go unnoticed. But them bring commercial versus vscode being free makes it hard for people to choose them.

I recently bought a personal license for Webstorm and really like it.

I tend to look at stuttering behavior such as

    Foo foo = new Foo();

as a problem with the language itself. That said, I do agree that writing Java without IntelliJ can be a pain.

on the other hand

if you look at source code of a random IntelliJ/IDEA/... plugin and on similar plugin in VSCode, it's obvious VSCode design is more clearer.

Which _will_ work for it long-term.

Yep.

Not seeing myself switch to VSCode anytime soon from IntelliJ or Pycharm.

If only JetBrains made their IDE version that eats less RAM I would gladly pay twice as much for it.

It doesn't replace the IDE, it replaces the simple text edit like Notepad++.

Not a problem I've encountered, but one that will be solved by the robust extension ecosystem of VSCode. You can apply this to any UX problem you might encounter with VSCode.

The IntelliJ story ends when they ask $300 a year, with no other option.

I completely switched to VS Code once I discovered the remote development feature [0]. It allows you to run VS Code locally but work on a project in a different environment (via SSH, Docker, WSL). The integration is seamless - search, debugger, terminal, extensions - everything looks and behaves as if it was running locally but is delegated to the configured remote. You can even have different remotes opened at the same time.

I use this setup primarily to have at least some sort of a barrier between my system and the gigabytes of NPM packages that get downloaded as dependencies. Moving between systems easy as well - I just copy the VM images. It also makes it easy to experiment a little bit. If I want to e.g. upgrade an important package and something goes wrong, I just revert the VM and I'm back in business. Having Arch as the distro is a nice bonus.

There's a chance that IntelliJ IDEs will get the same remote functionality as well but the timeline is unclear [1].

[0] https://code.visualstudio.com/docs/remote/remote-overview

[1] https://youtrack.jetbrains.com/issue/IDEA-226455

This is such a hugely undervalued feature, and no other editors seem to provide anything remotely close. I found it particularly useful for the COVID work from home - I yeeted my work laptop into a corner and just SSH into it to continue working with the ergonomics of my home desktop machine.

Not to be that guy, but emacs has had this for years via tramp.

That's cool, but you can just "screen emacs" since it's not implemented inside a giant web browser.

jEdit has this 15 years ago.

Remote has been a game changer for my development as well. Work forces me on a Windows machine with the full suite of corporate spyware. Said spyware loses its mind when compiling, debugging, language server inspection, git actions on large repo, etc. Performance loss is somewhere in the region 2-10x.

With remote, I am able to do all coding on a non-infested Linux server with almost seamless usability.

Your company is equally cool with you just having all of your code/IP on a unsecured (i.e. not running crazy large antimalware, not actually insecure) Linux box?

Note that this feature doesn't work in open source builds of VSCode, it's an MS only thing.

I use this feature in VSCode (free version), with this Microsoft extension: https://marketplace.visualstudio.com/items?itemName=ms-vscod...

I read about this fact elsewhere also. Could you expand on this a bit? My impression was that VSCode and its associated extensions are open source, so I'm curious how Microsoft could make certain parts exclusive to its own build of VSCode.

I am no VS Code user, but if this is true, we are at phase 2 of EEE. What will be next?

Eclipse foundation has a new project, Theia[1], which forks VSCode and one of the reasons they state is that the extension ecosystem is not opensource.

They want Theia to be a tool to build your own editor and it can be built as a hosted solution (like code-server) or a standalone editor

Edit: I see that the article also mentions Theia but this point about Theia vs VSCode is not mentioned.

[1]: https://theia-ide.org/

I was very disappointed to find that VSCodium wasn't able to do this. It makes me consider switching back to VSCode.

Ooh, if IntelliJ gets remote functionality I'll be very happy.

I use JetBrain's remote python interpreter functionality[0] with great success and convenience. For anyone whose development environment is appropriate for its use, I honestly cannot recommend it highly enough. It's only available under the full "Professional" license version, however.

This uses SSH and SCP to automatically deploy the code to the remote environment and run it with the interpreter on that machine, rather than your own local laptop/desktop. One advantage is that it does not require any special software to be installed on the remote server. I believe VS Code's solution requires a pretty hefty installation consisting of basically an entire copy of VSCode onto the remote server.

The downside of JetBrain's approach... I believe that it requires a local copy of the files in order to perform the "LSP"-like syntax error highlighting / suggestion functionality that JetBrains software is so lauded for. This could be difficult/inconvenient if your codebase is particularly enormous, or if you aren't allowed to mirror it locally.

However, given the amount of support that JetBrains has for this kind of setup, I wouldn't be shocked to see an additional option for something more in the style of "VS Code Remote Development"

0: https://www.jetbrains.com/help/pycharm/configuring-remote-in...

I spoke to the team in KubeCon last year and they said “our research team is looking into it” with a hand wave. I doubt IntelliJ will actually implement this anytime soon, sadly.

It is also great for string all dependencies for development together in a docker-compose file. On any machine you just have to git clone and open vscode in the container and you are good to go. Even if you require a particular version of postgresql, some compiler version or a complete Kafka cluster; everything can be configured in a Dockerfile/docker-compose file and stored with the code. No more pages long readme's of how to get all dependencies set up just right. Especially when often switching between projects and machines this is a godsend. And for onboarding it is so easy to get someone a fully configured working environment.

Absolutely. I build Android images (AOSP/kernel/lk customization) and at the beginning I was using Eclipse over a shared network folder (I have dedicated remote hardware to host and build these monstrous images), but everything was a chore. Then I switched to VSCode + Remote Development over SSH.

Imagine placing the workspace at the root directory of the entire Android source tree, pressing ctrl + shift + F and finding anything in less than a couple of seconds. For C/C++ code, press F12 just ANYWHERE on the code to go to the definition, no matter if it's the entire kernel code, or vendor or AOSP code: it just finds the definition at lightspeed.

For building I use the integrated console. If there is an error or a warning anywhere, you can just click on the console an it takes you to the file with the error/warning. Also it integrates perfectly with Git and has extensions to parse DeviceTree files.

And everything was just much more appreciated while working at home during pandemic.

It sounds like a testimonial advertising, but it's the way it is.

> I use this setup primarily to have at least some sort of a barrier between my system and the gigabytes of NPM packages that get downloaded as dependencies.

You can do something similar with IntelliJ by running npm inside a Docker container with your working directory mounted into it. IntelliJ will happily index the resulting node_modules folder without executing any code on the host.

The only thing that's been preventing me from fully adopting this is that I don't have my local shell environment (autocomplete, syntax highlighting, etc.) anymore. Maybe I'll have to look at getting that setup in a container sometime, and then copy that over to every container I use.

You can add "-v" flags in the .devcontainer/ json file that map host stuff in so that you get all of that stuff!

I use clion by jetbrains and been using remote development feature for almost a year now.

Maybe it works for literal remote development, but the jetbrains support for remote dev in a docker container is a complete afterthought. There's tons of critical, relevant feature requests that have been stuck in the pipeline for years. In vscode, it is well thought out and polished. My team desperately wanted development out of containers to ease on-boarding and standardization of development environments. Trying to make it work with CLion was a nightmare that was practically dead before it started, and we thought we'd never get it. Then we found vscode's support and have never looked back. I sometimes laugh looking back at what we were having to do to get it to even slightly work, and think about all the troubles we would have had ahead.

It's been pretty useful for developing on my Raspberry Pi. I wouldn't say the SSH feature is 100% polished, but it's pretty dang good.

I have built and used this[1] for some time now, ie. i run vim inside my devcontainer, and i'm happy with it.

[1] [link redacted]

I'm not a fan of VS Code because everything is a plugin.

And plugins are inconsistent, buggy, inconsistently documented, hard to use and find and update and goodness knows who developed them. Plugins can be duplicated, outdated, abandoned and incompatible.

But worst of all, a big pile of plugins isn't a consistent integrated product vision.

I gave VSCode a solid go, and I had to keep installing plugin after plugin, but it was truly painful trying to find where in the interface to use the plugin and how to use it.

It reminded me of using VIM as an IDE - not an IDE, a big pile of stuff that isn't integrated. I started using VIM as an IDE when I started programming and I believe it cost me a year of time - I should have gone straight to a consistent integrated IDE.

I prefer a batteries included approach such as the Jetbrains IDE's.

I absolutely do use VS Code - it's always loaded, but I only use it like a simple text editor.

You don't need all the plugins. You just need a curated set. And some of the plugins are fantastically high quality.

The Microsoft Python one is excellent, as is the Remote development one.

I'm a fan of VS Code because in spite of it having a plug in system, there are great plug ins there. And that one single great plugin is all that is needed (for that specific purpose)

I'd be more interested in VSCode if Microsoft's strategy was to relentlessly implement the most popular plugins into VSCode natively such that the most commonly used and needed functions were built in and did not require plugins.

The problem with systems that are really just frameworks for other to build on is they become reluctant to build stuff that plugins exist for. The philosophy becomes to depend on the plugins rather than built out needed features. This entrenches the spaghetti pile of plugins.

Plugins are great and necessary - Jetbrains IDEs have plugins. The difference is a philosophical one - are plugins there to provide core functionality, or are they there to provide uncommon use cases? VSCode uses plugins for basics, JetBrains builds basics in - with JetBrains you can never install a plugin and happily work away. With VSCode, the very first task you must carry out is to start managing your inventory of plugins.

Sorry to spoil the party here but I wouldn’t call it excellent. I need to set environment variables and PYTHONPATH in 3 places (for the integrated terminal, for background processes and for the debugger). New environments are only detected after restart of the UI and It doesn’t Index or allow go to definition for libraries downloaded via pip most of the time. Also no refactoring support...

This is really frustrating. Am I doing something wrong?

Does VSCode have something similar to emacs’s spacemacs, doom or prelude?

> Remote development one.

Careful with the Remote Development plugin. It does NOT have an open source license.

I think it's the core product values for me.

JetBrains IDEs are development environments, meant for editing code, in specific primary language. They really try their best to understand code that user works on (which is a hard problem, because code is frequently invalid while it's being actively edited), and make it as convenient as possible.

VSCode is - in my understanding - essentially, a step over older glorified extensible notepads on steroids. Unlike those older extensible notepads, it does have built-in programming language editing features, but mostly it's still not the core product but rather a job for extensions and language servers to fill that niche.

So for me VSCode wins over editors like Sublime or Atom, that don't have core programming language processing concepts baked in, but still loses to the specialized IDEs where specific language support is a primary feature (like PyCharm or GoLand).

> JetBrains IDEs are development environments, meant for editing code, in specific primary language.

I've used RubyMine and IntelliJ. IntelliJ kept me sane for the thankfully-short time I worked with Java, and I appreciate it. But I can't get past how SLOW RubyMine is. Even on my $4,000 MBP, it just feels sluggish. Maybe that's because I'm at home on Rails, and I can think faster than the IDE, but there's really not much excuse to my mind for being that slow, especially on top-end hardware. It once helped me debug a plugin of plugin of a gem, and I'll be forever grateful for that, but I keep trying it every so often, and failing to part with my cash for it. I pay a lot for software, in general, but that one's just too steep for my taste, when tools like vim, Sublime, and VS Code exist.

PyCharm is also a common IDE core with a bunch of Python-specific extensions on top. It just so happens that JetBrains ships those extensions pre-packaged under different names for various target audiences, and they - especially the Java ones - have a lot of features, and decades of polish.

IntelliJ Ultimate has support for all of the languages except C/C++, C#, and Swift/Objective-C.

Use Emacs - it's a big pile of stuff that's very well integrated, because the platform lends itself to deep interoperability - thanks to a strong conceptual model and extreme reprogrammability. :).

Jokes aside, I guess what VS Code needs is to grow a strong community of people who care about the editor as much as what they do using it. Emacs has managed to do that, so it's possible.

It seems like Emacs shares the same product philosophy of VS Code. Outside of the core functionality everything is an ELisp/Javascript plugin.

That explains Emacs amazing longevity, but as the article points out, Emacs longevity is actually a problem as its keyboard and UI conventions predate the modern conventions that came with Windows and MacOS.

There are two aspects of this that I run into:

- Features that should arguably be built in require searching for, evaluating, and installing a plugin.

- Some plugins spam you with a "What's New" page with each update.

Bookmarking is an example of these two in action: https://github.com/alefragnani/vscode-bookmarks/issues/175

> It reminded me of using VIM as an IDE - not an IDE, a big pile of stuff that isn't integrated.

I prefer to use Vim as a powerful editor, within Unix as my IDE.

same here, use it on the server and desktop, gave up on vscode one year ago, did not need my purchased jetbrains(webstorms etc) for 99% of the time.

vim rules for me, as a full IDE from the terminal.

I have to reinstall PlatformIO every time I use the program.

It only takes a second but its absolute madness.

I wanted to replace Arduino IDE so bad, but it kinda works. Certainly compared to the pain I experience on PlatformIO.

It's always worked well for me on Atom, for what it's worth.

I disliked Rubymine because it tried to do too much. And it didn't work well with my docker stuff. Which ultimately made a lot of it useless.

My VScode is tweaked to the languages I need and I can use one editor to switch between them.

And the linting and formatting just works.

Curious what language/env you tend to work in? I have found that working in JavaScript and TypeScript, I don't really need any plugins when using VS Code. I do install a couple, but none are essential, just some small niceties.

I'd rather take an editor where I add in the stuff I need instead of it coming with all the xruft I won't be using. Visual Studio would be nice but the UI is way too cluttered for me and I can't focus if I can't organize the views as I need them. No issues with VS Code. I'd just wish it'd be possible to pop out the file explorer and git views into their own windows but I can use other tools for those so no harm there.

> I absolutely do use VS Code - it's always loaded, but I only use it like a simple text editor.

Then you do not really need to install any plugins. Problem solved!

> It reminded me of using VIM as an IDE - not an IDE, a big pile of stuff that isn't integrated. I started using VIM as an IDE when I started programming and I believe it cost me a year of time - I should have gone straight to a consistent integrated IDE.

You don't start using Vim as an IDE. It's a waste of time, because like you said IDEs offer a complete product right off the bat. You start using Vim as a text editor, for text editor things, and when you're familiar enough with Vim's plugin ecosystem you may start to enhance your text editing experience with IDE-like features. And you may come to realize that's all you need.

Learning Vim for the sole purpose of tuning it into an IDE is a terrible idea no matter how you slice it. I blame people who hype their Vim setup as a complete IDE even though they started learning Vim as a text editor, not an IDE.

JetBrains is and always has been amazing, but I like VS Code mainly because I'm accustomed to Visual Studio which is a huge bloated mess, especially inside a VM. For me it's quite an improvement. I mainly do C# back end stuff, so YMMV. I'm sure C# is a first class language for VS Code.

VS 2019 without ReSharper does not feel bloated at all.

I totally agree with the everything plugin aspect.

Then consistent and integrated IDEs are a mix of “everything and the kitchen sink” and “our way or the highway”

Personally I prefered to pay the price of an ugly and patchworky workspace to get something that works like I want to work and without too many things I don’t care about.

> I'm not a fan of VS Code because everything is a plugin.

Replace "vs code" with "javascript" and "plugin" with "library" and you've just described the javascript ecosystem.

Isn't that the very definition of a programming language eco-system? Or is the point you are making being you do not like eco-systems?

Yes. And Gatsby has taken it to the extreme.

> And plugins are inconsistent, buggy, inconsistently documented, hard to use and find and update and goodness knows who developed them. Plugins can be duplicated, outdated, abandoned and incompatible

This is why my experience with VS Code reminds me of Eclipse.

I use VSCode with no plugins. It's an amazing code editor, and by default it does code highlighting for C++ and TypeScript. I build in a terminal, outside of the editor, the way it's supposed to be done.

Well an IDE is more than just a text editor+syntax highlighting+a terminal.

It's also about type hinting, refactoring, debugging, etc.

And for the two languages you speak of it just so happens that the support is shipped with VS Code since Microsoft is heavily invested in the development of these languages.

For other's (even Python) support varies widely.

But Jetbrains IDEs are exactly that a collection of plugins.

Did MS give up on fixing VS bugs and just went 180? Or did they plan VSCode to replace VS but then discovered it would be too much work?

Ride or die Jetbrains fan here, completely agree with these points.

VS Code is awesome. If you told me ten years ago my daily driver text editor on Linux would be a Microsoft product, well, you’d have been right.

Sane defaults. Snappy interface. Universal UI on multiple OSes that doesn’t suck. First class and best in class TypeScript support. It’s going to be hard to beat, now or five years from now.

It's good for JS. It's ok for Golang, since there doesn't seem to be anything better that's free. But I still feel it's an editor trying to be IDE. I love it for markdown/asciidoc though.

I'm a long time Linux user/developer, and I've completely switched to it for C++ on Linux.

I've used vim and various simple text editors for a long time, but wow is VS Code nice. The Linux port of IntelliSense (at least for me) works more consistently than any of the of the code introspection tools plugins for vim I've tried. It works especially well if you're using CMake - it can pull all of the header paths out of the generated build system without you having to touch anything.

(using Microsoft's C++ plugin and the vector-of-bool CMake plugin (which Microsoft took over development for))

Using NVim with go-vim, disabled gopls instead using gopls from native lsp. I am fine with that combo.

Markdown on Vim requires fiddling with formatoptions but combined with live :MarkdownPreview in the browser while you type in Vim is fine and displays mermaid among many other markdown extensions.

My only problem with it is performance when you load large repos and occasionally large files because it is an Electron app eventually. I know the extension ecosystem has thrived just because it is Electron but I wish MS worked on a native editor to achieve it.

People like to bash VS code performance, but try opening a 60MB JSON file in different editors on Windows for example.

Notepad doesn't even load and crashes, Sublime will takes minutes to even load the file, Notepad++ will be unusable as scrolling will take a few seconds, and in VS Code it opens immediately and you can seamlessly scroll to any one of the 600k lines without any delay.

For what it is worth, I have never experienced this issue on modern hardware, and I regularly work with a very large monorepo.

Perhaps it is my habit of opening a subset of the repo into the workspace rather than the whole thing (e.g. only the bottom 4 or 5 directory levels so there is at most only a few hundred files in the workspace - builds etc just run from the usual command line so not having the entire repo in the workspace is not an issue for my workflow) but I have been nothing apart from really happy with the performance and have never been found wanting more, apart from loading time but that only happens once or twice a week so I can live with that.

It has the rendering engine of a browser and that also has some advantages in rendering capabilities. Browsers are really good at rendering rich text, it's what they were designed for, and a native editor can't beat that.

There's the occasional big text file that I have to open, in which case Vim would do a better job. But usually VS Code has no performance issues for me.

See, I don't think that's possible. VSCode only has 10 or so employees full time. I don't think they could make a good text editor with this kind of dev speed on 3 different platforms natively.

Sublime is great but it updates once every other blue moon for a reason.

> My only problem with it is performance when you load large repos and occasionally large files because it is an Electron app eventually.

Discovering & pre-loading hundreds of thousands of files is slow on native too. I'm not particularly pleased with how easily folks write off web platform tech as somehow being the source of problems or slowness.

The one complaint that does seem fair is that the memory usage can be high, because there's so much runtime to load. Also, I just keep thinking about your ask here. You want a native editor. But it wouldn't be a native editor. It'd be a native Windows editor, a native Mac editor, a native Android editor, a native iOS editor, a native web editor, a native Gnome, a native KDE editor, &c &c; your preference seems to be that Microsoft have made at least 5 editors. I'm not sure how the plugin system could exist amid such a diverse amount of native runtimes.

the electron overhead is fixed. if it has problems with large repos it wouldn't be due to electron. it would be due to vscode itself or some extension you are suing.

There's a couple big knocks against VS Code that don't get brought up enough

The extension API is underdocumented. It's very difficult and time consuming to onboard yourself as an extension author with just the MS docs, since they don't cover the entire API and the vast majority of data structures are undocumented entirely. This is really annoying when functions take structures as arguments and have optional fields. Descriptive naming isn't descriptive if it describes how the argument is used by the callee, not what it means to the intent of the caller.

VSC also inherits the core weaknesses of Electron. Not overall performance/memory so much as startup time (just a second ago I had to wait 3 minutes for VS Code to boot because I had too many workspaces open when my laptop's battery died on me). It can't open multiple windows in the same workspace (this is actually a fundamental flaw when debugging any kind of extension that needs to open its own workspace). It's possible to build an extension that uses compiled node modules, which is great for performance and usability, but it's officially unsupported because those modules are only compatible with the node version of a client's VSCode.

But when all is said and done, VSC has shown that it's a great platform and easy to target as an extension author (or easier than others), LSP and DAP are huge milestones, and the architecture itself is just so friendly to extension that it's created a fantastic and lively ecosystem.

But petty gripe: please kill the git username/password fields when I git clone a private repo over HTTPS in the console. I don't like being aggro towards what other devs find cool, but I think hijacking a CLI with an extension incredibly annoying. And I can't find a way to disable that specific "feature" without disabling all of the git integration, which I use all the time.

Hi, VS Code dev here. We actually put a lot of effort into documenting API and extension development. This is why `API` is one of the main sections on our home page: https://code.visualstudio.com/api. It's also why we have very restricted API guidelines: https://github.com/microsoft/vscode/wiki/Extension-API-guide...

We'd love to hear more about the lack of documentation you're referring to. It's definitely a solvable problem. Could you create an issue so we address the problem? https://github.com/microsoft/vscode/issues

Also on

> But petty gripe: please kill the git username/password fields when I git clone a private repo over HTTPS in the console. I don't like being aggro towards what other devs find cool, but I think hijacking a CLI with an extension incredibly annoying. And I can't find a way to disable that specific "feature" without disabling all of the git integration, which I use all the time.

This can be disabled with the `git.terminalAuthentication` setting.

Thank you!

>Not overall performance/memory so much as startup time

Is this actually a problem, though? I typically use VSCode as a "focused" text editor; it's for working on a codebase for a long period of time (relatively speaking). A minute or do startup amortized over hours of work is not much of a bother really.

For quick edits, vim is still my go to. Different tools for different needs.

Yes, because of how VS Code has evolved we're not using it for quick edits but as a front end to entire systems. If I need to check something quick in a remote session that is configured through some extension in VS Code without simple terminal access and for one reason or another I haven't left it idling all day, those times will hurt my productivity.

I like the enthusiasm, but this article is a little too breathless to be fully believed.

> The most important thing I look for when choosing which tools to use is longevity.

In my time, I've programmed using Director, Microsoft QuickBASIC, FutureBASIC, THINK C, CodeWarrior, BBEdit, TextMate, Visual C++, Visual Studio, Sublime Text, Eclipse, Atom, VS Code, IntelliJ, XCode, and probably a few others I'm forgetting. I don't have any particularly strong attachment to any, except for maybe Sublime (which supplanted TextMate, which supplanted BBEdit).

Instead, what I've found is that IDE evolution is converging such that hopping between them gets easier and easier over time. The shortcuts and mouse behavior is becoming standardized, and the feature sets are getting more similar. These days, I just use whatever IDE is the "main" one for whatever language I'm developing in. Within a day or two, I'm up and running fine.

The only one I particularly enjoy using is Sublime and that's mostly for what it doesn't do than what it does. Sublime is fast and unencumbered, so it stays out of my way when I use it. I strongly prefer it when I'm writing prose for that reason.

I agree. With language server protocol becoming commonplace for auto-complete and static analysis, I don't see a huge difference between various text editors.

I've given VSC several months. I just went back to ST3. I find it refreshingly clean.

I'm in a similar boat, except I used VSCode for two years before switching back to Sublime Text. I remember watching [this funfunfunction video](https://www.youtube.com/watch?v=dIjKJjzRX_E) and thinking how much I related to what he says about becoming addicted to tooling. This was me with VSCode; I was spending a large amount of my work time tweaking it, adding plugins, tweaking plugins, troubleshooting plugins, removing plugins, looking for new plugins, etc.

However, the main kicker that made me switch back to Sublime was that I started it up one day and was astounded by how much snappier and responsive it was compared to my plugin-ridden VSCode. Admittedly, I do miss a lot of the plugins I used to use with VSCode, but at the same time, I'm happy to no longer have to rely on them.

The UI is an absolute mess.

"Check for updates" immediately shows "Downloading updates". That's not what I expected. How about some confirmation?

Start a .NET project and you see "Downloading package 'OmniSharp for OSX' (49713 KB)", "Downloading package 'Razor Language Server (macOS / x64)' (51227 KB)". No prompt. Just starts downloading 100MB of deps.

For some reason the Output tab down the bottom has 20 options in a dropdown menu to switch to different outputs ("Github Authentication", ".NET Test Log", "OmniSharp Log"). I'm not sure why I care about any of these - if I do, why are they hidden in a dropdown menu?

F# gets its own icon on the left menu for some reason.

"Accounts" in the left menu has a notification badge with a count of 1 because I'm not signed in to sync my settings.

The settings icon on the left brings up a menu of 12 different options, some of which launch a settings editor, some launch a pre-defined search of extensions, another pops up a modal dialog.

In a .NET project, if I "Start Debugging", it opens a launch.json and in a comment tells me "Use IntelliSense to learn about possible attributes", making me define my own launch configuration instead of a default

Compared to jet brains though? Id argue its a huge improvement.

In what way?

When I used Rider at my last job, it would pick good auto defaults that you could customize based on the project configuration, including automatically generating IIS express configuration values.

Are there more explicit downsides you can mention?

Comparison of what exactly?

JetBrains' IDEs have built-in update managers. They present you each plugin, giving you a tick-box of which ones to update. The Toolbox app manages the IDEs, allowing to update automatically or not, install pre-releases, and roll back. It's polished.

The IDEs use the established desktop UI norms of toolbar menus.

They come with pre-defined 'Run' templates for many languages/frameworks.

There is a single Event Log for output of updates etc.

The left menu has words so I know what the icons mean, and isn't obnoxiously large due to over-use of large icons.

Yes it’s subpar compared to Visual Studio as a .NET IDE, but that’s probably one of the reasons .NET hasn’t been prioritized yet: There is Visual Studio.

If you want a text editor with longevity try vim or emacs. They aren't dependent on the benevolence of a greedy corporation. Over time VSCode _will_ be raided by the bean counters at MS and it will begin to track you, give you ads about MS products, and lock you in to their ecosystem.

I'll never understand why a professional developer would give so much influence over their work to the likes of MS, JetBrains, etc.

Sure vim and emacs aren't the easiest to learn but if you're going to write software for a living it is not worth wasting your time with toys like this.

Two decades of vim here, and I switched to VS Code. As a "professional developer", it's just nicer to use, and makes me feel way more productive than ever. I definitely wouldn't call it a toy.

I'd like to assume you're joking but 20 years of vim doesn't get me anywhere close to the productivity of JetBrains or even VS code on their first years.

Vim first of all has its default set so that only very patient people can live with it. So you need to edit the defaults so much to make it slightly more comfortable, and you need to pick plugins that only some work as expected, mostly not updated in years and they add yet more crazy shortcuts no one can remember and still don't work like modern editors do.

I only use vim to edit config files on servers but VS code can do that these days, vim is losing a position for me as of late. Glad it invented modal typing but it's as ancient as one would guess.

> I'll never understand why a professional developer would give so much influence over their work to the likes of MS, JetBrains, etc.

To flip it, I'll never understand why a professional developer won't spend a measly hundred bucks on an IDE that has everything set up out of the box.

Also, VSCode and IDEA are both open source.

It's not that hard to learn a new editor and learning new software is something I enjoy. Even if Microsoft does ruin VSCode, who cares? Vim and Emacs will always be there waiting.

In the meantime, I'm loving PyCharm for Python, Visual Studio for C++, Sublime Text and Obsidian for Markdown, VSCode for Javascript, etc... Different tools for different jobs.

Tracking and advertising already happens via telemetry and suggested extensions.[0] However currently you can turn it off.

[0] https://code.visualstudio.com/docs/getstarted/telemetry

I don’t really understand “influence over your work” here. I agree that there’s a possibility MS will add some kind of monetisation I don’t like in the future... at which point I’ll switch editors.

But as it is, I’m much faster and efficient using VS Code than I am using Vim. It is in no way a “toy”. And it doesn’t influence my work. It’s a text editor!

I don't understand why a professional programmer sounds like a privacy activist. When they try to lock in, we would know, and someone will fork.

You do realize VSCode is open-source?

The last time I opened VSCode was a few months ago. My work has shifted to other things, so I needed it a little less than before. I really hoped that VSCode could be an Emacs replacement, but I think that's a bigger job for me to pursue than I want to commit to.

For me, Emacs is not perfect, but it has always been the most versatile software I worked with. It's very much (and I want it to really be) the everything text editor. I got the interaction model (with a few good modes) burnt into my brain. I find it hard to get used to anything else (I usually also end up installing plugins to emulate Emacs in other editors/IDEs, but they never as good as Emacs itself.)

VSCode does get a lot of things right out-of-the-box: the interface is snappier when doing things like code completions and language plugins are rather consistent with little effort. But that's where it stops for me. At least I understand its popularity.

The thing that bugs me about VSCode is it's labeled as open source but a lot of pretty critical and interesting components are closed source so you have no idea what's going on under the hood. Normally that's not too big of a deal (I use plenty of closed source apps), but when it's Microsoft it's hard to trust what they are doing with that data. That and I feel that this promotes vendor lock-in at multiple levels.

Overall claiming you're open source when a decent chunk of your code base is closed source is kind of like those people who always bring up that they are a non-profit organization and are doing things for the greater good, meanwhile it's mainly used as a way to evade as much taxes as possible while they live very generously. I have nothing against that personally but it's the way it's presented. It just gives off a bad vibe.

Are you aware of vscodium? https://github.com/VSCodium/vscodium#why-does-this-exist

I have not personally audited it to see if it's better or worse than upstream vscode, but I believe the spirit of the project is closer to what you had in mind

What are some of all these pretty critical and interesting components you mention?

The biggest feature is probably remote. This is what allows you to have your code in a remote location (SSH, WSL and containers) and still get an integrated experience as if things were all running locally. If your app is Dockerized or you use Windows with WSL and you like intellisense, you're likely using this feature.

Some of the language servers for popular languages are closed source too, which is weird because I thought the idea of a language server was to work together so all editors could get excellent language specific features without having to reimplement the same logic in every editor.

That's not an exhaustive list, just what I know off the top of my head. I also vaguely recall reading something about a year ago about some core bits of the editor being written in C++ for performance reasons and those are closed source but I can't find a reference and don't know enough about the code base to track that down so I don't want to say that with any type of authority. Would be great if someone more knowledgeable in the area could track that down, or come up with a more exhaustive list of things that aren't open source.

I guess they are referring to the Microsoft provided plugins which are proprietary and their license denies usage with any VS code fork. Personally I've never felt the need to use them, but admittedly, I barely use VS code at all.

Like the Chrome and Chromium relationship a lot of distros package VS Code as just Code for a version built by your distro without the proprietary extras.

Question I have for everyone who doesn't use an IDE

What is your workflow? I find the following to be true, in that one of 3 things happens inevitably:

1. The Text Editor becomes the IDE, (e.g., with VSCode, if you just live in plain HTML, CSS/SCSS/LESS and JSX/TSX/JS/TS all day, its actually pretty great, lots of well maintained extensions and Microsoft really put their energy into capturing into this market with VS Code I think. If you have more than ~10 extensions installed, I'd argue you got an IDE (not including themes or colorizers))

2. They have extensively curated vim or emacs setups that were built over time to add IDE-like features, in some cases I'd argue they become IDEs themselves via deep customization

3. They move to an IDE

So my question is if none of the 3 are true, whats your workflow like?

For context of my own workflow, it slowly over time is all around my IDE (JetBrains user, hardcore. You'll pry it from my cold dead hands). With the exception of running scripts (sometimes, like builds) and using git (git CLI is the best git interface IMO) I have moved it 100% into my IDE, and I'm so much faster at things, including picking up new languages

When I started, I used VS Code heavily professionally, and vim before that, and relied on the CLI for anything outside of editing the code (basically, I think I had some auto formatting setup too), but I hit a wall at some point where I never turned back and went full into JetBrains to this day

I run a pretty much stock configuration of Sublime Text alongside gnome terminal. I have no issues navigating projects as large as gecko/WebKit/Linux and getting spun up on a new language is really fast: Open the project, maybe install syntax highlighting if needed and you're good to go - as opposed to finding/installing an IDE.

My last Job had a large Java codebase and all my colleagues used Java based IDEs. I didn't see any performance disparity. I more than once saw a colleague take 5+ minutes making the same edit on a large number of lines because they hadn't learnt how to actually efficiently edit code in their IDE.

The way I see it, you need to keep the codebases you're working on in your head anyway (the parts you're working with anyway) to actually be productive. You do this by reading and understanding the source code on the screen. Until an IDE can provide a tailored human interpretation of the code it's analysing rather than some narrow static analysis I just don't see the point.

I use a simple code editor with as few extensions as possible, and a terminal.

My goal is to keep my setup as simple as possible so that I’m able to switch easily, but I’m not really looking for more features or functionality.

I'm exactly what you describe at the end: a simple Emacs editor (with Evil) and CLI for almost anything else. Building and running code? They all happen in the terminal. Version control? I tried Magit, didn't like it, and went back to git CLI in a terminal. Auto formatter? Likewise in the CLI; in fact I have shell aliases that automatically run them when I commit.

I haven't really hit a wall, and I personally think I'm just as productive, if not more, than IDE-using colleagues.

My answer is in this excellent series I read a while ago: https://sanctum.geek.nz/arabesque/series/unix-as-ide/

Which, admittedly, is essentially the same as the other answers you got, but that's how I've been working for three years, since I decided to use vim exclusively.

At the start, I was really tempted to install plugins, but ultimately I decided not to. Both to practice with the terminal (which has been immeasurably beneficial) and to make it as easy as possible to switch computers at the drop of a hat without losing productivity: just install vim and I'm good to go (and often not even that is required since vim comes preinstalled often enough).

For Python work I use a pretty much out-of-the-box Emacs, with "magit" being the only plugin of note installed. And I also used "web-mode" when I was doing webdev. magit is the best Git interface ever, and a built-in Emacs feature called TRAMP allows for remote editing. I'm running ipython in a separate terminal. I don't really understand why you'd need something more than a text editor to edit Python code.

Now for Common Lisp I use SLIME, which I guess does count as IDE, seeing as it's much more powerful than most IDEs.

Geany plus Makefile with automated functions. Build keys can be assigned to avoid Window switching.

What walls were you hitting?

Disclaimer, I have used Pycharm on a really big work project but most of the time, don't.

Given the talks from Microsoft's own React Native team regarding the 300x performance loss from Electron based apps, I am looking forward to the day it gets rewritten in React Native.

https://youtu.be/IUMWFExtDSg?t=1146

I'm looking forward to the day when you can have multiple windows open on the same project without going through some horrible kludge. Some of us (!) have more than one monitor and would like, say, to put the debug widgetry over on _this_ one.

(Edit: fixed three typos.)

I bet you are also looking forward to the day when web assembly kills js, and everybody stops using html and css.

You probably mean something in the ballpark of 3x or 300%, rather than 300x?

That would be awesome but would have be a complete rewrite of Monaco, and text editor renderers are near the top of programming dark arts.

Can React Native run natively on Windows/Mac/Linux now?

I used to be such a huge WebStorm proponent, but when Visual Studio Code reached the point where it could handle all facets of front (and back-end) development, the rich ecosystem and fast pace of updates, I cancelled my Webstorm subscription and never looked back. Admittedly, it took me a while to ditch Webstorm, because I loved that editor. The remote development session feature is amazing in itself. I thought it was a gimmick at first, but since the pandemic hit, remote development has been a staple for our company. Being able to pair with juniors and seniors alike to collaboratively debug and code, it's game changing. There is nothing like it and the stability of the sessions is impressive.

What you get out-of-the-box without needing to install a single plugin is more than some. If you're working with TypeScript you get everything you need, including an in-built TypeScript compiler. All that being said, I still lean on Sublime Text Editor 3 when working with large files, which VSCode is still not perfect at dealing with. It's easy to forget that VSCode is an Electron app.

>TextMate, released in 2004, is arguably the most influential text editor ever.

>TextMate’s most important innovation was that it was the first popular text editor that was primarily built around extensions.

I actually laughed out loud when I read this.

Emacs invented the extensible text editor. Emacs was very popular for a long time. It's less popular today, but it's the original prototype for Visual Studio Code and every other text editor "built around extensions". Not a MacOS-only proprietary text editor written in C++ and released in 2004.

The author is right about VS Code becoming the incumbent solution for text editors ... but for the wrong reasons. As he demonstrates, extensions have largely completed their evolutionary cycle with VS Code playing a heroic role in the final act. And he is also right about the benefits of having of a Very Large Corporation collaborating with the open source community.

But instead of asking yourself what will be your daily driver in 10-15 years, ask what you would recommend to a highschool student today? Hint: it won't be EMACS.

For me what makes VS Code sing is its vision of collaboration:

* Git is a first-class citizen.

* Live Share provides real collaboration for distributed workers where you can authenticate with someone else through your GitHub accounts. That sounds pretty good for the COVID era but it will become the norm for remote development. The documentation even has a HOWTO for running a technical interview! https://docs.microsoft.com/en-us/visualstudio/liveshare/use/...

Having said that, the Live Share authentication procedure needs some serious sandpapering of its rough edges! And I would really like to see other authentication providers for Live Share beyond GitHub and Microsoft accounts.

>Hint: it won't be EMACS.

Of course it will be Vim :p, jokes aside I think you may be surprised by the answers you get if you run such a poll

> * Git is a first-class citizen.

I don't see how it's an argument against Emacs since both Doom Emacs and Spacemacs (two of the most popular Emacs distributions) ship with Magit (the best Git interface imho) by default

> And I would really like to see other authentication providers for Live Share beyond GitHub and Microsoft accounts.

Given the current direction of VSCode development in general, this is more likely to never happen.

I adore VS Code. But I still find insane it does not have an overwrite mode! [1]

[1] https://github.com/microsoft/vscode/issues/86671 & https://github.com/microsoft/vscode/issues/1012

The "Aggressive development" point is what got me to switch to VSCode from Sublime. While most of my colleagues were switching to VSCode, I stuck with Sublime, after never fully jumping into Atom for performance reasons. However - and I'm assuming due to the open source nature of the platform, or the accessibility of JS vs Python, extensions were just higher quality on VSCode. I think the Go extension is maintained by Microsoft themselves. Very soon things just worked better in VSCode.

The Go extension is now maintained by the Golang team: https://golang.blog/the-vs-code-go-extension-joins-the-go-pr...

It would be killer if the sublime guys could just support the vs code extensions.

For those that like Vim, but also like some of the features that VS Code offers, but do not like VS Code itself and/or its Vim integrations or emulations, I must heartily recommend coc.nvim [0]. It's like using a modern IDE, minus the bloat and anti-features which make most of them (including, of course, VS Code) painful to use.

[0] - https://github.com/neoclide/coc.nvim

ALE [0] is also nice if you just want a lightweight way to add linting / formatting / name lookups / autocompletion without a lot of extras.

It uses LSP for everything, and can apparently be used together with coc, although I'm not sure why you'd want both.

[0] https://github.com/dense-analysis/ale

I was almost going to abandon vim in favor of VS Code due to the "intellisense" features, then I discovered coc.vim and I'm so happy that I don't have to leave vim

I will second this, I use coc.nvim for Typescript projects and it works great. coc + NERDTree + fugitive + a good theme like gruvbox and you're gtg.

Deleted comment

Let me guess: You missed the "more" link at the bottom of the page and instead launched into a conspiracy theory?

> This is the third time I'm posting this comment because it was removed, but doesn't violate any of the Hacker News guidelines. If it gets removed again, I know not to trust any discussion about VSCode on Hacker News again:

None of your comments were removed. They are all in the thread.

I want to like VS Code, but I can't stand the "dynamic" left side bar. It's used as an "explorer", it's used to handle "extensions" and it's used for search. I want a fixed left sidebar (fixed as an "explorer"). Is this something configurable?

You can try the following: 1. Open the explorer tab on the left 2. Drag every other item on the left bar into the explorer menu. This adds a little menu at the bottom 3. Collapse each of the menus at the bottom and never open them again

Kind of a weird set of text editors in the article. I think the preferred tools depend highly on your language and environment. I'm guessing this is for the JS-frontend specialization mainly. If you did Java, C* etc. then the ubiquitous text editors/IDEs were not these ones.

I have converted to VSCode because it just works and I don't have to mess with PATH or whatever. I run it on Windows, Linux and MacOS and it works the same.

I love that it's extensions-centric because now I can ignore them - instead of the editor bloating into a bigger and slower hairball over the years as devs add new features.

>I have converted to VSCode because it just works and I don't have to mess with PATH or whatever.

While I love VSCode and use it every day (mostly for markdown), I have definitely needed to play around with PATHs to get VSCode working nicely with my conda installs on both windows and mac (i.e. it never seems to actually point to the right python interpreter). No idea who is at fault here, but it seems to be a consistent problem for me.

VS Code is nice for green developers, however I always encourage finding a different editor. This helps encourage exploration, customization, and configuration. You will need to take the training wheels off sometime in your career.

Another reason to prefer other editors is they tend to stay out of your way. VS Code tries really hard to make you not even leave the window.

Anecdotally, a previous colleague once sold me on SublimeText. I had liked it and used the free version but VS Code was also free without pay. The colleague encouraged that it was better to buy a software sometimes (SublimeText license) than continue searching for a free solution for every tooling issue I had. It was the first time I was able to rework my reasoning as to why I should pay for software. The reasoning is simple: invest in yourself. This is more powerful than investing in an no-cost ecosystem to solve your problems.

Editor and tooling has been flame bait since vim and emacs and you're just stoking the flames.

The idea that VS Code is for "green" development only is flatly false, I've used it to work on and debug GCC, hardly green.

The idea you should always be looking for new tooling is also false. If you're a power user of emacs then enjoy it. Consider it your super power, I'm not interested in taking that from you.

VS Code is, in my opinion, thee editor for several languages. The package support is it's real killer feature and the fact that it hits a decent compromise on performance between Sublime and Atom. Atoms packaging is arguably better and more flexible but it leads to bad package performance. Sublimes packaging was annoying when I used it in the past, no better then the train wreck that is MELPA of emacs. Again, all of that being my personal opinion.

> Another reason to prefer other editors is they tend to stay out of your way.

What does this even mean?

> VS Code tries really hard to make you not even leave the window.

Isn't this exactly what vi and emacs proponents cite as a benefit?

Biggest selling point for Sublime Text is speed.

I pay for a personal subscription to the JetBrains suite, use IntelliJ and PyCharm all day, and have also used Visual Studio all day in the recent past. The combination of modern IDEs with modern hardware is pretty awesome. My use of Emacs fluctuates depending on the job, language, environment, etc. but I've mostly used it for Org mode and a scratch pad since I signed up for JetBrains.

That said, I tried Nova from Panic (https://nova.app/) the other day, and the native app performance makes a noticeable difference. I know it's doing less, but I can still search the codebase quickly and the resource use is like 10% of other IDEs.

I use JetBrains suite as well. If only they could offer ONE IDE that is configurable to be used on many programming languages. Having many different binaries is a pita.

I use VS Code every day and it's a great platform, but to claim it's the endgame of editors is one big hyperbole. It's a very opinionated piece of software that serves lots of popular niches well right now, but I haven't yet been able to find a mix of extensions that makes it a viable replacement for IntelliJ for Scala, to name one example.

I'd expect the next uber popular editor to be optimized towards completely different things, though. VS Code is a great all-purpose IDE for enthusiasts and professionals, who are willing and able to dig into pretty complex UIs and complicated concepts. Take the git integration – it frequently breaks (for me), and when it works, it's really very superficial and requires me to really understand what git is doing in the background.

Last year I've tried to teach my dad how to use git, so he can put his python robotics projects in GitHub. It's been eye-opening: All the idiosyncracies and complex ideas that I've grown accustomed to over the years, that's one Eiger North Face of a learning curve if all you want to do is get those Python files on GitHub and have some people collaborate with you there.

It's also pretty hard to discover functionality in VS Code. It wants to be everything to everyone, so it can't expose functionality in a way that specialized IDEs can – and even those tend to be either messy or sort of cryptic. It's really hard to be effective in any IDE without memorizing dozens of keyboard shortcuts, which isn't a problem for software people, because we either like this, or have grown accustomed to it. I guess that's why the Touchbar is wildly popular outside of software engineering and related disciplines – for apps that support it, it exposes functionality directly and in a context-sensitive manner.

Hundreds of millions of people around the world will start programming in this decade as the world is rushing into a future where code is the stuff that most of anything outside pristine wilderness that we ever experience, is at least partially made of or faciliated by, that all social, economic, political activity rests upon.

There is no tooling that would be appropriate for this kind of use case – whatever will end up filling that niche, the casual programmer who doesn't want to get deeply involved with software engineering, but get their semi-complex problems solved without tasking a team of SWEs, whatever will do this will have to be a lot cleverer, easier to use, more discoverable, more intuitive – make collaboration feel much more seamless – and still be very powerful. VS Code with its laser focus on the current developer crowd is probably not very well-suited for this.

> It's really hard to be effective in any IDE without memorizing dozens of keyboard shortcuts,

Curious if you use the command palette much? It should be a decent replacement for route memorization of keyboard shortcuts: How do I format this document agian? Hm... F1;form;enter done. And git push? F1:gpu;enter. Etc.

I work on vs code and am trying to improve this area so all feedback appreciated!

Hardly anything could pull my team and I from VS Code's performant UI, great Git integration, astoundingly fast project-wide file search, etc.

At the same time, the Go language server is the bane of our existence. It's so bad that it often blocks VS Code from saving files for minutes on end. To its credit, VS Code's handling of horribly slow plugins is as good as it possibly could be.

VS Code good, gopls bad.

I've used almost all popular editors for years, Vim, Emacs, Ultraedit, Sublime and of course VSCode.

But I switched back to Sublime about six months ago.

VSCode is mostly impressively good, it is even quite fast for an electron app. But still, not as fast as Sublime, and I think it degraded at some point, and I could sense it during work.

And then, I might be a bit paranoid but I think that VSCode could be used as a kind of trojan horse by Microsoft.

I don't want a future where everything is on the cloud, including all my tools and files.

I really like working off a thin client - less heat and more battery on local device. But I see your point

VS Code has some great features and plugins, and generally a good experience on both Linux and macOS. As a result, I use it periodically, and I like it. Most people in my developer circles use it exclusively, so it's definitely popular.

But I don't love it. Nor do I think it's the perfect code editor, or that we're in an Era of Visual Studio Code by any means.

I still find that I spend most of my time in vim as it is fast, and suits my development needs well without getting in my way.

In my experience: If you're developing anything outside of JS/TS/Web/Python, the experience in VSCode ranges from ok to totally broken. Which reflects the quality of the plugin ecosystem.

Can plugins really approach the productivity of a more specialized IDE like what JetBrains offers? I haven't seen any evidence that they can, but I'm open minded. The most powerful language support I've seen in VSCode is absolutely TypeScript, and its very good... but is it a plugin? Its not listed in my plugins, it "just works" upon a clean install. Do the Go, Rust, etc plugins just need another four years of work, or will they never approach the quality of TS in VSCode because TS is "built-in"?

And, to be frank, TS is only "very good". Its not "great" when compared to the support, for example, IntelliJ has for Java or VS has for C# when measuring things like the reliability and latency of intellisense and compiler feedback. Which, in my mind, represent the two most important things a code editor should do perfectly. When I have the question "wait, what's that io/ioutil function for reading the content of a file" in VSCode, I literally don't even consider typing "ioutil." and scrolling through the six functions in that package to get the answer, because I know before even trying that VSCode has a 20% chance of helping me. And that's a shame: Because this is by far the fastest way to get this answer; if it worked.

That's not even considering "latency from when I press a key to seeing the action on screen". VS Code is... fine. But my god its startling how much better Sublime is. It feels like spending an hour running on slightly damp soil, then suddenly finding a stretch of paved concrete. But, it lacks in the other productivity features I listed above, and I do think those are more important to get right, for the sole sake of productivity.

I mean, in short, if the next decade is VS Code As King, then it will be a sad decade. I don't trust that VS Code can solve these major issues it has had for four years. Code editors represent a top 3 item in the domain of developer productivity, and there's so much more work we need to do to get them right. We aren't there. And we'll probably never get there if we go all-in on VS Code. I'm so happy to see Panic try something different with their new Nova editor, and I hope we continue to see innovation in this space; not a VS Code monoculture.

I think if longevity is your concern, you can't go wrong with vim or Emacs. Both have been around for decades, which makes them that much more likely to be around for decades more.

This is also largely due to the rise in popularity of JavaScript. I still feel that the IntelliJ editors are still superior, and while it cost money it's not even a stop in the bucket compared to the productivity gains that come with their editors

> Learning software is an investment, and if you have to switch to another application later, you lose some of that investment.

I think the author missed a critical fifth point that they hinted at here. In my opinion VSCode is trivially easy to be productive with and not much of an investment to get into. Whereas heavier IDEs and then Vim at the far extreme demand some serious “learn how to ride this bike before you can do anything resembling useful.”

I enjoy VSCode for a number of reasons, dislike it for a few. One of the main pluses is that I start off productive on day one and can electively add complexity to further refine the tool.

I love tools with user-selected difficulty levels.

Vim has another problem. Once you grok it, it's very difficult to use anything else. If I ever find myself in an editor without some kind of vim mode, I'm totally hating life.

VSCode is pretty amazing but at the rate things are moving I can't imagine betting on anything being defacto for "decades". It's possible, and I even hope so, but with this kind of stuff I also always assume that a shift in perception in our industry can change overnight. Also, products themselves seem to go from "perfect" to "how did this become a joke" so quickly sometimes it's baffling. That all being said, VSCode is impressive and I applaud Microsoft. I still use Vim, but keep eyeing up VSCode.

To my mind VS Code (and not only VS Code, vim and other editors also) not only competes with editors, but with IDEs as well. It's interesting that he doesn't mention JetBrains at all. I'm curious to see if there is a trend of people migrating from it (or not?) and why.

> GitHub’s Codespaces also run VS Code as a web app, this time by spinning up an ad hoc development environment.

This probably can be the first time we'll see people use online code platform for real.

> It's interesting that he doesn't mention JetBrains at all.

Think you nailed the most salient point, quite curious in the corporate battle of wits on Twitter, HN, and other venues. Since HN rules discourage meta discussions, I'm gonna stop here.

VS Code is really meant for front-end development.

I wouldn't want to use it for anything I compile or debug. I'd use IntelliJ for Java/Kotlin, Visual Studio for C#, F#, Windows apps.

As with anything else in software development, it depends on the use case.

I'm still partial to Visual Studio and for text I use Notepad++. I used to use UltraEdit, which has some features that were extraordinary (column editing).

I've used VS Code for some things (PlantUML), but otherwise I find it cumbersome.

Have you been able to replace Notepad++ with UltraEdit? The column mode is superb. Also the way to remove trailing spaces ALT T G. etc.

Seems like everybody mentions GitLens as an example of a good VSCode extension, but I really wish more people knew about Git Graph [0]. It feels like having an embedded mini git kraken into vscode, beautiful graphs and all, and without any noticeable overhead.

[0] - https://marketplace.visualstudio.com/items?itemName=mhutchie...

I love IDEs... but most languages don't support IDEs. C# and Java are lucky to have a set of features that work well with IDEs - statically typed, OOP, without metaprogramming such as templates and preprocessor. All data is known upon compile time. With languages like C, C++ or D, a lot of code isn't known until compile time, so IDE cannot do any predictive magic. Same with refactoring, in C you can create new identifiers by preprocessor. In Java, you can ask the IDE to rename all usages of printStuff functions to printMoreStuff and you can be certain it will modify all the usages of this specific printStuff function, not the printStuff function from a different module. In dynamic typed languages the types aren't known until runtime so it's another struggle for IDEs.

That's why VSCode is so appealing for languages other than Java/C#. These languages just aren't capable of having the same kind of IDE support. If you can't rely on things like perfectly working autocompletion, automatic refactoring, advanced features like extracting methods into separate class, then all you need is a good notepad application. And VSCode is just that.

The articles talks about editors, but VS Code is mainly an IDE.

Its predecessors were in order Emacs + single-language IDEs + proprietary IDEs, then Eclipse and finally IntelliJ IDEA CE.

Emacs lost because it failed to update to reasonable modern conventions and because it used a niche programming language.

Eclipse lost because they released a bunch of different bundles instead of a single install (apparently because the contributing companies saw Eclipse as a common base for their proprietary IDEs), it was slow for the time, and had a bunch of unnecessary UI complexity (e.g. it had an unnecessary perspective system that would change the IDE layout depending on language, meaning that you couldn't just customize the IDE and have it apply for all languages, but had to customize each perspective).

IntelliJ IDEA lost because only the core was open source and major parts were proprietary, resulting in reduced 3rd party confidence.

VS Code is winning because they have a major company backing it that mostly doesn't seek to make proprietary IDEs with it except for minor proprietary aspects, uses the most popular language for extensions, avoids unnecessary UI complexity and is also fast and technically good.

Don't discount free. People can talk about a good craftsman paying for good tools, but corporate developers have to go through the corporate approval process to pay for just about anything, so free is friction-free.

Before VSCode the king of this was Eclipse. It was free, so it was everywhere, used by a plethora of companies. 2012-2015, when I was using it for vanilla Java development, knowing it let me get up to speed quickly on the Scale IDE, JBoss development from Red Hat, Mulesoft's MuleStudio, Teiid database virtualization, and Salesforce's IDE. VSCode is taking it's place, IMO; Salesforce has switched to it for its IDE.

It's interesting how vim and emacs both retained their popularity during the last few years. Probably because they cater to one specific audience.

Who?

Another cool thing about VSCode is it can be run in browser [1] now and this browser based VS code is available on GCP[2], AWS[3] and Azure[4] as well if you want to give it a try but note that there is usage cost in addition to the infrastructure usage for the cloud vm.

[1] https://github.com/cdr/code-server

[2] https://console.cloud.google.com/marketplace/details/techlat...

[3] https://aws.amazon.com/marketplace/pp/Techlatestnet-Visual-S...

[4] https://azuremarketplace.microsoft.com/en-us/marketplace/app...

The author makes some good points. However, very early on after being exposed to vim I decided "CUA" keybindings were the way for me, no context-switching required.

It's paid off handsomely. From DOS Edit, to Netware admin tools, Turbo Pascal, SimpleText, Notepad++, Sublime, Geany, and micro the strategy hasn't failed me yet. I like that they are mature and not changing a lot. Using another CUA editor takes a few minutes of tweaking the control panel. Having everything automated in the terminal with a Makefile or similar is another hedge. Easy to assign to a build key too.

So, perhaps the concern of moving to another editor is a bit overblown. Maybe if you've really locked yourself in—don't do that.

These days I use Geany 90% of the time. Micro another 5% via terminal. They are lightning fast, with just enough support. Have been developing Python and Web/Javascript for twenty years so I don't really need extensive completion. Identifiers, snippets, and linters, etc. are enough for me.

For huge work projects its Pycharm or other Jetbrains tool, but as I said only if huge.

I'm stuck. I'm writing Go and VueJS.

I tried Goland but it was too Java-y and too complex - there are thousands of settings. 4 different search options. 5 different methods of getting to the declaration for a function (and I'm never sure which one I should be using). I ended up spending more time messing with the editor than writing code, and there were too many incidents where I accidentally triggered a feature with a random key combination.

I love Vim but it makes my muscle memory incompatible with everything else. I stopped using it 5 years ago and I still hit ESC way too often.

I haven't tried Emacs yet. It's on the list, friends swear by it, but my experience with Vim has made me wary of investing that much time climbing a learning cliff again.

SublimeText was great, but support for Go isn't all that. Atom is too slow.

I'm back at VSCode for the moment. At least it's predictable and the Go plugin is workable. But I see the feature bloat and the complexity increasing. Its days are numbered. I don't see VSCode dominating the situation for much longer.

Try https://github.com/visualfc/liteide for Golang. Also,you can try emacs.

I bind shortcut keys in vim to common ones, something like this:

    :map ^Q :wq^M

It works good enough for me. I use vim keybindings also but this is sometimes useful.

I'm an iOS dev for the past 8 years, so I've been all in on mastering Xcode. I now must use VSCode for certain things at work, and while it's not my favorite, I love the plugin ecosystem. I really wish Apple had improved the ability to write Xcode plugins; instead they kneecapped it. To folks who say that VSCode plugins are a shambles: flagship IDEs have their problems too.

It's been interesting to watch some of the UX patterns popularized by the editors mentioned in the article creep into Xcode, though. Again, I dislike some, but I'm glad to see evolution taking place, and I need to repeat a mantra I've said many times: "always be learning." That's the only way to remain successful.

I don't actually use a ton of VSCode plugins, but I'll give a shout out for GitLens. It is magnificent. Big thank you to the maintainers.

I love how people bash the performance and memory consumption of Electron, but yet will concede vscode is somehow an exception.

You can write slow code in any language. There's games written in C or C++ for example that will get bad customer reviews for not running well enough for their level of graphics.

> I’m hoping it moves into the category with apps like Excel, Illustrator, Photoshop, software that has held the most popular position in its category for decades.

Products that have stagnated for decades, ignored by their intended audience due to lock-in and entrenched habits? (I have no opinion on Excel)

At first glance the history looks legit but there are missing holes. From 2004 till now we have multi platform/language editor called Eclipse. From early days it supports plugins. How that one fit in the story? Shouldn't author prefer that one for it's longevity?

The article seems to be focused on text editors, not IDEs. I'm not sure why it completely overlooks IDEs as an alternative. Perhaps the author is mostly a web developer, which I find is the main area where text editors really match IDEs in terms of features.

I think it's premature to say that visual studio code is the ultimate in human textual interfaces.

There's a ton to do with optimizing how text works. In a few decades, maybe someone will develop a properly functioning brain/neuron/text interface, bypassing VSCode entirely.

Regardless of whether that is feasible or not, it's really defeatist to just say "oh we give up, Microsoft has made the ultimate text editor" and call it a day.

That's not how the world improves, and you'll find that VS Code will also have its day when it's sunsetting and Microsoft throws in the towl and ends development on the project, similarly to how the Internet Explorer engine team was shut down.

Give it about 5 years, and then we'll talk again about this topic.

I'm glad you enjoy VS Code, but we'll have to see about longevity. I started my investment in Emacs about 25 years ago when it'd already been around 10 years before that (GNU Emacs), and it's still paying off plenty for me.

VSCode is pretty good but annoys me that many tasks are primarily mouse oriented and some keybindings require home/end/pgup/pgdn and arrow keys. Feels tedious when coming from vim/emacs.

I love VSCode, but of late I've relied mostly on vim and Textastic on the Mac, simply because of sheer _speed_ - either can be _much_ faster for simple edits across multiple files (I use Ctrl-p in vim) and have near-instant startup time.

But when I need to hunker down for a long session, it’s great. However, mine is so loaded with extensions that it feels like the “fat” IDEs of yore. And everything is constantly in need of updates.

Its big plus (and reason for success) is that it can be _anyone’s_ IDE, for anything. The extension ecosystem makes all the difference.

Honestly, the tools developed out of VSCode have made my Emacs environment so much more powerful, and so much easier to set up for new languages.

With the language server protocol & debug adapter protocol, I can just plugin in a couple of servers and have a full-blown IDE environment that uses a consistent interface across multiple languages. I remember spending so much time trying out and setting up ctags, ggtags, irony, rtags, gdb-mi, etc...

I don't see myself switching to VSCode because I can just take the best features from VSCode and use them Emacs.

My issue with the language server protocol is that it takes away power from the editor rather then giving power to the editor. Eg. sending text-edit instructions rather then providing an API for code intelligence. And in turns it creates too much work for the language server as it has to both make static analysis while at the same time baby-sitting the editor. Meanwhile the language servers I've tested is only half complete and the editor need a great deal of glue code and extra functionality for each language server. Also the language server need to run on a server, it would be much better if it was script based so it could run on many platforms.

Since I develop at work in a local VM with limited resources, I use Neovim + Coc that I found lighter than VSCode for NodeJs Js/TS, Python, Golang development. I can be very efficient in Neovim with a bunch of plugins fzf + coc + NerdTree. For editing VI is very powerful with Macros, global + normal commands, etc.

I use VScode for typescript web development, for instance for CSS editing I like having the color displayed next to the CSS value.

For Java I still largely prefer IntelliJ especially with Maven multi modules projects.

This trend of taking StackOverflow polls as global facts has to stop. It is so misleading. Not everyone is on StackOverflow, and not everyone on StackOverflow participates in the polls.

I can't help but see VSCode as a reincarnation of Emacs. It's written in a dynamic language on top of a native-code runtime, and you can extend it the same way it's "officially" built, right from inside it. Most interesting parts are such extensions. You can access anything internally by name, not hunting through menus.

It's also open source (though MIT, not GPL).

If not the particular implementation, but the approach finally has reached the deserved widespread popularity.

A bit of a tangent, but I think it would be worth distinguishing between vim-as-the-text-editor and vim-as-the-keybindings. For me, the value of vim comes from how quickly I can manipulate text, not necessarily that I can use a text editor in the terminal.

For bigger projects, I mostly use VSCode (and used IntelliJ in the past) but with vim bindings turned on. Because of this, I feel it's a bit difficult to compare the popularity of something like VSCode and Vim.

The Vim extension in VSCode is very clumsy for many things, not to mention the lags and the slowness (which defeats the purpose of using Vim keybindings) that's what drove me back, but I keep an eye on Onivim[0] which aims to be VSCode with Vim as a first class citizen.

0: https://onivim.github.io/

> Learning software is an investment, and if you have to switch to another application later, you lose some of that investment.

Learn lazarus, what's that: a data module. A neat way of grouping related data sources and sharing them between forms which can query datatables.

Learn spring boot. What's that? Services. A neat way of grouping related repositories which can query entities.

Turns out if you learn one thing very well you know a lot of other things that are similar in nature.

What I would love to see is a JetBrains code editor which is language-independent. VSCode is nice but it's still too sluggish. Sublime Text is what I really enjoyed back in the day but a lot of core extensions / plugins are stale.

Yes, I can configure IntelliJ to work with other languages but at the end of the day it's still a Java IDE.

I tried Nova from Panic the other day but it felt similar to VSCode in terms of snappiness.

If VS Code is an endpoint to incremental improvements in text editing, then the next big thing that appears will involve a revolutionary approach.

Text editing is mostly a solved problem, and arguably done better elsewhere. VS Code makes improvements on interacting with particular languages / DSLs.

I’ve switched to VS Code from Sublime and IntelliJ. Then it become so slow on a recent MacBook Pro that I finally switched to NeoVIM for editing any file of any programming language a year ago. I’m rediscovering keyboard shortcuts and custom macros. Couldn’t be happier.

Still, VS Code was a great inspiration to me. It felt much more light-weight than IntelliJ and features were superior to Sublime.

Anyone else think it's weird they used the term "text editor" ~100x in that article but what they're actually just comparing IDEs.

It's weird to read an article comparing the most popular "text editors" of all time and not have one mention Microsoft Word... I'd expect notepad, open office docs and pages to get honerable mentions on such a list.

It's just a disparaging term for people who think that good software comes only from a full IDE. To be fair though, MS Word is a lot more than a text editor, e.g. you don't save its documents as text documents but as bundles of style/layout/text/fonts.

Funny. I've basically done the same with UltraEdit. Although, when it comes to certain languages, I prefer to use the dedicated IDE. Especially if the GUI is involved. For .net, it's straight up Visual Studio. For Java, OpenBeans. And so on. I think VS Code will serve the same niche as the text editor + compiler crowd. IDEs are way too comfy to resist.

Performance is a huge issue with vs code. I’ve been using it for a couple of years and am seriously considering going to a minimal vim setup. My editor slowing to a crawl and needed to be restarted once or twice a day on a brand new high end MBP is a constant annoyance.

And if I want to test running a swarm or several servers locally, the memory usage really does become relevant.

There’s one big difference between a text editor and other example apps (Illustrator and Excel).

Excel is used widely and even with file portability. Microsoft Office is still what many people are used to.

Illustrator, In addition of been being popular. It uses their binary ai file format making it harder to switch from.

TextEditors unlike those 2 does plain text. So there’s at least no file lock-in for plain text.

He addresses that on his footnote.

> In most software categories, choosing the software with longevity is easy, the most popular tools are usually the ones that have been around the longest. Microsoft Excel and Adobe Illustrator were both released in 1987 and, for the most part, they’ve remained the most popular software in their categories since then.

Hold up! I'm out here still repping Lotus 1-2-3...

Hmmm, this article seems like a very Mac centered view of text editor history.

I was using jEdit long before TextMate was a thing and it had extensions and language customizations as well. If I remember correctly, TextMate mainly became popular because of all the Rails and Django developers promoting it at the same time developers were switching to Macs.

This is a valid criticism.

I tried to be careful with my language to not imply things were technically the first, but to describe a lineage. E.g., Sublime Text was clearly at least partly based on TextMate (lifting some technologies, like snippets and language grammars, verbatim), and Atom was so much based on Sublime Text that it's initial design could fairly be called a knockoff.

I think that the major players that lead to VS Code are TextMate, Sublime Text, and Atom, but I'll be the first to admit there's a healthy amount of subjective judgement there. And just me drawing on things I'm familiar with (e.g., the decision to focus on BBEdit, Vim, and Emacs as the earlier examples is simply because I know those editors pretty well). One thing I don't know much about is what TextMate's influences actually are, perhaps jEdit fits into the story there? I'm not sure.

In any event, I appreciate you pointing out these features in jEdit, so far that's the earliest example of a plugin system and an integrated plugin manager that I'm aware of.

VSCode looks great and has a nice debugger but going through plugin management again is too much for me.

I’ve already invested the time and effort to setup neovim with coc as my general go-to editor and have very few complaints. If I ever need a true IDE for something I’ll just open something batteries-included like Jetbrains or Pycharm.

Not sure what VSCode will become in future but for now VSCode is amazing for JS projects, quick browse & edits on adhoc files

But IntelliJ, GoLand, PyCharm etc.. is way more convenient for significant changes in code base.

And the data grip plugin provided by Jetbrains for Postgres / MySQL is light years ahead of any other DB GUI I came across.

No where in the article or the 247 comments does Jupyter Lab merit a single mention?

It’s clearly not a full fledged IDE. Yet. But it is building towards that. Is fully open source. Has a broad and deep ecosystem behind. Born in the cloud. Just got Kite plugin for better autocomplete.

If you’re doing data science it’s a very viable contender.

My workflow of the last 10 years when choosing editors:

Browse directories/read files/quick retrieval? -> Vim

Make a quick edit on anything and rerun compiler/test/docker run -> Vim

Write any kind of quick bash/python script -> Vim

Code read a project or work on a feature -> Fire up an IDE (IntelliJ mostly, or Webstorm if javascript)

With more years into writing code, I think VSCode/Vim/IntelliJ etc. are just tools to be used for problems that they are good at, depending on your background, and to maximize your productivity. It’s a very personal thing, and any single tool shouldn’t be expected to be versatile.

Maybe this is not the right place to ask, but I've tried to googled it without success. I use VSCode and Geany and code mostly Go,HTML/JS(svelte),Php and some python.

I love them both, but would like some unity between them :)

Does anyone have a theme-file for Geany that mimics VSCode's look and colors ?

> For big complicated desktop software, has any other category ever had so much movement?

Um... web browsers?

Is that a trick question?

I have been using Sublime since 3 months and I like how lean it is. I tried VSC but I find it heavy on resources on my i5 with 24GB of ram. Maybe it is a perception thing though. What I find interesting is that UltraEdit, an editor I love, is not even on the rankings here.

I have been a heavy sublime text user. Really love the product it’s fast and responsive compared to VSCode as vscode gets slow when handling alot of files and searching through them. Kudos to Sublime Text Team for making awesome product with never ending trial.

One of the features I really like about VS Code is the source control, which is super simple and easy to use and understand. Especially the diff view and resolving of merge conflicts using UI. I find Intellij to be somewhat more complex in this regard.

I find it interesting there is no mention of the new Adobe Brackets here. I've been using Panic Coda for years and will be transitioning to either Panic Nova or to Brackets.

Fully open source, written in HTML and Javascript. It was released in April of 2020.

I tried using VS Code but the vim keybindings were inadequate. It doesn't do anything I can't already do without it (except frustrate my muscle memory) so it lacks any kind of value proposition for me.

As much as I like vscode. I’ve yet to find a mainstream programming language that it provides support for better than a Jetbrains based IDE. Which is really sad, because if it did, I’d switch in a heartbeat.

JavaScript/TypeScript ?

Its biggest weakness is its biggest strength.

People said a UI based on web tech was backwards and slow. Turns out it os at least fast enough and enables cloud IDEs that can run in the browser.

Who wants to write the next generation of the Emacs concept in Julia (and maybe Rust)?

(mostly kidding but I would like to see it and work on it if there's people who wanna do it)

Quite simply I use VS Code as a notepad/quick editor. If I’m fully coding in an environment I’ll spend the extra setup on getting it into a Jetbrains IDE

As far as those that are on macOS are concerned, Nova seeks to challenge VS Code. [0]

[0] https://nova.app

Its okay for web stuff but I use Jetbrains IDEs for C++ and Go. They are way better. C++ crashes and gets into weird states all the time on VSCode for me.

I've heard from some of its employees that Jetbrains is on panic, they are losing tons of webstorm and pycharm customers to VSCode.

It is amazing, also, how they have integrated vim into Visual Studio Code! Sooo awesome!!

Author is working on it's own code editor, so article is more than biased.

Anyone know why I struggle to read the font on this site? It feels super light?

Really well researched and written. Kudos!.

I’m surprised that the product hasn’t been renamed “Microsoft Code” but there is still time for MSFT to drop the VS reference.

Excellent article!

jetbrains for work, vscode for personal

VS Code, the text editor, is a trojan horse.

Microsoft is selling you into the IDE, in small portions. This is similar to the IBM approach with JAVA last decade(s?).

You install a "text editor" for simple things, like code completion. Before you realize you don't even know which compiler you are using or where it came from. You just press F5 and look at convenient break points. And somehow it only runs right on Azure :) the last one is a joke (for now?)

As a language popularity grows, it approaches the Java curve. Just like nobody who uses `npm` like (or know) maven, nobody using VS Code know about the old java IDEs, and how they become todays Java IDEs. Or how the React monolith is the same as the Java Monolith.

I guess people mixing up java and javascript in the 90s... just thad more, long term vision?

You're right - it is a trojan horse and people are eating up the 'MS heart Open Source' PR. It's obvious when you look at what they're doing with language servers.

They've replaced the open source Python language server with a closed source one. The C/C++ was always closed. Their remote feature and collaboration tools are also closed. They're slowly making people depend on MS services without even realising it.

They want you to run your development environment on Azure and are making it possible piece by piece, turning your IDE into a thin client. And they're open about that aim but still call VS Code "open source". It is not - it has open source components and lots of telemetry so MS can develop those services. If people are happy with that, so be it but the 'love' they get is undeserved.

I'm legit confused on what you're trying to say. Are you saying tech stacks are a bad thing? Or that corporate investment or connection to a tech stack is a bad thing? What's your proposed solution or alternative?

One thing I _think_ you're saying that I do find important:

It's crucial to have experience in more than one ecosystem and tech stack, as you learn a lot from seeing communities reinvent the wheel and not learn from one another. You get to see common patterns in software development and engineering and, sometimes, you find novel approaches that are completely alien to the engineering ecosystem you started out in.

Which IDE? If you mean Visual Studio, that's a Windows only product and it's really only good for Windows specific development like C# and MSVC. If you do C# or C++ development on Windows or XBox then you're likely already using Visual Studio and the community edition is a free product for individual use or open source products.

If you mean some future IDE that MS is working on that they plan to evolve VS Code into, I don't see MS trying to sell macOS or Linux users a proprietary dev environment or toolchain. It's certainly possible but your post doesn't provide any justification for that position.

Indeed, Microsoft Edge for Linux too is a trojan horse. Windows needs to gain leverage against open development platforms. They they need to reach other ecosystems (fedora, centos, mac os). Just like Google when you use their technologies you bet the app is talking to the mothership.

> Microsoft is selling you into the IDE, in small portions

what are they selling me

I don't know even other platforms are starting to build plugin integrations into it.

For example, Google Cloud Code which lets you deploy/manage cloud run and k8s from it.

I was already bought into their IDE environment. :) VS Code runs much better than their old offerings.

You're right; my years of experience with Java, Maven, Netbeans, Eclipse (eugh...), and IntelliJ completely evaporated when I did 'npm init' on my current (Node and React) project, which I'm working on in VS Code.

A jumped to Atom and hated it and returned to Sublime. I have used VS Code, but never made the full jump because Atom set a precedent for Electron editors.

I switched from Atom to VS Code after a long time as I always disliked the way VS Code looks but at some point you have to admit that Atom is abandonware (Microsoft isn't going to develop two text editors) and VS Code is way more lightweight than Atom ever ways.

As far as I know, there are no serious email clients for Visual Studio Code. So the kind of obsessive users, the ones that want to do everything with it, the presence of which indicates a really good piece of software, don't use Visual Studio Code. I consider that a fatal indictment of Visual Studio Code.

"Every program attempts to expand until it can read mail. Those programs which cannot so expand are replaced by ones which can." -- https://en.wikiquote.org/wiki/Jamie_Zawinski

Surely even crusty greybeards would use a dedicated email client like mutt?

I hate visual studio programs. They are always so slow, buggy, and when they crash, the program vanishes from the task manger but is still are running from the background, so you cannot kill it easily. Visual Studio is a crutch for real coding.

OK, but this article is about Visual Studio Code, which is a different product.

If Windows processes don't appear in the Task Manager, either you have been thoroughly hacked or you are not an administrator. Don't blame tools.

i take it your an Ed guy.

Reply on news.ycombinator.com