
Goodbye VSCode, Hello Emacs Again - tangue
https://hotair.tech/blog/goodbye-vscode/
======
pluma
User of software A tries out software B, keeps using software A for most
tasks, tries out plugins for software B to make it feel more like software A,
eventually decides to drop software B again and return to software A full-
time. Nothing particularly interesting.

However worth emphasising:

> VS Code is an excellent IDE and I would recommend any new software developer
> to use it.

It's refreshing to see a take end like this. He acknowledges VS Code is a good
IDE although he feels at home with emacs. This emphasises that he didn't stick
with emacs because it is superior but because the cost of switching editors
simply wasn't worth it to him.

That said, this reads more like general tips for emacs users rather than a
critique of VS Code. So the title is a bit misleading.

~~~
grigjd3
Trying to make one took behave like another is often a silly practice. If
there was any design intention at all in a given tool, you'd just be wasting
effort trying to sidestep that.

~~~
nojvek
I don’t think many people get the fact that VSCode isn’t just a code editor.
It does a lot more than just edit code. Language servers provide deep
intellisense, refactoring, code lens, overviews etc. debug servers provide
debugging functionality. Tons of plugins built on top of the extension points.
Vscode itself is a light weight IDE with a bunch of extension points.

Emacs, vim, sublime are mostly text editors. If that’s what you really want:
edit code with a whole bunch of shortcuts use that.

If you want a light weight IDE use vscode. Code editors are a subset of IDEs.

Two different things.

------
alexozer
I too came to believe that VSCode could be a great end-all-be-all IDE for me,
and that I couldn't potentially miss much in the big, bloated "real IDEs".

Fortunately this summer I came to realize that VSCode, at least for non-
Javascript/Typescript languages, is laughable compared to the Jetbrains IDEs
for Python, C++, Java, etc. Even ignoring all of the extra "features", the
Jetbrains IDEs are just so much more intelligent at linting, code completion,
and symbol lookup. Vim support is _much_ better too.

I do wonder how WebStorm compares to VSCode; I suspect it may not support as
many hip frameworks but would still excel in the aforementioned categories.

~~~
specialist
I subscribe to JetBrains Ultimate. I use IntelliJ & WebStorm daily, PyCharm as
needed. I _LOVE_ IntelliJ.

Meanwhile, I can't overstate how much I hate JavaScript, nodejs, npm, etc.
Burning rage of a billion super novas. Bight on humanity. Crimes against
reason.

And yet. I'm switching to VS Code. I really wanted to hate it.

I'm all-in for VS Code. Because Language Server Protocol enables a noob like
me to create my own language plugin. Plus, with their docs and videos, the
onboarding was trivial. I'm still delighted by this experience.

Further, judging from their respective "marketplaces", VS Code clearly has the
mindshare and momentum advantage. It's an embarrassment of riches for such a
young platform.

Having tried and failed to create and maintain plugins for both Eclipse and
IntelliJ, this really feels like a sea change.

~~~
paulryanrogers
Jedit made supporting a bespoke language trivial. Glad to see VS Code is
making the process frictionless as well. Makes coding in such languages so
much easier on the eyes.

------
hollerith
I'm an emacs user who would be happier using vscode except that accessing
documentation about how vscode is implemented requires a live web connection,
and I try to minimize the amount of time I spend connected to the web.

I do my Emacs-Lisp hacking offline, which is possible because the emacs-lisp
reference manual and other useful resources (e.g., the entirety of
emacswiki.org as a directory of MediaWiki markup files) can be downloaded with
a single command line. In contrast it is too hard to find and render locally
usable collections of vscode, typescript, Electron or JavaScript documentation
larger than individual web pages.

There are many aspects of my life that require me to be on the web, but I HATE
THE WEB and would put up with a lot to avoid making yet another regular
activity of mine dependent on my being connected to the web.

There is no net connection in my apartment these days (though there is in some
of the common rooms in my apartment building) and I do all my emacs hacking in
my apartment.

I long ago got used to making a constant series of small modifications to my
emacs environment. Although I might choose to refrain from getting into the
habit of doing that if I could live my life over again, it wouldnt make sense
for me to unlearn that habit at this late stage of my life, which explains why
i would regularly need access to documentation on how vscode is implemented if
I were to replace emacs with vscode.

I used to like the web, in the 1990s and later, but it has slowly changed into
something I hate. HTML 5 for example severely diminished my experience of the
web.

------
DanielBMarkham
I just made the switch also, but from Visual Studio. (Blogged about it here:
[http://tiny-giant-books.com/blog/things-vscode-didnt-tell-me...](http://tiny-
giant-books.com/blog/things-vscode-didnt-tell-me-about-programming-in-f/) )

