
The Rise of Microsoft Visual Studio Code - Harj
https://triplebyte.com/blog/editor-report-the-rise-of-visual-studio-code
======
munchbunny
Having gone through Triplebyte's interview process, I'll propose another
interpretation: Triplebyte's interview is _on aggregate_ biased against Java
and C# developers. I'm not accusing Triplebyte of "being biased", but rather
pointing out that Java and C# tend to correlate to a skill set that
Triplebyte's test process values less.

My experience of Triplebyte's interview process is slanted towards
frontend/backend developers of web apps. Fortunately for me, that was my
background. However, in the team I currently work with, the team is in
aggregate heavily C# with only secondary experience in web frontend/backend
development. That's because their expertise is in low level security. Several
developers on this team are exceptions to the "don't roll your own
cryptography" adage.

They're all competent developers, but the version of Triplebyte's coding test
that I took (and passed) would be in unfamiliar territory for people in this
team. That's fine since most of Triplebyte's clients are probably looking for
web frontend/backend skills, but I think this means that Triplebyte's test
shouldn't be seen as an objective measure of programmer skill, just an
objective measure of fit for Triplebyte's clients.

~~~
ww520
Could you give some examples? I keep seeing annoying Triplebyte ads popping up
and not sure what it is.

~~~
munchbunny
What kinds of examples are you asking for? Like specific parts of the
interview?

