34 ms·

The Era of Visual Studio Code

• koolba 6y ago
  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.
  • BossingAround 6y ago
    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.
    • jhoechtl 6y ago
      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.
      • RMPR 6y ago
        For markdown I don't use/need a plugin, with entr[0] and Pandoc you can emulate the live preview feature easily, without even needing a browser. 0: http://eradman.com/entrproject/ http://eradman.com/entrproject/
    • Teknoman117 6y ago
      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))
      • abhijat 6y ago
        Have you tried out the vscode-clangd plugin?
  • kushalpandya 6y ago
    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.
    • stu2b50 6y ago
      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.
      • laqq3 6y ago
        > Sublime is great but it updates once every other blue moon for a reason. I like both editors (VSCode and Sublime) and just want to point out that Sublime Text 4 is in semi-public alpha. It is "semi-public" in the sense that the download link is given in the Discord channel, but anybody could join it. For nine months or so, there has been a new release of ST4 every 2-3 weeks. Development is definitely ongoing (though I'm quite happy with ST3 as it is).
        • spurgu 6y ago
          What are the main selling points of v4 vs v3?
        • jopsen 6y ago
          I was a huge sublime fan, but it seems like the plugin eco-system moved on. At the end of the day, I go where the plugins are.
          • square_usual 6y ago
            (Not a sublime fanboy or anything, just curious) What kind of plugins do you use that aren't on sublime? I was reluctant earlier for the same reason, but after I installed sublime-lsp I didn't think I needed much more.
  • deleted 6y ago
    [deleted]
• pjmlp 6y ago
  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 https://youtu.be/IUMWFExtDSg?t=1146
  • ssivark 6y ago
    You probably mean something in the ballpark of 3x or 300%, rather than 300x?
    • pjmlp 6y ago
      See the linked video, it is already on the specific moment they talk about it.
      • ssivark 6y ago
        Yes, I did, which is why I’m specifically mentioning it.
        • pjmlp 6y ago
          I stand corrected, did not read the chart properly.
      • Arnavion 6y ago
        Yes, and your video shows Electron at ~700% of UWP C++ while React Native for Windows is at ~200% of UWP C++. That means an Electron program's reference set is ~3x as large as a RNfW program's, not 300x.
        • pjmlp 6y ago
          I stand corrected then.
  • gimboland 6y ago
    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.)
• paulpauper 6y ago
  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.
  • gimboland 6y ago
    OK, but this article is about Visual Studio Code, which is a different product.
  • deleted 6y ago
    [deleted]
  • w0m 6y ago
    i take it your an Ed guy.
    • Skunkleton 6y ago
      Ed is for writing scripts. Real programs are made on hand crafted punchcards.
    • scottmcdot 6y ago
      To be honest, when I first heard my colleague say they were using "visual studio code" to develop their Python apps I thought they were repurposing some Microsoft vb.net IDE and hacking it to mesh with Python
      • zo1 6y ago
        The same team that does a bulk of the "python" language service dev for VS Code did the main plugin for python development in Visual Studio. It was actually pretty good. https://github.com/Microsoft/python-language-server https://github.com/Microsoft/python-language-server https://github.com/Microsoft/PTVS https://github.com/Microsoft/PTVS
  • HelloNurse 6y ago
    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.
• lxdesk 6y ago
  If VS Code is an endpoint to incremental improvements in text editing, then the next big thing that appears will involve a revolutionary approach.
  • colordrops 6y ago
    Text editing is mostly a solved problem, and arguably done better elsewhere. VS Code makes improvements on interacting with particular languages / DSLs.
    • Scarbutt 6y ago
      better elsewhere Like in unix tools or other text editors?
      • colordrops 6y ago
        emacs and vim are super efficient, nearly infinite in keybindings, and fully programmable and extensible.
        • makapuf 6y ago
          Except not doing ctrl-c ctrl-v easily. Or standard keybidings. I wonder if an offshoot with standard keys in a terminal based on vi would work (really simple and native, I used simple mode alas it almost were transparent but not quite. )
          • RMPR 6y ago
            > Except not doing ctrl-c ctrl-v easily. Or standard keybidings. I used to think like that but imho when you learn Vim registers it totally makes sense, plus if you're using it in a terminal emulator you can use ctrl-shift-c ctrl-shift-v. Now about Emacs I don't have much experience, but Doom-Emacs and Spacemacs use the System's clipboard by default.
    • megameter 6y ago