It's amazing how much muscle memory plays a role in tool adoption. The author
says "The mismatch between keybindings in VSCode and rest of my tools just
kept tying my fingers in knots"

You can't spend years and years doing something one way unconsciously and
switch without it being quite painful. I think once you're a Emacs user for a
decade or more, you're probably an Emacs user for life -- or at least it's
going to be painful to switch.

"It is important to note that the Project Manager addon may have improved
significantly since I last used it a few months ago"

Yes. VsCode is a rapidly-changing environment. When I started with it this
week, I had downloaded the most popular plugins just for kicks. As it turns
out, there were plugins for most every common thing I do. The switch, however,
was painful.

Looking at my desktop, I've got a dozen editors, half-a-dozen or more IDEs.
This is getting crazy. At some point, maybe Emacs is a much better long-term
investment. But if you do that, you miss out on seeing what all the cool kids
are doing -- and that's important for a lot of other reasons besides
programming (Marketing, for instance)

Sidebar: People get really, really attached to their IDEs. Maybe as much or
more as their favorite programming language.

~~~
hittaruki
What I have noticed is that emacs gets most of the cool things really quickly.
You might not get many complex UI elements like a sidebar that are very
popular, but other stuff like language server or linters etc that are built
for VScode or for specific languages gets a lot of love from emacs user
community.

------
fovc
Reposting[1] my Emacs setup for JS, which I've found very effective. (Seemed
more effective than my coworker's VSCode setup)

"""

(Disclosure: I'm the author of rjsx-mode)

The best setup I've found is to use js2-mode for .js and rjsx-mode for .jsx,
which parse the buffer for syntax highlighting, local refactoring (with js2r)
and basic linting. For typescript, use typescript-mode. Flow support is quite
bad ATM

nvm.el replaces the shell scripts from nvm.

Add a jsconfig.json to your project root and enable tide-mode for completion.
This has worked far better than tern-mode, which some people recommend.

For fuller linting than what js2/rjsx offer, use flycheck. Eslint support is
built-in, so it should just work, I think.

 _[2018 update: I prefer using tslint, which you can accomplish with:

(flycheck-add-mode 'typescript-tslint 'js2-mode)

(flycheck-add-mode 'typescript-tslint 'rjsx-mode)]_

Finally, for build management, I use prodigy to run webpack, babel, ts, etc.

Feel free to ping me if you need more help

"""

One thing I didn't mention then was using mocha.el for mocha/jest, along with
indium for debugging. I couldn't get realgud set up properly, but had no
issues with indium, including for typescript/babel code.

[1]
[https://news.ycombinator.com/item?id=14884940](https://news.ycombinator.com/item?id=14884940)

~~~
bryanwb
This is super helpful. would you mind posting your prodigy configuration? It
seems like an excellent tool to run tasks like `yarn develop`

If you have any special config for indium, I would love to see that too.

~~~
fovc
Sure thing. Here's the JS-related prodigy stuff:

```

(prodigy-define-service

    
    
      :name "webpack"
    
      :cwd "~/project/"
    
      :init-async (lambda (done) (nvm-use-for "~/project/" done))
    
      :command "npm"
    
      :args '("run" "build" "--" "--watch")
    
      :ready-message "Build Finished")
    

(prodigy-define-service

    
    
      :name "tsc"
                 
      :cwd "~/project/"
                       
      :init-async (lambda (done) (nvm-use-for "~/project/" done))
                                                                 
      :command "npm"
                    
      :args '("run" "compile" "--watch")
                                        
      :ready-message "Watching for file changes.")
    
    

(prodigy-define-service

    
    
      :name "server"
                    
      :env '(("PORT" "6789")
             ;; etc.
             )
              
      :cwd "~/project/"
                       
      :init-async (lambda (done) (nvm-use-for "~/project/" done))
                                                                 
      :command "npm"
                    
      :args '("run" "serve-dev")
                                
      :ready-message "Listening on 6789")
    

```

------
da_murvel
I can't read the article as I'm getting a security warning. But I've always
felt really awkward using an IDE like VS or Eclipse. Even as a beginner when I
had no experience of using anything else I thought it was a bit, uncomfortable
pointing and clicking and having numerous menu options in my face all the
time. So when I got introduced to Emacs by a former colleague I started out
with a great amount of scepticism, I mean why should Emacs be so great when
nothing else I had tried up until that point hadn't. (I went through VS,
Eclipse, Sublime, Atom and 15 minutes of Spacemacs in advance). And at first I
wasn't impressed, the concept of doing 99.9% of everything using only the
keyboard was completely foreign to me. But the more I got used to it, and all
basic key bindings, the more I grew to love Emacs. Today, some three years
later I can't even imagine myself developing using something else. I know one
can set up other IDEs to get basically the same functionality. But yeah, Emacs
comes with the functionality built in so why should I go through all the
hassle of setting up the key bindings in VS?

