Hacker News new | past | comments | ask | show | jobs | submit login
Why I Switched from Visual Studio Code to JetBrains WebStorm (mokkapps.de)
141 points by philonoist 10 days ago | hide | past | web | favorite | 157 comments





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...


It's been bugging me for a while now as I can't find the video but the Vs code team made a demo where they were able to jump to a dependencies source code on github inside the editor. Looked pretty amazing and would definitely solve the problems you mentioned.

It might have been --declarationMap, part of Typescript 2.9

https://github.com/Microsoft/TypeScript/wiki/What's-new-in-T...

Jumping to definition works with typescript projects correctly when this is turned on, but it's still not a solution for JS projects with definition files


Oh yeah.. In VS Code, where I wanted to go to the definition, and it took me to the Typescript file.. It's just insanely frustrating.

Your right it is the absolute worst possible behavior.

I get that information when I hover over the method/class/whatever.. I am looking up the definition because I want to see how this works.


...10x more frustrating when you see that there are >1 y old bug reports about this but it's always delegated as lower priority than smth else and after (I think, not sure anymore...) someone fixed some underlying functionality that was supposed to make this possible, the actual functionality of usable jump-to-implementation is still not fully implemented!

And I'm not saying that the devs don't care or not doing wonderful work... just that they've ended up with a codebase where something like this is genuinely hard to do.

And when they'll finally get it will still be frustrating as hell because >50% of the time it would jump to some unreadable transpiled code because there's no actual standardized way to jump to the original source the final js got transpiled from. In an ideal world, if some React component was written in OCaml mixed with Clojure and transpiled to JS, I'd want to be able to jump to the implementation into that actual original OCaml or Clojure code. But I get it, whoever would be smart enough to get that working reliably would probably make better use of their time trying to cure cancer or solve climate issues or go to Mars etc.

  </rant>

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.


..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...)


This is a rather tasteless joke.

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)


This is so true. Written documentation explaining the intent of 3rd party libraries is crucial. Comments as documentation is horrible to work with!

That's a strong argument against using front-end frameworks and other things that require you to run a build on your front-end code.

There are plenty of options to build fast, modern front ends without having to deal with any of that.

And you're right about IDEs too. Given the choice between a full-blown VS.NET + ReSharper versus VSCode + $1,000 in my pocket, it's just no contest. No matter your bill rate, you still break even in single digit hours of productivity gain.

As a solo entrepreneur, it's even more of a no brainer, since it's my free time that I'm gaining by working with better tools.


> a strong argument against [...] things that require you to run a build on your front-end code

Not really, if it's your own code that requires a build step, then you control that build step and the tools and all and you can have nice auto-reload and fully working source maps and integration with all your other tools...

Do whatever exotic build and transpilation makes you more productive when developing your application's code. But libraries and frameworks... it's not OK to have a large part of the ecosystem dependent on such build tools and at the same time have no usable tooling standardization to easily implement something as basic as "jump to implementation in original source".


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.

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.


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.


Developers who don't write any tests are often the most productive.

If you look at them in isolation, sure. If you look at the whole team you'll see that the untested code drags everyone else's productivity down because all the other developers can't modify untested code without fully understanding everything it does. They have no tests to give them any confidence that they're not breaking stuff when they change it.

Developers who don't write tests are fine if they're working alone, but they're toxic to team productivity.


In my experience this is the same for people who use a low level text editor as an IDE.

The code that comes out of developers that use IDEs is normalized in a way that makes it very easy to change. Sure, if your big enough you can spend all your time inventing linting rules and creating templates to generate scaffolding and tests.


Just use a formatter already and get over linter bikeshedding.

I honestly don't understand how people are still bickering over style guides in modern programming. Autoformatters exist in every major language. Git hooks exist. Company style guides exist. Pick one, and then it's never an issue what editor people are using, it's bizarre that this bikeshed still exists.

In all my years of using emacs I have not once been called out on formatting. In my last job the bastion of PEP-8 was a vim user. If you're talking about actual low level text editors like nano or notepad.exe, then sure, but vim and emacs are proper tools.

well, if you’re referring to the developer gagging hairballs of tests building tons of state for happy paths and individual edge cases then yes, perhaps. Concise property and generator based tests on the other hand are shockingly simple and useful to write

I think it really depends on the type of work you are doing.