• nemothekid 6y ago
  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.
  • bigdubs 6y ago
    The Go extension is now maintained by the Golang team: https://golang.blog/the-vs-code-go-extension-joins-the-go-project https://golang.blog/the-vs-code-go-extension-joins-the-go-pr...
  • vips7L 6y ago
    It would be killer if the sublime guys could just support the vs code extensions.
• nurettin 6y ago
  > 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.
• laksdjfkasljdf 6y ago
  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?
  • Kaveren 6y ago
    > Microsoft is selling you into the IDE, in small portions what are they selling me
    • valvar 6y ago
      Their ecosystem.
    • Scarbutt 6y ago
      Github and Azure integration.
  • a_t48 6y ago
    I was already bought into their IDE environment. :) VS Code runs much better than their old offerings.
  • Kranar 6y ago
    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.
• Scarbutt 6y ago
  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.
• andrewstuart 6y ago
  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.
  • Clubber 6y ago
    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.
    • lostmsu 6y ago
      VS 2019 without ReSharper does not feel bloated at all.
      • Clubber 6y ago
        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.
        • bouke 6y ago
          Exactly this, VS2019 running inside Parallels Desktop is so slow. I’ve tried optimizing to no avail.
• devit 6y ago
  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.
  • ralphc 6y ago
    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.
