I think I would rephrase this question as why would I stop using emacs for VS code and intellij? Seriously, there is no feature they have that my emacs config doesn't (AFAICT after using Intellij and VS code each for 4+ years). But I have the ability to work with emacs without ever touching my mouse. You may consider that only being "slightly" faster, but every time I use VS code, _feel_ slow because I know how fast I would have been in emacs.

Combine this with my tiling window manager and I pretty much only have to use my mouse to interact with web browsers. That's the killer feature that makes VS Code and Intellij _feel_ inferior to me.

Now I wouldn't go so far as to say that VSCode and Intellij are _actually_ inferior to Emacs. I think both are great in their own right, but after years of familiarity I have a fluency with Emacs (because of the keyboard oriented interface) that I could never have with them.

To be fair, for someone without emacs fluency I would probably steer them towards VSCode and Intellij as they are definitely more approachable. In fact, I have done exactly that for several of my friends and colleagues.

The no mouse thing is one of the best arguments I've heard. I'm not convinced it makes it worthwhile, but I'm willing to grant it's possible.

Why waste time learning about some fad IDE that will get replaced by something ‘better’ in five years? Newer text editors don’t do anything better than Vim, and they are strictly worse when it comes to their primary function: editing text.

‘You can install a vi emulator.’ - Waste of time. I already have vim.

My vimrc file still works. New machine? Just install vim and copy my vimrc over.

Emacs is a totally different experience. Emacs is essentially the interface side of an operating system. There is really no replacement for it except a UNIX command-line with a bunch of CLI tools for things like news and email that people have forgotten about.

I don't think the fact that Vim and Emacs were created a long time ago makes them inferior.

They keep developing and they are up to date with many/all programming-features. There are bunch of extensions that VScode just doesn't have despite it's huge extension store.

Also the main thing for me about these editors and especially Emacs is that you can program it. Not just configure it but actually program and do anything with it. You can hook into any piece of the code and change it. You can read the source code of any "extension" and patch it on the fly. I don't think I'm aware of any other editors that allow that.

It's huge power.

To be clear, I'm not saying the problem is they were created long ago.

I'm saying (from my pov, which may be wrong) that they don't seem to have as good of an IDE experience. Certainly the out-of-the-box experience with emacs/vim is much worse. And the learning investment is pretty steep. But even if you configure everything as an expert would, the experience still seems lacking to me.

Things you can do inside emacs (and have all this be tightly integrated so you can copy and edit data seamlessly from one "applicaton" to another, without leaving your editor):

- browse the web

- read/send/edit email, RSS news, usenet

- chat on IRC and other chat networks/protocols

- use org-mode to edit notes in an outline format with hyperlinks, executable code blocks, a spreadsheet, etc

- use magit, one of the most powerful git interfaces

- read and edit PDFs and LaTeX with visual LaTeX symbol substitution right in the editor

- program and configure the editor in elisp, with a whole elisp ecosystem used for every plugin (this alone would make me switch away from any other editor to emacs)

- use thousands of other scripts and plugins that are the result of 50 years of development

- absolutely everything customizable to the nth degree, as emacs is more of an editor construction set than an editor

You seem to be missing that they're not actually inferior tools. I can't think of a single thing that can't be done at least approximately as easily with emacs than with VSCode and the like.

Are they really? Do you get all the same plugins, all the lints and hover info, refactoring, jump to usages/definition, smart auto complete, etc?

They seem awfully limited to me by comparison.

Yes.

https://github.com/neoclide/coc.nvim

Or

https://github.com/neovim/nvim-lspconfig

https://github.com/hrsh7th/nvim-cmp

No different than installing plugins in VSCode for completions, they all work via calling out to a LSP server using https://microsoft.github.io/language-server-protocol/

When you don't understand something it's only natural to be unaware of its capabilities, yes.

> They seem awfully limited to me by comparison.

Can you list your most important feature(s) in chosen your ide or editor that you suspect emacs doesn't have or can't easily have?

How about the intellij inspections? It's a ton of lints that underline bits of your code as you type, with a wavy line, and you can hover over it to see what the problem is, and even potentially fix it automatically. Is there anything like that in the emacs world?

The ESS package (“Emacs Speaks Statistics”) does something like that for R without using an LSP.

`lsp-ui` does it for Rust at the very least but probably for other languages too.

Yep. You can use flymake or flycheck for that in combination with eglot or lsp-mode.

See https://github.com/joaotavora/eglot#diagnostics

The argument for vi is easily made. UNIX devs are constantly diving in and out of directories, grepping, awking, and otherwise spot checking code at the shell prompt. A terminal-based editor emulsifies coding and such command line activities. The argument for emacs is less easily made, and its dwindling market share evidences that. If you're a black belt in elisp like I am, all other editors seem unusable. But you're right. If I hadn't already spent years mastering emacs, I'd likely not give emacs so much as a look.

That's another good argument. Once you've invested the time learning everything about emacs, that's not a barrier to using it anymore, it actually kind of locks you in, since you won't have that level of familiarity in VS code or intellij (and anyway, they're not as friendly to modify.)

Emacs is not about being lightweight or faster to type with, this seems to be a misconception that stems from it being compared with Vim. Emacs is not a modal editor, it works just like your standard text editor as far as typing and navigation go.

As for the other things, Emacs has support for many more languages than VSCode or Intellij. An example of this, is support for (g)awk, or non-posix shell scripts, lots of lisps, jq, various config file formats, and other things that aren't "hot" right now.

There are other reasons too, like Emacs being a true FOSS project, which is important to me. There are lots of other things, these are just a few ottomh.

How do you know Emacs is inferior? How much time have you spent using it?

How are you sure VSCode and IntelliJ will be around in 10 years? 20 years? Why invest in learning a new tool every couple of years? How do I know MS doesn't suddenly kill VSC?

Also, why would I want to use an editor which calls home every few minutes? How can I be sure VSCode does not send my password files etc. to MS or OpenAI or whatever?

Also, Emacs extensibility and flexibility is unparalleled. I can mold it to fit _my_ workflow instead of molding myself to fit the workflow of some guys at MicroSoft.

Also, Emacs is self-documenting and has ridiculous introspection capabilities. My favorite example: do VSCode/IntelliJ have a counterpart of `view-lossage` (https://www.gnu.org/software/emacs/manual/html_node/emacs/Mi...)?

Also, the fact that Emacs is so keyboard-oriented (as others have mentioned) is not really about _objective speed_, but _subjective feeling of friction_ (and lack thereof).

Also, working with Emacs is so much fun. It's a piece of software so helpful that it almost feels like an A.I. assistant. ;-)

So, plenty of reasons for me.