- If you do low-level stuff like writing a hardware driver or a kernel module you will most likely be fine with a normal text editor because all in all it's not that much code

- My friends in a large PHP shop all use PhpStorm to work on large projects. They all tell me that you are way more productive in PHP with the specialized tools that PhpStorm offers. In the whole company there is not a single person who uses emacs or vi for PHP (a lot of them use vi for everything else, but not for PHP)

- I used to have a job where I had to switch between 2 dozen projects in the span of a few weeks and fix things. A proper IDE makes it much easier to navigate code you have never seen before. Without IDEs I would not have been productive in that sort of job at all


Absolutely this, I've worked on a project that was 450 assemblies and about 5 million lines codes split over a few thousands source files.

Without an IDE that can jump between those assemblies and source files it's an absolute nightmare.


It's a wonderful example of selection bias. Basically, vim/emacs is likely to select for people who are "good at computers" and reject everyone else. These people, in turn, are more likely than average to be excellent programmers. But I wouldn't necessarily draw the arrow of causation in this case. Not only does this not mean that IDE users are worse, it also doesn't mean that there are fewer great programmers among them in absolute terms (even though percentage wise, that's probably the case).

Full disclosure: I'm a vim user.


There is no selection bias because no selection has been done. It's up to you how you interpret the aggregated anecdotes.

Such queries are meant to discover notable impact, based on which you might invest in a proper evaluation.


But there is selection. Most "normal" programmers can't even _exit_ Vim, let alone use it with any degree of proficiency.

This is not an example for selection bias, but rather that correlation does not imply causation.

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.

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.


The world is jam-packed to the brim with posers, in every walk of life.

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.


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.

You would also think that every coder lives on the west coast and makes $300K+ year....

Would you mind being a bit more specific than using vague language and analogy? What are all these modern development tasks?

+1 I use intellij for big projects because of the jump- and refactoring stuff but I know I could do it with VIM if I'd know it better.

A good example is SpaceVim that enables people who don't want to configure everything to use VIM as an IDE that provides most of the tools you'd need for developing.

E.g. it has a linter for python, mouse support and code-completion. I don't need much more to develop most of the time.

VIM is awesome and I think what most people whining about it ignore is the fact it runs in a terminal (vs. some big bloated piece of sh*t).


* Find usages

* Go to definition

* Extract method

* Introduce parameter

* Inline variable

* Rename method

* Rename variable

In a Jetbrains tool these are automatic / atomic operations.


All of these can be done in emacs/vim as well for most of languages. None of the above is modern by any standard.

Feel free to demonstrate how in either of the above to highlight a block of code, extract it to a function and replace all the duplicate blocks with a call to the newly extracted function correctly across an entire codebase in a couple of keystrokes.

Or have a go at https://github.com/daviddenton/refactoring-golf


What planet are you people living on? It's like you just whack the word "modern" on the front, stick your hands up and say "haha, you couldn't understand, grandad". Programmers have been doing these things since the beginning of time.

I programmed exclusively with text editors for a number of years. Of course you can do anything in a text editor that you can do in a modern IDE as long as you have patience. I would even go so far as to say that having the experience of using a text editor instead of an IDE is a valuable one; certain types of edits really can be done much more efficiently in vim than an IDE so it's an excellent tool to have at your disposal. But text editors simply can't match the sophistication and efficiency of a good IDE that is built to interact with your code programmatically from the ground up. For example, here is a list of refactoring operations that IDEA provides as atomic operations that can be done in a few clicks/keystrokes and instantly, safely undone with a single keystroke[0]:

* Change signature

* Convert Anonymous to Inner

* Convert to Instance Method

* Encapsulate Fields

* Extract refactorings

  * Extract constant

  * Extract Field

  * Extract interface

  * Extract method

  * Extract Superclass

  * Extract variable

  * Extract parameter

  * Extract into class refactorings
* Find and Replace Code Duplicates

* Generify Refactoring

* Inline

* Invert Boolean

* Make Static

* Migrate

* Move and Copy refactorings

* Pull Members Up, Push Members Down

* Remove Middleman

* Rename refactorings

* Replace Constructor with Builder

* Replace Constructor with Factory Method

* Replace Inheritance with Delegation

* Replace Temp With Query

* Safe delete

* Type Migration

