Modern IDEs are magic. Why are so many coders still using Vim and Emacs?

I don't really get this article. Nobody uses a stock "familiar" vim or emacs for programming unless they aren't doing much more than small personal projects. If you are working on relatively large projects, though, and you use vim or emacs, you are probably going to spend a lot of time installing packages and configuring your text editor to the point where it basically is an IDE, albeit one you have pretty much created bespoke for your exact needs. And while there is tons of time to be wasted in setting up a dedicated IDE, I think that the main problem that an IDE is trying to solve (and usually does a pretty good job of solving, in my personal experience) is reducing the amount of "startup" time required for getting a project going.

Our fingers are often the bottleneck between thinking up code and getting it in the app, so that’s where folks look to optimize shortcuts.

I think this could only be the case if you're writing code that you've already written a couple of times before. It seems ridiculous to prioritize that kind of simple or boilerplate code over everything else.

High availability and fast startup is important to people who make small edits to a lot of different projects, often in different languages. Being able to load and edit quickly is important. Setting up a project just the way you like it hardly matters since you'll be gone tomorrow. This can be sysadmin work, or it might be someone who jumps around a lot between different tasks, or someone who works on cross-cutting concerns that affect many different projects.

Full-fledged IDE's tend to appeal the most to people who spend all day working on a single monolithic project on their own machine. Startup time matters less because you will be using the IDE all day and often leave the IDE open overnight. Spending the time tweaking project settings so all the advanced features work pays off. Refactoring tools save lots of work because you're dealing with a lot of code. Advanced searches and navigation matter because it's a large project.

Of course there is overlap. IDE's can be used for multiple projects. But these are the endpoints.

I used to spend a lot of time working in and on Java IDE's, but later switched to VS Code because it's more of a happy medium with an editor-like fast startup along with some advanced features. (This was back when I was coding at all.)

I use all the modern language servers inside vim. It's not even difficult to setup. Installing a new one is one command.

vi (and derivatives) and emacs are free software. Properly free. That's important.

And it's not really that vi is my ide; the whole terminal is. It's fast, familiar, aesthetically minimal, extremely flexible and configurable, etc

Developers are a finicky bunch. Like a dog refusing to walk on wet grass, there always seemed to be a bit of resistance to changing up a routine. We love what we grew up with, be it Star Trek jokes, Vim, or Emacs.

Okay, so we're establishing a context of a psychologically driven choice. Fine, maybe you're right. Let's see...

The endless war between Vim and Emacs users has continued ad nauseam over the years. It’s less a war at this point than a grumbling shuffle of ingrained habit and stubborn resistance to change.

Endless war, scary! Let's check out that link. Funnily enough, the highest rated comment is about using both and their relative strengths. Seems thoughtfully reasoned, but it could be a fluke. Let's check out some other responses, hmmm, the popular consensus seems to be just that.

It’s less a war at this point than a grumbling shuffle of ingrained habit and stubborn resistance to change. Vim and Emacs users, once at each other’s throats, seem to have implemented each other’s keybindings (a thing they actually do) to take on a common enemy — any modern IDE.

With the old wars coming to their conclusion, now, we are see all the hordes of grumpy and misguided Luddites banding together through the power of implementing custom keybindings to work their arcane practices against the elegance, power, and status of any modern IDE. /s

Further, IDEs are often too much tool for the job. Beginning programmers are much better served by simple text editors vs. massive programming behemoths.

As coders’ careers evolve less through their expertise than who is signing their paychecks, there is always a constant code editor available to them regardless of which IDE the company prefers.

It could be seen as an act of willful defiance or just personal preference, but text editors are always there.

The lack of subtlety from these content marketers is palpable here. But I love the approach, I'll be honest it got me as far as downloading the VScode .deb. Something I've already used through work and was fine using because Vscode is nothing special to learn or adjust to, it just replaces out-of-the-box mobility at the benefit of minor conveniences.

I don't use a different editor (nor an IDE) for a combination of two† reasons:

• I haven't seen anything that has a must-have feature that my current editor doesn't
• The times I've tried other editors or IDEs, I end up missing something that my editor of choice has (and I don't want to spend time finding, installing and configuring plugins just to replicate the collection of missing things)
• I'm opposed to the closed-source-ness and/or the (un-opt-out-able) telemetry of the proferred editor/IDE

Part of it might just be laziness+inertia, but a lot of the bells and whistles I see in full-blown IDEs makes me think: Whatever happened to using tools that "do one/few thing(s), and do it/them well"? Modern IDEs seem to want to fulfil the roles of file manager, terminal, shell, window manager, disk searcher, version controller, differ and more. I ask: were your existing tools that played these roles so terrible?

• "I have easy access my shell right there while I edit!" Yeah, okay, but I never had trouble switching to or controlling the position or desktop of my terminal window(s).
• "I can search for substrings in my entire project tree!" Well, I'm pretty satisfied with /ag|ack|ripgrep|grep|egrep/.
• "I can commit any subset of diffed lines right inside my IDE!" Cool, but I feel pretty proficient with /git (diff|add -p|restore -p|stash|commit|log|blame)/.
• "I can see and navigate any part of my project dir tree right here on the left!" That's nice, but fuzzy file finding has served me well enough for years, and, if I dare say, it's faster than navigating with eyeballs+mouse.
• "I can set up multiple cursors and type in multiple spots at once!" I'm content with the search-and-replace functionality of my editor, as well as its keystroke macro and script-on-the-spot features.
• "I get inline linting warnings!" I suppose that grants a tiny productivity boost, but shouldn't your team/project have linting on commit, or linting in CI?
• "I get autocompletion/suggestions from my project's identifiers and its dependencies as I type!" Okay, fine, I don't really have that, but I've been doing without for so long, and don't feel the worse for it.