~~~
mehrdadn
It sounds like you used VS as a text editor rather than as an IDE (because you
only needed the former, especially as a beginner). It's a little bit like
using your car to drive across the block. It's definitely less comfortable
than just walking, but it doesn't mean you'll have an easier time if you just
try to walk everywhere.

~~~
jgtrosh
Emacs is not to VS what walking is to driving. It's more like a programmable
car instead of a Microsoft™ Drive Studio. I don't think there's a good real
life comparison.

------
wrecursion
I have spent a lot of time trying out various editors over the years. The only
thing I absolutely require is some basic vim emulation that works the way I
expect.

To me, vim, neovim, spacemacs, emacs - all require a bit too much
configuration for my taste. I just want things to work, without having to
spend a lot of time micromanaging them. I tried Atom, but always found it to
be super laggy. SublimeText is really nice and fast, but it seemed like some
of the support packages were behind the times - and I could never get vim
emulation to work the way I thought it should.

I have found that VS Code really hits the sweet spot with performance, package
management, and vim emulation. Packages are well supported and super easy to
manage, and the vim emulation does all I need from it without any noticable
lag. I rarely need to change any configuration more than a line or a few at
most.

Like others have mentioned here, I still do everything with git from the
command line - except maybe the occasional diff perusal in gitlens.

------
baldfat
I still am loving the VSCode with the VIM extension. I write in Racket, R,
Python, JS, and Haxe. I still find Code to be the best for me and the support
in the extensions make my life easier. Only thing I don't use is the Git
extension, I still us git shell.

~~~
matwood
I'm in a similar boat. I use gitlens for informational purposes (diffing, see
changes, etc...), but do all my git operations on the CLI. It's a bit
irrational, but I know the git CLI and don't trust the GUIs to do the right
thing.

So now I use Intellij for anything Java, VSCode for all other coding and Vim
for quick edit tasks. The Vim keybindings keep every editor feeling familiar,
but I have the editor benefits where needed (I couldn't imagine writing Java
in anything but Intellij for example).

~~~
Insanity
IdeaVim is a great plugin! I love combining vim with the power of IJ like
that.

~~~
baldfat
It was a lifesaver for me a while back. I am so glad we have good choices for
a Vim Extension in so many tools.

------
keymone
every now and then i change things up and explore the field. textmate ->
sublime -> vim -> emacs -> idea -> (now) vscode.

i really want to like emacs, i think it's probably the most productive
environment if you sink a thousand hours into fiddling with your configs and
get things just right for yourself but ultimately it's a breath of fresh air
when most stuff just works out of the box and your config is just bunch of
checkboxes and simple text fields (or json). i've tried spacemacs and i've
tried writing my own config - none of it is even close to how quickly you can
get comfortable and productive in atom/vscode, even if the productivity
ceiling is (maybe) lower than that of emacs.

i'm in constant cognitive dissonance about electron apps. atom and vscode are
just incredibly good projects.

~~~
snlnspc
I'm not much of a dev and historically just did things in n++ or vim. I gave a
few IDEs a shot as I delved further into development, but wound up sticking
with vim and eventually moved to spacemacs.

the initial task of setting emacs up seems to be one of the most common
complaints, but I don't feel I really went through that with spacemacs. other
than adding a layer now and then, I think I've made less than 20 minutes of
changes to my config total, most of which was looking into a bit of lisp.

perhaps I should've tried a vim plugin for other ides, but I can't see myself
switching to something like vscode or a jetbrains ide despite agreeing that
they're good.

------
ArtWomb
VS Code is the IDE for people that think they hate IDEs. It's extensible
enough that you can turn off all the intellisense and highlighting. And just
have a pure, performant editor. With multi-cursor shortcuts. A spiffy built-in
terminal. And "Zen Mode" for full screen focus ;)

~~~
carlmr
I love IDEs, but I need something that gives me a good consistent editing
experience between all the languages, config files and everything in between
that's not tracked in a project file of some IDE. That's VSCode for me.

My initial reason for switching from Notepad++ to VSCode was file search
speed. We have a lot of 5GB folders at work that I can search in a few seconds
in VSCode. It needs 2-3 minutes in Notepad++. That is of course thanks to
ripgrep.