* Use Interface Where Possible

* Wrap Return Value

Meanwhile, merely performing a simple pure-text find-replace across multiple files using vim and emacs is a chore. And better hope you don't screw it up because there's often no easy way to safely undo such a change, especially not with a single keystroke. The idea that even master-level users of vim/emacs could begin to hope to replicate the operations listed above with the depth, accuracy, and user-friendliness that IDEA offers is simply laughable. Any granddad worth his salt is perfectly capable of understanding that advancements in software have yielded tools that are by far and away objectively superior for a wide variety of development tasks.

[0] https://www.jetbrains.com/help/idea/refactoring-source-code....


That's cool, if you plan to work on the same technology forever. I think why vim/emacs users have over IDE users is that when you change technology or company or team, you can just change some things about your config and keep working. Try replacing a cool IDE for assembly with a cool IDE for PHP and then a cool IDE for Clojure.

> Meanwhile, merely performing a simple pure-text find-replace across multiple files using vim and emacs is a chore.

It is not, i do that fine in emacs. Half of your list can be done with regex replace. Things like extract and refactor needs language specific tooling that can be done with text editor too(see LSP). And some stuff on your list doesn't even apply to other languages that they have community support for e.g. Rust.

But sure Jetbrains has put lot of effort on these tools for a few languages that you can certainly benefit for a large project. Outside of that good luck using it for any other language.


Good luck with regex replace for most of these operations. Seriously, you're gonna need a lot of it to do these things correctly and consistently, if you can even do them at all. And even then it will be about 10-100+x the time and mental overhead that it could be with an IDE.

I don't see how they could be done with regexes. It seems to me that most of them require class hierarchy analysis so that you don't touch the wrong method that just happens to have the same name.

Yeah, exactly. Every time I try doing these things with regex there winds up being some edge case where something that should have been picked up isn't or vice versa. Then there are ambiguous cases of references in comments and non-code files for which IDEA provides a very straightforward UI experience to include or exclude by various categories or on a case-by-case basis.

Even in the best case scenario where regex works, you've still spent unnecessary mental overhead writing regex, a tool that is so difficult to use properly that it is the textbook example of being a 'solution' that causes more problems than it solves. Why subject oneself to such unnecessary hassle?


In terms of undoing, I use git and I could undo it with just a few keystrokes. As for the refactoring, yeah, you're right, that stuff would be difficult. I'll keep it in mind if I ever do need to do that stuff. It hasn't happened yet, though.

Lol, k. Good luck.


If I can't do a "modern development task" with emacs or vim and a smattering of standard Unix tools, then I question the sanity of said task. At the end of the day we're editing text. Plain text has stood the test of time exactly because you can process it with tools that everyone knows and have been around for decades. If you find yourself needing special purpose, proprietary tools to handle your code base then you should really reconsider where you're going.

Sane or not, it pays the bills...

It really does help to get a reminder from the IDE regarding which methods exist and what their parameter lists are. For C, ctags works well enough I guess and we can complete function names that way. But for Java and C#, I can't imagine that going well.


Real coders boot up their computers and type

  CALL -151
  !
And type 65C02 assembly.

Now get off my lawn.....


Let me just remind you of what the GP post said:

> Beyond a certain level of codebase complexity, there is simply no way to do the job with a text editor

An absurd claim. How can you interpret my post as a "get off my lawn" type thing?


Well because it is. With a large codebase, things like navigating through a solution, automated code refactorings, intellisense, etc. can be done with IDEs. Do you all so litter your code with print statements to debug?

Are you just playing ignorant for fun? You must know that there are people out there hacking on the most advanced software projects we have such as the linux kernel or C compilers etc. and they don't all use IDEs.

And what percentage of developers is that? That’s about like the same bubble thinking of every developer works on the west coast making $300K a year that you see on HN.

And some people also still write in assembly. I also thought that any high level language was useless. Then I thought anything more high level than C was for beginners.

But I grew up and start being more concerned with making money and implementing solutions than having geek cred...


Good for you, man. I hope the money continues to bring you happiness.

I personally am most productive when I work instead of faff about with different tools each week, so I guess whatever you’re good at is a good approach. If you used vim since the ‘90s you probably don’t waste much time with learning different editors all the time.

I obviously also write more code when I don’t write tests, but the code isn’t better or more useful. I remember the times when there was much less testing so other people’s code was kind of useless a lot of the time.

