A post on Irreal about the customizability of Emacs caught my attention today. It talks about how younger developers don’t use Emacs and why they should. It specifically pulls out the following quote from a Hacker News post regarding it:

The specialized app user lives in rented apartments; the Emacs devotee walks through an ever-expanding mansion whose rooms rearrange themselves to their thoughts.

I’m not sure I entirely agree with the sentiment. Sure, Emacs is vastly more customizable than pretty much any other text editor tool out there. The whole thing is just a big ball of Elisp sitting atop a VM that handles lower level interactions in C. You can get away with pretty much anything you want without having to go through those lower levels, because much of it is exposed inside code. Additionally, changes you make to the environment are immediately available to you without any stop/restart/update trickery. This is incredibly valuable when changing things.

However, I dislike this bit specifically:

the Emacs devotee walks through an ever-expanding mansion whose rooms rearrange themselves to their thoughts.

Yes, and no. You have to build those rooms yourself. Yes, you can build those rooms yourself, and building them is easier (or even possible) than it would be in any other tool, but you’re still building them. There is also the idea of need. Do you need such a system that accommodates every bespoke aspect of things? Do you need to build a window manager because you don’t want to context switch? Do you need to manage your music library in your editor? Do you need to read your email, usenet, or RSS posts in your editor? Likely not.

I love that Emacs is so extensible, I love that I can tweak each bit to what I prefer. However, I don’t need it. Most of the tools I use I understand how they work, and fit them into my workflow, or discard them. Most of my interaction with them is not one of frustration or fighting against some imagined interaction model. Most of the time I’m just using the application. Sure, there are times that I struggle to figure out how or why an application does the things it does, but those are usually the applications I discard because they don’t fit what I need. Bending their utility to my needs is not always the best solution, I probably don’t even need that functionality, if it’s not immediately apparent.

Some folks want to own every bit of their environment and change it to their bespoke needs. They want every keystroke, every click of a mouse button to summon or dismiss tools as fast as the display can shove the pixels on the screen. That’s fine. Most people don’t do those sorts of things. In fact, most people don’t even find the setting screen. While I would certainly argue that developers do look for the settings screens, I’ve been pretty horrified working in a tech office where developers have a hard time even getting their own environment set up correctly. As it turns out, lots of developers just do this as a job. They don’t care how the tool works and are fine with using the default options. Some upstart junior developer can weed around in the settings and find changes that will help, but most are just there to plug in some code and go home. Coding is not their interest.

There is also the conformity aspect. Some young developer coming into the office is not going to be given the choice of development tools. By and large they are going to be told what tools they use, how the environment is setup and how to build the application. This will vary from office to office, but conformity is a big thing in large development houses because it reduces defects and keeps everyone working the same, without weird one-off setups that break things in new and interesting (read: expensive) ways.

So, sure, Emacs is luxurious if you’ve got the time and energy to devote to it, it’s also a completely manipulatable environment that works the way you think it should. It’s also old, which kids hate. It’s also ugly, which kids hate. It’s also extremely fiddly with new technology, which kids hate. I love Emacs. I love that it’s ugly, that it’s old and well worn, that it interfaces with anything that can output plain text. But it’s not “cool”. VSCode is “cool”. Cursor is “cool”. Nova and Sublime Text are “cool”. It doesn’t matter how good Emacs is, it’s not “cool” and that makes the effort to learn it that much harder than it is to say, get into VSCode, which has GUI’s and tools that hook into their already existing workflows of new and cool tools.

That’s a huge gap to overcome.

Edit: Jack Baty has also recently posted about how much that effort usually takes. Often Emacs gives us a lot of leeway in how we approach problems. That can end up being a hinderance to actually getting things done. When you have endless customization, where do you stop? Sometimes, less is more.