
Why I Switched from Visual Studio Code to JetBrains WebStorm - philonoist
https://www.mokkapps.de/blog/why-i-switched-from-vscode-to-webstorm/
======
nnq
Maybe people should realize that the problem is with the _JS libraries
ecosystem_ and how _most are build in a way that "just jumping into a
lib/framework to read its code and see what it does" can't seam to be feasible
anymore_.

For example, in a React app if I'd want to jump from a `Route` import from
react-router to it's _readable_ code definition [1], NO IDE or editor around
is capable a properly doing the jump, I either get to a Typescript definition
(VSCode does this - imo _the worst possible behavior_ ) or to some unreadable
transpiler outputed code.

This creates _a huge divide_ between _framework /library/component-author_ and
_" lowly" client/user-programmers_.

Compare this to the Python ecosystem where basically _any_ editor or IDE can
help me jump to the right place in a library's nice and readable code, and
even in the worst case where the author didn't bother to write either tests or
docs I can still make use of foreign code just fine...

[1]: [https://github.com/ReactTraining/react-
router/blob/master/pa...](https://github.com/ReactTraining/react-
router/blob/master/packages/react-router/modules/Route.js)

~~~
namelosw
I'm not sure if this is positive or negative. But somehow more or less
encouraged JavaScript community move towards:

1\. Minimal interfaces 2\. Better documentation

Say like React although the codebase is more or less difficult to read. But
the most useful surface-level APIs are quite minimal and intuitive. There are
more minimal libraries follow this pattern.

And for the documentation -- probably because of the minimal interfaces,
successful JavaScript libraries tend to have better documentation over most of
the languages. A lot of documentation with both quick start guide and great
higher level design or motivation explanation, instead of just generating doc
from comments.

I think that's why this community is moving fast forward because people trying
to be communicative, and constantly trying to simplify and introducing new
ideas. It's very hard for people just read the code to understand some brand
new concepts without a good understanding of the high-level constructs.

~~~
nnq
..that's like saying: _" We're proud to have the best the anti-suicide-by-
jumping building meshes system and workplace psychiatric counseling in the
world! The world record rate of suicide amongst our employees prompted us to
implement and perfect this measures to such a high degree, that now we're
considering to pivot our entire business model towards selling 'employee
suicide prevention consulting services', since nobody has more experience than
us with this!"_

(But jokes aside, yeah, you're right, there's lots of JS libs with much nicer
interfaces and docs than Python ones, I agree...)

~~~
moosingin3space
This is a rather tasteless joke.

~~~
nnq
In retrospect I'd delete it if I could. I was imagining it inside a Dilbert
cartoon in my head and it seemed funnier than it was. Again, I'm sorry for it,
mental health issues are not a joke, I should know that. And I should also
know that the tech community finds them less funny than others do, and for
valid reasons.

(...hanging out with ppl from the healthcare field made me too used to
cruel/gross/insensitive/politically-incorrect/borderline-sadistic jokes,
always forget that the rest of the world is less desensitized to death and
suffering than us :P)

------
owenwil
I made a similar switch from VS Code to PHPStorm and had a remarkably similar
experience. When I started using a proper IDE, I really began to get
comfortable with the inner workings of what I was doing–debugging the
frameworks I was using, jumping directly into methods and doing fairly broad
refractors with their refactoring tools. I’ve found it’s made me a better
developer by making that process simpler, while being very good at pushing me
into optimizing my code, be it through PHPDoc or simply not being consistent
in my implementation. I was surprised, but also, came to realize IDE platforms
seem to be stigmatized by many developers in the web industry: they seem too
heavy or not useful, but I’d argue it made me 10x more productive once I took
the time to use one.

~~~
jsmeaton
I really do think you (probably) need to use an IDE properly, so you can at
least make a conscious choice about what you’re giving up, or use other tools
that provide similar capabilities.

For example, I know a bunch of people that use print debugging, and don’t
“get” visual step debugging. But most of those people haven’t used a proper
debugger before.

I’m primarily a python dev using vscode. Pycharm debugger (and remote
interpreter!) blow away the vscode debugger. But I can use CLI tools (ipdb)
nearly as well as any visual debugger. It’s a conscious trade off that I make.
Specifically, I prefer the editing experience in vscode over pycharm, but can
bridge the gap in other ways.

Know your tools. Know the capability of other tools.

------
founderling
When you guys think about all the developers you know, do you rather see a
positive or a negative correlation between the usage of high level tools and
developer productivity?

