Image above NOT a title for Burrough’s 1912 story “A Princess of Mars” ¹

This is an essay inspired by Greenberg’s 1996 “Mother of All Emacs papers"². We learn in that paper that Emacs was born of a necessity for a text tool that had to solve several problems:

1. Hardware (memory space) limitations
2. Costly, lengthy compilation times for other programming languages
3. Steep learning curve compared to arcane character-editing tools, which were painfully close to the assembler and showed it

It succeeded in all of these, and after we look at how it succeeded we’ll be ready to think about its viability in an age where the problems have changed completely.

1. Memory Limitations: A Thing of the Past (mostly)

For the most part, the same limitations that produced advice to make single-letter variable names “so they take less space” are long gone. Space, at least of the sort that quibbles about memory consumption of individual characters, are likewise long past. These days memory concerns only come into play when either working on embedded micro-systems or on Big Data (speaking of terabytes at the small-end of the Big Data spectrum).

Emacs, and any other “text editor,” still struggles with Big Data issues; however, for the small stuff, Emacs remains as excellent as ever.

2. Compilation times (re: benefits of the REPL)

³

Perhaps you, too, have had friends or teachers who remember the days of punch cards and of compilation that took hours for even homework problems. Like the space limitations, this class of problems has been largely done away with; even aggravated by the compilation step of C or Java, that aggravation is mostly a privilege of the particularly impatient. There are exceptions; re-compilation becomes a growing issue as projects become more elaborate. So, for software engineers working on massive code-bases, the REPL remains an excellent solution to side-stepping re-compilation at all but the crucial pre-production junction points (say that ten times fast!).

This is one of the reasons the LISP model of solution was found: by having a REPL that is literally the same thing driving my program’s running process (and this is where there’s a difference from Almost REPLs like the Python prompt) means that I don’t have to rebuild the whole thing to get an accurate picture of the changes I just made. This is the particular solution of the REPL referred to in the multimacs paper, and doesn’t consider the several other advantages of REPLs and the REPL Driven Development that stem from this same solution. Now the feedback we desire isn’t as much driven by compilation, but simply rapid feedback as we interact with you system. Solutions that have nothing to do with your editor, like Figwheel (Clojure) and Redux (React.js) demonstrate the benefit of feedback when even having to press the refresh button on the browser seems too slow (which, once you’ve tasted the better ways, it really does). For simple things like HTML and Javascript auto-reloading, emacs simply extended to solve that space⁴. Emacs also plays nice with the modern solutions (most of which are no longer editor-solveable).

3. Learning Curve

It’s a sign of the times when we find out that Emacs, with its notoriously steep learning curve, had as one of its original purposes to be easier to learn. It only takes a little reading to find out what it was replacing – times when keyboards were non-standard and when producing a single character on the screen required some finger gymnastics. Long gone are those days, even from the memories of most people who send characters to screens. Now we are left with an Emacs that seems much more complex than solutions like VSCode, Sublime Text, IntelliJ, and other pick-your-flavor-of-the-moment editors. In an evolution reminiscent of the popularity of “Word Processors” like Microsoft Word and Google Docs over text editing solutions like Emacs and LaTeX, the new solutions rightfully strike toward having something beginners can quickly get up-to-speed with. This is a fact.

I won’t here make any arguments about Emacs addressing the learning problem (I’ll leave that for other articles). I’ll jump to the end of that argument: while it’s a fact that at the start of the scale, getting started with raw Emacs is more difficult than those other solutions which specifically aim to solve that problem, it is also a fact that on the opposite end of the scale the powers of Emacs mastery place you in an echelon above what’s possible in other solutions. Further, once you pass that beginning phase of the scale, the things you may learn as you develop your Emacs skills have deep ripple-effects that can make you a better programmer, better engineer, better student, and better computer operator. I have found that Emacs is a gift that keep on giving as I learn new technologies, mathematics, cognition, and seek to lead an Abundant Life.

What does Emacs solve in 2021+?

Aside from the re-calibration of the three original solutions Emacs provided, what else is the value proposition of Emacs in 2021+?

• Stability. Emacs had its first release in 1976, after which it achieved the successes of its original design. And yet it still continues to serve developers young and old in 2021. This is mind-numbingly bizarre in the technology world and especially in the hyperbolic part of that world that is web development, in which field I work. Instead of switching tools when Microsoft or Google or that rich new startup offers an upgrade, you have a tool that has literally been excellent for generations of humanity. This alone neutralizes any critiques of learning curve – compare, what was the learning cost of every switching point to a new tool for a user? I have invested in just one learning curve, even if it is a big one.

• The Mental-Space ecosystem. Precisely because those who need easy and quick solutions shy away from Emacs, those who do use, develop, and master Emacs are generally of a high level of intelligence in their respective problem spaces. This means that the solutions that are created are often smart, innovative, and deeply useful, and likewise the help you receive when you draw on the community is better than your average web search returns (except when you’re dealing with the cranky Old Poops that are sometimes out there).

• Scope. While some popular tools aim to achieve a wide coverage (VSCode does a good job of this) of many different languages, its age alone means that Emacs is going to have an upper hand here. Perhaps there are new languages that VSCode supports faster than Emacs does; the nature of Emacs, though, is that it will be Extended soon to meet people’s needs – in fact, once you have some experience under your belt, you can readily be the one who champions that extension effort.

• Non-programming. Whether it’s note taking, instant messaging, email, blogging, studies, letter writing, and an alarming number of non-textual endeavors, Emacs never says “I can’t do that.” That’s not always a good thing; the ability to “do anything” is, after all, what lead to the Lisp Curse, and a lack of boundaries is a problem for products in general. It is still a problem for Emacs; however, the apparently immortal features of the tool means that Emacs plays by some different rules. It means that you, or I, or any other user, defines our own boundaries; the tool has thrived by not setting the boundaries for its users. While not setting boundaries for yourself makes you a victim⁵, the ability to set your own boundaries with your tool, instead of thinking about pushing boundaries, is a unique value proposition.

• A learning tool. Stemming from all the previous points, I have found Emacs to be a superb tool for learning technologies. Like all the best tools nowadays, exploring the community can bring awareness of new techniques, tactics, and APIs. But its ability to mold to whatever needed means that it can simply empower its users in whatever endeavor they are doing, in anything where a computer is needed. As a perpetual student, this use of Emacs has been a valuable fact for me through more than a decade of university experience, not to mention in my professional life as I live the high-metabolism of a web developer.

Footnotes

¹ Poster for the John Carter movie, based on Burrough’s classic story “Princess of Mars”. Originally I had a cover-image for the book itself, but thanks to a community member I recognized it as hasn’t aged as well as Emacs has. You can see what I’m talking about here: https://artistsuk.co.uk/acatalog/PRINCESS-OF-MARS---Bruce-Pennington-2369.html

² Actually, “Multics Emacs” is his title, but since I don’t understand what Multics actually means, I had better read it again… https://www.multicians.org/mepap.html

³ Photo of a card-reading computer from Stagg’s 2015 article, “There is no such thing as stateless” https://medium.com/@stestagg/there-is-no-such-thing-as-stateless-321938e4e16b

⁴ Some more emacs-powered hotloading that works great for primitive html/JavaScript situations

• Skewer Mode for JS hotloading https://github.com/skeeto/skewer-mode
• Impatient Mode or HTML hotloading: https://github.com/skeeto/impatient-mode

⁵ I wrote on the problem of not setting boundaries here: https://tech.toryanderson.com/2020/08/20/danger-of-diversions-in-emacs/