VSCode is good but as someone who’s been writing software for nearly 40 years, I really feel you’ve over doing the compliments by a long long way.
Compilers, operating systems, browser engines (unfortunately) and reverse engineering proprietary hardware/firmware are all significantly harder challenges than writing an IDE.
in fact there have been excellent IDEs around for decades before VSCode came along. Yes the industry lacked an LSP but that doesn’t mean that languages severs didn’t exist before then, there just wasn’t a standard before so everyone did their own thing.
Having built in terminals isn’t a new innovation either. That is and always has been the norm.
And most of the other accomplishments aren’t any more unique either (eg lots of software projects have monorepos).
It’s ironic that you say VSCode is the greatest productivity tool in the history of software engineering when VSCode is dependent on so many pre-existing technology’s like Electron, web standards, GUI frameworks, compilers, operating systems, device drivers, etc. in the grand scope of the engineering, VSCode occupies a very small fraction of engineering effort and in a niche that was already crowded before it even entered.
Is it the best IDE on the market? some might think so. JetBrains certainly have their fans too. But even if it’s the “best”, it’s extremely hard to argue that it is that far ahead of the competition and that innovative to deserve the accolades you’re describing.
VSCode isn't the most complex of projects or most widespread etc. But from perspective of engineering a large project is about making 100s of small and large choices. In hindsight, lot of them are wrong. Take any software WinNT, Linux, Atom, IntelliJ, Adobe* you can now with all the extra information available today can find some decisions that were wrong.
With VSCode these wrong decisions are very few and minor compared to the brilliant choices made by the team. That's why it is right to cite it as an engineering excellence project.
The software you mentioned were pioneers in their category. On the other hand, VSCode had the benefit of learning from the many IDES in the saturated market that came before it. If VSCode was one of the first IDE it would not look anywhere near the same because it wouldn't be able to lean on the lessons of past IDEs like it does today.
Dunno, just getting VSCode to run and debug a project requires manually editing cryptic config files which is what almost any IDE does much better...
Indeed; while VSCode is held up as the "best ever IDE for everything, period", what those people gloss over is that they are web devs, not C++ hackers who need to be able to easily build projects (and have good, reliable syntax highlighting and autocompletion). In the rare occasion that I use VSCode for C++ development, I just use cmake from the built-in terminal because I really don't think VSCode is designed to build C++ projects.
VSCode is not tied to a specific language so the job of handling config files is left to the extension. Not every language has a fixed project structure so I think the major extensions have kept structure-dependent things out. In C++ for example there are CMake projects and GNU Makefile projects. Not sure why such extensions haven't bubbled yet.
Other IDEs have their own fixed project structure and a project config file specific to their IDE. This means running and debugging is easier in their IDE if your project works in the specific way intended by the IDE, but this locks you to their IDE.
By your logic Sublime is an even higher feat of engineering since it made even better engineering decisions.
Ultimately they’re both very fancy text editors, not ‘the greatest feat of modern software engineering’.
I’d happily switch from Sublime to VScode or EMacs or any of the other umpteen code editors. I’d shudder to have to go back from Git to SVN. Even Mercurial seems milquetoast in comparison.
Similarly, what about the Linux kernel?
What about C?
> I’d shudder to have to go back from Git to SVN.
What are some of the Git features that make a big difference to you? I use them on different projects and I end up using them both in the same very basic way (check out code, make changes, check code in).
local commit
All git operations are several times faster than their SVN counterparts, and git is more storage efficient as well. This becomes especially relevant for larger repositories.
Merging. Sure you can “branch” on svn but you merge at your own risk.
Spot on.
And I would rather say that Atom was an engineering feat in terms of that they developed Electron and tree-sitter.
One also has to take into account that Atom started long before VS Code so for sure the VS Code team could make much more informed decisions and learn from the "failures" of Atom. And things like TypeScript wasn't around when Atom started.
Admittedly this is a little bit of a nitpick (and I agree with your general sentiment re: VSCode devs benefitting from prior art) but for clarity's sake — Atom v1.0.0 was released mid-2015. TypeScript v1.0 was early 2014 and had been usable since 2012 pre 1.0.
They were very much contemporaries of one another, though obviously TS popularity has surged since 2017/2018.
Also, the Monaco code editor (a core component of VS Code) was started for the Azure Portal and then used by the IE Dev Tools experience for several years before Atom. VS Code didn't have Electron until after Atom, but they had a running start in several core component areas.
I agree that it is an exaggeration to call it the greatest pieces of engineering of our time. Still there are many technologies that are well liked but haven't developed in many years. There are many technologies that are here today but severely limited. And there are many technologies which promises potential for something better in the future. There are very few pieces of software that are here today and ticks a lot of the boxes of computer science. That are open source, cross-platform, extensible and has a modern stack.
> browser engines (unfortunately)
I often wish it wasn't so but the reality is that a shit ton of development has gone into browsers and in many cases other areas just aren't comparable. Even more so considering most resources go into proprietary technologies.
> reverse engineering proprietary hardware/firmware
As as side note reverse engineering hardware can certainly be very hard. It is also something that can gather far more credit than it probably should compared to actually engineering a solution in the first place.
> There are very few pieces of software that are here today and ticks a lot of the boxes of computer science. That are open source, cross-platform, extensible and has a modern stack.
Open source: there’s loads. I’m very surprised to read that comment here of all places. But even if we take your comment at face value, licensing has naff all to do with engineering impressiveness.
Cross platform: again I’d beg to differ there there aren’t many. And again I’d also like to point out that something not being cross platform doesn’t negate it being impressive engineering.
Extensible: this is another metric you’ve added that I disagree is a requirement
Used a modern stack: this absolutely shouldn’t matter when one talks about “of all time” like the GP was. Otherwise you’re intentionally skewing the results to only include recent developments.
> I often wish it wasn't so but the reality is that a shit ton of development has gone into browsers and in many cases other areas just aren't comparable.
The point of the GPs tangent was comparing all software engineering.
Sure, if you say VSCode is the greatest software engineering project of all time then suffix that comment with a dozen footnotes describing a dozen exclusions to the scope, then the claim might be more reasonable. But that wasn’t what the GP said and nor is it then “greatest”.
Frankly though, I wouldn’t even extend that description of his to modern IDEs specifically, let alone the broader context they intended.
VSCode is good but as someone who’s been writing software for nearly 40 years, I really feel you’ve over doing the compliments by a long long way.
I agree.
Lots of people talk about how great VS Code is. But how many of them would sing that tune if they had to pay for it?
VS Code's killer feature isn't customization or extensibility. Clearly it isn't speed or stability. It's price.
Well, it has to have something beyond price if it's taking by storm the editor arena that always has had great editors.
I think it has gained its place in the eternal emacs vs vim discussion, and that's a feat to be reckoned. In 15 years there will be other fancier editors but VS Code will still be there.
VS Code is good, but not THAT good. It has unparalleled remote editing with the SSH extension, but the actual editor is beaten by Sublime.
I can buy that people like it, I don’t dislike it, but it also isn’t sliced bread. There’s peers in the market that are ahead in various ways, so VS Code isn’t the end all be all, even if it is cool.
I think VSCode's impressiveness is less about the pure engineering challenge (although I do think even among popular, well-used IDEs there's a large differential in things like performance, which points to it not being a trivial problem), and more about making smart product decisions to strike a great balance between extensibility and performance / smoothness. There's not a singular big hairy problem to solve, but if you compare VSCode to other Electron apps, it's clear that the VSCode team really took the time to make sure everything was as performant and polished as possible.
And in terms of "well it depends on other technologies for it to work", this describes pretty much any innovation in software since the very earliest computers, including all the examples you listed.
Sure, we do all stand on the shoulders of giants. But the other things I listed requires significantly more research and development effort than building an IDE does.
Also I dispute that VS Code is the quickest editor out there. It’s faster than its Electron counterparts but that’s a pretty low bar. This isn’t a dig at VS Code, it’s my default IDE (well that and vim). But the largest part of the reason I use VSCode is because it’s free.
That, for me, is its real advantage. But that’s not an engineering achievement.
Honestly I’m not a fan of VSCode as a user. It’s too generic and lacks identity (too powerful to edit simple configs); it auto-updates every time I start it; it’s too complicated to configure; JSON is ugly and it’s 2022, why not favor GUI configurations?
If my goal is to program in language X then I should be able to grab a product and get started without fuss. VSCode is a whole lot of fussing about.
That being said, it’s very stable and performs well—I will give the devs a massive kudos for that. Also if I did a lot of NodeJS dev work it would probably classify as a proper IDE for that.
But all-in-all I would prefer something purpose-built with minimal configuration out the gate for development workloads (C/C++, Java, C#) and a more minimal editor (nano, vim, eMacs, notepad++, geany, etc) for editing configs.
> it’s too complicated to configure; JSON is ugly and it’s 2022, why not favor GUI configurations?
GUIs can change layout and users have to spend time learning where things are. Someone who is using a text editor is probably comfortable editing text.
Well unfortunately that’s a typical assumption developers make. “It’s an editor, Bob! The users ought to know how to read JSON!” Well thought-out UIs actually help the user find things and they don’t need to change all the time.
Unfortunately, even though we engineer with code, reading long streams of text is actually a terrible user experience by itself.
Good user experience should hold the user’s hand through the process so they don’t need to sift through a haystack of configurations.
VS Code has the power of emacs and an autogenerating UI which maps to the configuration files. To me, that’s the easy way out—make the UI map one-to-one with the data underneath, obviating the burden of considering the UX of each configuration path, and missing out on the benefits of good UX.
As far as I know most configuration can be done through GUI. You have both JSON and GUI views of the preferences. It seems the GUI is automatically generated from the JSON-schema that validates and gives autocomplete to the JSON editor.
I respect your experience and opinion, but you’re missing the point here.
VSCode delivered a fantastic user experience. It reached a product market fit other editors could only dream of (let alone any editor based on browser tech). This, must have required engineering smarts and very thoughtful collaboration between product and engineering.
Hard engineering = delivering the best possible outcome within tight constraints/requirements. I’m sure the VSCode team was trying to hit a very specific number in responsiveness, startup time and memory usage.
Yes, compilers fall in that category as well as modern chip manufacturing (single digit nanometer fab FTW!). Those folks are the unsung heroes. However, we cannot discredit the fantastic product experience of VSCode. It was not possible without some innovation, clever engineering and a well thought out architecture. (I am sure they learned from Atom’s failings)
Update:
> The VSCode team didn't have to make Electron. They got to use it, though. Along with the various lessons learned by the Atom project.
Yes! They are progressively a huge leap forward, built on the contributions of others before them. Now the VSCode framework has spawned a new generator of tools (such as Obsidian).
> Atom was built by incredibly smart people, who had full control over the platform and several years of head start, and they were still out-engineered by the VSCode team at every turn.
The VSCode team didn't have to make Electron. They got to use it, though. Along with the various lessons learned by the Atom project.
I dunno, I'm not convinced that a compiler or OS is a harder problem than an IDE. "Turns out humans are complicated and making computers do things they want is hard."[1] UX design is not only a whole complicated field in its own right, it imposes additional technical constraints that interlock with UX ones in complex ways. (E.g., VS Code's plugin API is architected the way it is partly to limit the ability of a plugin to accidentally add latency in the places that are most critical for usability, or otherwise undermine the editing experience.)
Obviously some compilers and OSes and IDEs are larger in scope than others, but all else being equal, if I had to pick one to write and it was really important to deliver something good, I'd rather do one of the former.
(This applies to any kind of GUI program that needs to be very feature-rich in order to meet the needs of power users, and where user productivity is at a premium because those users spend all their time in it. IDEs are just the subcategory of that that we as programmers most often use.)
[1] https://wiki.alopex.li/LetsBeRealAboutDependencies#yeah-but-those-are-all-big-complex-gui-programs https://wiki.alopex.li/LetsBeRealAboutDependencies#yeah-but-...
I think a "compiler" isn't too bad — certainly easier than an IDE by a long margin. An optimizing compiler OTOH, can be a bit of a beast. Because the optimization passes self-interact, on every line of code, repeatedly, any small error in the passes can dramatically amplify (or cancel out!). It means the level of quality of the optimization passes is (by necessity) much, much, much higher than plain old SW. It's just ... very tedious.
I’ve written hobby compilers, hobby kernels and hobby IDEs.
The later was by far the easiest for me.
Maybe you’re brain is wired differently but I can only speak from my own experiences.
It seems like not really an apples-to-apples comparison anyway. Designing a text editor, there are just a lot more subjective questions.
The technical issues are also sort of different, fixing latency problems is a totally different type of problem that developing a framework for how an optimizing compiler should do its thing. Both valuable and hard things to do, hard to come up with a metric to rank them.
> In fact there have been excellent IDEs around for decades before VSCode came along.
I wonder what everyone's favorite IDE is. I don't think I could put my finger on a single one and claim that it's the best.
I really liked Lazarus (for Pascal), because it's perhaps one of the snappiest tools I've used for a language that also compiles pretty fast. Though it's certainly not as modern or smart as JetBrains products.
I rather liked NetBeans (for Java and PHP), because it's truly free and can be relatively lightweight. The interface doesn't feel overbearing either, you get some framework/library support out of the box and even projects like jMonkeyEngine built upon NetBeans for their game engine editor. It's like libre JetBrains lite, but struggles with larger projects.
I rather liked MonoDevelop (for C#), because it felt like the .NET equivalent of NetBeans, was lightweight, functional and just worked without getting too much into your way. That said, it never really got as much attention as other products in the space (Visual Studio or JetBrains Rider).
I acknowledge the success of Eclipse (for Java and other languages), because I've seen that platform be used for anything from being an IDE for programming, to niche modeling tools and graphical programs. Some also swear by its incremental compiler (for Java), but personally it feels sluggish to me (like running JetBrains IDEs with low RAM) and its stability is inversely proportional to how many plugins you have.
I acknowledge the success of Visual Studio (for .NET and other languages), because when your platform is a walled garden, you can make sure that the experience is focued on doing things within it decently (like XCode, I guess), even though sometimes the IDE felt similarly heavy to JetBrains offerings and was more opinionated towards what you can do with it, as well as the platform support.
I like JetBrains IDEs (IntelliJ and their other offerings), because they have perhaps the best autocomplete and code refactoring/inspection tools out of any other solution out there. The plugin ecosystem is rich, the language support is pretty great, the experience across various languages is similar enough. Though the obvious downsides are large system requirements (you need enough RAM and project indexing is slow, having 6 Java projects open and 2 front end projects open is a pain), bad run configurations (that making sharing run configurations across Windows/Linux really hard because of interpreter selection for scripts etc.) and confusing menus (due to how much functionality there is, a bit like Visual Studio, though the menu structure changes for different IDEs from them as well). The benefits still outweigh the negatives and so I pay for all their tools.
I like Visual Studio Code as a text editor (for anything really), but it feels like some of the refactoring and code editing support is lacking, especially when working with enterprise codebases. You can get pretty close to a fully fledged IDE with it, but at that point you're also trading some of the performance and lighter footprint away. Regardless, most of my projects have a .workspace file in them and I use Visual Studio Code together with JetBrains products.
I like other attempts at feature filled text editors as well, be it Fleet (though was a bit too unfinished last I tried their preview), CudaText (really interesting project with lots of nice features) or anything else, really.
At the end of the day, there is no single best IDE, just different ones that are suited for different tasks.
Edit: actually decided not to include the nano vs vi/vim discussion, since that's not super relevant to the discussion. Either is fine, I like the simplicity of nano more.
>I really feel you’ve over doing the compliments by a long long way.
Well, that shows the bar for Web Developers these days are so low, that even VSCode could even be on the list of "one of the greatest pieces of engineering of our time."
Web developers are so abstracted away from everything, their understanding of computing and software is really hurting the industry. And the sad part is not only are they the majority in software development, they are also the most well paid and vocal.