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.

No way, it sucks when you've got a monolith full of unnecessary gadgetry. Right now VSCode is already getting pretty bloated w/ builtins

I could not understand why anyone would be happy if VSCode came with 50 core un-installable plugins and none of them were useful to you, since everyone has slightly different projects they're working on. It would be inefficient and it wouldn't cater to a larger user base.

There's a happy middle ground that far too projects choose: building a modularized system, but distributing core, currated plugins with the system.

Effectively, I don't care if I receive a batteries-included product where the batteries are pre-installed and on-demand loaded, vs one where they're permanently installed.

This is the difference between an opinionated vs non-opinionated IDE

You seem to prefer opinionated, where other people like the fact they can pick and choose from various plugins to my their IDE their own, and if they do not like the default implementation of a feature there likely is another plugin that may work for them.

For example there are a couple of git plugins, all of them act slighty different based on the workflow of the users of that plugin, if MS came in and said "No this is how git workflow is in VSCode and no other way is possible" that would turn off alot of users

Further you stated another glaring problem, Jetbrians mikes IDE's plural, specialized for each lang they are targeting, VSCode needs to work with many lang, there is not a VSCode:Python edition, and VSCode:Powershell edition, etc et c etc

It is just VSCode and plugins add the Languages you need / want support for

I thought that until I realised IntelliJ Ultimate is really IntelliJ + WebStorm + PHPStorm + RubyMine + PyCharm + Goland and with plugins you're covered for most major PLs except C,C++ and C# which require 2 separate IDEs.

And Swift/Objective-C require AppCode. They all have a fantastic SQL/database admin tool built in as well.

JetBrains has Rider for C#

Yeah but you need to pay separately because it’s based on ReSharper, there’s no .NET plug-in for IDEA Ultimate.

But if your buying the full version, then the full library is only another £100 to begin with.

Cheaper for personal use, and free for students.

https://www.jetbrains.com/idea/buy/#commercial?billing=yearl...

There's also the issue of managing separate apps which I find to be a pain.

"only" another £100? That's a lot of cash.

That depends on perspective. If you are a professional programmer using JetBrains tools as daily drivers then I think think £100 over the InteliJ price is pretty reasonable to get access to their entire library of tools.

Consultants make at £400 day here, dotnet devs usually more.

If you are a hobbiest, it's cheaper.

And the costs decrease each year.

If you are saying £100, then it sounds like it would offer you money for value, so it's probably not for you.

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

