The interesting thing about Vim and Emacs is not simply how quickly you can work. It’s the simple fact that Vim and Emacs let you edit your text at nearly the speed with which you think about making your changes. Since you have no need to make selections, to switch to the mouse, or to hunt through menus, your mind is free to focus on what’s important while you edit: Your code.

This is to say that when you’re writing code, there is only one thing you want to think about: What your code must do and how it must do it. Whenever you stop to make changes to code you’ve written, it’s an interruption; you’re forced to think not about what your code is doing but how to make the changes that are necessary. So, instead of stepping back and make a visual selection and changing my mode of thought from code-writing to text-editing, Vim and Emacs allow me to perform the edit and be done with it, without having to expend more mental energy on the task of making the change.

And when you take your hand off the keyboard to grab the mouse, it’s another kind of context switch: You’re no longer thinking about the code, but about the text you can see on the screen and the visual elements that surround your editing area. Then, you must make the switch back to writing code, as your hand hunts for the home keys. With Vim or Emacs, this context switch never needs to be done, and your mind never needs to leave the task at hand: that of writing code.

A lot of people, myself included, use Vim or Emacs as their preferred tools because they’re liberating in the sense that you spend less time thinking about editing and more about what changes you’re making. Because, really, what is programming but juggling lines of text?

Plugins and extensions? I bet nothing comes close to R# or IDEA in terms of refactoring support […]

These kinds of tools exist. Tips and methods abound. The only limit to Vim and Emacs is that their primary purpose is editing text. But that still doesn’t stop anyone from making it the umbrella under which their entire IDE is built.

I think the source of your consternation is that you choose not to see value in Vim and Emacs. That’s fine. I’m not going to try to convert you.

But I will say that having tried every text editor and IDE I’ve come across, I still go back to Vim. I’m comfortable with it, I’m happy with the tools it gives me, and my Linux desktop meets my every need as an IDE, all in the terminal window. It has made me dependent on Vim’s peculiar command structure, but because Vim runs everywhere, that has never been a hindrance; only a boon.

Two points. First, it’s not the typing throughput that makes a difference, it’s the latency. In other words, the elapsed time between when you’ve decided to make an edit and when you’re done making the edit and back thinking about the problem. A couple of seconds can make the difference between losing your train of thought or not.

Take something simple like swapping two lines of code, for example. An experienced vim user can do that essentially from muscle memory with ddp. You use more mental capacity than is apparent when you have to precisely maneuver a mouse, make sure everything you want is selected, hit ctrlx, up arrow, ctrlv, and then make sure you included the line break and everything is still indented correctly. It’s like texting and driving. You think you’re paying better attention to the road than you really are. I prefer to keep my mind on the problem.

Second, nothing precludes a vim user from using an IDE when it suits him. There’s a reason why almost every IDE has an option to specify a custom editor. I quite frequently use an IDE for navigating and debugging, and vim for editing.

The linux command line is the ultimate integrated development environment; vim and emacs seamlessly interpolate with the unix toolbox to create a streamlined development environment that really has no equal.

I bet nothing comes close to R# or IDEA in terms of refactoring support (“Rename” refactoring implemented by means of “Search and Replace” is not a refactoring IMO); others are trivial.

Not all code is nicely statically typed or in a language that allows good tooling (refactor, find references, auto-complete, etc) support. These editors still have strong arguments for them when working with these languages.

They also work well with build scripts, config files, log files, and other shrapnel that needs to be built/analyzed/grep’d/coddled/tweaked on (often CLI only) *nix environments, which still make up a sizable portion of production code platforms.

Do said editors have a justified place in a modern software development ecosystem?

Yes.

1) If there is no good IDE for the programming language you work with (which is most of them, really).

2) If the IDE can’t handle the size of your project.

3) For various tasks when you just want to change a text file quickly without waiting for an IDE to open and initialize.

Intellisense/refactoring support is really the only compelling features for IDEs today. I expect in the future pluggable libraries will be created to provide intellisense/refactoring for various languages, so one can have the same level of language support in Emacs/Vim as in IDEs. (For some languages such libraries exist already.) If it happens then Emacs/Vim will be the preferred development tool for a number of developers, because they provide a different experience than an IDE (leaner, quicker, simpler, etc.).

I personally feel like that coding in vim has helped my coding ability, much the same way that learning to properly handle memory and pointers in C or learning functional languages like Haskell has helped me to grow as a programmer. It is much easier to understand and be able to effectively utilize something at the higher level when you understand how to handle it at a lower level.

I find them useful for quickly editing a configuration file on some system (possibly production), that I only have terminal access to. I would never use it for actually developing software because of how sophisticated IDEs are today.

I never really understood why people even bother talking about optimizing typing speed, as if that’s the bottleneck in development or something. It’s not even close to the time I save from using an IDE.

Also, how does does switching from keyboard to mouse break your train of thought?

Once you set up your IDE you almost never have to worry about any configuration. It’s not like you’re constantly wasting time figuring out how to do something IDE-related.