*shrug*

† "Our two weapons are fear and surprise...and ruthless efficiency...."

I don't do much actual programming these days, mostly Terraform, YAMLs, bash, a little Go and Python; Intellij IDEA is mind blowing compared to vim, at least for me.

I find that any vim setup becomes your own really quickly, and so do the problems, and you're stuck figuring them out instead of doing the work.

I still use vim when I randomly SSH somewhere, but for anything on my local machine I prefer Intellij.

Emacs? You'd have to be insane to use that.

Small changes on a remote server: I'll use vim. I know the basics and the basics are what I am guaranteed on any of our servers.

Big changes on a remote server: Either pray that it is a git repo so I can check it out locally, edit it in my IDE, push out a new branch, check out my changes, and test, OR probably fuck up a lot. Once I know I did it right I'll make an MR. I have pretty bad ADHD and my biggest struggle is attention to details. Its very common for me to make small syntax issues. So I heavily depend on linters and syntax validators in my IDE to try and avoid committing as many of those as possible. When its small changes I'll risk it and try to be extra careful since the whole git route is a bit cumbersome, but for anything more than like 10 lines I'm going to my IDE.

When else I use my IDE: Any time I am working locally on my machine. If I'm going to be copying and pasting things from multiple files I'll use my IDE as well. Navigating file structures in Vim compared to in VSCode or IntelliJ is night and day for me. I have no idea how people do complicated things with VIM. Really I try to go out of my way to avoid using VIM and stick to my IDE as much as possible.

All that said, I do use vim extensions in my IDE. I like the aspect keyboard-based navigation, I want to keep that. But that's about the only aspect of VIM I want to use.

I grew up with Joe (Joe's Own Editor), switched to Vim for syntax highlighting after a few years. Many years whence, after beign dragged from Linux VT into X kicking and screaming, and after a few false starts, found Sublime Text.

In parallel, moonlighted on a few jobs requiring VS (C#) and Eclipse (J2SE, Android).

About two years ago started serious effort to switch to Pycharm (Python, JS) and then IntelliJ (Python, Kotlin, JS, Go).

Having used all of the above for extended period of time, I'm most comfortable in Sublime, for the following reasons:

• all IDEs I used are pretty slow compared to editors like Sublime or Vim, all that magic in the background eats up enough CPU cycles to noticably affect interactivity
• same for memory - IDEs (and VSCode) are huge memory hogs; IntelliJ/Kotlin + Gradle + webpack devserver + two browsers (chrome, firefox) + a few other unavoidable hogs (slack, sigh...) routinely brought my 16G RAM laptop to its knees - look, it adds up, okay?
• I never actually warmed up to all that magic touted by big IDEs and thankfully managed to avoid projects where that'd be inevitable, so tje cpu/memory/cognitive load was too much of a price to pay for something I rarely used
• no language is a second class citizen
• I don't have to fight with IDE to recognize my build environment and to pull up correct dependencies for autocompletion/typecheck/its magic
• haven't stuck with Vim throughout cause I love how easy it is to set up project structure / tabs / layout with Sublime, it's well integrated into the graphical environment, and it's just enough visual user-friendlyness for me

Nowadays I use Sublime (w/ just a few basic plugins) on my machines and vi/vim when SSHd (or when writing git commit messages in command line).

I have learned so much from using Emacs that I could imagine using an editor that wasn't designed in the same way. Lisp was the first programming language that clicked with me. You can make Emacs EXACTLY what you want, and you can do anything in Emacs. Emacs does have a rather steep learning curve, but instead of plateauing at power-user level, it keeps letting you optimize it. Also, with the Language Server Protocol, I can get IDE-level functionality for the vast majority of languages.

My dream for computing in the future is that an entire OS is built on the Emacs philosophy, so I can make MY computer fit with MY brain, not the other way around.

It’s not hard to get features commonly associated with IDEs on Emacs. If you use a distribution such as Doom Emacs, many things will be reasonably plug and play. I understand that there are things other programs do better, and essential features that are only available on certain IDEs, but so far that was not an issue for me. I started using Emacs relatively recently. I find it useful and flexible. I tried IDEs and the popular Electron based text editors, but customizing them was a pain and the interface was not as responsive. I saw no reason to use them, especially because everything I needed was also available on Emacs.

Emacs has actually useful features, this is not just about performance...

And yeah, I also like Vim, but for other stuff.

This article really misses the mark. Most emacs (and probably vim) users add packages that provide the same functionality of as an IDE.

The only modern IDE I prefer to use is VSCode, and in that case, I still use Vim key bindings since I've become used to editing in vim. The reason I use VSCode is because it's the fastest modern IDE with autocomplete (which is all I really need). I could try to configure my vim setup with whatever language servers I need, but for the time being, VSCode works.

I have been the guy who used IntelliJ on teams that used Eclipse (for java) and Atom (for scala). The tools you use shape the code you create: Linting and refactoring tools are the more obvious but project organization in general is heavily influenced by the IDE, at least in java world. You don't build class hierarchies so deep when you need to keep them in your head instead of being autocompleted on the fly. Same with names, and code snippets. Frameworks like spring get very hard to use without IDEs that know their idiosyncrasies as they change things around a lot.

A small ecosystem of simple (commandline) tools is in my opinion easier to adopt if you are developing something in the open and is my preferred way of doing things (I'm vim team, though). For professional teams on restricted computers and software it is miles easier to just get a couple licenses approved and share your IDE configuration.

IDEs are tooling just like package managers, linters, version control, code repositories, and perhaps even frameworks. I would advise against using tools different that the rest of the team if you plan on sharing code with them.