• RealStickman_ 6y ago
  It's interesting how vim and emacs both retained their popularity during the last few years. Probably because they cater to one specific audience.
  • temporama1 6y ago
    Who?
    • hatmatrix 6y ago
      Nerds.
      • el_dev_hell 6y ago
        And people with fewer options. There are plenty of situations where you are stuck with Vim or Nano (Vim usually comes out on top if you're doing anything non-trivial).
    • RealStickman_ 6y ago
      1. People who do most of their work in the terminal and don't need a full IDE for editing their config files. A subset of those imo would be those who have lots of different servers they ssh into and like to have the same (or similar) editor everywhere. (vi and vim for example) 2. They like a more lightweight editor. Being able to configure anything relatively easily if you know what you're doing would probably also fill into this. 3. People who primarily use keyboard based navigation and like not having to move their hands as often. I count myself to this group, as I recently discovered doom-emacs and absolutely love the keybindings it has. (vim keys for navigation. Functions are handled by the spacebar and a key combination)
• xeromal 6y ago
  Anyone know why I struggle to read the font on this site? It feels super light?
• api 6y ago
  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.
• cek 6y ago
  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/86671 & https://github.com/microsoft/vscode/issues/1012 https://github.com/microsoft/vscode/issues/1012
• sixstringtheory 6y ago
  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.
• k__ 6y ago
  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.
• TYPE_FASTER 6y ago
  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/ 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.
  • sdevonoes 6y ago
    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.
    • pseudalopex 6y ago
      Most JetBrains IDEs have almost equivalent IDEA plugins.
    • vbsteven 6y ago
      IntelliJ ultimate edition + other language plugins is basically this. Most alternative Jetbrains IDEs like Rubymine and Webstorm are just Intellij with a predetermined set of language plugins. I have Ruby, nodejs and related plugins installed into my Intellij and it works exactly the same as Rubymine or Webstorm.
    • signal11 6y ago
      With IDEA I can do Java, Web, SQL, Python, Rust.
    • Constellarise 6y ago
      IntelliJ Ultimate with the plugins does this but it's not quite as smooth as the individual IDEs.
• valvar 6y ago
  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 https://github.com/neoclide/coc.nvim
  • ohazi 6y ago
    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 https://github.com/dense-analysis/ale
    • deleted 6y ago
      [deleted]
    • toupeira 6y ago
      ALE also supports CLI linters and formatters, LSP support only came later and is entirely optional.
  • agrippanux 6y ago
    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.
    • RMPR 6y ago
      > a good theme like gruvbox Let me guess, Theprimeagen? While Fugitive is very good, I've yet to find a better Git client than Magit, that's actually one of the things that make me reluctant to switch to Vim full time.
  • triyambakam 6y ago
    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
• ishcheklein 6y ago
  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.
  • throwawaybutwhy 6y ago
    > 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.
• sdevonoes 6y ago
  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?
  • nahtnam 6y ago
    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
• jiripospisil 6y ago
  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 https://code.visualstudio.com/docs/remote/remote-overview [1] https://youtrack.jetbrains.com/issue/IDEA-226455 https://youtrack.jetbrains.com/issue/IDEA-226455
  • stefan_ 6y ago
    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.
    • necubi 6y ago
      Not to be that guy, but emacs has had this for years via tramp.
      • xxpor 6y ago
        As someone who used tramp and switched to VS Code, it's absolutely not the same thing. The difference is plugins work on the remote side of the connection without having to be aware they're in a remote connection. VS Code makes this work by having an agent running on the remote host. For the first time I actually got autocomplete and code jumping working without a horrendous amount of effort.
• switch007 6y ago
  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
  • mas3god 6y ago
    Compared to jet brains though? Id argue its a huge improvement.
    • no_wizard 6y ago
      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?
    • switch007 6y ago
      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.
• bigpeopleareold 6y ago
  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.
• dividedbyzero 6y ago
  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.
  • jakear 6y ago
    > 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!
• qppo 6y ago
  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.
  • stu2b50 6y ago
    >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.
    • qppo 6y ago
      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.
• redisman 6y ago
  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.
  • ImaCake 6y ago
    >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.
    • int_19h 6y ago
      The problems with Conda usually have to do with its activation. If you manually activate whatever environment you want before starting VSCode, it should pick it up fine. But if you don't, and then later you pick a conda environment, it'll try to auto-activate it in the terminal for you - and this part is brittle, because anything else using the terminal can interfere with it (and vice versa).
      • ImaCake 6y ago
        Yep I think you are right. It does seem to be when VScode tries to auto activate it. This github issue had a solution in the form of adding an empty string for a particular option in settings.json [0]. This fixed it for my mac install. I can't remember what I did on windows to fix it. 0. https://github.com/microsoft/vscode-python/issues/4434 https://github.com/microsoft/vscode-python/issues/4434
• rock_artist 6y ago
  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.
  • mirthflat83 6y ago
    He addresses that on his footnote.
• Waterluvian 6y ago
  > 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.
  • city41 6y ago
    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.
    • RMPR 6y ago
      > If I ever find myself in an editor without some kind of vim mode, I'm totally hating life. Most of the Vim emulations are subpar (slow, lacking features), not to mention when they redefine some keybindings[0], so my life still ends up to be miserable. 0: https://rmpr.xyz/Internationalization-with-Doom-emacs/ https://rmpr.xyz/Internationalization-with-Doom-emacs/
• highpost 6y ago
  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/technical-interviews 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.
  • RMPR 6y ago
    >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.
• SparksAndQuarks 6y ago
  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.git-graph https://marketplace.visualstudio.com/items?itemName=mhutchie...
• NewOrderNow 6y ago
  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.
  • dewey 6y ago
    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.
    • NewOrderNow 6y ago
      I agree. It is definitely here to stay.
• yepthatsreality 6y ago
  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.
  • mlboss 6y ago
    Biggest selling point for Sublime Text is speed.
    • yepthatsreality 6y ago
      Yes agreed. It’s miles ahead of VS Code in that department but I thought that was fairly obvious and overstated, so I withheld the criticism. It always interests me when others don’t include speed in their requirements.
  • voxl 6y ago
    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.
• EugeneOZ 6y ago
  Author is working on it's own code editor, so article is more than biased.
• rcarmo 6y ago
  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.
• frusciante29 6y ago
  Like a lot of MS products, VSCode has dived head first into UI complexity. Coupled with an Electron-based foundation, I don’t see a great future for it.
• bitwize 6y ago
  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.
• nickjj 6y ago
  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.
  • orange8 6y ago
    What are some of all these pretty critical and interesting components you mention?
    • est31 6y ago
      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.
      • orange8 6y ago
        If I've never heard of those plugins, they cannot be that critical or even interesting.
        • jen20 6y ago
          Live Share is probably _the most_ interesting feature of the entire editor, and is not open source or usable with VSCodium. See [1] for further links. [1]: https://underjord.io/the-best-parts-of-visual-studio-code-are-proprietary.html https://underjord.io/the-best-parts-of-visual-studio-code-ar...
• et1337 6y ago
  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.
• macinjosh 6y ago
  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.
  • zeroxfe 6y ago
    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.
    • cutler 6y ago
      It's not like you have to give up Vim anyway considering the good-enough VSVim plugin gives you most of the Vim basics. Personally I have found JetBrains' Vim plugin to be the best.
      • theCodeStig 6y ago
        I've tried vim support extensively in VSCode, IntelliJ, and Emacs. The vim plugin for VSCode is sorely lacking; particularly with macro support. For my use case, it's unusable. The vim plugin for IntelliJ is slightly better. It's usable, but I still find it lacking. In my experience, the best (by far), is Evil for Emacs.
        • cutler 6y ago
          I think it's unrealistic to expect a plugin to provide macro support.
      • macinjosh 6y ago
        If you use vim to its utmost a plugin that emulates vim in another editor pales in comparison. It is like learning to play an instrument. Some people stop digging into it when they learn to play a few tunes but the true beauty comes out when you really invest the time into it.
• munificent 6y ago
  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.
  • richiebful1 6y ago
    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.
  • TheRealDunkirk 6y ago
    I've given VSC several months. I just went back to ST3. I find it refreshingly clean.
    • keb_ 6y ago
      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 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.
• Zenbit_UX 6y ago
  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.
  • bigDinosaur 6y ago
    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.
• stephc_int13 6y ago
  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.
  • shmoogy 6y ago
    I really like working off a thin client - less heat and more battery on local device. But I see your point
• catern 6y ago
  >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.
• willbw 6y ago
  I find this post along with the comments in "A Picture of Java in 2020" https://news.ycombinator.com/item?id=24551390 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.
  • paxys 6y ago
    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.
    • hocuspocus 6y ago
      In practice we're pretty far from that. Most statically typed languages, even fairly recent ones that took on LSP compatibility early, are still better supported by JetBrains' IDEs.
    • spullara 6y ago
• spongechameleon 6y ago
  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.
• catern 6y ago
  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.
  • nayuki 6y ago
    "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 https://en.wikiquote.org/wiki/Jamie_Zawinski
  • gilrain 6y ago
    Surely even crusty greybeards would use a dedicated email client like mutt?
    • catern 6y ago
      No, Emacs is notorious for having many email clients, and many users enthusiastically read and send email through Emacs. Likewise, there are email clients for vim, though I presume they're relatively less popular.
• DigitalSea 6y ago
  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.
• izgzhen 6y ago
  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.
• g5becks 6y ago
  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.
  • chiffre 6y ago
    JavaScript/TypeScript ?
    • g5becks 6y ago
      Webstorm crushes vscode in every way. Especially for typescript.
      • chiffre 6y ago
        That is a subjective opinion
• no_wizard 6y ago
  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
  • deleted 6y ago
    [deleted]
  • kccqzy 6y ago
    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.
  • mixmastamyk 6y ago
    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.
• jasoneckert 6y ago
  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.
• mixmastamyk 6y ago
  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.
• ossftw 6y ago
  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.
• grumple 6y ago
  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.
• davidblue 6y ago
  > 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...
• barkingcat 6y ago
  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.
• TedDoesntTalk 6y ago
  > For big complicated desktop software, has any other category ever had so much movement? Um... web browsers? Is that a trick question?
• fmakunbound 6y ago
  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.
• j4ah4n 6y ago
  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
• Fishysoup 6y ago
  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)