Personally I use Sublime most, because I’ve done that for years, but for rookies reading this, don’t go and get Sublime just to mimic me. If you’re starting out then use whatever people you can get information from use, so you can ask questions and they have less friction when helping you. So if you write C# targeting Windows, having Visual Studio proper will be a boon so you’re probably using the same thing as the Stackoverflow people. Doesn’t matter that an Internet forum user uses Sublime or vim.

My comment reads like it comes off as snarky, apologies.


Actually your comment was insightful. I have a bad habit of editor jumping. Went from vim (6mo) -> emacs (18mo) -> vscode (8mo) -> and have been using sublime for the last month. Keep switching because I don't feel productive in them and kept getting a grass-is-greener vibe every time I'd see someone online using it. Maybe it's because I never specialized and really got gud with one of them. Would have stuck it out with emacs but using it on windows is a big meh (way too much fiddling, generally speaking). Popped off vscode because... microsoft. although it had the most surface polish of the editors I've tried, and intellisense was nice. Sublime has been good to me so far, but the available themes leave something to be desired, and the emacs keybinds are iffy. Maybe I just haven't found 'the one' and at this point, there are too many features from each editor that I like that I may never find it. Emacs came closest, but learning to configure it was too time intensive, had to cut my losses and find something more portable and time efficient. Guess I'll just stick with sublime from now on and say that's that...

> do you rather see a positive or a negative correlation between the usage of high level tools and developer productivity?

Absolutely none whatsoever. If anything it's negative. I have never found "speed of editing" to be remotely correlated with good code or even productivity.


most people here aren't talking about speed of editing, but rather speed of code navigation.

That way it's easier to figure out what's going on in larger codebases, or one even just one you're not familiar with.


How many automatic guaranteed safe refactors can I do with VIM? Of course I’m referring to statically typed languages.

Something as simple as renaming a method and it is automatically renamed in your entire code base is a life saver.

https://www.jetbrains.com/resharper/features/code_refactorin...

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.

Tests aren’t about productivity. They are about maintainability when you have to make changes. How many large code bases have you dealt with?


The Language Server Protocol [1] makes such refactors possible in Vim (and other editors).

[1] https://microsoft.github.io/language-server-protocol/


So it’s possible, have any implementations where you can use VIM and do massive project wide refactors?

I haven't personally done any massive ones, but vim-lsp and tsserver have worked fine on a tens-of-thousands of lines large project.

It's the same gubbins that VS Code uses for all of its cleverness.


Personally I see no correlation. I need an ide for 3 use cases: jump to definition, find all references, refactor (replace all occurrences). I’m sure vim can do that but I don’t know how and am too lazy to learn (open to consider that makes me less good a developer)

The best programmers I know actually have zero editor loyalty. They've used vim/emacs, Visual Studio, VSCode, Atom, Sublime Text, etc. for significant periods of time. They're always willing to drop their current editor for a new one that seems to work better for them.

> The best programmers I know actually have zero editor loyalty.

Thanks. This comment made me feel like a best programmer.

Jokes aside, I love trying new tools, and it's probably just curiosity, and every tool you try either teaches you something you like, or something you don't. For instance, it's unlikely that I'll ever use an editor that doesn't have a vim-like plugin (for input), but I can't get myself to actually use vim anymore. At the moment I mostly use VSCode, Emacs, or IntelliJ... depending on the language and the support editor's for my workflows (in that language). In emacs, I tend to use the terminal in my editor, whereas in VSCode I'm usually switching between iTerm and VSCode. I sometimes run tasks, builds and debug from IntelliJ, but I'm not sold on the embedded terminal.

I'll have to be honest with myself here though: I often feel that whatever editor I'm using does indeed impact my productivity and that none of them is perfect, and perhaps this is why I'm never happy with any editor in particular. I've never really used a proper IDE other than XCode (maybe emacs counts as one, but I don't think the way I use emacs counts), so I'm always curious when I hear people talk about Visual Studio + ReSharper. I'm not a .Net developer and I don't use Windows, so I'll probably never know.

That being said, my productivity also varies from stack to stack. I'm not as productive in JavaScript as I am in Go or (I would say) Rust, and I think it's just down to the fact that the tooling is great in most editors, as well as outside the editors. I'm not sure I can confidently say that bout JavaScript/Typescript (although much better now than say 5 years back).


1. That depends on the developer

2. Dev's who use VIM/Emacs are probably already living in their computer so you can't really say if they are good because of the editor they use or the other way round

3. What do you mean by "productive"? Closing more tickets in a sprint? In the end not only individual efficiency is important but also the future of a project. With test you document stuff and ensure at least the tested things won't break (if it's mandatory the tests are executed on every build).

