Sure, you all have root password in your computer. Unfortunately, I belong to a lower race: the corporate developer. I work in a Windows 7 machine, don't have root password and there's a big wall called proxy around me.
I didn't know about VSCode before this HN post, but I was trying to use a new editor instead of Notepad++. In my 5 minutes comparison match between Atom and VSCode, Atom was knocked out in the first minute. To quickly test a new general code editor I just want 3 "simple" things: column selection, regexp search and replace, and a python mode.
Atom: got the regex, must install a column mode extension, need to install a ntlm proxy authentication downloaded from (argh!) Sourceforge, configured it after some google searches, failed to install the extension because it needs a compiler. Ops, just spent 30 min for my 5 min test. Can't spend more time playing with a code editor, must go back to work.
VSCode: Download the portable version https://code.visualstudio.com/docs?dv=winzip and unpack it. Just works.
You've got a new fan VSCode!
VS Code is a code editor. It has IntelliSense (not text-matched autocomplete, IntelliSense), debugging support, git integration, parameter hints, go to definition, code peek, etc. (http://code.visualstudio.com/docs/editor/editingevolved). The goal is to give you code editing features with the speed and simplicity of a text editor.
They're both free and lightweight, so I use them both pretty much daily.
I find Notepad++ is great for handling really large files and changing UTF encoding or line endings. VS is good for pretty print formatting code/XML to be more readable, among many other non-text things such as debugging.
If you need to do those things often, there are specialized tools, including in the command line, and for batch processing.
No need to do it in an editor.
In OS X and Linux (and Windows with Cygwin etc) there are several command line programs such as unix2dos (line ending conversion), iconv (encoding conversions) etc for doing just that, so that you don't need to do it in an editor and can even automate the work.
That said, I use too many editors for my own good. (I'm active in both main churches.) Neither Notepad++ nor TextMate are competitive with VS Code, Emacs, or Vim, IMO, and I use all five regularly.
Also, do Windows editors have that Alt+drag rectangular text selection feature that most/some OS X apps have?
On the contrary we have mostly consistent ctrl/shift + arrow behaviour over the last 15 or more years(I don't know before that). :-)
Are you saying Windows has consistent Control/Shift + arrow behavior?
OS X is pretty consistent about this too, though Control+Arrow moves between Desktop Spaces, not related to text, but you can modify a lot of system/app shortcuts from Preferences -> Keyboard -> Shortcuts.
Mac using colleagues explained that it was because the applications where written using different toolkits.
Problem is: until at least 2012 not even Apple was consistent about it.
Not sure if other editors do this too.
It may be that the customisation is a bit less polished (eg, no way to quickly set themes) and the user community is less developed. But it really does everything and much better than the others IMHO.
 - http://www.pspad.com/en/
And if you can believe it, Adobe actually produces a decent code editor: Brackets.
Wikipedia: "Visual Studio Code is an open source source code editor"
For the 1% of devs working on system level stuff we provide VMs or separate physical servers that aren't joined to the corporate domain and don't have sensitive information on them.
But honestly, giving a developer non-admin privileges of their own (as in their work environment) computer is like giving a carpenter a rubber hammer to hammer nails. I find it insulting.
Consider the irony of that, when one of the approved pieces of software is a compiler. We can make our own programs, hello!?
Really? This question from a security engineer on Hacker News? I can tell you've never developed on Windows because (as pointed out) Visual Studio needs root level permissions to operate. The level of access a user needs to run my program has nothing to do with the level of access I need to build the program. They are completely disjoint.
I can't even imagine writing a kernel hardware driver in a corporate setup if they at subjecting development environments to strict lockdown.
I don't recall needing it for debugging though, even when attaching to a running process (was your process started as a different user?)
Thing is, why do developers create software that needs administrative access to the os? I wish that I could simply download a zip of the software, extract it and run.
And already this wouldn't work: most software is distributed only through an installer. Heck, even PortableApps website distribute their portable products using an installer!
This applies to any OS being used.
If you are an external, might additionally need to have an employee sitting with you in case you are trying to use something business critical.
Why? Tell me, if you were a system's administrator in charge of 10.000+, would you risk it? That's everything that's bad in corporate culture, but as you get big, it happens.
Atom has Sumblime-Text-style column selection using (on Win) CTRL-ALT; it works very well and feels familiar for people coming from Sublime Text (which has been very popular for years now).
Actually, column selection is one of the things where I prefer Atom to VS Code (I love both editors for different reasons).
But maybe you needed some particular style of column selection?
My last attempt at this was to install kdiff on a corporate machine
I used Notepad++ for a few years before Sublime, I eventually switched because of the lack of Notepad++ support on Linux. I didn't want to have to remember the commands/shortcuts for two editors (and I avoid using Vim if I can).
I'm not really sure how a half-IDE/half-editor intersects with corporate concerns, to be honest.
What do you mean by python mode? Just syntax highlighting or something more advanced like an integrated REPL?
There's a few other nice-to-haves, but those are the big ones.
FWIW since you mention Notepad++, Zeus is another Windows based programmer's editor with those three features.
Sounds like an undeserving environment for a developer. Why not vote with your feet?
To vote with my feet I'd have to accept an income downgrade of about 30%, higher risk of unemployment, and even then (heck, I'm looking for something like this right now) it's hard to find.
It's a tradeoff, for sure.
But also most companies are waking up to the notion that trusted network models are not effective. It just takes time to change.
1) Making it so that employees can't take vacation at times that are particularly bad for a project because they're 'entitled' to it. This was already frowned upon (we always did get to use our vacation eventually, so it wasn't so bad), but now it's in writing -- which is good, rules should be written.
and, more importantly to the megacorp:
2) Eliminating owed vacation from their books & marginally reducing cost. Now if somebody quits or is canned, they're not owed a payout. I'm guessing the average employee will probably also take a couple of days less than they did under the old system, yielding a further savings.
(Note that I've since found out it's better to support SSPI and NEGOTIATE)
That's before we even get started with SSL interception -npm/node and possibly Ruby's gem don't use the system cert list.
The answer is not to vote with my feet (because there are lots of reasons to stay) but work to make things better for developers in more restricted environments. Geez, wait til you startup kids go work for the Government one day ;)
>Why not just set up atom to use your existing corporate proxy?
"Many of these text editors support proxy servers, but none of them that I have tried support NTLM for authentication and if your corporate proxy is using NTLM they simply cannot connect to it. Or lets say not directly! Actually the only solution I have found is to use a software called CNTLM that can act as a proxy server itself and behind the scene it can connect to another proxy server that is using NTLM." 
In my previous job, the company runs a MITM proxy, it broke SSL checks for package managers. You ended up having to disable SSL checks and load up company-issued certs.
I asked whether we can find a solution to this issue on the company forum, as there are other developers and data analyst whose life can be made easier if this just works, the response I get was: "just download them manually", I kid you not.
The first difficult thing is to discover that I have to install the sublime-style-column-selection package. So it failed and didn't researched more.
It's not just me -- we had a trainer giving a class, & this guy lived and breathed Atom and he couldn't install an updated version of an existing package from our network either. His solution was to tether his phone.
I love linux/unix, but the problem always was with the lack of an awesome text editor cum IDE, yep there is eclipse but it is too clunky, I do not like sublime as it isn't FOSS (call me crazy), gedit took way too much memory, geany is fast and mean but the UI sucks plus functionality isn't that great.
Enter VSCode, code writing feels amazing again, not the functional part, but the actual manual part.
I do not like vi because I primarily was learning web dev and I didn't really get my head around using vi effectively and still learn the web dev, so I am not a emacs/vi superstar as I have heard that both of them are fine text editors.
but for the people like me who don't or can't use terminal based editors, VSCode is quite literally the best.
The new Che project of Eclipse does seem promising, but the last time I tried installing it, it took around an hour, consumed GBs of my bandwidth and still nothing.
I am still Waiting for the day I'll be able to program in its entirety on my android device.
I used Atom but it is too slow, it is surprising that VScode and atom share the same ancestor but one is blazingly fast and Atom is so damn slow.
Edit: yep vscode didn't transform coding on unix, it merely changed it to some extent, and why the downvoting? point out where I am wrong, I'll get to learn!
Vim and Emacs are still superior if you want to put the time in, and both have non-terminal interfaces. They can also be both customized to be whatever you want them to be, there's not really a limit to their functionality except what plugins are already written. Ditto for Atom, though of course, it does seem to be more web based for the moment (though Atom does have great plugins for Go, Nim, and I'm sure a bunch of other languages).
In the grand scheme of things, tools like compilers, debuggers, interpreters, other command line tools (like completion servers), etc..., matter more than editors anyway.
Edit - for the record, VS Code seems great. But it's not revolutionary.
TBH, not every developer is willing to become a power user or interested to learn an IDE instead of the language itself. Being someone who worked on VStudio alot and now on Linux/Mac based tools, I can safely say that Microsoft tools are Developers friendly most of the time. It's good they are introducing same touch for Linux/OSX community.
verbs like ci" (change inside ") which deletes inside the current double quotes and leaves you in insert mode are pretty easy to get used to. dd deletes a line and puts it into the yank register so you can paste it somewhere. u undos an action.
using a plugin with visual studio is pretty king to get the best of the IDE and the most common vim functionality.
Classic SO answer on why vi: http://stackoverflow.com/a/1220118/1772636
edit: here is another classic why vi answer that is a bit different http://www.viemu.com/a-why-vi-vim.html
Humans have this funny thing as they grow older - they look at a thing, maybe try it out for few seconds, and then immediately determine it's too difficult and it will take forever. They rarely bother to spend actual five minutes, to the clock. If they did, they might actually have learned something.
25 minutes of deliberate practice - a single Pomodoro - is enough to become acquainted with several of Emacs features - like, navigation by semantic units and incremental search and autocompletion. You won't get proficient in that time, but it's enough to rewire yourself to actually start using it when writing code. Which will then lead to you becoming proficient while doing your regular, billable work.
Seriously, set up a Pomodoro timer, sit in front of Vim or Emacs, and try to practice a few things. You'll be surprised how fast you can learn.
(And yes, I did that, so I'm not talking out of my ass. I actually almost doubled my Emacs productivity once in 5 pomodoros - in 2.5 hours - two of which I spent watching Emacs Rocks videos, two on rewriting s-expressions with Paredit, and one on multiple-cursors.)
To reach a level of skill where using emacs is easier/faster/better than something like intelli-j (for instance) requires significant dedication and repetition.
Far, far more than "a few hours".
Not the parent, but I've spent a significant amount of time with pure vim. I use vim bindings in everything from my web browser (vimium, vimperator) to my WM (i3 & kde vim navigation bindings), to my text editors & IDEs (atom, VS, sublime)
Despite all that, I still find using pure vim to be ineffective relative to just using Atom, Sublime, VS or whatever with vim bindings. I may have internalized the most basic navigational concepts, but the more advanced / esoteric shortcuts that are essential to use vim as an exclusive editor are still ones I need to look up - and that's not counting stuff specific to vim packages liked nerdtree.
At the end of the day I'm sure you could always argue that I should have practiced differently / better / more or whatever - but to what end? There are plenty of full featured text editors on all platforms that do everything I need. Why on earth should anyone force themselves through dedicated practice just to learn the intricacies of a 20 year old editor?
Not parent but I have. I still would recommend something else for all the stuff I work with.
That said, it is amazing, I just believe in my line of work people are better off spending time learning an ide, esp refactoring, efficient search/ replace as well as how to enable block selection.
I sometimes do to. In particular, when that stuff is Java or C# - it's hard to beat the support IDEs gives you there. So I personally opt to switching said IDEs to Emacs keybindings instead.
(Also, one could argue that you need IDEs there mostly as crutches to support the weak language, but that's a topic for another day...)
> better off spending time learning an ide, esp refactoring, efficient search/ replace as well as how to enable block selection.
Refactoring - if you mean semantic transformations supported by your IDE, then yes. See above. But for search/replace and block selection no IDE beats the convenience of Vim and Emacs. They simply can do that better and more naturally (along with plethora of similar things helping with selection and navigation). And this is exactly the type of thing I was talking about in my previous comments - you can learn both under one Pomodoro if you focus solely on it, and then normal work will quickly take you to proficiency.
For example, do productive programmers tend to use Vim or is it the other way around? It's hard to find the causality.
I really don't think that's what's behind my attitude toward code editors, though. I've been writing code for thirty-odd years and making a living at it for twenty-five, and I've spent the majority of that time working on dev tools. Compilers, mostly - but I've written a couple of editors, too, plus a debugger, a couple of linkers, an assembler, you name it. So I have had a lot of time to think about tools, and have been lucky enough to get several chances to put my ideas into practice.
I'd have trouble remembering the names of all the different editors and IDEs I've used over the years. Emacs and vi are ubiquitous now but that was certainly not always true, and on some platforms, particularly embedded environments, using anything but the officially-blessed toolchain can make your life unnecessarily difficult. I have learned to get my work done using whatever tools happen to be on hand. That's meant a wide variation in the kinds of features which are available, the specific control-key bindings, the details of the build environment, pretty much anything you can imagine - so I have learned to rely on the basics and ignore the rest.
I find it far more frustrating to deal with a sophisticated tool that isn't working quite right than a simple, brainless tool that does the job but requires a little extra manual labor.
I'm not here to play with editors, after all, I'm here to build software, and the editors are just a means to that end. Time spent learning sophisticated editor features has to justify itself in time reliably saved using those features, which has to be balanced against the time wasted when they don't work quite right or when you have to go dig through the documentation to remember how to use them, times some distraction multiplier for the fact that you're thinking about the tool instead of the job you're using the tool to do. In my experience, there's been too much change and not enough actual need for sophisticated editor features to justify their cost.
Even if a sophisticated editor could allow me to perform certain editing tasks more quickly, that wouldn't change my overall productivity very much at all, because I spend far more time reading and thinking than I spend typing or editing. I type fast enough already; it's my brain that needs to be accelerated, and the best way I've found to do that is to eliminate distractions and focus as much as possible on the problem I am actually trying to solve.
I wrote a simple terminal-based editor a couple of years ago, including all the features I use every day and none that I don't, and I've been using it for all my daily programming work ever since. It's an unabashedly personal expression of my own taste, so I wouldn't necessarily recommend it to anyone else, but I like it and feel good when I use it. It's nice to know everything there is to know about the tool, so that I never have to think about it or try to remember how it works. Perhaps some day I'll be working in some new environment with some new toolchain and I won't be able to take ozette along with me, but that's fine - wherever I go, I'll be able to get my work done with the tools I find there, because I'm comfortable doing my job with the basics.
1 - http://www.github.com/marssaxman/ozette/
I was thinking more of the sorts of automatic refactoring tools some people really like to use in their IDEs. I haven't found that such tools save enough time to be worth learning how to use them.
Very few programming workflows are so complicated that it is simply not possible to do something without first creating your own highly customized environment within Emacs. However, very, very many programmers do have a lot more fun screwing around with customizing their work environment (editor, window manager, shell, etc.) than using that environment to get actual work done (myself included).
Which is not to say that Vim and Emacs aren't awesome tools, I just wouldn't generalize anything about anyone based on the tools they use.
You will see that after you learn how to use Vim you won't want to use anything else to edit text, you emails, browser and word processing will be in Vim.
You only think that because you have used it and became accustomed to vstudio. As someone who has used vstudio, eclipse, atom, intellij, vim, emacs - I can safely say that vim and emacs are far more 'developer-friendly' than the others.
The sole concept of IDEs specialized for one language makes me cringe.
Of course an IDE like QT Creator does many things better.
But it's a tradeoff always.
Can you explain this a bit? I don't see that Sublime, VS Code, Atom, etc. were made for one language, at all. As a little background, I've used vim for a while, then switched to Sublime Text, and am just trying VS Code. I find Sublime/VS Code/Atom to be far easier to customize than vim.
I was indeed referring to Eclipse and Visual Studio.
From what I observed around me, for some reason, people don't use these to edit:
- Files written in a in-house domain-specific language.
- Configuration files.
- Makefiles and project files: vcxproj, sln ...
Actually, I observed that these kind of IDEs discouraged people doing the above things, giving them the impression that it's not "real development" (I suspect that this is, in part, where the bizarre term "scripting language" comes from, but this is another debate).
That is the power of vscode, it provided a good enough way to play with code, yes not outright innovation, but an awesome text editor nonetheless.
I'm not saying Vim and Emacs are the be-all (I program mostly in R, so RStudio is my main tool), only that VS Code hasn't changed anything fundamentally. It's just a good editor.
Or, hell, even Kate?
Of course you can do a lot with extensions, but at least in Atom's case they break a lot for me.
Bear in mind that the claim wasn't that it's better in some ways, but that it's sweepingly better than the stuff that came before (and Atom wasn't even mentioned by the OP, which is funny--I mean, I don't use it, but it's obviously in the conversation).
Uh, if you edit tens or hundreds of text files per day, it's a game changer.
EDIT: that's only the most trivial benefit of git integration
I guess the killer feature of VS Code is multiple cursors (Ctrl+D). I only know of Sublime Text and Atom who also have this feature on Linux, not sure about Kate. Sublime Text is closed source and not gratis, Atom is slow and buggy.
No, not built-in. They both have plugins, and allow you to set the key shortcut to whatever you please.
That they are not built-in really doesn't matter though. All these editors revolve around plugins, and it's common practice to save your preferences on github or the like so that it's easy to use the same settings and plugins on every machine.
I think you have to wait a few minutes, then it gets activated.
> No, not built-in. They both have plugins, and allow you to set the key shortcut to whatever you please.
That's too complicated for me. Last time I've tried to set up vim and emacs to my liking it was a mess: A lot of copying and pasting around random code, changing configuration files I didn't understand, ...
Granted, Atom, Sublime, VSCode etc. are easier to start with because they expose customization through JSON files instead of a custom programming language. But if someone where to tell you that they didn't understand how multiple cursors worked in VSCode, you would tell them to learn their tools and send them a link to the relevant page of the documentation (if that).
If you know your editor, adding functionality like multiple cursors is easy. The greatest strengths of extensible lightweight editors like VSCode and Emacs, is that such functionality is only a package away.
No that's the thing: I would tell them to press Ctrl+D, simple as that. Multiple cursors in Sublime Text, Atom and VSCode are intuitive and it's the first time in an editor that I actually use them.
I want to keep on top of my current branch, what is untracked, what is unstaged and staged, quick diffing, etc. It actually helps a lot with productivity since I don't have to actively query for this information when it's all in one screen.
If I used another editor, I would like to have similar features. Maybe it can be done, but I am quite fluent in magit already, and one major thing keeping me from moving to another text editor for my current projects (if it actually mattered.)
The only 'plugins' I use are a keyboard shortcut (cmd+space) which puts me in a terminal window and rupa/z for jumping into a project directory.
Another scenario: You type `git status` and see a file called `src/a/very/long/path/file.c` hasn't been staged yet. Now you need to type that file path for git add or git diff. Takes more than 5 seconds, but it's just a simple click on a + symbol in VS Code.
works on linux/mac too
little features like ctrl+P which lets you to jump to functions rather than play with files, I didn't know any other editor which allowed this feature to be there.
It is a great way to code if you don't want or can't use vi/emacs, I don't have the luxury to learn all the nook and corners of emacs, I started using Go plugin in vscode and today I have built go apps and written partially completed book: http://github.com/thewhitetulip/web-dev-golang-anti-textbook...
i tried giving vi a chance, but nope. couldn't bear it for more than a day, large webapps require a UI IDE, vscode > everything else I tried till now
Literally every other popular code editor supports some form of "go to symbol".
Go ahead and downvote it, but after all every programmer worth his/her salt does realize that the choice of IDE/text editor is ultimately a personal opinion, so long as you as a person are comfortable using it, that is good for you, it does not make a tad bit of difference to anyone else in the world.
I think the parent was talking about modern text editors such as Sublime, Atom, Brackets etc.; Vim and Emacs are completely different beasts (note: I love both).
Within the category of modern text editors, VS Code is in my opinion revolutionary in several ways - I will give you three examples
The first feature that I find "disruptive" is the way VS Code offers a standardised interface for debuggers, hence debugger plugins are much easier to create - and you can see that VS Code already has debugger plugins available for many languages: https://marketplace.visualstudio.com/vscode/Debuggers?sortBy... the availability of such plugins for Atom and Sublime Text is not nearly as good.
The second aspect where VS Code changed the game is the clever way it leverages Electron (the framework it's made with, Atom is made with Electron too) - while creating clever workarounds to known Electron bugs - e.g. VS Code, unlike Atom, does not suffer from this bug https://github.com/atom/atom/issues/10720
The third aspect is the git integration - since Atom is sponsored by Github, you would think it has the best git integration out there - but VS Code has gone the extra mile by giving you a great user-friendly UI interface for staging and committing (yeah, I know, anything more complicated than git add -A requires the command line - the fact is that nearly 50% of all the git commands I type are git add -A, LOL).
PPS I totally agree with you about the importance of tooling. But e.g. if you have a debugger that does not have an interface to your editor it becomes hard to set breakpoints. So the editor needs to integrate with your tools and VS Code is great at that.
I don't need an instruction manual to figure out how to close VSCode.
Oh but that's needlessly hard and annoying? Well so are Vim and Emacs.
> I don't need an instruction manual to figure out how to close VSCode.
To close GVim, you click the 'x' in the upper right/left corner, like any other window.
Alternatively, you could just close the terminal window.
I still use emacs for quick editing, moderately complex search-and-replace in limited numbers of files (for when I don't want to bother with perl), and a handy scratchpad for throwaway things, but I don't intend to do a lot more software development in it anymore.
I like being able to use other languages for editor extension, having a competent graphical and text layout layer with image support, and quite frankly I find emacs development tedious now.
So... Do I need a few more years of time to "get it?"
I am not aware if that feature is available in other editors, I tried light table for a short time, but it isn't getting much attention since they are working on some other product. ctrl +P transformed the way i write go code, now I dont' have to bother to remember which file stored what, just ctrl +P function name, as i know what all functions I am using or I can just scroll!
I do, however, agree with you. Mostly because you can customize Atom and VSCode to have all the same benefits as Emacs and Vim. Except for running them in the console, which I know some people like having the option of doing.
I mean, what is going on, why people tend to blow VSCode out of the water about how good it is!? I mean, ok it is cool, has some really nifty features I would like to have in some X editor, but no way in hell it is as game-changing as people state. And I really can't see my self switching from Vim to VSCode. Even when I decide to use GUI Editor (I am not HC vim user, for some environments I use it, for others I don't), it is Sublime. I ditched Sublime for Atom since December, and on OS X, it is working very well. Not blazingly fast and smooth as Sublime, but it is far far better than before.
But all in all I am not biting that Electron base for text editor. I mean ok, JS is cool, web is the future, flexible cross-platform solutions are the thing, but it still isn't comparable to native stuff. At least to me, it is getting there year by year but still a long way to go.
For my personal project (which is in Rust) I use Atom, which is new for me, but I find to be really impressive. Both its plugin system (which allow for all the extensibility and in my case Rust support) is fantastic, and I don't know where the complaints about speed come from (it's far lighter than IntelliJ, obviously).
I've really been enjoying Atom when I do use it, and don't see why I'd switch to VSCode unless it had better support for Rust. But perhaps I'm missing something.
I am a bit turned off by VSCode, it's workflow by the looks of it feel strange to me. Yes I've tried it, yes it was in beta, but right now I am having only Vim on my Mac. Uninstalled Atom this morning, got a little bit frustrated.
It just feels like a web app, I mean it basically is. And when I dragged it to AppCleaner, it is so heavy, 260MB+.
I want GitHub to stream line it. If other were able (look at VSCode for example) that GitHub can. That things leaks memory very now and then. Sublime feels rock solid and blazingly fast compared to Atom, and there you see the difference between native and web. Those fractions of seconds are important when you have app like text editor, especially if used by developers and geeks. :)
And remember, no one is saying you have to use these programs. Console editors and IDEs will still be here. This is another option for people who want it, which has turned out to be a lot of people.
When my IDE stops working one morning because yesterday's system crash resulted in a plugin being unable to load properly and subsequently peppering me with dialog boxes or worse, crashing the IDE, then it is definitely clunky.
When I just want to do code browsing across 500,000 lines of code and it takes 2-3 seconds every time I hover over a symbol just to populate the object list, that is slow.
Your experience sounds great. My experience has been that every IDE configuration falls into rot after 6 months to a year or so and the whole thing needs to be deleted and reinstalled. That's also slow.
Meanwhile, vim+ctags+gdb have given me years of reliable service. More than once I've had an IDE collapse into a pile of errors and turned to my trusty basic tools, only to leave the IDE as the steaming mess that it turned into for weeks or even months as I just didn't need that browsing or inline debugging power at the time.
I'll be an Emacs user for life, but I am currently recommending Atom to people wanting to move away from language-specific IDEs and dabble in a text editor, because it has enough of the Emacs nature while not being too daunting.
Emacs has functioned as an "advanced text editor" for at least 20 years and probably longer. There's a very common misconception that Emacs is a "console editor", but the reality is that when you first launch it in a windowed environment you get something that looks an awful lot like Sublime, VSCode & Atom: a text editor window with a menubar and toolbar similar (yes, it's not perfect!) to what you'd expect from any other editor native to your chosen platform.
The time investment involved in learning how to use it is also considerably less than implied elsewhere in this thread. In fact I really doubt that it's significantly more than you'd have to spend educating yourself about any other "advanced editor"'s configuration, keybindings for non-obvious actions, extension mechanism, etc. It's easy enough to learn the (admittedly unconventional) keybindings for a handful of common things like opening and saving files when you have the menus to refer to, and by default it'll even open a buffer containing clickable hyperlinks to helpful things like tutorials. I still haven't seen an editor or IDE with better built-in help.
Even configuring Emacs isn't all that hard: there's a built-in interface for installing packages, most of which will pretty-much auto-activate once installed (i.e. less need to mess around with elisp), and for changing configuration there's "customize", which is a nicer way to change configuration variables than just editing a JSON file. When you do have to start writing some elisp code (you'll almost certainly have to write a little) the documentation is superb and there are more than enough resources on the web to help you. A programmer who is already familiar with a dynamic language like JS will probably have less trouble learning elisp than a C programmer did 20 years ago.
These days I'd say the most confusing thing about Emacs is working out which of the many competing packages you should choose for whatever it is you're trying to do. Age is working against it here, because what was the almost-universally-recommended package five years ago - for which you'll get plenty of helpful google search results - has often been superceded by something better.
But with a handful of plugins installed (yasnippet, helm, projectile, auto-complete) it's (IMO of course) still the best editor out there.
I understand that VSCode has changed coding for you. But how has it changed anything for the 92.8% of developers that don't use VSCode?
I haven't loved working with a tool so much since Delphi 6, it has plugins for everything I want to do, they work really well, I can have a project open and use multiple languages seamlessly, it's extremely customisable.
It's right up there with Linux in my "tools I wouldn't want to live without" category.
That said as a lightweight alternative when I don't need an IDE I'm very much liking vscode, it's a strange world when my favourite linux editor is made by microsoft.
A big factor is probably that I started programming using Jetbrains tools (except some c++ in codeblocks before that). It's so awesome everything else just sucks.
The problem is when i want to try some language that is not well supported by IntelliJ. No matter how cool the language is i get frustrated by editors like sublime/atom/emacs.
Let me turn the question around. What does VSCode do that Sublime, Atom, Emacs and Vim doesn't? Nothing.
The switch to Atom was actually pretty simple. Many Emacs shortcuts still worked, and setting up a linter and multiple cursors was easy.
Another thing is that there are GUI versions of both Vim and Emacs. You don't, however, have a console version of VSCode, which means you can't use it over SSH. This isn't that big of a deal for some people (maybe even most), but for sysadmins logging in to a server to do some work, access to their editor of choice would be great.
The problem with your statement, and why you receive downvotes, is that you reveal that you really don't know what you're talking about.
That's probably because those two platforms have already had superior tools for a long time. On Linux, vim reigns supreme. So it is easier to revolutionize code editing on Linux
The fact that you think that VSCode is revolutionary compared to vim, only displays your ignorance. Vim can do the exact same things VSCode can, and it has been able to do so for quite a bit longer.
I'm a heavy IDE and Emacs guy though, so perhaps I'm missing something.
Light Table might deserve the term "transformative", but I didn't find it usable enough to rely on.
Nope. Visual Studio Code was created before Atom. Although both VS Code and Atom are based on Electron and are both Chrome-based. VS Code does seem to be stealing Atom's thunder as what they say 
Atom = 2014
VSCode = 2015
Am I missing something? Sure, MS had some preview online IDE thing before VSCode came out, but that's not the same thing obviously.
Visual Studio code was originated from "Monaco" team, dated back in 2013.
Eletron (formally Atom-shell) was dated in Feb-March 2014.
That makes sense. I use things from the future all the time. /s
The source you cited even says this!
I prefer Intellij so much I use CLion instead of Xcode on OS X and Visual Studio on Windows 10.
I can build .exe's that run fine on Windows this way and executables that run on OS X (using the X-Code supplied compiler and build tools that CLion depends on for OS X). I can get qt, wxWidgets and GLFW UIs working for both platforms from the same code base with CLion.
I've noticed this happen especially on big projects/files.
Also, sometimes the auto complete popup is very slow to appear and causes lag.
I don't use many GUI text editors and have not compared VS to Atom/sublime, but for me this is just unacceptable.
So instead you decided to use an electron based editor?
Don't get me wrong, Atom and VSCode are both great. But "memory efficient" is not a word I'd use to describe either.
Sure, if you find fault with and don't use the 14 other options, the one you're left is, quite literally, the best.
VS Code is not FOSS, either, I believe? [EDIT: Wait... it is open source. Must have missed that announcement]
I do like it a lot, though. KomodoEdit is pretty neat, as well. Even though it's closer to a full IDE, it feels very responsive. If either VS Code or KomodoEdit added something like paredit, I'd switch to them.
As someone who got through engineering school on green screens and vi, I eventually cobbled together a massive collection of Vim plugins... to make it work, essentially like ST, with a side bar, tabs, fuzzy searching, and all of that. Once I discovered ST, I was happy to pay the measly $60 whole dollars for a license which I could run on all 3 desktop platforms, across half a dozen computers.
VSCode magically fits this one narrow set of definitions to reshape the field of coding on Linux and Mac? Are you even serious, or is this just trolling? You're going to let the fact that it's closed source remove it from your list? I obstinately ran Linux on the desktop for 19 years, but I know a good, pragmatic deal when I see it, open source or not.
Also: Doesn't ask me to save my unsaved files when I close the editor. Sublime Text called this feature "hotexit", but in Atom there's no way to disable it.
Can you elaborate?
It is a great replacement for notepad, but that's what it is. wrong tool otherwise for a large project.
>ut why spew uninformed bullshit when any semi-knowledgeable linux/unix dev knows that vim and emacs run laps around vscode, sublime, etc
Because the rest of the entire world doesn't share your opinion.
if you really use vi for a large scale project then salute to you! I am fine with vscode, I want to get things done rather than learn my editor (read spend valuable time learning nooks and corners and the million shorcuts which I'd have rather spent on building my application product or startup)
I even wrote a short tutorial about writing webapps in golang: http://github.com/thewhitetulip/web-dev-golang-anti-textbook...
all thanks to vscode + go plugin
Honestly you sound very misinformed. Vim is capable of pretty much everything that VS code is capable of and then some.
Nice claim, now do you have data to back up your claim? Meanwhile let me ask you a few quick questions.
Okay, how do you automatically organise imports in emacs?
Can you jump to the declaration of an expression with just pressing one button? How do you extract functions or values quickly without having to fiddle around with copy paste? If you use a language with type inference can you quickly view the inferred type by pressing a single button?
All my billable work the last 3 years have been with Emacs (ok, except for the last month, that has been Atom). I have never missed the functionality of an IDE.
I usually try to keep my source files and config files smaller than a few hundred megabytes. Sounds like you might need more specialized tools for your unusual approach to editing source code.
Didn't ever understand people who used it for the things Notepad++ could do back then though.
I realize that's a pretty harsh statement but that really sounds like the worst possible way to go around writing code.
The patterns of use take a little getting used to coming from Atom or Sublime, but VSCode gives me real static-language IDE features that "just work" simply by installing the Go plugin. Comparable functionality in Atom requires multiple plugins and I never managed to make a few of them work at all. The control+tab file switching quickly became second nature.
I never had the performance issues some people have with Atom (on a 5 year old laptop), but VSCode feels a little quicker at some things. Nothing to write home about.
I love Atom's direction (plugability, a well-cultivated ecosystem, discoverable configuration), but for sheer usability I'm sticking with VSCode for now.
It just works. The workflow is fine for me, git integration is a plus. Compared to Atom, I don't need to try plugins to get descent functionality.
Actually, it's the first MS product I use in like... 10 years?
I used to be an emacs fan, I used to be an Eclipse plugin developer, I used to be a WebStorm user... now I prefer VSCode.
I love how it makes the best of screen real estate compared to WebStorm
I have actually been really impressed. It's fast and responsive, even on Linux, and the TypeScript tooling is fantastic. I think with a bit more UI work (like vi keybindings) it could potentially become my preferred editor.
Having said all that, many of the unimplemented parts in extensions across the board come down to limitations in the VSCode extension APIs. I've been watching the VSCode team, and they're actually pretty sharp and welcoming, too, so most issues should be ironed out, given enough time. (Although it hasn't been prioritized at this point.)
However, the appropriate unit of measurement to describe how long I've been using Vim is "decades", and through observing (but never seriously using) the attempts to emulate it over the years, I've spent a lot of time thinking about what it would actually take for an app to really support Vim keybindings—aside from actually just being Vim. Unfortunately, even if we assume a team with infinite resources intent on achieving perfection, there are several things about Vim that prove to be irreconcilable with the way almost every interested app is implemented. The only way around this will have to come down to Vim users either collectively participating in some "Great Vim Shift", or just ignoring the remaining gaps entirely and continuing to put up with incomplete emulations.
Visual Studio Code would be the editor, Omnisharp the Intellisense platform, I think they were also developing some sort of common debugging interface, etc.
It would be a lot nicer than the current Visual Studio setup, where the installation drags in 6GB of cruft.
Of course, this would involve an internal power struggle between Visual Studio Code and Visual Studio proper, and I hope VS Code wins :)
In the C# talk at Build , they demonstrated visual debugging using VS code. It was pretty awesome.
We built this extension sample to show the capabilities of the extension API - https://github.com/alexandrudima/vscode-vim.
We've done some work to improve the API for the extensions. We'd love your feedback. https://github.com/Microsoft/vscode/issues/3600.
I've thought about doing a vim implementation for years where motions are expressed as composable functions projecting from text range to text range with commands taking a list of text ranges, mostly because I'd like to whether non-text based motions (e.g. AST based or generalized cursors) would work. I like VSCode and expect to move over to it so I've thought about starting my project but the scope of doing a good implementation is daunting.
Congrats on the 1.0 release, VSCode is a great product.
The ideal VIM mode plugin for VS Code would do the same.
I'll take a look at making something similar.
I wish I could stick to one editor but there is always some editor that does a way better job at a particular task. Each editor has its killer feature. I have tried turning emulation of emacs/vim on many editors to provide consistency and its never been really good. Thus I have several "default" keybindings in my head.
Because of this I try not to rely on too much magic or customization that any editor provides and instead write lots of shell scripts (Bash, Groovy and Python) to do code generation and to find things.
But I'm always wondering ... could I be more efficient by sticking to one.
VSCode will probably just become another editor I have lying around. Probably for Typescript.
I think switching between Emacs and Vim is a good idea but more a question of keeping your hand/mind coordination flexible for different input paradigms. I'd be skeptical that they're really that different in terms of efficiency for a task, but I'd say learning both really well will make you more efficient in general.
(I actually keep both open; Java files I edit in Eclipse, but pretty much anything else goes to Emacs. I also have Emacs keybindings and Emacs+ plugin installed in Eclipse.)
The only thing that trips me up really is switching from vim to one of those others, and I sometimes run vim modes in those.
One of the major reasons I keep vim in my repertoire is that it is on every machine I have to SSH into and it can handle monstrous files. Vim is also better at editing config files (SSH ops stuff) in general since you are typically manipulating and not creating content.
That said, learning new keyboard commands is sometimes a real PITA. When I'm tired, I sometimes find myself trying to close Visual Studio or Sublime Text with :q.
For a task I'll use whichever editor needs to least amount of learning, re-learning, and fiddling.
It amazes me that there was a time where I learned Emacs just for Clojure.
 Every few years I'll try an IDE. I've been doing this for over twenty-five years. I've yet to find one that I like. Over time, my bar for "what I like" has fallen to the point where now it's "it doesn't crash when loading a simple one file program." 
 The C/C++ "version" of Eclipse. I tried using it to help browse a C++ application at work. It never worked.
My favorite place to work right now is on OSX. It's Unix so you get all the command line goodies plus it has a very good GUI and great tools in the graphical environment as well (I'm thinking of XCode). Plus, I think Objective-C is pretty neat.
5. SCOPE OF LICENSE. The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not
* work around any technical limitations in the software;
* reverse engineer, decompile or disassemble the software, or otherwise attempt to derive the source code for the software except, and solely to the extent: (i) permitted by applicable law, despite this limitation; or (ii) required to debug changes to any libraries licensed under the GNU Lesser General Public License which are included with and linked to by the software;
* remove, minimize, block or modify any notices of Microsoft or its suppliers in the software;
* use the software in any way that is against the law; or
* share, publish, or lend the software, or provide the software as a hosted solution for others to use, or transfer the software or this agreement to any third party
So with the msi installer a different license?
It's noticeably slower than Sublime on a good workstation and it has a bunch of very minor annoyances that Sublime simply doesn't have.
When you encounter these annoyances dozens of times a day, it really turns you off from using it because a good editor should make you happy, not infuriate you.
For example, the way VSCode deals with multiple buffers and the sidebar is really poor. It tries to be cute and keep the sidebar's state in each buffer, but it's done really poorly and constantly disrupts you.
Is this a jab at Atom? I like this.
So I believe it's a jab at both.
However, even after setting wrappingColumn to an arbitrarily large number, VS Code greatly outperforms Atom. The click accuracy within a long line is off by several characters in my quick test, but good enough.
I was never comfortable using Atom because it would grind to a halt whenever I accidentally opened any files with long lines. VS Code just may be the first MS product that I'll use on my Mac on a daily basis. Looking forward to testing it out on a couple projects.
It's also, just very slightly, too slow. By too slow I mean that everything I do just lags a tiny bit; I can type characters faster than it can put them on the screen, clicking in the file browser is not instantaneous, etc. It's a small thing but it really bugs me. I guess I'm just spoiled by ST3. :/
I would like to know what potential gains could come from using a GUI text editor.
I miss things from Emacs sometimes so I keep it around. I miss macros, I miss some of the more stellar Emacs packages (Tuareg for OCaml and Cider for Clojure in particular) but I do a lot of editing nowadays in Atom and Code.
My experience so far is that extensions on VSCode "just work", but they're scarce, and difficult to discover and install.
My experience with extensions on Atom is that they are numerous, cover a very wide variety of needs/wants, and that they frequently break when the main editor updates. I haven't been able to install/update the Omnisharp extension successfully since the npm debacle a few weeks ago.
I dabbled with Spacemacs, and it seems nice, but I couldn't work out how to migrate my existing extensive org-mode customizations without digging deep into the Spacemacs package management system.
* Intellisense - this is *incredible*, and it works out of the box with VS Code
* Git stuff is pointy-clicky integrated...this is a big time-saver for me, since I check stuff in just a few times a day, and I don't have to think at all about git commands after writing a bunch of C#. I can click my way through instead.
I'm also pretty comfortable using a mouse--i.e. I don't feel the need to keep my hands on the keyboard at all times--because, when it comes down to it, I spend a lot more time thinking than typing.
I use VS Code when I'm working in one codebase because it has a nice tree view of the files and has a pretty nice "working files" feature where you can easily switch between files you're working on (I usually have five or six files I'm working on at any given time; sometimes in Vim I'll open them all up in a terminal multiplexer and switch between them, but that can end up frying my brain). Seeing the tree structure just helps me visualize the codebase better. VS Code also has a really nice search feature that searches through every file in the folder you have open (I could just grep but it's convenient to click on a result and go straight to the line in that file)
Git integration in VS Code is pretty sweet as well; it has a really nice diff viewer built-in and it's easy enough to add and commit changes (I still use the git cli for branching, rebasing, etc.)
I use Vim whenever I'm in a terminal to edit various files here and there. I feel a little faster in Vim when working on one file, and I do like a lot of the shortcuts/commands a lot better in Vim. Vim also has much better find/replace with regex, and it's a lot easier to extend Vim.
I guess what I'm trying to say is that I don't see VS Code as a full-on replacement for Vim, but a different tool that I use in a different way.
I use byobu as a multiplexer, and I just like it's shortcuts for switching between terminals and tiling etc better than vim's tab shortcuts.
- Having the full type info for every single thing in the code with simply hovering over it (not just when typing)
- Ability to "peak at definition", to get a little interspersed window with the definition of functions etc,
embedded right into your editor.
- Out-of-the box file tree with single click opening, and window management (I use a lot of powerful vim commands, but window management just was too much for my head).
- Maybe something more I've forgot.
In general, the out-of-the box experience is so much greater than vim. I know you can replicate most of the above with a super-fancy setup, but I just don't find the time to get my head around much more than http://github.com/fatih/vim-go and a few personal .vimrc tweaks.
Now as others have mentioned, I just hope for a more feature-complete vim-mode in VSCode.
What I'm really looking for is something like Atom's Neovim Mode , allowing me to use Atom's flexible UI (hey there, CSS) with vim's modal editor, wealth of plugins, and my config (keybindings, etc...).
It might be nice editor, but it hide to much information for my taste. "You need to setup a launch.json file", well fine, but at least be a little more helpful than that, don't just open an empty file. Starting the debugger either crashed the editor or do nothing, but never informs me as to what the issue might be.
At this point Vim and shell is easier to get started with.
Why not both? I use Emacs+evil. I use VS+VsVim. I don't understand why this isn't the preferred mode for everyone? Pick the best environment/shell/whatever, then make sure it uses vim for actual text editing. Problem solved.
Microsoft is doing some very cool stuff these days so props to them. "VSCode has done the thing that nobody expected MS to do, change the way code was written in Unix/Linux" though? I believe the term irrational exuberance applies. Let's not get carried away here.
There are some days when I wish that I had enough money to employ a small army of "thought leaders" to "organically" shape discussion on Internet Message Boards.
Alas, my single upvote will have to suffice. ;)
This post prompted me to try VS Code and I must say, I'm really impressed. There are still a few rough edges but I do understand it's still young.
As soon as the Vim extension becomes usable I'll be on board I think; things like visual selection don't appear to work correctly at the moment.
g; and W/E support would be nice (as someone said on this thread, everyone has a different subset of Vim they use ;-) )
Oh. ex-mode is not something I'm planing to implement.
They are often a lot easier to do with Cmd+Shift+P.
It was an uphill slog and I've put it aside for now, but I will keep coming back to it. In the meantime, I feel like I will just have to go to windows and Visual Studio 2015 to get the working experience.
Visual Studio is still a bit nicer with regards to handling all the .fsproj stuff, and visually showing you the order of your files, but the editing itself on vscode is definitely on-par with it.
> Today, we’re excited to report that more than 500,000 developers actively use VS Code each month.
I've come to expect Microsoft is just going to do that, and it needs to be accepted if you want to use their stuff. Fighting against it is a recipe for a headache. Unfortunately (or fortunately) this editor is great for Typescript and that's my passion.
A competitor should show up in this space and make me even happier.
That said, the available extensions seem pretty bare. I don't see many mentions of REPL interaction, and there are no extensions for many languages. I'm glad it's getting attention, but I suspect it'll take a decade of loving care to bring up to the level of most people's emacs configuration. I see no reason that couldn't happen more quickly, though.
I have been using it a lot lately to write snippets of code in C or HTML.
emacs on the console at the servers is unbeatable. the daemon just sits there, and I can fiddle with bash, config files, php, css with ease.
As a full IDE, eclipse is still the best for PHP development. Has a myriad of plugins that make it so powerful: pdt, phpunit, code/lib/docs integration, per project configuration, etc. its amazing!
Now, for js and scss, its a bit more complicated. and this is where vscode is shining for me. I had to learn a few command bindings and a few things are weird for me still: ctrl+x yanks the line, on linux middle click isn't default, "folders"...
One of the things I like the most tho, it is written in a language I can understand. Aptana used to be a favourite of mine, but because I couldn't write any code for it, I was limited to bug reporting and waiting. This being in typescript, I feel I can look into the source code and write a PR.
I yet to explore it deeply, but i'm sure it will just get better and better.
have a nice day!
Here's a blog post with bit more info on setting up VS Code with the pre-release version of the C# extension (and debugging support): http://www.tattoocoder.com/setting-up-asp-net-core-debugging...
When I have an idea or want to use a new editor tab as scratch space, it's really important to me that whatever I put there isn't lost if I exit the editor. When I close the tab, sure, ask me if I want to save it somewhere. But when I close the editor itself, I want it to reopen and restore everything exactly as I left it.
The last thing I want to deal with is coming up with a path and filename when the editor can easily create a temporary file and map some unique id to it for later use until I tell it explicitly to save or discard it.
I would also like to see the C++ intellisense plugin that's under development improved further. I've found it to be a lot slower than QtCreator at indexing symbols.
I still spend a lot of time on remote systems, so vim is a big part of my tool box. There's also the weight of Atom. If I'm working on big project, I get it all loaded up and work in Atom, but if I just need to tweak a thing or two in a file, vim is still my go to.
I asked because so much people say "If you're serious about development then you need a serious editor: you should learn vim/Emacs because it's a once in a lifetime investment that will boost your productivity beyond what other tools provide". This mantra doesn't match my own experience.
I think Atom and VSCode provide 3 main advantages over vim: the out of the box experience is better; using a GUI offers a more powerful user interface; extensions are easier to install and work better.
It's like comparing fish and zsh: Atom and VSCode are more like fish; vim and Emacs are like zsh.
Getting used to things, takes a little bit.
Is there such a feature now?
Switching between multi-file projects should be almost as easy as switching files within a project.
Overall, fairly impressed with 30 minutes of play.
It's to the point now where the conversations are becoming like this:
"I really like this new tool from Microsoft"
"But Linux is just as good if you install X, Y, Z and are willing to spend hours learning the intricacies of the kernel"
"Embrace, Extend, Extinguish"
As developers, can we all be happy that Windows users are finally getting a nice range of really wonderful tools to use?
Not everything in computing needs to be a great ideological battle, especially when the majority of us are writing simple line of business apps in our day to day careers.
I like working with VS Code, although I'm just starting out.
But one thing bugs me: Is there a way to get VS Code to automatically complete the tags and add the closing tags?
I know about intellisense, but I fail to activate something like autocomplete. I know about Intellisense, but I'd like something that, for example, just fills in <div></div> when I am writing <di + ENTER.
I know some other editors have that feature and I know it got disabled in VS Code because of problems - can anyone elaborate and explain why?
Now I'm on Atom, which has the best VIM support I've ever seen (haven't tried evil-mode, though) and seems to support a similar feature set. They felt about the same speed, too, on this 2013 Macbook Air.
Regardless, other than that quirk, I did really like VS Code, and I'm glad there's more competition in the free editor space :)
I use Atom a lot, but I wish it had support for the goto column command (pipe), proper search/replace support (it does weird things with the trailing slash, deleting words at the end of lines, and macros.
And it's working. Despite having messier code, performance problems, and fewer Vim features implemented, it has over 3x as many users as the next most popular one listed in the VSCode extension gallery.
Anyone have any luck creating an extension with mac classic? Tried manually adding the theme (following their doc) and no luck. Then created a msft account to try and create a package to install it as an extension and couldn't get past 401 on create-publisher.
Back to sublime for now, but I'll keep an eye on this one.
I'm really hoping they look into this. I miss the intellisense from VS ever since I moved full time to Linux development.
The editor experience was smooth and fast, with fast intellisense.
I had NodeJS debugging working after 5 minutes reading a VSCode NodeJS page on the VSCode site and clicking a couple of buttons in the editor.
I had a very good initial experience and will use again.
Actually it does. I just opened one C# file and got that prompt to install C# extension, after which everything was back to normal.
> This is intentional. The C# plugin is now an additional install instead of bundled with the installer. https://code.visualstudio.com/updates/vFebruary#_languages-c...
I do wish it had a global symbol search, similar to Sublime's (cmd+shift+r). It's indispensable for code navigation.
If you need a real terminal - why not simply open one and split it next to Code using your window manager?
I would use it at work if I could turn off the phone home feature.
You can: https://code.visualstudio.com/docs/supporting/faq#_how-to-di...
The Future of Visual Studio (https://channel9.msdn.com/Events/Build/2016/B859)
Building Desktop Apps in Visual Studio vNext (https://channel9.msdn.com/Events/Build/2016/B824)
WPF > Silverlight > UWP
All your skills are transferable.
You should take a closer look at it's features.
As someone who uses Visual Studio for everything, I have a hard time understanding how people can get anything done in Atom/Sublime/Notepad++/etc.
This is a classical hammer/nail example. Big red sign to me.
I'm a long time Visual Studio user, and that what you are saying is exactly the problem I see in MS-based developer circles.
Visual Studio is not appropriate for everything. As a matter of fact I don't use it at all for SPA development anymore, but just for server side stuff.
However, to give you few arguments:
1. VS Code and Sublime work on Linux/OSX/Windows and I do work on all three of those. Having the same tool is a great gain here.
2. Editing capabilities of VSCode and Sublime are definitely superior to Visual Studio, to the point that I find myself copying pieces of code from Visual Studio to Sublime, editing it and pasting back to Visual Studio.
3. Speed is not comparable. Visual Studio has become a bloated beast. Sometimes it takes a minute to start it, and then you enjoy busy freeze times whenever you push it just a bit harder than it likes.
All in all, I find my self being much more productive when not using Visual Studio for anything except pure .NET development.
I'm eagerly awaiting a mac version of 4coder (http://www.4coder.net/).
I know it seems like such a minor thing, but I can't have that attention seeker on my screen. Which is a bummer, because I think IntelliSense and its Git integration are clear benefits over Sublime Text. And apart from this issue, I really, really like the UI.
It's just too clunky for my taste.
It's also hilarious that Atom gets shat on for data collection when no one cares that VS does it too. Microsoft can do no wrong, only OSS projects have standards to live up to.
>completely different product
then call them both
emacs and (g)vim have a gui mode.
I'm curious about your answer to this: would you argue that MS should combine Word and VS Code into one text editor?
The Internet Archive seems to have a version listed on the 'Abandonware' listings.
FWIW, I can't figure out how to integrate vim into my workflow, since the text editing controls are different than they are in the rest of my OS.
Have you? Or did you read the placeholder document for a version of vim that isn't anywhere near ready for general release? Because if you know where a branch or a build of vim 8 is, I'd appreciate a pointer.
Sorry if I sounded like I was endorsing it. Did you not read my comment?
Can't say much about it, haven't upgraded yet, but the write up on it looks promising.
Normally I'd be the first jumping on Microsoft products and criticize them but this is a strange statement. Most of what you can find in VSCode runs on nodejs so if you want a specific features in a CLI you don't need VSCode, just install whatever nodejs lib you need and use it from the CLI.