In other words, is your experience that developers who use an IDE are more
productive then developers who only use a text editor?

In my experience, the (very few) developers I know who only use VIM or Emacs
are way more productive then those who use an IDE.

The reason seems to be that they tend to 'sit back and think' about the task
at hand. And then come up with elegant solutions. While the developers who use
a lot of tooling seem to hope that the tooling will kinda force them to do the
right thing. But from what I witness, that never works out.

I see a similar thing happening with coders who do a lot of tests (test driven
development), some tests and no tests. Developers who don't write any tests
are often the most productive.

~~~
not_kurt_godel
Out of the hundreds of devs I've worked with, I can think of exactly two who
use(d) vim to edit code with any regularity. Both are fairly proficient above-
average devs overall, but I'm pretty sure they also use IDEs heavily and only
use vim for quick things. Beyond a certain level of codebase complexity, there
is simply no way to do the job with a text editor, even with fancy macros. Vim
is an elegant tool, but is simply outmoded for many modern development tasks
in the same way that a hammer is outmoded by a nailgun. You might always need
a hammer in your back pocket, but it can't compete with a nailgun for large-
scale repetitive tasks.

~~~
jjeaff
Interesting. From reading HN, you would think every coder worth anything is
hacking away with emacs or vim on black and green terminal screens.

But I suppose people that use emacs and vim are like vegans. Those that do,
are definitely going to tell you about it.

~~~
arcturus17
What’s with this vim vs IDE debate anyway - vim works wonderfully with the
IntelliJ suite and many other IDEs.

If you’ve been doing vim or emacs since the 80s then great but I’m not going
to go through months of configuration hell to repurpose vim into an IDE when I
can do it the other way around.

~~~
not_kurt_godel
My feelings exactly. Like I said, there's nothing wrong with a hammer (vim),
but it's a poor use of time using one to fasten 3000 nails to frame a
building. I think vim/emacs users get defensive and militant because they've
invested significant time and effort into learning a specific set of skills
that tie into their professional, and to an extent personal, identity. It's an
understandable psychological defense mechanism to reject the notion that those
skills are significantly less valuable nowadays, but it doesn't negate the
fact that their judgement is being clouded.

------
hansflying
Very biased article and by the way, tslint will also warns you if you don't
use promise:

[https://palantir.github.io/tslint/rules/no-floating-
promises...](https://palantir.github.io/tslint/rules/no-floating-promises/)

~~~
hansflying
ABSOLUTELY EVERYTHING in this article is wrong. I just opened a typescript
project in VSCode, created unused function and a class method and I
immediately get warning that they are unused. So the author can't even check
the facts before writing an article...

~~~
steve_taylor
TypeScript is definitely a first-class citizen on VSCode. I’m considering
TypeScript in my next React project and will definitely consider using VSCode
instead of WebStorm. I’m a long time WebStorm user and ES6+React developer.
TypeScript looks like it can solve a lot of my pain points and it supports JSX
syntax (TSX).

------
__m
I love the jetbrains toolbox. I do unity development with Rider, Android
development with Android studio, web development with webstorm, python
automation and ai learning with pycharm, java development with idea and I use
it as diff/merge tool like the author (additionally you can toggle blame mode,
which shows you the last person who edited the individual lines, at what time
and with a color coding that highlights recent changes). Having a familiar
user interface for all these IDEs and on top of that available on Mac, Linux
and Windows won me over. I started with Rider for unity since I mostly use
macOS and Monodevelop did not spark joy (vs for Mac didn’t exist yet and I
prefer the user experience of the jetbrains IDEs).

~~~
gloggy
Yep, this describes me too. I work on multiple OSs, in multiple languages and
I use everything from CLion to WebStorm. The interfaces are consistent on each
OS, all the commands are the same, and while not the fastest IDEs in the
world, my dev machines are good enough that I can run them comfortably. I
think good IDEs make me more productive. I find the whole "you're only a good
programmer if you program in ed" line to be really disingenuous.

------
ashnehete
I can understand that people may perceive VS Code and WebStorm as
alternatives. Though, as rightly pointed out by the author, the former is an
editor while the latter is an IDE. The whole post just says that in 10
different redundant ways.

~~~
matharmin
What's your definition for an IDE that does not include VS Code?

Just because VS Code feels lightweight, doesn't mean there is any fundamental
limitation preventing it from supporting all the features mentioned in the
post. In fact, as the author and others mentioned, you can achieve many of the
same features with plugins in VS Code.

Yes, WebStorm is better in the points mentioned by the author, and the
JetBrains IDEs are amazing in general. But saying it's because one is the
editor and the other an IDE is completely wrong.

~~~
carlmr
People like VSCode so much that they write extensions that mimick some of the
more useful IDE functions. But an IDE comes preconfigured for one
language/environment.

I almost don't code JavaScript/TypeScript, it's not very useful in embedded
work. I use VSCode, but I have no use for this IDE. This article is
meaningless if you're not in the same niche as the author. While VSCode is an
editor that is made for any language.

~~~
stephenr
> But an IDE comes preconfigured for one language/environment.

I can’t count all the languages IDEA Ultimate (also JetBrains) supports via
plugins.

------
Lowkeyloki
Having used both, I can say without hesitation that they're both fantastic
works of software. I personally use vscode as my daily driver now because it
has all of the features I care about from WebStorm but it's free.

(I also have a license for Sublime Text and used that for years. I still
prefer vscode now. But a developer's IDE/editor is a deeply personal choice
and everyone should use whatever software they're most comfortable and
productive with.)

~~~
cheerlessbog
Sublime just isn't able to iterate as fast as VS Code can - it's closed
source, and seemingly one or two developers. So I expect the gap to widen. Of
course if Sublime already fills your needs, that's not a problem.

------
Niksko
While VS Code presumably can do almost everything Webstorm (and other
Jetbrains products) can, my experience in my fairly large software company is
that most of the people that use VS Code don't actually bother to install the
plugins to bring it up to feature parity. Out of the box functionality is
underrated, even seemingly among devs who have the skills and knowledge to
tinker.

~~~
eridius
VSCode has a ton of extensions but very frequently there's no good information
about which extensions you should actually use, and whether you need to
configure them to get the best behavior.

For example, the other day I went to install a GraphQL extension for syntax
highlighting and there was something like a half-dozen competing extensions,
with no good way of figuring out why I should use one versus the other. I
eventually ended up picking the one that looked the simplest, because all I
really wanted was syntax highlighting and nothing else.

~~~
cheerlessbog
The VS Code extensions manager shows a star rating, download count, extension
description, a list of the commands they expose, often the popular extensions
have animated gifs showing how they work. What else are you looking for?

For example when I installed VS Code I needed a Git extension. There are
zillions but only two or three that are clearly ahead of the pack and it only
took a few minutes to try each one.

~~~
eridius
What I'd really like to see is "date this extension was last updated", and
ideally a full changelog. If I see 2 extensions that claim to do the same
thing, with similar star ratings, where one isn't being maintained anymore but
the other is, there's no way to tell from the extension browser that one of
them is still under active development and the other isn't. Download counts
are nice but they're also totals, they don't tell me about recent activity, so
e.g. if one is an old extension and one is a new extension, the old extension
is going to have a higher download count regardless of the relative quality of
the two extensions. So "date this extension was last updated" as well as a
"recent download count" would go a long way toward making the extension
browser easier to use.

~~~
cheerlessbog
That makes sense. maybe you could suggest it to them, if nobody did already.

------
disillusion
I would like to try to switch to a JetBrains IDE. Especially the refactoring
tools look to be much more advanced then Atom or VSCode.

At my workplace, most developers are either full stack or backend (python). As
such, we have a grab bag of PyCharm licenses. However, I am purely a frontend
developer, so frontend related tools are much more important to me then python
support.

Unfortunately, the last time I tried PyCharm the integration with linters,
toolchains, different template languages etc. was quite limited. Or perhaps I
couldn't find the needed extensions or where or how to configure the right
settings. I don't know if this is a JetBrains IDE thing, or simply because
PyCharm is so geared towards Python development only.

The projects I work on are integrated in different backend systems. So one
might be a C# project with Razor templates. Or it'll be some PHP with another
templating language. Or it might just be mustache or handlebars. It might be a
SPA in Angular, Vue or React. It might be purely Node.JS project. Some
projects have Webpack, some have a Gulp toolchain. Linters might differ
between projects. Folder structure also differs, one might have the git
repository in the root. Another will have it one or two levels down. Some use
a python virtualenv. Others use a docker container. Others use no enviroment
management at all.

In my experience, because of the different nature of the projects, the PyCharm
editor offered little extra functionality over Atom/VSCode, while missing a
lot of simple extensions that Atom/VSCode does have. I was also quite a bit
slower to start up.

Is it possible to configure / extend PyCharm to offer the same frontend
related functionalities as WebStorm, or is a separate license needed? And is
there support, or are there extensions, to support different toolchains,
linters, templating languages etc. per project? The backend language support
can be limited, as long as the very basics are there, and I'd like advanced
frontend support for refactoring, debugging, etc.

~~~
stephenr
The language specific apps (pycharm, rubymine?, phpstorm, webstorm) can’t run
most other language plugins.

Get IDEA ultimate (also jetbrains) and just install the language plugins you
need.

I use this to write php, shell, sql, javascript, css, html, a little ruby, a
little python, makefiles, and hopefully some D-Lang soon.

~~~
arcturus17
> language specific apps

Isn't IDEA to Java what PyCharm is to Python?

~~~
vbezhenar
Intellij Idea Ultimate is a universal product. Yes, it supports Java (and that
support probably can't be turned off), but it allows to install support for
almost anything (I think that Objective C and C++ is an exception). You can
install PHP, Python and other languages. PyCharm is basically Idea with Python
plugin and without ability to install other language plugins.

~~~
stephenr
Thankyou this is a better summary than I’d have written while on my phone.

------
loxs
Currently I use WebStorm, but I also always have a spacemacs window open, to
do the things that WebStorm can't do.

Fresh example from yesterday: I open a .graphqlconfig file in WebStorm, which
is a JSON file. Good luck making WebStrom open it as a JSON file... One minute
later, I've opened the file in emacs, M-x json-mode, M-x mark-whole-buffer,
M-x json-reformat-region, did the changes I needed to do, carried on with my
life.

So it's not that WebStorm (or any other fluffy high-level tool) is perfect or
"enough". There is always this one thing that will make your life miserable if
you are religious with these things.

~~~
abdusco
You can assign non standart file types to various languages.

[https://www.jetbrains.com/help/idea/creating-and-
registering...](https://www.jetbrains.com/help/idea/creating-and-registering-
file-types.html)

------
Illniyar
I've used both. Webstorm is definitely slightly better in most things. Little
things like better handling of closing tags or more useful context menu.

VSCode is massively easier to configure and has a lot more plugins. Most major
plugins are covered by Webstorm or plugins, but it's the small things that
give you an extra push.

Webstorm is more polished. VSCode is faster and more configurable. They are
nearly equal rivals in my book, except one thing. Git integration in VSCode is
horrendous. I work with git constantly while I code and the lack of proper
support is a considerable productivity hurt.

------
namelosw
I use WebStorm/IntelliJ/Rider/VS+Resharper at work. And use Emacs off work,
occasionally use WebStorm/Rubymine. Recently I picked up VSCode and I think
it's good.

For most of the functionalities, I think WebStorm still won. But VSCode
typescript completion is great. WebStorm typescript completion is somewhat
strange.

However, the mindset of WebStorm follows IntelliJ, of course. You cannot
switch projects or single file as simple as code editors. Although it can be
achieved but it still feels weird. IntelliJ is constantly trying to improve
this like scratches, but it will be still different from code editors.

And something off topic, I found IntelliJ/WebStorm is pretty much following
Emacs for a lot of features. Like the VSC system is very alike Magit and they
deprecated their RestClient and use an editor-based approach just like Emacs
RestClient, or simply scratches. Seems a very good strategy to copy from Emacs
community at least for MVP.

------
Theodores
One thing that the JetBrains editors have that isn't found elsewhere is
support for SVG.

Once you take SVG to a certain level the desktop graphics programs no longer
help, they add too much cruft and you also can't do things like have the
origin of your drawing in the middle of the canvas. Having the origin in the
middle makes things easier to mirror, rotate and so forth, which you might
need if building an icon set.

Being able to live-edit a SVG opens new possibilities, you don't have to
assume that you need the graphic design tools to 'draw a box' and you can keep
shapes such as circles as circles, not some huge long list of points specified
to 9 decimal places.

Right now I am building a SVG drawing that needs to take numbers to draw it to
scale, I would never be able to do this without building a prototype in a
JetBrains editor.

------
karmakaze
I use IntelliJ IDEs for statically typed languages (and Ruby/Rails), the
refactoring/ navigation is top notch and search is super quick.

For web work I use VS Code because it has the best plugins for Vue, React,
etc. I would also use it for less popular languages.

~~~
giancarlostoro
Same here. For D the best thing is VS Code or Emacs (Spacemacs) atm. I also
swap to VS Code for when resources are tight on a system (VMs sucking all the
juice). And when I need a lighter editor I open up Sublime Text 3 or VIM if in
a Terminal.

------
dfischer
I've used a lot over the years – always in VIM mode. As I have moved to GO
recently I was using VS Code but found it bugging out at times. I switched
over to Goland (I used to be heavy in WebStorm). It just works. I am happy.

~~~
kmlx
intellij idea ultimate with the golang plugin feels like a swiss army knife
for go :)

------
realusername
It's always the same debate, on my case all the features of Webstorm he's
listing I will likely never use them whereas the lag issues & the clutter
interface of Webstorm just make it a no-start as my main editor.

~~~
kmlx
you mention speed. then you’ll be happy to find out that sublime text is much
faster than vs code. on my mac even my intellij idea ultimate is faster than
vs code. from my experience, vs code is the slowest editor you could possibly
use, slower than a full blown ide, slower than a text editor. it’s just a slow
piece of software.

~~~
realusername
Yes indeed I know, I hesitate to go back to Sublime because of that, VSCode is
still pretty slow and the RAM usage isn't great.

------
xrd
As the author points out, refactoring is terrible with Code. I use it as my
primary editor but often fondly think about how well Android Studio does
refactoring. I'm going to give Web Storm a try.

------
lostmsu
Wait until they see ReSharper/Rider/IntelliJ.

------
seddin
There also this cool text editor, simple and fast, called Pluma and available
on Ubuntu Mate which I really enjoyed using.

~~~
firmgently
A fork of gedit 2 (for anyone interested in such trivia)

~~~
shakna
Well that took me down a rabbit hole.

Xed is a fork of pluma, and is an X-App included with Linux Mint. (Seems to be
under very active development.) [0]

Pluma is a fork of gedit2, seems mostly to integrate it nicer with MATE.
(Seems to be under very active development.) [1]

gedit is also still around, and is still "Gnome's text editor", and seems to
be under very active development. [2]

[0] [https://github.com/linuxmint/xed](https://github.com/linuxmint/xed)

[1] [https://github.com/mate-desktop/pluma](https://github.com/mate-
desktop/pluma)

[2]
[https://gitlab.gnome.org/GNOME/gedit](https://gitlab.gnome.org/GNOME/gedit)

------
skrebbel
Tldr: nothing fundamental but WebStorm has a few features that the author
likes that VS Code doesn't have.

~~~
v-yadli
Agreed. Nothing fundamental but js sugars.

For me the IDE is more like a text editor bundled with extra goodies. E.g.
multi-window (thus multi display), more elaborated software hierarchy (not
just for code editing) vs. a main panel as editor and side panels as
auxiliaries, automatic window management like Eclipse perspectives (or in VS,
when you debug, it switches to the different window layout).

It’s not black and white unless you go with nano or notepad.exe. You can also
roll your own ide with tmux, i3 etc.

btw have you guys ever tried to hack gvim window handles into Visual Studio?
:-)

------
revskill
On average, VSCode is enough. Consider a Rails project. For Jetbrain, you
better use RubyMine for the Ruby part, it's the same as WebStorm, but for Ruby
projects.

Now you better use WebStorm for the frontend part, right ?

In case of VSCode, one Editor to rule them all, both backend (Ruby) and
frontend(Typescript) part.

~~~
virtualmic
> Now you better use WebStorm for the frontend part, right ?

All functionality of Webstorm is included in RubyMine and PyCharm (I use
PyCharm daily). Ref:
[https://www.jetbrains.com/ruby/features/](https://www.jetbrains.com/ruby/features/)

~~~
steve_taylor
It’s available as a plugin, with a different release schedule than WebStorm,
so it’s always lagging behind WebStorm.

~~~
virtualmic
I just tried 3 latest features for Webstorm listed here:
[https://www.jetbrains.com/webstorm/whatsnew/](https://www.jetbrains.com/webstorm/whatsnew/)

All are working on my latest version of PyCharm Pro.

------
brownkonas
WebStorm is a bit of a resource pig. Running the stack plus WS plus browser
has exhausted RAM, 16GB mind you, on a lot of our teams laptops.

~~~
vbezhenar
I can launch AAA game, virtual machine with database inside, Intellij Idea,
Android Studio, tomcat with my web app, Android Emulator, browser with bunch
of tabs and other insignificant software and I have enough free memory from my
16GB. I have no idea how could you exhaust 16 GB with Webstorm and browser
alone.

It's not a slim software, sure, but 16 GB?

------
Lapsa
have you found vim in your heart?