4. Of course tools matter. In our company there is people who still use eclipse and sometimes they just need their time to fix the IDE. My team exclusively uses intellij and I can't remember the last time we had to deal with such a mess.


If I got a job offer and they insisted on using Eclipse, I would most likely turn it down. Once you are used to Intellij, there's no going back. I even paid for a private license that I use for my own projects.

I sometimes open VS Code for small for small non-project related files, but I am much more productive with an IDE.

One thing that many get wrong in the VIM vs IDE comparisons are the benefits of keyboard shortcuts. They assume that VIM has a significant advantage, but you can have that with IDEs too.

The JetBrains products have keyboard shortcuts for almost anything, so you do not have to use a mouse unless you want to. I'm sure the same could be said about other IDEs as well. Many forget that when they compare against VIM.


Don't know how I managed to trigger you here but:

- I would also not use eclipse and turn that down - Maybe you are more productive. I have seen people who will be more productive than you just using their customized VIM (I'm 100% sure about that) - You say "something" has an advantage over VIM (or EMACS) in the means of keyboard as input interface? Think again or at least try to let someone show you what VIM can do with just a keyboard ;-)

The difference is not only about the control with a keyboard. The true beauty of VIM etc. lies in the fact that you can use it without an X Server (so also over SSH). Then there is efficiency - VIM can do a lot more with a lot less resources. A PC that will already choke when you open up your project in a full-fledged "give me 2GB of RAM" IDE will seamlessly open up in VIM in seconds.

When you're traveling and want to preserve battery, VIM also comes in handy. Not everything I do needs the refactoring features of an IDE and I also don't have to use the test runner every time I do / change something (also there is CLI tools that are totally OK to use).

I think you are trying to compare something you don't really know.


I only use Vim, currently inside WebStorm. From my anecdotal experience, people who are willing to learn vim/emacs are also willing to learn a lot more about the whole programming experience, tools and theory. They usually are more productive, but I don't think it's vim that's making them productive, it's the other way around usually.

I learned vi originally for a job where I had to work on legacy hardware systems and it was that or nano and for whatever reason I couldn't stand nano. At the time, I was also using a small set of 3-4 different IDEs for the "regular" (RF/embedded) work.

Fast forward a few years on that job, I'm finding myself utilizing a workflow that's tracking closely to ESR's TAoUP. I still have to lean on the IDEs for certain classes of problems that I might come across, but they became a tool in my toolbox instead of being the toolbox.

That was all well over a decade ago. I haven't touched an IDE in my full-time work since 2013 or 2014, when I wrote my last line of C#. If I had to go back, I'm glad that VsCode has appeared on the scene in the meantime, but I wouldn't be thrilled about it.

My personal opinion is that living at the layer that I live at, in a terminal with a multiplexer and doing things that leans heavily the UNIX philosophy, gives me an understanding of the systems that I create that I perhaps wouldn't get otherwise.


Most of my colleagues use vim with tmux. One uses emacs and one uses atom. I myself switch around, but recently switched back to sublime due to its stability and speed over atom and vs code.

I see no correlation at al.


Any fucker not writing tests is more productive in the short term, but in the long term risks your entire business. Unless your business is getting hired by marketing directors who want pretty demos to laud over their internal developers, in which case you practically have to write garbage to hit the deadline (not your fault; fault of the internal devs for not quitting instead of working for a twat).

But on the bigger issue, correlation is not causation.

Many new developers start with an IDE because. So you’ll see a lot of inexperienced developers using an IDE. On the other hand, back in the day, if I wanted to have any chance of editing this file on the arse end of a 9600baud dumb terminal then vi is the answer. So there are old bastards still programming, who therefore have a ton of experience, who use vim.

Does using vim make you a good coder? Fuck no. Does using an IDE make you a bad coder. Also no.

I use an IDE. I’ve used an IDE since ‘92. Then it was slick edit on OS/2, at a company working on some of the hard bits of supermarket system, and everyone used it. One of the best programmers I know uses vim. However every other best programmer I know uses an IDE. I suspect the vim guy is wired differently. So if vim seems right to you then use it. If an IDE works then use that. Anyone tells you you aren’t a proper coder unless you use vim or emacs or edlin then they are telling you that they are a pretentious twat. My friend who uses vim will not tell you to use vim. He’ll tell you why he likes it.

But write fucking tests.


For the last 10 years I've worked with perhaps 200 developers, I haven't seen a single one who uses vim or emacs, whether they are 20 or 50 years old. Maybe it's the nature of the work - web development (frontend and backend).

I've known a few who use sublime text, and there was no correlation with either being a good developer or being productive (though I haven't met a bad developer using sublime yet, mediocre ones are common enough)


