Visual Studio Code 1.4 | Hacker News Reader

Visual Studio Code 1.4

code.visualstudio.com

285 pointsjoseraul152 comments

I've been using VSC as my daily driver for a few months now and it's great -- even on nightly builds. The most powerful features is the tasks.json. Once I learned to use it (the docs aren't good on it), I was able to utilize it to bring a more cohesive experience across many code bases.

I enjoy the fact that it gives an integrated experience and allows community extensions. This is a big change from atom where everything must be cobbled together, hope that it works and will break. My hope is that the MS team will pitch in on the most popular extensions per language and take them to the next level as well.

To top it off, it's one of the most open development processes I've ever seen. They have a clearly defined roadmap, release schedule and even tell you exactly how they work in the wiki (https://github.com/Microsoft/vscode/wiki). It's fantastic to see such a large company open up like this.

Me too. I was a bit skeptic at first. Been a long time vim user but wanted to try something new. I now use it to code Python (I write a lot of it). It works very nicely. So much that I'm in the process of making it the official company -wide text editor for python at work.

I'm curious, what's the thought behind having an official company-wide text editor? The companies I've worked for usually take the route of "leave their choice in tools up to them", which I appreciate.

I never got this either especially when editorconfig exists.

I can understand it, if it's not too draconian. It's nice for some central power to have coherent walktnroughs on how to set up an editor to lint, etc. If another dev wants to use a different editor and can make it work, it's fine by me, but I can't see anyone "supporting" every editor out there.

We needed a good standard setup that fit our needs. People can opt to use something else as long as their code meets the style guidelines. But its easier to use the same tool. We share tips and tricks a lot. That way we improve our workflow as a whole.

Why not vim itself? We tried it. They are more used to GUI centric editors. (shrugs)

While I agree with what you are saying, editor config is a good tool to enforce coding standards across multiple editors (as a bonus it already supports VS Code)

http://editorconfig.org/

Thanks for the link. I will check it out.

As long as it is implemented as a reference standard and not enforced, I think it is a good idea. The official tools are built into the standard PC build that new starters get, and inexperienced new starts would be expected to use it as company documentation will be optimised for the "company standard" tools. Experienced workers should be free to use what-ever they like as long as their output is 100% compatible with the company standard (so doesn't pose any collaboration difficulties).

As part of the Visual Studio Code effort, the .net intellisense was split into a stand lone server to be used from any editor. So I'm going the opposite way, hoping to do more and more in vim and less in VS.

Do you have more details on this? I'd love to be able to use the .NET intellisense in something other than Visual Studio. Thanks!

http://www.omnisharp.net

Omnisharp existed as a community project well before VS Code. It's great to see MS adopt and build on it.

What's the rationale behind forcing people to use an editor (especially a specific editor for a single language)?

They can use anything as Long as the code meets the requirements. But having one official tool makes it easy to work together (in our case).

To get stubborn people to try new tools for a change.

Of course their goal is conformity, easier management (e.g. everybody gets the same linters, code formatters, etc), but the above is a nice side benefit too.

There are tons of people using some antiquated editor and swearing by it, that get amazed when they are forced (by a job) to use a modern IDE and see what it can do for them.

And I'm not talking about Emacs etc -- which can do a lot if you set it up right, I talk about people coding e.g. Java with Slickedit or whatever. Heck even Vim users are sometimes surprised of the convenience (and turn-key use) of embedded debugger, build system, actual AST-based auto-completion, refactoring tools, etc.

Because when we code, actually editing text is the least of our worries, and yet this is what most simple "programming editors" focus on -- it's not like we're building huge ASCII art paintings...

How did you manage to leave vim keys so easily?

I still usa vim a lot, too.

There's a vim key extension that's pretty good too.

I tried it for python but the pip panel almost immediately soured me on it. Whenever I tried typing something in it, it would lock up the whole program for minutes at a time - absolutely atrocious.

I use the regular command line. The VSC terminal is currently not that good.

Out of curiosity, how did you get it working for Python?

Last time I checked, there's no official Python support. There are some unofficial plugins, but none of them have true Intellisense support for Python. (e.g. a la Pycharm, or even Visual Studio Tools for Python).

I know they mentioned they were working in it a few months ago on a HN thread, but I haven't heard anything about it since.

There is a doc page describing the features supported by popular extensions. https://code.visualstudio.com/docs/languages/python

Lots of usage out of the top extension. Not quite to PyCharm level, but getting there.

What are some of the custom tasks you've been using in it? I've found I'm using the integrated terminal significantly more than I ever did with the tasks, but maybe I'm missing something really cool.

I work across many code bases and technology stacks so I use it to standardize tasks such as: build, test, continuous testing, running and linting. Without it I would have to remember the command for each code base.

How is that different to normal IDEs?

On Windows I still prefer the full VS but on OS X Code is great.

Full VS is a lot lighter than it used to be. There is a preview of 15 (confusingly, the next version after 2015) available now.

"Visual Studio “15” Preview 3 (which is different from Visual Studio 2015 Update 3)" - naming is hard.

https://blogs.msdn.microsoft.com/visualstudio/2016/07/07/vis...

Would you expand on tasks.json? Where would I learn more besides docs, are there any specific source files? Does it support passing variables like the current file? Would you mind sharing your tasks.json?

Edit: it looks like an issue about tasks.json presents some good examples: https://github.com/Microsoft/vscode/issues/981

Edit2: and here's the information about variables: https://code.visualstudio.com/docs/editor/tasks#_variable-su...

https://code.visualstudio.com/docs/editor/tasks

Still no auto-import on Typescript. The main reason I use Webstorm over VSCode currently.

What I am talking about:

  * new Foo|

  * <Ctrl+Space>

  * (Automatically inserted by editor top of the file where imports are) import {Foo} from "../relativePath/to/Foo.ts"

  * new Foo(param);|

Working on a large TS codebase without this is absurd. Webstorm is way ahead of VSCode in this area, including things like multiple named imports like:

  * import {Foo, Bar} from "../../foobar.ts"

Additionally, things like refactoring filename that affect the all imports that reference that filename -- not sure if that got added in VSCode recently tho.

Nor "organize import", you're right. I became too used to this in other editors, and now my (manually managed) imports are a royal mess.

There's actually an extension which can do this: https://marketplace.visualstudio.com/items?itemName=steoates....

I have been trying to use VSCode for languages besides JS, like C# and C++, but I've been getting stuck. There's a big opportunity here for someone to write up some brief tutorials on how to use VSCode for other languages. So far, the instructions are basically "Get VSCode. Enable the C++ extension. Enjoy!"

That's not enough, especially when it comes to setting up debugging, which c'mon, everyone needs. The json config file for C++ debugging has zero documentation. Until there is some more documentation besides the extensions readme, it's going to be a little challenging for new users to pick this up and have a delightful experience.

I've been using VSCode for C development fairly successfully, although I don't recall if I ever got the debugging working (due to the same reasons you describe). I do remember getting debugging working was a nightmare and had only minimal success on various different platforms (linux, OS X).

I'd suggest installing the clang extension, this was the best out of the box experience for auto completion etc in VSCode.

Thanks to both of you for the feedback on the debugging options for the C++ extension. I'll pass this on to to the documentation folks to get better launch.json documentation released.

I know it isn't ideal, but in the meantime, the best way to get more info is probably the comments that appear when hovering over the fields in the launch.json file or to open up the package.json file to read the comments about each available field in the schema for the extension. The package.json can be found in the .vscode sub-folder of your user account. On my machine, this would be ~/.vscode/extensions/ms-vscode.cpptools-0.8.1\package.json.

You're not wrong about the documentation for "launch.json", but one thing to play around with is: open it up and use the autocomplete. It helped me discover loads of options that I hadn't seen documented anywhere!

Not sure if this is helpful but I just found their Github repo consisting of the tips and tricks for VSCode.

Github: https://github.com/Microsoft/vscode-tips-and-tricks

Hi, I'm from the VS Code team. We've tried to address this including for C++ https://code.visualstudio.com/docs/languages/cpp.

Can you confirm that you have seen that doc? I opened an issue on github to address the lack of documentation for C++ debugging. https://github.com/Microsoft/vscppsamples/issues/135

Thanks to the awesome plugin from Luke Hoban, VSCode has been great for writing Go. The best feature is the integrated debugging. Granted, it still relies on Delve, so you have the associated madness with taming that beast (self signing certs on OS X? Although that appears to gone now with the homebrew package).

But just being able to type some code, set a breakpoint, run to it, and inspect some locals makes me so much more productive than the Printf driven debugging that so many masochists still cling to.

I felt bad for Sublime. It would be hard for Sublime to compete with MS's free IDE. MS finally decides to take over the open source code editor market. VSC also borrowed many features from Sublime such as its famous integrated package manager and keyboard based shortcuts.

Although you can get the coding support in Sublime through Omnisharp: http://www.omnisharp.net/#integrations

They are providing the same tools they use to drive VSC to many popular editors, including Emacs and Vim as well. It seems that Microsoft wants to give you the best support they can in whatever environment you like!

Those were not invented by Sublime. Lots of older editors have those things, including TextMate and even GNU Emacs and XEmacs. XEmacs had a package manager since the early 1990s.

What Sublime has going for it versus these other editors is ease of use and a much better looking UI. But VS Code has that too, and it's free.

MS just doesn't do anything for free even it appears to be that way at the beginning. It simply tries to woo developers to play in their ecosystem.

For me at least, it still lacks this 'perceived' reactiveness, that millisecond of delay that I don't have with Sublime or vim. I don't know if it's placebo but I have got to use what _feels_ right to me.

This is why we cannot have nice desktop tooling unless it comes from Big Corp getting their revenue from licenses and what have you.

FOSS has spread so much that IT is probably the only industry where people nowadays expect to sell their work using tools they got from others for free.

It is very hard to make a living from donations and books (which tend to get pirated) alone.

I also felt the same for Sublime, but I think they need to innovate much faster if they want to complete in this space.

With Visual Studio Code, I think, MS is trying to reinvent their VS family of products. Since the current Visual Studio is strongly tied to Windows and MS has accepted the multiple operating systems future (I think, in MS roadmap, revenue from Cloud Operations is one of the major factor), it's important for them to have a developer platform which works great on all the operating systems. HTML5 and JavaScript provide this opportunity to create that development tools platform for the future.

It also leaves the possibility open to port it inside browser/cloud with a lot of code reuse. If Internet Speeds improve a lot and computing in cloud becomes a lot more cheap, I think in next 10 years, for typical web projects, developers might just prefer remote development environments, which they use for coding from an App/Browser.

It's good to see that MS didn't wait to first port .Net on major Operating Systems as part of their .Net Core initiative and then write their cross platform development environment on top of that. Instead they have taken the bet on HTML5/Electron.

It's already integrated in various websites. The Monaco editor is used on Azure and you basically get VS Code in your browser along with a console and error log. I believe they also use it in other places like Bing.

Don't feel bad for them. They paved the way for all the great text editors we have now, but they missed the point where they should have opened up their core. If they didn't, there's a good chance Atom, VSC and others wouldn't exist.

Sublime doesn't lag to the point whole words disappear when typing over Citrix. VsCode with VIM over any connection is a nightmare. Sublime handles it like it is local. Big big difference on the main reason you use a text editor, to edit text.

The reason I use it: It's the only Editor that supports debugging JS in Firefox with this extension https://marketplace.visualstudio.com/items?itemName=hbenl.vs...

AFAIK the only editor that really supports the Firefox Debugging Protocol so far.

Number one drawback of VSCode, for me, is poor vim keybindings, especially visual mode. If that was fixed I'd use it extensively.

Came here to find if it had Vim bindings.. I guess I'll wait to use it :/

The current release notes explicitly mention some API changes they implemented to better support the vim extension: https://code.visualstudio.com/Updates#_extension-authoring

I wanted to use VSCode when I started writing TypeScript three months ago, but I found the Vim plugins super lacking, so I used Atom instead, which has a much more robust Vim plugin.

However, I tried VSCode again last week after being disappointed by continued bugs in atom-typescript, and was happy to discover the Vim plugin (https://github.com/VSCodeVim/Vim) had made a ton of progress since I'd last given it a shot. It's still not quite as good as Atom's, but it's definitely getting there. Plus, the project's team is very active and friendly - I actually submitted a PR a few days ago fixing a bug (the VSCode extension development workflow is super easy, it turns out!) and they quickly merged it :)

I also found out that the VSCode developers know that it's an important plugin, and they actually have a category of issues on the VSCode repo specifically for extension APIs they need to add to make the Vim plugin as powerful as possible. This new update includes several of those, and I have a feeling by the end of the year the Vim plugin in VSCode will be on par or better than that of plugins for other editors.

Is it as good as the Ideavim plugin for Jetbrains editors?

That is the benchmark that I use to judge other vim plugins.

I don't know what turned at MS exactly but something did, at least in the department where VS and VSC are developped. I've had major bad experiences with reporting bugs to MS in the past (almost as if they had a standard 'by design' or 'wontfix' message generator). The last couple of years however, not so much. Submit a report, get a reply like 'thanks for the detailed report, we're on it' and then the bug is fixed in the next service pack or version. And now they're also doing PRs for VSC and other things and the response times seem ok (well, a tleast yours was, but it's still sorta 'unseen' for MS). If it continues they might reach a point where the competition (including open source) starts to look very bad - there it's sometimes still the usual business as it was with MS: report a bug and/or PR, nothing happens, for months or even years.

They don't get restricted by backward compatibility.

I too wrote a PR a few days ago to not switch to visual mode when selecting text in insert mode (which breaks snippets and wrapping text in braces).

I'm pretty busy right now, though, and will probably not get to finish it in the next week. If anyone wants to pick it up, I'd be really happy: https://github.com/VSCodeVim/Vim/pull/544

What advantage is there to Atom or Vscode over vim/neovim? (Honestly curious. I can see why people might prefer it to notepad, but if you're already a vim user..?)

One day we will have a conversation about X text editor without mentioning vim. Not today.

That day will be long after all the non-modal heathens are converted.

I don't see a problem with this. Frankly, there are probably more people using Vim keybindings in another text editor than using raw Vim itself.

How does it handle other vim features like window splits, macros and programmability?

It's easy to modify key bindings to emulate popular editors. For example, Emacs key bindings are trivial to emulate.

But Vim/Vi don't just have keybindings; they have modes. Emulating editor modes is a significant undertaking. It's not just a change to the settings file -- it requires a lot of programming work. I wouldn't hold my breath waiting for Microsoft to emulate Vim modes in VS Code. A plugin is your best bet.

The plugin that comes closest is "VimStyle", which ironically has the lowest number of installs and ratings out of the top three. I assume that's because it was a bit later to market. However, the top two are garbage.

Hey, I'm one of the authors of https://github.com/VSCodeVim/Vim. I'd love to know how we can make our extension better. Feel free to drop by our slack or drop a GH issue of what you think we're missing.

I just tried VimStyle and wow you are right. This extension is smooth!

A few months ago I compared different Vim plugins for VSCode and found amVim to be the best for my needs. It's not without its bugs and limitations, but it's good enough:

https://github.com/aioutecism/amVim-for-VSCode

VSCodeVim was not that good at that time, but I haven't checked it recently for a fresh comparison. So make sure to also check out VSCodeVim in addition to amVim.

Visual Studio Code is currently my favorite editor. Fast, informative intellisense, great debugging environment, good git integration, faster than Atom, etc.

I love the git integration so much that when I'm preparing to commit on a visual studio (proper) project I'll type `CODE .` in powershell or the package manager console to inspect and edit my code before pushing.

Agreed, I kind of wish that MS could come up with a way to get rebase/squash and pull --rebase working in the editor, having a 3-way merge in VS Code would be awesome... unfortunately it doesn't work well as a system editor choice for git cli.

Been very happy with VS Code, though I wish I could revert to pre-tabs file behavior, I'd like the space back... it took getting used to, but the list switcher was a better UX imho.

> I wish I could revert to pre-tabs file behavior

Adding the following to your User Settings should get you pretty close:

  {
    "workbench.editor.showTabs": false,
    "workbench.editor.enablePreview": false,
    "workbench.editor.enablePreviewFromQuickOpen": false,
    // ...
  }

Cool, thanks, anything to re-integrate left/middle/right into a single list again?

Not that I've found.

Fast? Really? What are you comparing it to?

> faster than Atom, etc

"Fast, informative intellisense" not fast in the general sense. Also, faster than Atom .

Whenever I try a new text editor, I run into a problem: I absolutely love the feature where it auto-completes based on other words in open windows (or other files in the open project). But there's no official term for this so I can never tell if a text editor has it.

Years ago this used to be called "hippie expand", but I can't figure out a more modern name that is used. Does anyone know what Visual Studio Code calls this feature, and/or how to enable it (assuming it even exists?)

You mean you have a text editor that knows what words are on the page in a CHROME tab (for example)

Or you mean, that if you've got 2 text files open as tabs in the same VSCODE window typing in 1 tab will auto-complete with words from the 2nd tab?

Where have you seen this feature as it sounds AMAZING!

Pretty sure he means the latter. Several editors I've used over the years supported that. The ones I can remember are Scite, UltraEdit, PNotepad and Vim.

It auto-completes with words from tabs in the same VSCODE window. Atom has similar behaviour with autocomplete-plus.

I mean the latter (other open windows in the text editor). TextMate and Sublime both operate this way, as opposed to IntelliSense style auto-complete where it only operates off of symbol definitions (class names, function names, properties and variables, etc). Which makes sense, because TextMate and Sublime don't really "understand" your code like Visual Studio historically does.

Sublime Text doesn't do this by default although there's an extension[1] to do that.

[1] https://github.com/alienhard/SublimeAllAutocomplete

Intellisense? Autocomplete?

It isn't Intellisense since it isn't using type information but the context of the text buffer to determine possible completions. Autocomplete is too vague.

I think it's just part of autocomplete, but it has to have an expanded set of contexts it uses. I think VSC only checks for actual existing types/properties in that context. But other editors can be more intelligent: IntelliJ's IDEs, for example, will automatically autocomplete a new method name to a method that some code is referring to but that doesn't exist yet (it knows I'm trying to create it). I'll check what variables you created and suggest some names for new variables depending on context. Etc.

It's really vague, but I'd still call it autocomplete.

Some editors, like Notepad++, end up using whatever they can find as a means to autocomplete. So you end up with a huge list of suggestions for anything you type. But it's because they lack the power to analyze the code and actually know what's allowed where you're typing.

This is only 20% relevant, but I've been messing with the Vim extension YouCompleteMe, expecting very intelligent completion based on the syntax of the language.

However, at least for C++ code, it seems like just a dumb symbol-lookup, suggesting only other symbols in the file, regardless of whether they syntactically make sense or not.

I must be doing something wrong but I don't know what. It seems to do a better job with Python, where it knows about keywords and built in functions.

(fyi, compiled with Clang Complete enabled).

Answer the question "Does your editor support autocomplete?" isn't very useful, since autocomplete only means, can the editor feedback some choices (wherever those choices may come) into your typing experience? We really need a better vocabulary to describe and differentiate between the many kinds of auto-completions, or we might just talk past each other when comparing the powers of our editing experiences.

I don't know what it's called specifically in context of other open Windows, but I'm guessing the functionality could be described as a feature of "IntelliSense" (but I think IntelliSense is Microsoft's name for it).

I wasn't clear about this, but in my experience with Visual Studio back in the day, IntelliSense only operates off of defined symbols (function names, class names, variables, etc). Whereas text editors such as TextMate and Sublime don't seem to "understand" the code as much, so instead they just autocomplete based on all word they find in the open project or Windows. But I actually prefer this more loosy-goosy style of autocomplete, so was just wondering if this new Visual Studio works that way (since it seems to be geared more towards dynamic languages such as javascript than VS was in the past).

In a dynamic language like javascript, yes VS Code works exactly like this.

You mean [autocomplete](https://en.wikipedia.org/wiki/Autocomplete)?

Yes, but there are two different kinds of autocomplete -- MS's "IntelliSense" style which actually understands your class/function/variable definitions and only gives you options it thinks are legit, versus more loosey-goosey style where the text editor just uses all words it finds in the open project or windows (regardless of whether or not they make sense in the context of the programming language).

Historically, Visual Studio has only done the stricter "IntelliSense" style, but I am wondering if this new version handles the looser cases like TextMate and Sublime do.

Even older versions of Excel had this. Now I'm dying to know what it is called too...

It should be pretty easy to build a plugin that makes this happen. By default I think it auto completes from the buffer of existing document.

Emacs has dabbrev-completion and dabbrev-expand which, I guess, shows its age...

Unfortunately there isn't a clear name for it. There's a bunch of sibling comments that, I think, don't quite get it right. Autocomplete is a feature. For any given autocomplete implementation, there can be a number of different sources to actually populate the AC UI. Company mode in Emacs (COMPlete ANYthing) works this way - it's a general AC framework, and different modes can provide different AC sources to it. Hippie completion, in Emacs at least, refers to a combination of a variety of sources - text in the current buffer, in other buffers, on the kill ring (e.g. Recently copied text), etc.

This is very true indeed. Company mode is the completion framework that rules them all. I have abandoned the older ac-alternatives in favour of this. And it's easy to write new backend source plugins too.

I've seen it called dumb auto-completion. Where intelligent auto-completion is called "intellisense".

intelligent auto-completion knows the variable type and available methods/properties. Whereas the dumb auto-completion just match the words.

Great work on the integrated terminal. I'be been waiting for this. Might even fire up Windows 10 with Ubuntu shell and see how everything works together.

If you're curious, the integrated terminal is actually xterm.js behind the scenes: https://github.com/sourcelair/xterm.js

I find it amusing that the stack I'm using to write a systems application is javascript all the way down, from the editor window to the terminal it runs in.

(not bashing. just saying it's amusing. I freakin love VSC.)

The future as foretold by "The Birth and Death of JavaScript" (https://www.destroyallsoftware.com/talks/the-birth-and-death...) gets closer every day :)

I honestly wouldn't be surprised if someone like MS announces a new open source "JS to efficient native machine code" compiler one of these days.

MS Chakra JS VM is already open source: https://github.com/Microsoft/ChakraCore

Like all high-performance JS VM's their JIT's already emit efficient machine code. If Google, Apple or MS could get JS running any faster they would've.

Javascript is the new turtle.

I don't know what your comment means, but I'm intrigued by it. Which turtle are you talking about?

I guess it's a reference to the "it's turtles all the way down" expression: https://en.wikipedia.org/wiki/Turtles_all_the_way_down

That link led me to this page: https://www.sourcelair.com/blueprints/sourcelair/xterm

I tried to sign in with Github, but the site requests full read/write access to my account details, my private/public keys and all repositories. Wat.

What's interesting is that (at the bottom of the stack of JavaScript turtles) xterm.js depends on pty.js. Windows does not provide a pseudoterminal API like Linux, so there is no official way of writing a terminal emulator that behaves like the builtin one (conhost.exe.) Because of this, pty.js uses winpty-agent.exe and winpty-agent.exe does its magic by starting a hidden conhost.exe in the background, effectively screen-scraping it, then writing a sequence of xterm-like control sequences to a pipe that will recreate the state of conhost's screen buffer.

This works well enough in practice, but it relies on a few strange hacks. For example, it writes a marker into the console's backbuffer to detect window scrolling, and it enables mark-mode in the hidden conhost window to "freeze" it while it queries for changes. Also, it's not very robust to changes in the console implementation, so it broke for a little while due to the console changes in Windows 10 (though this was fixed quickly.)

Because of this, it's strange to see Microsoft using it in an official product. I'd love to see them add a proper pseudoterminal (pseudoconsole?) API to Windows 10. There is clearly a need for it.

I suppose if you had the Linux Subsystem enabled, you could host a session there, and I'm sure there are a billion tried and true ways of sharing that session with the built-in VSC terminal.

If the Linux Subsystem were standard, you could depend upon it, but I guess not since it needs to specifically be enabled?

not well, big flaw with the ubuntu shell is that there is no reliable way to interact with the linux filesystem from a windows program ( like vscode ). You can work on the mounted C: drive /mnt/c . However, I have found a number of dev tools don't really like working with it ( meteor / mongo ). Thing crash. They work fine on the linux filesystem though, it's just you can't reliably use windows programs to access files, you have to use things like vim inside the shell to edit stuff.

This editor is also very good to write Golang code.

Have you done an overlap against LiteIDE?

Doesn't seem to have debugging. If that's the case it already lost.

I'm sure it's a great editor but it's, to me at least, a bit weird to have to read a privacy statement for an editor to work out what it's actually sending home.

https://www.visualstudio.com/en-us/dn948229

I guess it's open source though so if anyone's really bothered they could fork it and take all that stuff out.

You can disable all telemetry in configurations.

Even with all telemetry disabled you can still see it attempting to connect to MS domains. Just open the developer tools (F12).

What would be some of the cool features that only exist on VSC that Sublime doesn't have?

Out of the box (which matters - just because an extension exists, doesn't mean everyone who would benefit from it can find it, add it, configure it, etc.)?

For one, nice git integration. You can see lines added/changed/removed in the gutter, unobtrusively.

Sublime has a plugin that does something similar but it's not out of box and it's not as nice/polished.

This is just one thing.

And some great features inherited from Visual Studio.

Peek definition. when you want to peek a few lines of a method or type, you don't have to go away from the current position. In Sublime and Atom, it really bothers to open another tab.

Navigation through overloaded methods.

When a text editor is built to help people coding easily and make itself extended easily, it has to include some basic infrastructure so that extensions can focus on their specific implementations.VSC does this well, it is not only a text editor, but also have a skeleton of an IDE, and left all other things to extensions.

The newer dev builds of Sublime Text introduced a way to render popups (that hover over text) using a subset of html (minihtml). It's already being used to show a list of references under the cursor as well as better build errors. I imagine there will be extensions taking advantage of this soon.

The cool telemetry phone home features that cannot be turned off in a reliable way (think updates). It's the feel good vibe that runs through all new MS apps and Win10. We should thank the third CEO for his great vision and be happy to give him all insight he needs. He is clearly steering his thriving platform to the next level.

Not sure if you're being sarcastic or not. Collecting data to improve the software is a great virtue, but not providing a reliably way to turn it off is definitely not cool.

Judging a specific part part of a behemoth company based on the controversial and by no means decidedly unethical actions of another are as annoying as using Micro$oft as a slur.

Debugging

My main one is the top-notch TypeScript experience.

it's actively developed.

Anyone know how to hide the bug icon from the left bar?

Other than that I absolutely love vscode. I use it on osx and linux daily. It really hits the sweet spot for my work flow. Cheers to the team for another great release.

vscode is now my favorite editor when I'm not dealing with command line(e.g. vi), I used to edit with another light weight editor geany.

Thanks for all the efforts to make vscode a great tool.

I recently switched over from a combination of Sublime and Notepad++ to VSC. The only thing I found was Notepad++ opens up files almost instantly and there is still a bit of a noticeable lag with VSC, so when I need to be jumping in and out of different scripts Notepad++ is still my preferred choice, but for actually writing code, VSC is golden.

Hopefully I can uninstall Notepad++ in the near future!

VSC rocks. I am on .NET/Win platform and I can open and work on the same .NET Core project both on VSC on Mac and VS2015 on Windows.

I tried to use it for C++ development on Linux. A project I'm working on uses Qt, and I put QT's include directories into the configuration file as was described in documentation. I was unable to get autocompletion to work with Qt and after 10 minutes I gave up on it and went back to using Netbeans.

Have you tried Qt Creator? Its really good for normal C++ development and even better for Qt specific development.

A colleague uses it on OSX, and it's awful: unstable, crashes, hangs during debugging, the debugger doesn't always update the displayed values, doesn't grok auto declarations, etc. So far, Netbeans is the best free C++ IDE I've tried.

What about KDevelop?

Waiting for version 5 to try it out because it has clang-based completion.

I'm actually finding myself torn in that VSCode is a Microsoft product that I'm actually liking. For Unity development it offers a much snappier + cleaner experience than the built in MonoDevelop editor, and as a general text editor it seems more responsive than Atom.

I'm curious about the note on them having implemented an IME for CJK and Indic character input. I thought an IME was a component of the operating system or a contextual widget that appeared like an onscreen keyboard and was separate from the text editor itself.

"By default, VS Code shows snippets and completion proposals in one widget. This is not always desirable so we added a new configuration setting called editor.snippetSuggestions. To remove snippets from the suggestions widget, set the value to "none"."

Sold me on it.

1.4 still has an odd bug - it can't deal with some fonts:

  https://github.com/Microsoft/vscode/issues/5537

I don't think that a HN version release thread is the place to get publicity for bugs.

It's a very odd bug. If you take a minute to read its description, you'll see it causes rendering issues depending on the font name. It's also a bug that does not affect Atom or other editors based on it, which makes it even more odd.

I think HN is precisely the place to highlight things like that.

I'm not particular about what editor you choose. I've been looking for a good JS IDE. Webstorm is of course the only real player in this space (with an amazing IDE) but it's pricey. I've been watching VSCode with great interest. However, every time I try the editor it's a huge letdown. Buggy, crashy, shitty and weird interface (they have completely made up their own tabbing/splitting paradigm for example, which is buggy and alien compared to existing patterns). It claims to be an IDE but doesn't come close. I think that one day VSCode will actually be an IDE, but it's been a repeated abject failure to date. Based on the current progression I would avoid it for at least the next year, and then I think its potential will be visible.

That's funny, I don't know that it's been referred to as an IDE so much as a more advanced code editor.. which is about all I use it for... I generally have my rightmost screen with iTerm and 3 windows split, one tall, the other two quarter screen... next to the left is VSCode for the project/directory I'm in, left again for browser, left for lync/outlook etc.

As a code editor, I've really liked VS Code.. I haven't ever setup any integrated debugging, or used the tasks options... so I can't comment for that, but for my use it's been very stable.

If you want a full blown IDE with integrated debugging, etc, then you're right, it's less than ideal... having to edit json config files is cumbersome, and I'm guessing they'll get a GUI over that once it's more feature complete... as it stands, the core works well...

Though I do wish I could get pre-tabs behavior back, once I got used to it, I preferred the switcher ui on the left.

You should be able to get most of the old behavior back by adding this to your settings.json: `{"workbench.editor.showTabs": false, "explorer.openEditors.visible": 10}`

Thanks.. is there a setting to re-integrate the left/middle/right into a single list?

A lot of people refer to VSCode as an IDE, but their PR doesn't call it anything more than an extensible editor (perhaps a distinction without a difference). I would hope, for JetBrains' sake, that their commercial IDE stays far ahead of a free editor enhanced by volunteers. That's what their customers are paying for.

I got used to the UI after some time and haven't had stability issues, but a lot of extensions I've tried have been half-baked or worse. My main complaint is that cold startup is too slow to use as an all-purpose editor.

I switched from WebStorm to VSCode several months ago and haven't looked back. Tabs are fine now since the last two releases. Occasional crashes, but nothing like Atom which for me was almost unusable.

My favourite thing about VSCode is how fast it is. WebStorm and Atom are dogs.

Visual Studio 2015 is the only real player. Have you tried it? I've compared it to every other IDE and nothing comes close. Of course, you need to add quite a few extensions (addons) to make it really nice but other than that, it's got the best autocomplete and the best debugger outside of Chrome Dev Tools.

Add the Node.js Tools for VS and the Tools for Apache Cordova extensions (including the kick-ass VS emulator for Android) and you've got a complete kit for programming JS everywhere. Developing ionic apps with this tool is an absolute dream.

EDIT: And it's free.

I've extensively used WebStorm, VS2015, and VS Code for writing JavaScript and TypeScript (both server-side and client-side). VS2015 was the worst of the three. When it worked properly, it was pretty good, but it was incredibly bloated and buggy. It installs GBs of extras onto your machine that you have to painstakingly remove and hope they don't mess anything up. I dealt with a bug that required me to remove some packages and not others. It was a nightmare.

WebStorm is the best, but it's absolutely loaded with features that most people won't use. VS Code supports most of these same features, but they must be implemented manually via config files and scripts. A lot of people will prefer the latter approach because it leads to a leaner starting configuration.

I found the debuggers of all three to be fairly similar, although VS Code's was very slightly less usable.

Edit: To clarify, I used VS Code and VS 2015 at the same time. After getting frustrated with both, I switched to WebStorm and haven't looked back. Every time I think up a "nice to have" feature, I find out that it already exists and is configurable via GUI.

VS Code does not claim to be an IDE.

Reply on news.ycombinator.com