• deleted 6y ago
  [deleted]
• adrianlmm 6y ago
  I've heard from some of its employees that Jetbrains is on panic, they are losing tons of webstorm and pycharm customers to VSCode.
• kahlonel 6y ago
  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.
• Eric_WVGG 6y ago
  > 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)
• nine_k 6y ago
  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.
• mikece 6y ago
  I’m surprised that the product hasn’t been renamed “Microsoft Code” but there is still time for MSFT to drop the VS reference.
• oshea64bit 6y ago
  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.
  • RMPR 6y ago
    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/ https://onivim.github.io/
• jtxx 6y ago
  jetbrains for work, vscode for personal
• iamAtom 6y ago
  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.
• syspec 6y ago
  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
• 013a 6y ago
  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.
• rbosinger 6y ago
  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.
• l8again 6y ago
  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)
• deleted 6y ago
  • z3t4 6y ago
    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.
• matthewtovbin 6y ago
  Excellent article!
• devilduck 6y ago
  The editor wars will never end. People will always stan their favorite editors and drag the editors that did not work for them personally. Time is a flat circle.
• rawoke083600 6y ago
  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 ?
• deleted 6y ago
  [deleted]
• deleted 6y ago
  [deleted]
  • twblalock 6y ago
    > 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.
  • detaro 6y ago
    Let me guess: You missed the "more" link at the bottom of the page and instead launched into a conspiracy theory?
    • MetaDark 6y ago
      Haha yep, I was commenting around 2AM. I probably should have just gone to bed.