In general I agree with you. But! I do know a couple programmers, one who is in his 20's and one older who use vim for everything. Honestly i would say the they are more productive doing it. Watching them work is astounding. Unfortunately the learning curve to that level is Everest like.

I use Sublime or VS Code but for no purpose that I could not put Vim to if I wanted. Most of my coding work is reading and thinking. When navigating, I mostly use regexes (relying heavily on standard code format). After using VS for twenty years, I decided to try this more textual approach two years ago, and I believe I have become a better developer for it. An IDE makes it so easy to drop into the debugger. I try to gain understanding of the code and drop into the debugger only if necessary. With this barebones approach, I more deeply understand the system and more often fix bugs at the root rather than the symptom.

Haha. I've coded in plain text editors for years and now I'm using PHPStorm and I'm so much more productive with all the tooling it provides. Refactoring is so much easier, resulting is cleaner and easier to maintain code.

Seconded. There is no going back. Sure I can do clever things in VIM and navigating with the home row keys is great, but it is just so much quicker with phpStorm. No closing tags go missing, even English language spelling mistakes don't slip through.

On first use I found there were a few frustrations and I still end up with lots of quotes where I type something= only for phpStorm to enter quotes for me that I am not quite expecting.

I also had a problem of finding 'jkjjkjk' in my code from vi habits of using the j key to move in the document.

For me phpStorm is where the real work happens, I know I am not really good enough to do it in vi whereas I once believed that. Sometimes you see a missing closing bracket highlighted in phpStorm and know you would have wasted a minute or two testing had it been done in vi.


> Developers who don't write any tests are often the most productive.

This should not pass code review. If it doesn't have tests then it's a landmine for other programmers in the future, since they can break it without realising - possibly entirely indirectly, such as through a library change.

The most "productive" techniques I've seen are all metaprogramming - assemble something which matches the domain well and use that to produce a large volume of code from specification-as-data.