------
mrweasel
I love the idea of VSCode, but I find it rather confusing to use. The
configuration of plugins is non-trivial to figure out, sure you can copy paste
a bunch of stuff from the web, but how do I figure the configuration out on my
own? The best answer I've come up with this far is "You don't".

Even opening file/projects is a bit weird to me.

VSCode isn't necessarily to blame for this, it's just different from TextMate
and Vim. Still I've found it rather difficult to get started with.

~~~
artimaeis
> The configuration of plugins is non-trivial to figure out, sure you can copy
> paste a bunch of stuff from the web, but how do I figure the configuration
> out on my own?

For what it's worth I feel like the best way is to just explore the settings
and see what's there. Ctrl-, to open settings, then you should see the default
settings on the left side. Most plugin authors are pretty good about putting
decent comments to explain their configurations, and the auto-complete should
help to evaluate any options available.

> Even opening file/projects is a bit weird to me.

I've been using it 2 years now and still find the Ctrl-K Ctrl-O command to
open folders awkward and nearly impossible to remember.

~~~
parthdesai
>I've been using it 2 years now and still find the Ctrl-K Ctrl-O command to
open folders awkward and nearly impossible to remember.

    
    
      cd path/to/folder && code .
    

Pretty easy to remember tbh

------
kylestlb
I'm surprised that the author didn't like the emacs vscode plugin. I've been
able to tweak it to cover most of the text editing and movement commands I use
in emacs. In fact I find myself less and less in emacs for front-end stuff
because I haven't been able to really configure tide (or tern, etc) to work
optimally.

------
roryrjb
I really like VS Code, it has some good plugins and it's faster than Atom, but
it's still too slow. I use VS Code, Sublime, Intellij or Vim which is my
favourite editor. It's my favourite because it runs in the terminal and it's
fast. Unlike some others the interface is less important. I like the fact that
I can easily run the same setup for Vim on my laptop, via SSH, on OpenBSD, on
Linux, inside VirtualBox without a GUI, etc. For Node.js, Python, Perl I think
it's all pretty good across all those editors, the only thing I'm struggling
with is a good IDE-like experience for Java in Vim. Anyone have any pointers?

------
atjamielittle
I'm a long time emacs user and switched to VSCode for the same reasons (the
amazing JS support in VSCode). For keybindings, I'm using the Emacs Friendly
Keymap extension and didn't find it to be quite as buggy as the author
describes (I might just be using less key combinations though).

I used emacs for writing JS for years, and for the time js2-mode was amazing,
but the JS I'm writing now is quite a bit different. JSX and Vue templates
complicate the situation as well.

Since VSCode is written in JS, I suspect that it will always have advantages
when writing JS in the same way that emacs will probably always have an
advantage when writing Lisp.

------
joeevans1000
I use both and am an emacs fan. First off, the key-bindings in emacs are its
ridiculous weakness. That's why many smart emacs users use a vim emulator for
motions and the other frequent actions. The idea of pressing two keys to move
a character is absurd, especially for keys so awkwardly positioned to each
other. So, the idea of abandoning VSCode for its lack of the worst part of
emacs is certainly not a convincing argument. That said, I keep both editors
open. I suggest for anyone wanting to do that to enable vim bindings in both
editors and save your fingers.

------
haolez
I love Emacs, but I don’t use it anymore because of the key bindings. I like
them, but my pinky started aching when using Emacs for long periods of time.
Reconfiguring all of them, including the ones from the modes that I use,
doesn’t feel like it would produce good results in the end.

Since ditching Emacs, I’ve been using Atom, VSCode and Micro, but Emacs is
superior IMHO. But multicursor support is really cool in these new editors!
I’m using it all the time :)

~~~
dmortin
There is a simple solution for the keybindings: sticky keys. WIth sticky keys
you can press the keys one after the other, so you don't have to hit certain
keys with your pinky, for example.

