Making Emacs Popular Again (2020)

Would you say that BASIC is more intuitive for web development than JavaScript?

The syntax of something is only one part of its intuitiveness. A large part is the context of which it is used.

At least you had Emacs!

Lisp "lists" (cons pairs with terminating nil) act kinda sorta like sequences (although the elisp names don't agree with Common Lisp names)--until you need length() and your algorithm blows up to O(n^2) or you replace a value and your list walker blows itself into a mess. This is part of why Clojure shot the idea of building lists up from cons pairs and gave explicit syntax for certain sequence types and made them fundamental.

Which would be fine if all the pedagogy didn't teach stupid cons-pair lists and recursion as THE fundamental pieces of Lisp when they should instead have a gigantic red klaxon saying "Don't use these outside of toy programs as they're a maintenance and abstraction nightmare."

Other grief: #() syntax makes read-only vectors. The syntax for what is basically [] is every other language: (make-array 5 :fill-pointer 0 :adjustable t) I can go on and on and on about the usability disaster that are sequences and collections in Common Lisp. And then let's add the joy of a Lisp-2 on top of everything else.

The problem is that the Real Lisp Programmers know to ditch those and go grab better abstractions when doing Real Programming. However, the extra abstractions are just annoying enough that stuffing things into an unlabeled list is too convenient. So, you see a small number of good abstractions and a bunch of little unlabeled "containers" passing data around with cadr and caddr. There is a reason why a "labeled struct" is a fundamental part of most languages and gets its own syntax.

And even "Practical Common Lisp," which like I like very much, introduces macros before collections. And look at how much time it spends on vectors and hashes (which are FAR more important to building most programs) vs cons-type lists (this ratio holds even as far back as Touretzky in 1986--it's gotten a little better over the years). And then people wonder why nobody uses Lisp for real programming?

So, sure, you can use the Common Lisp standard--and get saddled with a bunch of good design decisions from 40 years ago that now look absurdly stupid.

Or, you can use Scheme which has nothing built in and construct it all yourself. Oh joy.

Alternatively, you can just use a modern language that made design decisions in merely the last decade.

I read through the comments here a couple hours ago and heard all the same arguments that come up whenever folks talk about emacs vs. other editors|IDEs|platforms|OS's. As such, I didn't feel the need to add my own comment to the fray.

But as I was scrolling through the front page, the title of the article struck a chord.

I'd say that emacs was never popular. It is (and always was) a fairly niche product used by those who found something about it compelling.

Even "back in the day" emacs usage was dwarfed by vi (vim didn't exist), notepad, Wordstar, WordPerfect and even ED/EDT[1].

Full disclosure: I am a long-time emacs user (25+ years, preceded by using the Epsilon Programmer's Editor[0] -- a commercial emacs work-alike -- for 5+ years).

[0] https://en.wikipedia.org/wiki/Epsilon_(text_editor)

[1] https://en.wikipedia.org/wiki/EDT_(Digital)

I've used full Emacs and Emacs style editors (mg, jove, epsilon) for over 40 years and programmed in LISP for longer than that. In the 1990's it was evident that Emacs was in decline.

For a couple of years, I used Vi because IBM's lawyers were afraid of the GPL; during that time I found Vi to be a superior text editor than Emacs. Sometime in the late 80's, Emacs and the GPL were accepted by IBM's planners, and I switched back to Emacs. Quite a few of the AIX kernel developers did end up using Emacs, even though Vi had its advantages as a text editor. It was the customizability of Emacs and the ecosystem of high quality packages that drew me back to Emacs. (For example, a developer on my team wrote the tower of Hanoi command. Try it out: M-x hanoi). Emacs became a general purpose tool for interfacing with your system. With Emacs, I didn't need a graphical terminal to work with multiple windows, I didn't need Norton Commander to have a powerful, portable interface to directory management. It has incredible outliner, mode for LaTeX, interface to git, etc., etc.

My point is that it wasn't the text editing (Vi handled that better), it was everything else, and that everything else was enabled by Stallman's brilliant insight that the editor should be built around a powerful interpreted language, LISP.

LISP was key to the success of Emacs. In the 1980's, people were excited about LISP; by the 1990's the excitement was wearing off. The LISP Machine companies weren't commercial successes. While some LISP compiler/interpreters performed well, Emacs Lisp was simply adequate. In CS programs, Scheme was being taught instead of the more fully featured LISP--Scheme has a simpler tighter core of fundamental features and consequently was a better choice for the ubiquitous undergrad Programming Language smorgasbord courses.

I needed an embedded interpreter to be a key part of a distributed network of servers I was designing. LISP was my choice, but my companies own, very experienced, developers rebelled. Smalltalk, Prolog, and even building our own C-based language interpreter were all viewed as more acceptable than LISP.

The way to make Emacs more popular isn't to persuade people that they want a customizable editor that requires a great deal of LISP expertise. That just won't happen. Pick a language from the one of the top 15 languages and allow Emacs customizations to be developed in one of these languages. Here's one measure of the 15 most popular languages[1]: Python, Java, Javascript, C#, C/C++, PHP, R, Objective-C, Swift, Typescript, Kotlin, Matlab, Go, VBA, Rust.

Out of the 15 languages listed above, many can be disqualified for obvious reasons: R and Matlab are not general purpose enough, Rust is far from interpreted and has a slow compiler, and so on. In my opinion, Emacs would be more popular if its core supported Python or Javascript or even Go (say running in a separately compiled process that interacted with the Emacs server via IPC). I'm not a Javascript person, but Javascript is likely the best solution; I would gladly take the time to learn how to use it for Emacs configuration and customization. If Emacs was customizable in Javascript, there would be an army of developers working with it.

[1] https://pypl.github.io/PYPL.html