(Oddly, the only area where nobody bothers to do automated integration testing in my experience is embedded code, possibly because it's too hard to set up)


Productivity is irrelevant if quality is low and generally, developers who don't use proper tools produce low quality code. It might be small issues, but details matter. Wrong or missing docblocks, bad formatting, no linting, unused variables, extra use statements, etc. I see it all the time from developers who don't use a proper IDE, but even from developers that do but don't know how to use their IDE. Developers who use simple editors like vim/emacs/etc. generally are the worst offenders. The attention to detail is generally not there because there are a ton of tiny details that go into making good code and paying attention to them over thousands of lines manually (vs. having an ide that will take care of them automatically) is difficult. Even things like navigating code and debugging seem to be difficult to impossible to do efficiently for these developers. We are all human and have human limitations.

I'm in no way saying these developers are not good developers, but they do produce a product that's often below par, below expectations, and below what they could do with proper tools. I do not understand why they stick with substandard tools. If you want vim key bindings, they are available in any ide. Startup time is simply not a factor when it occurs at most once per day, if that. I think developers love to focus on issues of personal preference and fashion to the detriment of using the best tools available. Sure, if you can produce great code with a great attention to detail with the editor of your choice, great. Keep at it. But if you can't keep up with the attention to detail and numerous requirements that go into writing great code because your tools are inadequate, defending the tools because of personal preference and fashion is ridiculous and lessens the quality of the final product. That is unacceptable.


I see no correlation

I've personally found tests to be invaluable. Yes, they take longer to write than just writing the initial code, but they help save time on testing bugs in the future and ensuring that the code you have written does not regress, especially when refactoring the code.

I've not necesserily always used test driven development, but something close to it, especially for non-UI code where I try and aim for high test coverage.

Tests also help when writing code that implements specifications (JSON parser, XML parser, JavaScript engine, etc.) as you can have tests for each part of the specification and the various error cases.


If I just 'sit back and think' I wouldn't use Emacs at all.

I believe at least for Emacs people use it because it's an interactive environment like Slime. With this kind of interactiveness, I can think by playing with the code. Just like sketching with a pencil instead of a pen.

Most of the time 'sit back and think' doesn't work because if your business model is dynamic you have to break your existing design and refactor, unless you are just solving a problem in a small generic domain. At least for OO languages. That's something IDEs are used for.


Word! I have seen many implementations turn into ridiculous over engineered monsters because the IDE enabled bad designs to clamber into an almost-functioning states.

A think this depends on whether the code being written depends on a lot of other code (frameworks and libraries for example). People that use full-featured IDEs have a much easier time exploring large or unfamiliar codebases so can explore more paths.

The best developers I have worked with, in terms of either productivity or 'ability' use high level tools all of the time. And among the worst developers I have known are people that only use vi.


Anecdata: I fairly recently switched from vim to VSCode, and don't feel like there's any meaningful productivity difference. I've enjoyed using VSCode, but any difference in task overhead feels trivial - likely because I still need to spend the same time considering a given item, and whether I spend the time on overhead tasks or tabbing between files doesn't really change when I come up with the solution.

And possibly due to vim binding mode you don’t need to relearn keystrokes which is the main productivity killer.

I don’t see a correlation there. Without autocomplete and all kinds of insights, you have to be experienced to make working with a simple editor feasible. Given the same experience, I don’t think that working with a simple editor is faster.

I see a correlation, but I am an emacs user. One thing that rings true is how people use git. I find that the people who use IDEs to do it just want to do it the IDE way, like always merging with --no-ff, and not actually thinking about what they're doing and coming up with their own solution to the merge.

> I see a similar thing happening with coders who do a lot of tests (test driven development),

I mean, yes, but isn't that obvious why? In my work I can safely say I've written the most code in the shortest amount of time. This has allowed us to meet deadlines. But it's all untested. Writing tests obviously takes more time and effort, but I do think they are a good thing. Getting 100% test coverage for every project and following TDD too strictly is silly, though.


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...


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...

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).

VSCode has Local History?

Of course it's biased, it's a "Why I XXX" article ;) - what did you expect?

Regarding the floating promises warning, this setting is off by default, so you have to know it's there to activate it. Additionally, VSCode's integration with tslint output is mystifyingly poor, and I assume it is this that the author is referring to. There's clickable output in the build output window, but no popups in the text editor.

I like to run the compiler and linter manually, so I can see all the issues in one list. Popups in the editor are handy but clickable output in the build output window is good enough.

Some people prefer to work with file watchers, so the error/linter output is not as accessible. They probably need to be able to see everything in the text editor. But even if you work the way I do, you may well wonder why you don't get tslint editor popups. I've certainly wondered it myself. I can do without, but they're certainly handy.


I don't think it's deliberately biased, just a guy who's not very invested into the VSCode/Typescript ecosystem who's going back to his known tools.

FYI TSLint still has a large amount of config required to get it working, and the vscode integration still has a "wont-fix, upstream" bug where it won't lint files unless they are open in the editor. So you need to manually run tslint from the commandline. See: https://github.com/Microsoft/vscode-typescript-tslint-plugin...

I'm guessing that webstorm does this this more auto-magically for the user.


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).

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.

I do Java with IntelliJ and everything else with VSCode but I’m about to switch everything to IntelliJ. Microsoft has done a tremendous job with VSCode - I’m particularly amazed at how fast it’s risen - but honestly every time I switch between Idea and Code I miss the former.

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.

You can debug inside VSCode. That is an IDE. Practically by definition. A text editor is Sublime text.

Debugging isn't the only thing - I used to use a standalone debugger years ago.

The key factor for me, is the ability for the tool to understand the codebase at some level. It needs to be able to tell me where a symbol is used, let me refactor that symbol (e.g. adding a new mandatory argument, or changing the argument order, or renaming the symbol) with as little extra work from me as possible.