[https://en.wikipedia.org/wiki/Sticky_keys](https://en.wikipedia.org/wiki/Sticky_keys)

I use it for many years with Emacs and I have no pain in my hands.

------
mi_lk
After fighting with lsp-mode on c++ and python, finding out they just work™ in
vscode gives me the opposite thought. Still love living in Emacs though.

~~~
currymj
well, the Language Server Protocol was developed originally for use in VS
Code. So not surprising it works better!

(i also wish lsp-mode would improve.)

------
Bizarro
_My VS Code experience became even better when I learned to drop //@ts-check
in every file._

You don't have to do that if you setup a jsconfig.json file in the root of
your project.
[https://code.visualstudio.com/docs/languages/jsconfig](https://code.visualstudio.com/docs/languages/jsconfig)

------
rjammala
I tried many editors including VSCode but keep coming back to Emacs. So far no
Emacs emulation mode was able to give me the full Emacs experience.

[https://sites.google.com/site/steveyegge2/effective-
emacs](https://sites.google.com/site/steveyegge2/effective-emacs)

~~~
swah
Yeah, I used to love Emacs as well, but nowadays there are just so many
languages and frameworks, all running together.

I bet Steve himself is coding on something like Intellij/VSCode, dropping to
Emacs only when the craziest text replacement job is required.

------
no_wizard
I am a huge proponent of VSCode for new programmers because it comes with a
lot of good support for very basic things and even some advanced things.

I do find however that it is something that skilled programmers will likely
outgrow except perhaps a subset of them. I myself moved on to the JetBrains
family of IDEs and use vim for minor edits or doing edits on the command line.

I’m not sure how Atom lost out so badly in this they used to be pretty good
but I hardly hear about them anymore

edit: given that my response was a little vague, i'll elaborate.

Visual Studio Code is wonderful for getting your feet wet in programming. New
Programmers i've worked (interns, usually) have tended to have professors that
teach Java and use NetBeans (i mean whatever, fine). So often thats what
they've used as their tool, and usually not a tool that they enjoy all that
much (in my experience).

Usually I have them start up with VS Code and the feedback I always get is
that they feel more productive, especially after adding a few plugins. I think
VS Code is just more intuitive to get the hang of and for the most part has a
power plugin ecosystem that can take one far enough not to feel like they're
completely out of the loop.

Where Visual Studio Code and the like start to break down for me (Vim has this
problem too, and heck, I have found very few other IDEs that can even handle
this properly) is when you get into multi-language projects where you have
code that is interdependent on some level.

For instance, with Python, I can get Jinja syntax highlighting in just about
any editor, but I have yet to find another editor that so perfectly will
autocomplete my variables from my Python code into the template and vice
versa. Even better, as of recently, I have noted that not only do they
complete my variables, but my @context functions are showing up as well, as
well as my filters. JetBrains is worth every. damn. penny. This is such less
mental overhead to worry about (especially because, if anyone who has read my
posts here will note, I'm prone to typos)

Once you get to a point where you are consistently living in more complex
projects and have multiparadigm code you're writing, I haven't found any tool
that handles it this way.

I just can't get over how good JetBrains is at making their product suite. I
recommend them at every turn. I do not however think, just because there are
so many features (and a great plugin ecosystem that it has) recommend it to
outright beginners, there is a bit of a ramp that will get in the way of
learning I have found if you start people off on it right away (Even with the
awesome free versions like PyCharm EDU or Intellj EDU, they're just too
overwhelming for newer programmers I have found). With that said, everyone I
have worked with who has interned with us has ended up on a JetBrains IDE if
they come work for us and I haven't had any real complaints yet.

Disclaimer: I don't work for, nor do I receive any compensation from
JetBrains. I just think they're a damn good product and deserve to be
recognized.

~~~
carlmr
>I’m not sure how Atom lost out so badly in this they used to be pretty good
but I hardly hear about them anymore

No stellar team at Microsoft supporting the project?

~~~
lazerwalker
Given that Atom is created/maintained by GitHub, and GitHub is now owned by
Microsoft, that's technically untrue :P

------
cmmartin
The best editor is the one you are most comfortable using. When I hear someone
argue that editor x, or even language y, is superior, I remind myself that
what they are probably saying is they know that one the best.

------
mullikine
I've been living in tmux since 2009. Vim and emacs have remained strong
editors all this time. They helped me to see that I need to transcend from the
editor and create my own languages. Now racket will continue to augment my
editors for years to come. It's all about the text my friends. Not the
scrollbars.

------
liftbigweights
If you are on linux, use vim or emacs or a linux-centric IDE. I prefer vim,
but others like emacs/etc. But one reason why I will never use VSCode on linux
is because they collect data ( or reserve the right to ).

If you are on windows, use VSCode for the light stuff (though I prefer other
editors ) and Visual Studio for serious coding. I know Visual Studio is
"heavy", but if you are going to do windows programming, you should have the
hardware to support their IDE.

All this evangelism by VSCode and the other side really doesn't contribute
much. The key is to stick to a tool and develop some expertise.

------
dockthis
I can say that for vi(m) users, there is an excellent plugin for VS Code that
works quite well. I still struggle with git in VS Code though, I prefer using
git on the command line.

~~~
elboru
VS Code has a terminal integrated in its interface and it’s just a short key
away from view. You don’t really need to point and click.

------
pulsarpietro
Well done!