• seanwilson 6y ago
  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.
• mraza007 6y ago
  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.
• know_prashant 6y ago
  Really well researched and written. Kudos!.
• bengalister 6y ago
  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.
• aichi 6y ago
  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?
  • Liquid_Fire 6y ago
    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.
• itprofessional4 6y ago
  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 https://github.com/cdr/code-server [2] https://console.cloud.google.com/marketplace/details/techlatest-public/vscode-cloud-ide https://console.cloud.google.com/marketplace/details/techlat... [3] https://aws.amazon.com/marketplace/pp/Techlatestnet-Visual-Studio-Code-in-browser/B087RHWHNT https://aws.amazon.com/marketplace/pp/Techlatestnet-Visual-S... [4] https://azuremarketplace.microsoft.com/en-us/marketplace/apps/techlatest.vscode-cloud-ide?tab=Overview https://azuremarketplace.microsoft.com/en-us/marketplace/app...
• kwanbix 6y ago
  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.
• rvz 6y ago
  As far as those that are on macOS are concerned, Nova seeks to challenge VS Code. [0] [0] https://nova.app https://nova.app
• tierriebin 6y ago
  I try to stay away from Microsoft as much as possible. They are not to be trusted. They had to kill the open source Atom editor first to achieve this success.. I hope more dev's refuse to blindly follow the herd, so there might be a change MS won't lock us in for good.
• marcus_holmes 6y ago
  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.
  • higerordermap 6y ago
    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.
    • marcus_holmes 6y ago
      like I said, I love Vim. If we could change every other editor to be like Vim, then the world would be a better place. But we can't, and my muscle memory isn't refined enough to hit "ciw" in Vim to edit the current word, and not in any other editor. Especially web input controls, that tend to react badly to hitting ESC halfway through an edit :(
  • varbhat 6y ago
    Try https://github.com/visualfc/liteide https://github.com/visualfc/liteide for Golang. Also,you can try emacs.
    • marcus_holmes 6y ago
• mesid 6y ago
  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.
• nicholasjohnson 6y ago
  It is amazing, also, how they have integrated vim into Visual Studio Code! Sooo awesome!!
• ChicagoDave 6y ago
  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.
  • kwanbix 6y ago
    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.
    • ChicagoDave 6y ago
      My text only use cases have dwindled so I really don’t use either that much. I do have a lifetime license for ultraedit when I need it.
• blumomo 6y ago
  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.
• skocznymroczny 6y ago
  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.
• frankzen 6y ago
  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.
• paul_f 6y ago
  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.
• pmuens 6y ago
  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.
• bregma 6y ago
  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.
• jarjoura 6y ago
  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.
  • robenkleene 6y ago
    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.
• deleted 6y ago
  [deleted]