~~~
compumike
[https://triplebyte.com/interview_guide](https://triplebyte.com/interview_guide)

------
hprotagonist
There are some warts, but it seems nice from afar. The biggest wart is/was the
"FUCK FUCK FUCK" git clean vs git reset UX error:
[https://github.com/microsoft/vscode/issues/32405](https://github.com/microsoft/vscode/issues/32405)
. This is a fantastic demonstration of why i exclusively use git from a
command prompt -- i _know_ what will happen and nobody's going to reinvent
terms to put on buttons that just confuse me.

In my life:

\- I'm committed to emacs for org-mode and LaTeX editing and daily use.

\- I paid for sublime so i will use it -- and multiple cursors everywhere is a
boon for quick and dirty data munging.

\- I write serious python code in pycharm.

\- I write serious c# in full blown Visual Studio

~~~
kbd
> This is a fantastic demonstration of why i exclusively use git from a
> command prompt...

Thanks for this. I've always felt the same way but haven't been able to put my
finger on why. As more things get integrated into my editor (I use VSCode) I
feel like I should use the shiny features, but for source control I think I'm
going to only use the commandline forever. (Edit: though plugins such as
GitLens that give you source control info inline are fantastic.)

Along with some nice features I've added, such as my 'git af' (add + fzf)
shortcut[1][2], the commandline is very usable (don't have to 'git add' and
type filenames manually).

[1]
[https://github.com/kbd/setup/blob/65b3d0abcb34540b43880792e8...](https://github.com/kbd/setup/blob/65b3d0abcb34540b43880792e8f7512ee0ec1abd/HOME/.config/git/config#L44)

[2]
[https://github.com/kbd/setup/blob/65b3d0abcb34540b43880792e8...](https://github.com/kbd/setup/blob/65b3d0abcb34540b43880792e8f7512ee0ec1abd/HOME/bin/gsf)

~~~
pstadler
Same here w/o fancy tooling around Git, but a couple of aliases.

I will refuse to use any Git tools or UIs, but the standard CLI, until the end
of my career.

Besides that, my IDE/Editor is neither a build tool manager nor should it run
my app from within an integrated console having specific settings. The
projects people are going to inherit from me will always be editor-agnostic,
the environment they run in will never depend on a certain setup that can‘t be
documented clearly and they will always run within an isolated context, i.e.
the project root.

~~~
ascagnel_
I agree on part of that -- VSCode has a pretty good Node debugger, and you can
run it with a listen hook (and therefore set it to run via a npm/yarn
package.json script). Similarly, I feel like it's OK for an editor to run a
script from the app in an integrated terminal, as long as that script is still
accessible from a standard CLI.

Git is complex enough that I don't trust more complex operations (basically
anything beyond push, pull, add, and checkout) to be handled by a GUI, but a
GUI can make for a great code review tool.

------
johngalt
> Engineers who use Go are also especially strong. If you know why, please let
> me know.

Because there is almost no reason to learn Go. Most shops want
JS/Java/Python/C# etc... The primary reason to learn a language like Go is
because you want to for it's own sake.

It's not that you must learn Go in order to be good, or that knowing Go makes
you better. Rather it's difficult to be bad and still have the desire/interest
to spend time learning something unnecessary.

~~~
eindiran
This is what Paul Graham calls the Python Paradox; namely that in 2004, when
Python jobs were relatively more rare, you could find smarter Python engineers
than Java engineers for any given project.

"[I]f a company chooses to write its software in a comparatively esoteric
language, they'll be able to hire better programmers, because they'll attract
only those who cared enough to learn it. And for programmers the paradox is
even more pronounced: the language to learn, if you want to get a good job, is
a language that people don't learn merely to get a job."

[http://www.paulgraham.com/pypar.html](http://www.paulgraham.com/pypar.html)

~~~
pvg
Both of these are still just very roundabout ways of telling yourself you're
awesome because of whatever mildly unusual thing you think you might be doing.

~~~
bitcrusher
And this comment is just a subtextual justification for making sure you still
feel valued for not doing anything unusual.

This could go round and round. The point is that there SEEMS to be a
correlation with people who learn things for the sake of learning them and
folks who do well at exercises that test for adjacent skills.

~~~
pvg
_you still feel valued for not doing anything unusual_

I didn't really express any thoughts or feelings about doing unusual things,
real or perceived. Doing unusual things can be great! Telling yourself you are
awesome can also be great! I do think, though, that the type of thought
expressed in the "The Python Paradox" and related writings (say, the bit about
blub language programmers) is pretty lousy. It was lousy then and has aged
even more poorly.

------
interesthrow2
It's a good text editor, first and foremost. Compared to netbeans, eclipse,
visual studio, even intellj idea in my opinion. The same thing that made
textmate, then sublime text successful made VSC successful. I takes a few
seconds to launch, even on my celeron machine with 2Gigs of RAM, it's
relatively minimal and unlike intellj it doesn't appear to be analyzing my
whole hard drive for hours for no reason...

the irony is that Microsoft did hire Eclipse creator to work on that
product... hopefully it doesn't end up bloated. Having an open spec for
language servers is also a smart move. While others have their proprietary,
often non speced protocol, now any text editor can implement the same protocol
and basically use any language server already developed.

So kudos for Microsoft, it's a great piece of engineering.

~~~
AsyncAwait
> It's a good text editor, first and foremost. Compared to netbeans, eclipse,
> visual studio, even intellj idea

Have to disagree with VSC being better than Intellij. I find Intellij
refactoring, debugging and autocomplete far ahead of VSC, especially when it
comes to supporting leaser known features, or recently released language
changes.

~~~
jhall1468
VSC and Intellij aren't the same thing. If you want better refactoring and
debugging there are definitely plugins that do exactly that. Hard disagree on
autocomplete, I've never run into a single situation where Intellij did it
better.

~~~
williamdclt
Well, hard disagree on your hard disagreement, I've never ran into a situation
where VSCode did better than Intellij/Webstorm :)

Often, the problem is the order of suggestions, it was magically almost always
right on Webstorm and not as good on VSC

------
atombender
VSCode is fast and it's certainly the best editor/IDE I've used since back
when I was a Java dev using Eclipse back in 2006 or so.

But I recently opened up Sublime Text to compare some editor behaviour, and
the difference in UI performance is _astounding_.

It's possible that VSCode has regressed a bit the last couple of years. It was
always faster than Atom. But comparing it to Sublime shows that there are
clear advantages to writing UI code in a natively compiled language. Sublime's
widget drawing seems very well optimized.

VSCode has also become slower for me the last few years, simply from the load
of extensions. I use the ESLint extension and the Go extension heavily, both
of which parse code a lot. Neither is doing any sort of incremental parsing,
so there's potentially a lot of churn. There's also some kind of indexing of
symbols that happens in the background in the language server or in the
extension. I sometimes have to kill the "Code Helper" process because it's
sitting there consuming a whole core when idle.

Overall, VSCode is becoming increasingly closer to how I remember Atom, when I
used it. I worry that it's slowly turning into Atom, performance-wise.

~~~
sho
> the difference in UI performance is _astounding_

I could not agree more. I've made numerous attempts to embrace the new hotness
that is VSCode but I just cannot get over the performance. Yes, it has some
cool features, the plug-in ecosystem is booming, and it sure looks pretty. But
at the end of the day none of it is compelling enough for me to put up with
the constant lag.

It's funny because after several of these experiments I have literally
wondered to myself if I'm getting stuck in my ways or becoming a so-called
"greybeard" due to my long term adherence to Sublime Text, but is constantly
getting annoyed with how slow an editor is really a hallmark of old age? I'll
wait for your web page to load, I'll wait for an ssh command to return. I will
not wait for my bloody text editor. I have no patience whatsoever. Now god
damn it NOW!

Another thing I wonder is how many of those VSCode users have simply never
used anything better. If all you've ever known is an iPhone 5, you probably
think it's pretty great - maybe you think that's just how phones are! This
impression will be totally ruined of course when you try an iPhone X...

~~~
Waterluvian
I feel like if I took a serious shot at sublime I wouldn't be able to go back
due to performance snappiness. Then I'd be miserable because I think vscode is
superior in many other ways.

------
kcon
It seems strange to me to compare VSCode against PyCharm, IntelliJ, and
Android Studio separately. While PyCharm, IntelliJ, and Android Studio are
distinct applications, I believe they share much of their code, UI, 3rd party
plugins, and workflows for all being JetBrains language-flavored IDEs.

On the other hand, VSCode supports different languages through its extensions
instead of having separate language-flavored applications like "VSCode
Python", "VSCode Java", or "VSCode Android".

So I feel that reaching for IntelliJ vs. PyCharm vs. Android Studio is roughly
equivalent to installing a particular set of extensions in VSCode. If you look
at it that way, the data from the article seems to tell a different story -
while VSCode has grown significantly in popularity, JetBrains IDEs seem to
dominate in terms of overall usage (11.3% + 6.9% + 4.1% = 22.3% vs. VSCode's
16.8%).

~~~
lowercased
I didn't see any js or php specific stuff in their list, but have to assume
phpstorm or webstorm might be in their 'other' category as well, pushing JB up
to closer to 25%(?)

------
sbilstein
VSCode is fast, stable, and the plugin ecosystem really beats Sublime Text at
this point. I was skeptical because Microsoft but it is hands down my favorite
editor.

~~~
nystorm
I'm also skeptical of microsoft products, but they have come a long way since
getting their new CEO. I've gained a lot of respect from them for better
integration with non-windows platforms.

~~~
belltaco
Someone said big companies are like aircraft carriers, they take a long time
to change course and travel to the right destination, but if they do, once
they are there they bring massive impact compared to more nimble and smaller
sea vehicles.

------
jokoon
Like it was said in this thread, as long as you have an editor that is built
on something js-related like electron or node-js, it just cannot beat
alternatives that are made in C++.

I've tried VSCode because I wanted to have UI breakpoints with GDB, I admit
that vscode seems better than atom, but for performance I have my doubts.

I really don't understand why engineers choose to use JS to made a text
editor. I know that js and the dom have enabled the web, but it's because
there was nothing better, choosing js to do non-web stuff doesn't only sound
silly, IT IS silly.

~~~
21
Do you think it's a coincidence that some of the most used and loved desktop
applications lately are written in JS/HTML? import_pkt_ws_btc_deribit_v2.py
Could it be that it's extremely hard to do these kind of applications in
traditional GUI frameworks?

~~~
pjmlp
Could it be that many JS devs don't bother to learn how GUI frameworks are
able to do stuff where Web is still catching up with the 90's?

~~~
atq2119
You're perhaps more snarky than necessary, but I think you're getting to the
core of the problem.

The web has unfortunately made JS a very common first language, and created an
army of people who know JS. Then rather than learn, say, C++ and Qt for
building cross-plattform GUI, they stick to the language they know even though
it leads to inferior results.

------
33degrees
One of my favorite things about VS Code is how usable it is with its default
configuration, and how easy it is to customize to my liking. I found Atom and
Sublime Text very frustrating in that regard.

~~~
davidwparker
Interestingly, I found Atom to be much easier to customize. There are still
things in VS Code I can't customize that I used to have in Atom.

That said, I've been on VS Code for a little more than a year now and it's
grown on me.

~~~
33degrees
To be clear, I meant easy in terms of how little I have to do the get it
working to my liking. Atom might be easier to customize in general, but it
requires more effort overall.

------
brokenwren
VS Code solves different problems then IntelliJ, PyCharm and Atom. I'm not
sure this is a fair comparison. For example, I wouldn't ever code a full Java
stack in VS Code. I'd go straight to IntelliJ.

~~~
munchbunny
Separately from being my JS IDE of choice, VS Code has for the most part
replaced Notepad++. It's quite good at being a general purpose "heavyweight"
text editor.

~~~
ourmandave
Has anybody written a Notepad++ to VS Code command translation guide?

I use Notepad++ for all sorts of text related things (cutting, sorting, making
100s of julennne phrases) but not as an editor.

If there was a cheat sheet of VS shortcuts I could ditch Notepad++ completely.

~~~
freehunter
VS Code has a printable cheatsheet of keyboard shortcuts that it prompts you
to view when you first open the editor.

~~~
misterdoubt
Also available here:

[https://code.visualstudio.com/docs/getstarted/tips-and-
trick...](https://code.visualstudio.com/docs/getstarted/tips-and-tricks)

I, too, am making the Notepad++ -> vscode move.

------
cbhl
Frankly, I think we're seeing the results of the new era of Python paradox.
Except it's not Python 3, it's TypeScript, VS Code, and React.

If you look at the education space, many of the deployments are either
Chromebooks or iPads. Back in 2012, the "learn to code" sites (like Khan
Academy or Code.org) ended up building their lesson plans around JavaScript.

[https://johnresig.com/blog/introducing-khan-
cs/](https://johnresig.com/blog/introducing-khan-cs/)

People who were in 3rd- and 4th-grade in 2012 would now be finishing up high
school. Someone in 7th- or 8th- grade would have just finished a bachelor's,
or maybe be looking for their second job after two or three years in the
industry.

For these folks, TypeScript/VS Code/React would be a short jump from these
learn-to-code-JavaScript-in-the-browser sandboxes.

As for Go... I suspect that's the set of people who can handle Google-scale
software complexity. So either former Google employees, or people who are in
the kubernetes ecosystem.

------
lowercased
The "live shared coding" angle in VSCode makes it a great option in many areas
where there's a need for it. People have been asking jetbrains for this for a
decade, and there's nothing on the horizon as far as I can tell.

~~~
jxramos
wow, never realized that was a supported feature. I must have glossed over
that feature in that then feature release
[https://code.visualstudio.com/blogs/2017/11/15/live-
share](https://code.visualstudio.com/blogs/2017/11/15/live-share)

------
kyberias
Ok I stopped reading when they started drawing graphs how well the people
using certain editors fared better in their test as if the editor could have
anything to do with it.

~~~
jgtrosh
Depending on the task and the familiarity of the user with the editor, it can
make a big difference! As an extreme example, a good 80s programmer might work
efficiently on a file in ed, but nowadays approximately no human could do
that.

~~~
kyberias
But their tests don't measure "how efficiently" the candidates edit files, do
they?

~~~
nameless912
OTOH, I've found that having a mastery of Vim helps me out a LOT in interviews
where I get a computer to work at. I can actually type faster than I can think
at this point, so I get to express my ideas pretty much as soon as they come
to me, which allows me to "look more impressive", I guess.

They certainly shouldn't judge based on the choice of an editor or language,
but 1) seeing that someone is very comfortable in _any_ editor and _any_
language shows they've been at it for a while, and being able to express the
right answer quickly is almost as important as finding it at all.

------
talltimtom
Well that settles it, I’m off to program some Go code in Emacs.

------
zygotic12
I've told you guys before - my 10 year old son scored 'well above average' on
their interview process. We live in the UK but they are still trying to
recruit him. And no - he cannot write code.

~~~
Double_a_92
The interview process reminded me of the theoretical exam for a drivers
license. If you pick the option that sounds least crazy, you're fine.

~~~
zygotic12
I wonder if you just nailed being a prog

------
indemnity
I'm not Microsoft's biggest fan (I switched away from .NET and their platforms
a few years ago, switched to Mac, etc).

But I use VS Code, it really is a great little editor with a good ecosystem.

The JavaScript support pulled me in, but it's a pretty decent Rust environment
now as well!

------
ammon
Another interesting angle on this is that VS Code is free (and open source),
while Sublime is proprietary and (nominally) costs $80. I wonder how many
people don't use Sublime because of the price? Atom is free too and never
surpassed Sublime.

~~~
scrollaway
Edit: Disregard, I don't know wtf I'm talking about.

~~~
neurobashing
It's right there on the home page:

"Sublime Text is available for Mac, Windows and Linux. One license is all you
need to use Sublime Text on every computer you own, no matter what operating
system it uses.

Sublime Text uses a custom UI toolkit, optimized for speed and beauty, while
taking advantage of native functionality on each platform."

Are we talking about some other sublime?

~~~
scrollaway
Shows me for not actually double-checking, I was pretty convinced. Is that a
recent addition or is there another editor I'm thinking of?

------
NotANaN
"Do Emacs and Vim users have some other characteristic that makes them more
likely to succeed during interviews?"

I think the Interview Pass Rates chart makes it clear that the answer is a
statistical "Yes", at least for Emacs.

~~~
emacsuserrrr
Maybe it’s because the editor was taught to students at places like MIT,
Berkeley, etc?

~~~
waynecochran
I learned emacs in the late 1980's -- it is now an ingrained part of my brain.
I hate when I have to use an IDE w a different editor -- at least most editors
(and GUI components like browser textfields) respond to common emacs key-
sequences.

~~~
saagarjha
This feature makes switching from macOS to most other operating systems
annoying, because I keep trying to ^E and realize it doesn't work…

~~~
waynecochran
I hit C-x C-s all the time in IDE's and I think sometimes it inserts weird
invisible characters into the source -- fun.

------
shmulkey18
Newspaper headline: "Emacs text editor makes people smarter."

------
lowercased
> However, it seems that the average C# or Java engineer who goes through our
> process does less well than the average Ruby or Go engineer. I have no idea
> why.

Given that they have the test info... and they're the ones deciding
pass/fail... it's a bit strange they "have no idea why". Well, perhaps just
this person doesn't?

Are people not finishing the projects? Do the projects have syntax errors in
them? Or logical bugs? What metrics do they use for "pass/fail"?

~~~
chadash
I have a theory on this. For most interview style coding problems (which tend
to be algorithmic in nature), scripting languages such as python or ruby:

1) are less verbose

2) don't require worrying about typing

3) have really easy ways to manipulate strings, iterate, etc., which are often
found in interview style problems

Java and C# have many advantages over python and ruby, but I think that they
put you at an inherent disadvantage for many interview style questions which
often require you to solve an algorithmic or data structure type problem in a
limited amount of time [1].

[1] This doesn't explain why people using Go would tend to pass at higher
rates, but since the Go community is comparatively much smaller, there could
be other factors at play there.

~~~
jamestimmins
My job involves interviewing many engineering candidates, and I see the issue
with typing all the time. A competent Java dev is at a disadvantage compared
to a competent Python dev, simply because it's statically typed and more
verbose, meaning there are more lines of code which means more small problems
that can arise. That matters greatly in a short, time-boxed context.

~~~
bryal
> A competent Java dev is at a disadvantage compared to a competent Python
> dev, simply because it's statically typed and more verbose

I don't think that the fact that it's statically typed is the problem. For
example, I don't believe a competent Rust, Go, or Haskell dev would be at a
disadvantage due to static typing, but rather the opposite.

~~~
ubernostrum
As someone else who's run a lot of interviews including tech exercises (as
much as I hate the typical way they're done, I haven't been able to eliminate
them everywhere I've worked), I have the same experience as the parent
commenter. Yes, even with "good" statically-typed languages like
$YOUR_FAVORITE_LANG_HERE.

Candidates using those languages can often sketch out the right algorithm and
the structure of what the program would look like, but under time pressure
have trouble producing something that actually will compile and run properly
(and as much as I want "showed they got the right algorithm and how to do it"
to be a pass, it isn't always). The "executable pseudocode" nature of the
popular dynamic languages is a big advantage there.

It's definitely even worse for C#/Java style languages (though C# is better
than it used to be), because of all the heavyweight design pattern stuff you
need to implement to do things that are just natural idioms in the dynamic
languages. But it's something I've seen happen in a broad range of static
languages.

------
JustSomeNobody
> Do Emacs and Vim users have some other characteristic that makes them more
> likely to succeed during interviews?

I think it comes down to users of those editors probably are used to keeping
code/libraries in their head more. IDEs tend to suggest a lot to you and if
you're not used to having that happen you could get more nervous during
whiteboarding rituals.

Edit: I guess this really doesn't apply as their interview process is on the
web.

------
satysin
I have tried VSCode a few times for C++ on macOS and always found it more
hassle than it was worth to get it up and running.

I saw it had debugging options and I thought that looked pretty cool but it is
a bit of a mess with tasks.json and some other file I have forgotten about
now. I recall I did finally get a working setup but it wasn't portable between
folders/projects as the binary filenames were hardcoded and I just lost
interest in fixing it.

I think the VSCode team could make this a lot smoother. I want my tools to
simplify these things for me with automatic configuration like every other
editor seems to be able to do. Not sure why VSCode needed a couple of json
config files to know to use /usr/bin/gcc on the current C++ file when no other
programmers editor does.

~~~
jtsylve
I'm not sure when the last time you've tried, but in the last year VSCode has
come a long way towards "just working" out of the box for C++. They've
specifically focused on it. If you've got some time, I'd recommend that you
checkout Rong Lu's CppCon 2018 talk.
[https://www.youtube.com/watch?v=JME1i3vCRR8](https://www.youtube.com/watch?v=JME1i3vCRR8)

------
hellofunk
> With 17% of the pie, VS Code was the editor used by the majority of
> Triplebyte candidates last year.

Huh? This has broken the world of math for me.

~~~
ammon
Just changed it to plurality. Thanks!

~~~
hellofunk
Almost! :

>tl;dr Visual Studio Code usage is rising rapidly! VS Code is now the editor
chosen by the majority of engineers during programming interviews, and it
appears to be rapidly taking market share from other top editors.

------
d_burfoot
It's interesting to me that Go does so well. I have a buddy who convinced his
shop to switch over to Go for the following reason: he knew that they were not
going to be able to consistently hire good programmers, and he thought Go was
a way to mitigate the problems arising from this situation. In other words, Go
is a language where newbie programmers can still do okay. He also claimed that
Google developed Go for this reason, referencing the infamous Ron Pike quote
("They're not capable of understanding a brilliant language, but we want to
use them to build good software").

~~~
triodan
Go makes it really hard to do stupid things, and that makes it a really good
language.

------
dcchambers
This article has some very interesting data beyond just showing the rise of
VSCode. Fun read.

------
cjensen
Just as an aside, there is this sentence in the article: _" On the peninsula,
where larger companies tend to be located, you see a lot of Java developers.
In San Francisco, where startups dominate, you see more JavaScript."_

None of the non-SF cities is on the peninsula. They're 100% in the Silicon
Valley / Santa Clara Valley.

------
welder
I was also surprised to see how much VS Code has grown in popularity among
WakaTime users in such a short amount of time. [1]

[https://wakatime.com/static/img/wakatime-editor-
usage-2018-1...](https://wakatime.com/static/img/wakatime-editor-
usage-2018-12-07.png)

------
yayana
Intellij, pystorm, Android Studio (and half of "Other") make up more than a
quarter and are the same jetbrains editor with different plugins pre-installed
and some plugins unavailable..

That is more than VSCode and these identical IDEs are all over the place in
these charts.

So what was I supposed to have learned from this article?

------
hartator
Worked with a bunch of them, always come back to Sublime Text for performance
and multi-cursor support.

~~~
brink
Emacs has multi-cursor support.
[http://emacsrocks.com/e13.html](http://emacsrocks.com/e13.html)

~~~
hartator
Is that native?

~~~
brink
It isn't, and it's better because of that.

All "advanced" features should be a plugin so you can pick your favorites.
This way, if someone comes up with a better multi-cursor system, there's no
politics involved about which multi-cursor system to come to a global
consensus on. Just switch your personal config over to the new plugin and get
on with your life.

~~~
hartator
Hum. The things is it's probably breaking other features and other plugins
then. Try Sublime one once. It's like night and day. Everything works as if
you were in single cursor mode.

~~~
brink
I used sublime for about a month and couldn't get used to it. Maybe I'm just
too indoctrinated into Emacs. :)

------
adrianhel
What I would gladly pay 100$/month for is Vim with correct syntax
highlighting, intellisense and nice plugins (such as fuzzy finder) by default.

It would not need to be Vim, but I have only tried one Vim emulator that
didn't suck and was terminal-first: emacs with evil-mode. Let that be the bar
for vim-emulation.

Why is nobody doing this? I think this would appeal to a lot of people.

The criteria for me to to pay for something like this would be:

1\. Terminal first. It would either have to become my main shell or open fast
within my shell.

2\. Vim based or with GOOD Vim emulation. Macros, remapping and all normal
mode key combinations must be implemented.

3\. Fast terminal<->editor loop. I don't want to wait >300ms to edit a file.

4\. Actual production quality zero-config syntax highlighting, intellisense
and fuzzyfinder.

Sign me up!

------
sinuhe69
Funny how people analyse data and draw conclusions without applying any
statistical method. Yeah, maybe more people use VS Code, but I don't think it
has anything to do with people's failure or success.

~~~
akerro
> I don't think it has anything to do with people's failure or success.

Unless the interviewer is a big fan of VSC and they favour other VSC users.

------
pzone
VS Code has taken me off Emacs for Python development on Windows. I was never
able to get a clean and speedy code completion, navigation, or refactoring to
work with Emacs. I hope the situation changes someday.

~~~
nickysielicki
The same engine that VSCode uses is open source [1]. With lsp-mode [2] or
eglot [3], you can have the same stuff working inside emacs. I've actually
been writing Java inside emacs lately --- yes, _java_ , and I have had very
few issues.

One caveat, development on the emacs LSP stuff is moving very quickly, so I
don't recommend using ELPA/MELPA/etc. to install the plugins. I use
straight.el [4] to manage my plugins, they're checked out from the upstream
source and can be updated at-will. You'll also need an up to date version of
emacs, ie: 26+. (That's the current release, but it's not available in some
distributions ie: debian/ubuntu yet.)

\---

[1]: [https://github.com/Microsoft/python-language-
server](https://github.com/Microsoft/python-language-server)

[2]: [https://github.com/emacs-lsp/lsp-mode](https://github.com/emacs-lsp/lsp-
mode)

[3]:
[https://github.com/joaotavora/eglot](https://github.com/joaotavora/eglot)

[4]:
[https://github.com/raxod502/straight.el](https://github.com/raxod502/straight.el)

~~~
PurpleRamen
Python-lsp with emacs is dreadful bad. It's slow, bugged and doesn't integrate
well. Worst is how often the helper dies.

The microsoft-helper is supposed to work better, but it seams harder to setup
with linux, so I hadn't the chance yet to try it.

------
brianzelip
The killer feature for my switch from Atom was the built in terminal. Enough
to let me be ok using a ms product temporarily to try it out. I appreciate
their energy behind it - the update schedule, the changelog write ups, the
listening to the feedback from the users.

I really liked the json config of atom. the code gui isn't my fave but it's
ok.

Two other things helped me transition easily:

\- click a button to edit `PATH` or whatever so that `$ code` opens up the
editor from the terminal

\- atom keymapping

The coffee script use in atom was unfamiliar territory for me too, so that
part seemed distant.

------
craigsmansion
> The first thing that jumps out from this graph is the prominence of Visual
> Studio Code.

Maybe to some. 10.2% percent for vim!

For some reason that makes me really happy even though I use emacs. I guess
the (d)evil you know...

------
avshyz
Anyone who still uses VSCode, probably haven't read about all the features
IntelliJ and its ilk offer. The local history, for example, and its
integration with the test runner (knowing at which point of your editing
process your tests started to break) has saved me a tremendous amount of time.
(I've accidentally erased changes that were uncommitted with a stroke of a
`checkout -f`, and managed to save hours of work with that feature alone.)

------
eterm
These conclusions are frustrating to read because they haven't handled the
numbers properly at all and have drawn poor conclusions.

Take a scenario where Java/C# are popular and have 20 people applying for each
position but Go isn't and only has 5 people applying for each position.

You'd then have a far far better "pass rate" for Go developers. But it doesn't
actually say anything about Java or Go in terms of developer proficiency.

------
lostgame
The only issue I have with VS code is it's awful UI/UX performance - it
behaves like an Electron app or something.

I realize that's a fair insult around these crowds, but it really does have
that lack-of-polish, weird-UI/UX feeling. I know Microsoft would obviously
never build an IDE off it, but I'm almost curious to see what on earth they
did wrong.

Comparing it side-by-side with Xcode is certainly the easiest way to tell.

~~~
vtesucks
Because it is indeed an electron app

~~~
lostgame
Wow. Any and all respect for the app - lost.

------
reaperducer
Because of the popularity of VS Code on HN, I decided to give it a try. It's
good. Much better than Electron or Atom for my workflow. And much faster IME.

The one thing that keeps me from switching from my current IDE is the lack of
Whitesmiths brace formatting. I'd pay up to $15 for a Whitesmiths plugin.
Until then, I can't change. But I'll keep checking.

~~~
slig
For those not familiar (as I was), here's what Whitesmiths style looks like
(straight from Wikipedia):

    
    
        while (x == y)
            {
            something();
            somethingelse();
            }
    
        finalthing();

~~~
master-litty
The horror!

~~~
quickthrower2
Yep the loop never runs, is infinite, or x and y are member or global
variables that are mutated elsewhere.

------
ChrisCinelli
I like VSCode a lot. The only reason why I sometimes switch to other
alternative is the multi-file search results. When the fix this, I will be a
happy camper:
[https://github.com/Microsoft/vscode/issues/63465](https://github.com/Microsoft/vscode/issues/63465)

------
thedirt0115
What editor do Go devs use??? Their numbers for Go only add up to 12%!
[https://d25hn4jiqx5f7l.cloudfront.net/file_attachments/files...](https://d25hn4jiqx5f7l.cloudfront.net/file_attachments/files/original/96551f0f84b87bd438ab1e7be23c269038383620.png?1543937640)

~~~
fanf2
Yes, that chart shows that they have relatively few people doing their
interviews in Golang, so their outlier pass rate should have correspondingly
large error bars (which you have to imagine because the graphs were drawn
without any statistical sophistication).

------
CrazyCatDog
Sure, maybe it is the old-school nature of Vim and Emacs that makes then
standout in performance, but why not throw a years-since-graduation variable
into the equation to find out with greater certainty?

------
Miltnoid
I recently helped make a VS Code extension during a Microsoft internship, and
I found the language server interface really easy to use. It really makes it
easy to write an extension.

------
nickpsecurity
"Do Emacs and Vim users have some other characteristic that makes them more
likely to succeed during interviews? Perhaps they tend to be more willing to
invest time and effort customizing a complex editor in the short-term in order
to get returns from a more powerful tool in the long-term?"

One thing I noticed on Lobste.rs is that a lot of them like the old school
editors. That's normal. What was more interesting was that they were
constantly sharing and discussing their customizations that made them more
productive. Kept making me want to have another go at those editors. I didn't
since I came from Windows with big, full-featured editors that could do
everything (or Notepad++ or Notepad). Still, I keep reading those comments
since there's always new and interesting things people are coming up with.

In other words, I think the author is onto something worth further
investigation and comparisons. Especially comparing VS Code programming to
experienced folks using highly-customized, full-featured setups in the other
stuff. I bet the results would be more interesting than a random person tried
using Emacs or whatever.

------
laythea
Where is Notepad++??? !!!

~~~
thebigspacefuck
Hanging out with Bloodshed and Code::Blocks