microsoft already has an IDE like this for their core languages; it's called visual studio. it's kinda bloated, but it's still a great tool for languages that microsoft has deigned to grace with its direct attention. for anything else, you're SOL; the plugin ecosystem is pretty limited for VS. the more VSCode reimplements plugins "natively" (isn't it all JS anyway?), the less it has a reason to exist.

It’s pretty easy though. You open a Python file, it asks if you want Python plug-in installed. Then you’re pretty much done except specifying your virtualenv. If you have linter settings it will ask if you want the linter installed.

The big thing with Jetbrains is the cost. PyCharm is $9-$25/month and VSCode is free

> If you have linter settings it will ask if you want the linter installed.

And then, despite automatically identifying the local python venv, install the linter elsewhere so it doesn't work.

But it integrates it wonderfully when you install the linter yourself, or if you use the bundled pylance.

Or, better yet, to re-implement the best plugins as installed by default plugins that could then be enabled/disabled by the user.

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

Unlike the FANG companies, Microsoft doesn't tend to rip the carpet out from under independent developers like that.

Wasn’t there recently a thread were Microsoft interviewed someone that has a third party dev tool, declined to hire him and then recreated the same tool with almost the same name without acknowledgement?

You mean the app that he named almost the same name as another, long-existing Microsoft product? (NuGet) It's not like AppGet was developed in a vacuum. And it's definitely nowhere near the situation like Facebook cloning Virtual Desktop, threatening to crush the original developer if he didn't join them, and naming it the exact same thing.

Right, but they would. Plugins aren't paid right now, so all I'd think it would take would be Microsoft saying "hey, people like your plugin, we'll pay you to maintain it, and if you don't want to maintain it, we'll inhouse it."

To avoid left-pad situations

I don't know about VS Code, but in native VS, there are lots of paid plugins. There just isn't a store. You buy the plugins from the developers.

It's all open source. Is there anyone making money from VS Code plugins? Why does it matter if MS "steals" the code?

>Unlike the FANG companies, Microsoft doesn't tend to rip the carpet out from under independent developers like that.

No, they roll them into the carpet and sodomize them like they did with Keivan Beigi and at most just sheepishly say sorry after some public outcry.

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?

In my company we use pyenv with virtualenv and everything works seamlessly. VSCode automatically runs the activate script from pyenv in a new terminal (in my case it is even the fish shell), debugging works fine, and I can go to definitions.

Note that a new extension, that works alongside the original python extension, has been developed by Microsoft: Pylance. It speeds things up based on pyright, a python type-checker.

For refactoring you can use rope [0] as a VSCode extension.

[0] https://github.com/python-rope/rope

Hey, thanks for your input. I will look into using pyenv so that might solve my problem with "go to definitions".

However, I was also having a lot of trouble with environment variables, especially PYTHONPATH. How do you solve that?

Also rope did NOT work well for me. When I tried to refactor (rename) a function definition, it also changed variables in unrelated scopes that had the same name and were not related to the function at all. So I did not gain anything from that which I couldn't achieve using CTRL+F replace.

I've never had any trouble with PYTHONPATH, I guess this is solved by pyenv with virtualenv. You just need to select the project interpreter the first time you open the project and it should just work.

I haven't used rope extensively, it's too bad that it doesn't work well. It's open source so I guess it needs more contributions.

Yeah, my experience of attempting a very simple refactor (change variable name) with the VSCode Python plug-in is:

“Rope is not installed. Install?” - so I need a package in my virtual env just to rename variables?

“Rope is installed. Refactoring failed”.

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

I only dabble in VS Code on occasion, so only saw this in passing: https://github.com/VSpaceCode/VSpaceCode

They do have extensions that install multiple other extensions.

I think Facebook did make something like that a few years ago.

are you asking if anyone implemented the 3d first person shooter DOOM inside of the vscode plugin system? that could be a summer of code project for some aspiring coder.

No, DOOM Emacs is like a variant of Emacs: https://github.com/hlissner/doom-emacs

> Remote development one.

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

I’m curious, why does this fact require that on be careful. I’m not trolling, I’d like to understand the cautionary stance.

I think this person wants you to be careful the way you should be careful around using Windows 10, or Apple App Store, or the iPhone, or Dell Laptops.

Absolutely everything we use has non-opensource components, unless you try to pursue the path of a purist.

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.

How are you guys all working in one language?

I work on a stack that has ruby on rails on the backend, javascript on the frontend, .NET Core apps to do data transformation, and some NodeJS thrown in there, too. I have to switch back and forth between these projects regularly. There is no other tool like VS Code that provides me the flexibility to have snippets and highlighting and the things I need to maintain these projects, while also giving me the flexibility to switch between languages and syntax on the fly without having to wait 20 minutes just for the IDE to load up.

Huh, I feel the same way about IntelliJ.

Java, Python, Go, Terraform, Bazel, all in the same IDE at once. Best in class refactoring for all of them. Handles the monorepo surprisingly well (Bazel is a big help here, too).

I had to bump the memory a bit on the IDE, but after hundreds of thousands of lines of code the index gets large.

I used to use VSCode heavily... Emacs before that. But now with IntelliJ I don’t really need much else. The plug-in ecosystem is really nice too.

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.

That's true, but that's Jetbrains core product. They sell it as Python IDE, batteries included, and they develop it with that intent.

VSCode does not get that kind of love, it is marketed differently and has different core values.

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

But there are JetBrains IDEs for those too — CLion, Rider and AppCode respectively. No IDEA how well they work though.

Can’t speak to CLion and AppCode, but Rider is spectacular. It integrates all of Resharper’s (JetBrains’ C# code analysis tool) features with the IntelliJ core that run circles around the bloated, buggy mess that is modern Visual Studio (not to be confused with Visual Studio Code).

Love Rider. ReSharper makes Visual Studio unacceptably slow though. It's already borderline without RS but adding it makes it totally suck, for me at least.

I'm aware. They cost more money though.

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.

It's a slightly different philosophy. Emacs is best viewed not as text editor with plugins, but as a Lisp Machine emulator with a text editor. The joke about it being an OS is more true than people think: what you get is a (2D, not 1D like shell) text-oriented programming environment, back from the times where "a programming environment" meant a fully end-user-programmable OS.

This has an important downstream consequence on the "plugin" ecosystem: since these "plugins" are better seen as small applications running on in a shared, restriction-free OS, they don't need a fixed and restrictive API to interoperate. The entire Emacs is the API, and as long as an elisp app follows conventions and plays nice, it will almost seamlessly interoperate with every other app. And in cases where it doesn't (e.g. you try to use two apps that do roughly the same thing), it's relatively trivial to patch out the conflicts yourself. Having an integrated debugger and REPL is also helpful :).

VSCode philosophy feels more restrictive compared to that.

As for the keyboard conventions, it's true and it impacts the market share, but that's a problem for almost any software that reaches longevity. Conventions come and go, so it shouldn't stop one from learning a tool that keeps proving its worth over decades. And in case of Emacs, if you don't like the default keybindings, you can quite easily patch them up to follow whatever convention you fancy :).

Terminology is a slightly worse problem because you can't patch that out if you don't like it - but then again, it's just a bunch of terms you need to learn; par for the course for any developer.

Keyboard conventions do come and go but muscle memory is expensive to reprogram. Your hands are also irreplaceable. So I go for the most efficient that's not too radically unfamiliar or painful.

And honestly one could spend a career learning every editor/IDE in depth without ever accomplishing anything else. Embedded is especially bad as one often must use the IDE integrated into the platform's SDK.

I think you missed the point where they mentioned you can change any and all keybindings in Emacs.

Right but that requires learning Emacs well enough to change bindings. Then all the other tweaks one makes to a tool like text expansions, macros, and learning differences in find-replace, refactoring, and autocomplete.

There's no more learning required for changing Emacs keybindings than in other IDEs. If you don't want to go the scripting way, you can use the Customize interface, which is Emacs's equivalent of Settings dialog in most other software. Hell, unlike most software, Customize interface gives you a choice between applying changes temporarily and permanently, so you can try things out and if you mess up, just restart the editor.

(Under the hood, stuff you change via Customize gets serialized into a file called custom.el. But you don't have to know that to use it.)

Current keyboard conventions go back to 1984 and the Mac, and no sign of them changing anytime soon.

The article mentions Excel, for example, coming a few years after that and going strong today.

So I really do think Emacs predating those conventions is not going to be overcome.

The difference between VSCode and Emacs is the difference between an extensible text editor, and an editor that was designed to be extended, molded, and shaped as you work. At any time within Emacs, you can evaluate Lisp code to extend or modify its functionality. What's more, the always-on presence of Lisp turns Emacs into a computing environment with strong editing primitives, rather than a text editor with stuff bolted onto it. I use it to automate tedious tasks, where it serves as a sort of Lisp-programmable super-shell that can ingest data from processes and network connections into buffers, as well as the inverse, all under the control of a powerful programming language.

I'd like to hear more about how you use Emacs as a "super-shell". Do you avoid shell scripts entirely in favor of Emacs Lisp? You mentioned network connections - do you actually do scripting with Elisp's networking primitives?

I've long felt that this was an obvious and good use of Emacs - as a central coordination point for the entirety of one's computational life, with everything manipulated programmatically from a single programming environment with both rich UI capabilities and a full-fledged programming language. No other project seems to understand the value of such a central point... but still, there are many ways Elisp could improve to make this kind of usage easier.

> I'd like to hear more about how you use Emacs as a "super-shell". Do you avoid shell scripts entirely in favor of Emacs Lisp?

No. But I do use Emacs Lisp to automate certain tasks and then wrap them up in an Emacs interface -- like highlighting some JSON to submit to an API endpoint, or using ivy to select a Docker container to start or stop.

> You mentioned network connections - do you actually do scripting with Elisp's networking primitives?

Emacs provides an OOTB way to hit API endpoints in the form of 'request'. So it's not just the networking primitives, but the utilities built on those primitives that Emacs comes with.

> there are many ways Elisp could improve to make this kind of usage easier.

Emacs Lisp has had two major warts: speed, and the lack of lexical scoping and CL-like constructs. The latter is largely addressed. The former is being worked on with efforts like gccemacs.

Question: how do you become most efficient in writing python?

Your answer: Learn Lisp!

Technically true even in spite of emacs, but if every engineer out there learns lisp to write better python wouldn't that be an interesting world.

Why? A good Lisp will give you a decent ride around the block. Even without reaching code-data-equivalence enlightment, it's a fast way to round your knowledge of various paradigms and approaches.

> At any time within Emacs, you can evaluate Lisp code to extend or modify its functionality.

This is also true for VS Code (with JavaScript instead of Emacs Lisp of course). VS Code is just a bit more organized on the surface, giving it significant advantages over emacs in that regard, but also a bit more closed in culture.

I've recently switched from Spacemacs (vim-style modal editing and keyboard commands, in Emacs) to "Vanilla" Emacs.

I've been finding that once I changed capslock to become control, the various keyboard commands in Emacs make a lot of sense to me. In fact, far more than I thought they would, to the point where I'm feeling a lot more comfortable and competent performing the shortcuts, which means I remember a lot more of them. (Remembering shortcuts has always been a problem for me because I have various Adult ADHD issues.)

Sure, it's just one person's anecdotal and subjective, experience, but I've found myself using Emacs to edit my code (mostly Terraform and Ansible) much more than VSCode.

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.

out of curiosity what language do you write primarily?

I actually deal with a lots of code, c/c++/js/python/golang/lua/sql, guess what vim can be configured to work well for them all: autocomplete, syntax highlight, auto-format,etc. along with nerdtree, I rarely need mouse at all during coding.

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.

Arduino also has "Arduino Pro IDE" that's based on Theia, a VSCode fork.

https://blog.arduino.cc/2019/10/25/new-arduino-pro-ide-a-clo...

https://github.com/arduino/arduino-pro-ide

Yes it seems to be different everytime I use it. But the one time that the debugger worked was amazing. Wish I could make it happen again.

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'm running VS2019 inside a VM on a Mac and it's horrendous, particularly compile times. It does feel normal on a proper Windows box though.

I see no reason for the compile times to be different. Windows is known for slows file system access though.

Exactly this, VS2019 running inside Parallels Desktop is so slow. I’ve tried optimizing to no avail.

The Mac version of VS is not actually VS at all, it's rebranded Xamarin Studio. I assume the GP was talking exclusively about "actual" VS when he says it's much better now, which I also agree with.

He mentioned "in a VM", so I'm guessing he's running the actual visual studio on a windows VM (guest OS), in his mac (host OS).

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?

As opposed to something like python, which is "batteries included".

There you go: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

Batteries included! All you ever need to work with JS.

I agree that there should have been some kind of "core" package for Node.js that is supervised by the developers but still an optional download, but the people that were initially in charge of NPM fought that idea to death in order to make people... use and rely on NPM.

Some people absolutely took advantage of the situation from a financial standpoint and created a business opportunity for themselves, at the expense of the community.

Yes. And Gatsby has taken it to the extreme.

Gatsby was everyone's darling just a couple of years ago!

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