Jetbrains tools allow me to do all of that (in PHP at least. I write about as much JS as I eat mud) where no others I've seen do.


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.


It's less of a distinction then it used to be, but IDE's tend to be workspace/project first, and editors tend to be folder/file first.

You would typically point an IDE at a metafile that described the source files, build settings and so forth and it would discover the editable files. All this in a semi opaque manner, bootstrapped by some menus or templates. In contrast in an editor, you might generate the metafile only when your project becomes too big for the defaults to be sufficient.

You're right that the distinction is much more blurred now. For example you can do a lot in Visual Studio now without using a "project" file.


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.


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

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


any text editor with sufficiently powerful plugin capabilities can become an IDE, but AFAIK you can't turn any IDE into a Text Editor (there is no way to disable everything but the editor by default)

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.)


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.

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.

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.


MS's attitude towards package managers has always confused me. even in vs2019, typing in Microsoft.something sometimes brings up paid extensions as the first result but not always. no way to rate an extension with an explanation in nuget(or vscode) means i'm usually googling "good extension for [x]" instead of using the package manager search

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.


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.

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

Maybe the fact that they don't install such extensions indicates that they don't actually need them? I switched from IntelliJ to VSCode precisely because it was too slow and cluttered due to the sheer amount of extra features it provided, most of which I never used.

Even if all those extra features are useful, I'm still willing to compromise the core experience of editing and navigating code, as that's always what I'm going to be spending the majority of my time doing. I need that to be fast, easy and reliable, which is not what I have found to be the cast in IDEs, vs editors.


You can use the vscode/extensions.json in any project to have a one click install for anybody who opens it in vscode.

https://code.visualstudio.com/docs/editor/extension-gallery#...


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.


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.


> language specific apps

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


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.

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

PyCharm contains all functionality of WebStom

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.


You can assign non standart file types to various languages.

https://www.jetbrains.com/help/idea/creating-and-registering...


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.


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.


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.


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.


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.

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.

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

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.

> lag issues & the clutter interface of Webstorm

I know a few developers who stick to editors like VSCode for those kind of reasons, but as it turns out, they actually never spent time learning how WebStorm works.

WebStorm and the rest of the JetBrains family of IDEs are extremely configurable, and speed is not an issue in my opinion: I've spent a lot of time programming with PHPStorm (including database servers and Web servers running in the background) with a 1.1ghz 12" MacBook.

In addition, it comes with batteries included. No need for plugins for what should be standard functionality.

Looking at them work, they could save so much time refactoring, jumping between code, clicking instead of using shortcuts, etc. that the investment would be paid back within at most a week.


> WebStorm and the rest of the JetBrains family of IDEs are extremely configurable, and speed is not an issue in my opinion

Speed is totally an issue for me with Webstorm, there's a small typing lag, very small yeah but noticeable, no typing lag is my top priority in an editor, above all the other features.

> Looking at them work, they could save so much time refactoring, jumping between code, clicking instead of using shortcuts, etc. that the investment would be paid back within at most a week.

Every Webstorm user talks about refactoring like a major feature for them but I found it not that useful personally, that's not a feature I would use anyway.


Well let's just agree that one's mileage might vary on this, because I use both VSCode and IDEA, and whereas neither really has input lag on my machine, typing in IDEA somehow feels smoother thanks to some interface programming trick that I can't put my finger on.

How's it cluttered? You can simply hide everything. besides that, the default configuration only shows the main editor and two tool panels (left and bottom), the same as VS Code.

You got the answer in your comment, "you hide everything", yes but by default there's a good 80% of buttons I will never use including the top bar and a good part of the side bar. The menus themselves are also too cluttered, it "feels Java" to me and that's not a compliment.

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.

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.

Have you tried Atom?

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.

Wait until they see ReSharper/Rider/IntelliJ.

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

If we're going to list editors, I think I have a few in mind ;)

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

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

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

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


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

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? :-)


also, VS Code has those features, but is an extensible editor and not an IDE so you don't get them out of the box but that's by design

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.


> 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/


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

I just tried 3 latest features for Webstorm listed here: https://www.jetbrains.com/webstorm/whatsnew/

All are working on my latest version of PyCharm Pro.


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.

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?


have you found vim in your heart?



Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: