I think part of the trend of IDEs losing favor is that for years they controlled the build. I think that build environments have changed so much in the past 3 years or so that having the IDE control it outright has quickly become untenable. Sure, for some languages, like Java or C# I think it still makes sense to use a full-IDE. But for JS and Typescript, where you might run webpack or node or chrome or docker, the concept of an IDE understanding and providing an intuitive notion of how to run that code, is becoming harder and harder to match user expectations.

Outside of the JS/TS realm? I don't know, I can imagine Jupyter and other notebook technologies really taking off too. I don't really see those as writing programs, however, I see that more as an exercise in data preparation that can be used in some other long-running API or otherwise.

Going a little beyond too - I am seeing more and more shops (including ours) that are adopting an ALL JS/TS approach and leveraging React, GraphQL on top of Node. I think the reason is that we're collectively deciding on reducing our code knowledge footprint. Companies are favoring fewer languages because JS/TS is "good enough" now to handle the backend of something major, it begs the question on why we should use Java or something similar for our APIs. We are also finding places where we can write something on the front end, and magically also run it on the backend for doing some similar operations.

I disagree. Webstorm provides all of the tools you need to customize your build, you don't have to use them at all but they're there when you need it.

Webstorm integrates with popular build tools like Webpack and Gulp, and adds support for more tooling all of the time through plugins.

There is really no reason to use another IDE for JS/TS unless you can't afford its very reasonable price.

Webstorm is essentially the only IDE that makes any sense for doing JS/TS work. Visual Studio is an unbelievable dog when you throw more than trivial amounts of JS code at it, to a degree that I cannot really understand, especially the apparently enormous resources that have been thrown at the problem in recent years. I routinely see VS splutter and die on smallish front-end projects when it runs like butter on six-figure LOC .NET and C++ solutions with dozens and dozens of projects.

I run Webstorm in VM environments with 2-4GB RAM and 2-3 vCPUs and for the most part it's pretty smooth even with image editing programs and multiple browsers open.

> Amongst the current crop of engineers, there seems to be a stigma against even trying Eclipse or IntelliJ. I kind of feel like junior engineers are missing out on discovering some much more powerful tooling and forming their own opinions.

For me it's the text editing features that these IDEs lack. I'm definitely giving up advanced language integration, but I (and many) make the choice to do this for more powerful and/or preferred text capabilities.

Vim, Emacs, Kakoune being my main examples. Not just a "vim mode" - I've never used one of those that was even remotely useful for me, heh.

The jetbrains editors are amazing, if you learn the keystrokes. I see few bother to explore/learn them though... I haven't found an editor that matches the features.

My main prob with jetbrains is project setup sucks, and the support for quick editing an arbitrary file is awkward. so for quick editing of a file I end up in atom or vim. I'm currently trying to get vs code's editor to be as similar as possible to intellij as possible. it looks like code's editor is pretty solid and full featured.

What are some text-editing features that you find IntelliJ lacking?

It's more about the style of editing. Ie, right now I massively prefer Kakoune style editing. I choose that over Vim, despite Vim having much wider support.

When compared to Vim, it's not about one specific "feature" that vim lacks, it's Vim, it has just about everything - it's about my editing UX, and vastly preferring how Kakoune does it.

Now would I choose IntelliJ if it could perfectly replicate how Kakoune does editing? Without a doubt I'd choose IntelliJ. Yet I massively doubt that's even possible.

Fwiw, I've been dying to use a GUI editor, but I cannot give up first class implementation of my text editing methodology of choice, be it vim, Kakoune, etc. It's not about "is it possible to do X", it's possible to do nearly everything in Notepad.

IDE's tend to work best for people who work full time on a few projects and make complex edits. Then it's worth setting up the IDE properly, indexing the project, maintaining the IDE configuration, and learning the shortcuts.

But if you are jumping into a lot of different projects that were written by a lot of different teams, and making tiny, local edits, configuring an IDE properly for each new project is a pain. Startup time on a new project is more important than advanced refactoring. It's hard to beat an editor for opening a file or directory you've never seen before and making a quick edit. You can be done before a more powerful IDE has even finished indexing the source code.

The newer editors are gradually getting more IDE features without losing fast startup, so I find them appealing even with a lot of experience with IntelliJ.

     > It's hard to beat an editor for opening a file or directory you've never seen before and making a quick edit. You can be done before a more powerful IDE has even finished indexing the source code.

I can't imagine this _ever_ being the case. Setup of an IDE is trivial compared to wrapping one's head around the first time look at a new project. I mean, you're talking about cracking open a new project you've never seen, making an edit and "being done" in a matter of a few minutes !

This is perhaps doable if you're talking about assembly-line-cookie-cutter projects, or maybe you're talking about super-geniuses? It takes me a minimum of hours to days before I'm ready to "make a quick edit" on a project I've never seen.

One of my first jobs was writing PHP when editors only had syntax highlighting support for the language. I learned to write, debug, and refactor in Vim and 15 years later I’ve continued to do the same for Java, C, C++, JS, etc. Projects with 10s of KLOC (one of them might be 100s).

It’s a different state of mind from IDE users. Not better or worse, just different. I’d hate to be stuck in IntelliJ all day, but most of my colleagues love it. As long as we’re all productive, to each their own.

That said, I’m a polyglot, so learning specific IDEs and plugins for all of the different languages and DSLs I use throughout the week sounds miserable to me).

I learned to code in Jupyter notebooks. I can't wrap my head around an editor or IDE, I build programs by writing small snippets of code, with all my variables loaded. When it does what I want I move to the next cell. Eventually I'll paste it all into a text editor do some final debugging and that's it. It is very annoying though when I want to start on an old program. I think I should try Spyder or something soon.

A quick edit might be something shallow like changing a config setting, editing a template, or maybe fixing a bug where you have the stack trace and it's a one-line change. You can find the file to edit based on a search, make a quick patch, run tests, and send it for review by someone who understands the project better. Deep understanding is not required.

Plus, per-project IDE configuration should be extremely minimal—maybe 15-20 minutes at most?—so I can't imagine that ever being a bottleneck for a new project.

If you're correctly automating and using templates, setting up the base for a new project shouldn't take more than 5-10 minutes.

Can personally confirm, I tried learning .Net Core by starting a MVC project on my Mac with VS Code, and after a few months of pain I found Rider which works on both my Windows and Mac machines, and works much better.

As far as I'm concerned, either go whole hog with an IDE or stick with lightweight editors like Sublime/Vim/Emacs and rely on CLI tools to find errors.

Coming from a background of using emacs & vi, I actually feel the exact same way about Eclipse, IntelliJ, Atom, SublimeText & all the like. It's odd to me to have such painful extensibility & so few tools to let me actually automate tasks, and so many layers of complexity to get in my way.

I feel that engineers who don't try out emacs & vi really are missing out on some amazingly powerful tooling (more so emacs than vi — but vi lives within a Unix shell in much the same way that emacs's text-editing capabilities live within emacs-the-OS).

Ranges from language to language.

For example, VS Code pulls TypeScript definitions of your JavaScript dependencies and thus has superior intellisense.

Also, the plugin ecosystem uses JavaScript, so it tends to be more cutting edge, especially if you're working on a JavaScript project (i.e. same language as plugins). For example, VS Code and Atom had Prettier code-formatting when IDEA didn't. And they sometimes have the best support for newer languages like Elm.

I'd be wary of painting people as junior developers just because they don't use your preferred IDE.

No, I meant literally junior developers who join organizations fresh and are immediately steered towards VS Code, Atom, Sublime by their organization and not even provided Eclipse/IntelliJ as an option.

For me it’s 99% about performance. IntelliJ is dog slow. I simply won’t accept an application with that level of cruft to run on my machine 24/7. Give me a simple text editor.

Also, if you have so many instances of a name in your codebase that you need automated tools to change it, and you haven’t already split that code out of the repo into a well named and stable library, I consider that a code smell. You’re building your house on jelly.

In the rare case I end up in that spot, I can use sed.

Intellij can be made faster by: Using SSD Stuffing jdk on ramdisk Disabling inspectors you do not need

I actually wonder about this too. At my previous job, nobody was using IntelliJ despite developing in Scala and Java. The code base was complex, not using an IDE had a noticeable effect on the kind of code people were writing. The code was much less cohesive, and looked more like a series of scripts than well architected.

I've been using WebStorm and find myself using more and more VSCode which seems to be catching up. The three key differences for me are 1) licensing (working in different environments and can not always bring my own tooling or get tooling for the team fast enough to make it worth my while). 2) State: VSCode may not have a in depth model of what is going on but I can point it anywhere and get immediately some level of productivity. 3) Language agnostic. I often don't even know what I will encounter when I start out.

Working longer on a larger code base I would prefer a specialized IDE like WebStorm hands down but that seems not to happen so frequently.

JetBrains offers a ~ $200/year subscription license that gives you all of their tools, for exactly that scenario, IE: I need python on this project, ruby on that one, etc. As a professional developer, $200/year is just a small business write-off and totally worth the money to have one set of tools that I can bring to bear on any project. So, you might check that out to overcome your licensing concern, if you prefer WebStorm et. al over VSCode.

Just checked, for individuals the "All Products Pack" is $250/yr. and for Organizations/Corporate use is $650/yr./user

Maybe I got a "repeat buyer" discount or something then. Either way - even at $650/year it's just the cost of doing business / immediately deducted from your taxes.

I tend to toggle back and forth between Intellij and Sublime. This is almost entirely because Intellij feels slower and less responsive. My Sublime setup gets me 90% of the way to Intellij.

I wish Intellij was as snappy as Sublime. I wish it was as intuitively keyboard driven as Sublime. I wish the community around Intellij was half as helpful as the Sublime one when it comes to plugins, extension, customization.

I try all the popular editors (Sublime, VS Code, and Atom) every few months, because I would LOVE to replace IntelliJ IDEA for this very reason. That said, I always come back to it because the intelligence and refactoring features are vastly superior to those of any other editor I have used. If I could have the best of both worlds, I would switch in a heartbeat, but I just haven't found that to be the case yet—though I'm hopeful that other editors will catch up soon.

I never got an IDE to properly work with a C project. Even vendor provided IDEs tend to break in many subtle ways.

There are just too many opaque things going on, everything is slow and if you don't sick to the workflow intended by the authors of the IDE, everything is lost.

I feel like if the language has not been designed with an IDE in mind, it's hard to get the integration right.

Plugins make this somewhat usable, and they usually mean that it's easier to get some of the features for smaller languages. A lot of small languages only have plugins for Emacs, Vim, Atom, and VSCode. Sure, if you're doing Java, Eclipse is great. But if you're doing Nim or Idris or something else small...

In VS Code especially, the level of support in the IDE very much depends on the language. For example, TypeScript has code search like Find All References that goes beyond text search, it understands classes, methods and interfaces, it supports code formatting and import organisation/cleanup.

It doesn't have as much refactoring support as eg Resharper, but it has the basics covered and honestly - even when I was using Resharper, well over 90% of the refactoring I did was renaming variables, which VS Code has covered.