(via https://web.archive.org/web/20151026175204/http://tuxdeluxe.org:80/node/178)

The Church of Emacs Posted May 1st, 2007 by editor in Software Libre Martin Howse

Genera. Home of the brave coder but very much not located anywhere near the land of the free; Genera, the legendary OS and fully featured development environment running on the historic Symbolics Lisp machines, and later, in the guise of Open Genera, on Alpha hardware.

Genera presented the ultimate interface running on top of an extremely interrogative operating system. Despite being highly proprietary, and indeed marking an historic split which, as we'll see, lies at the very birth of free software, Genera's users could dig deep into highly exposed or extruded code within a tightly integrated mesh of OS, GUI and object oriented Lisp language. Code was the interface, and at the heart of such interaction was an Emacs, a supremely flexible macro based text editor whose current free incarnation is GNU. Indeed the Lisp Machines had two Emacs, EINE and ZWEI, morphing into ZMACS under Symbolics. Echoing the recursion wrapped up in the GNU acronym, EINE stands for 'EINE Is Not EMACS'. And how better to follow up this first editor than with ZWEI, or 'ZWEI Was Eine Initially'. Such wit is well wrapped up in both the code and culture of GNU Emacs.

The story of these Lisp Machines, spawned in the hacker haven of MIT AI lab in the mid '70s, underlines the history of GNU which is so richly embedded in this supremely flexible uber editor as both code and culture. As open text and self-documenting application GNU Emacs contains information regarding free software, which can readily be accessed with a few keystrokes, within its own codebase; another inspiring recursion.

Thanks to the obscuring clouds of blind advocacy which mar the GNU project under the sign of a so called ease of use matching feature for feature the dull functionalities of other OSes, the sheer uniqueness of GNU Emacs in both design and use is often ignored. And the age-old adage, misapplied across a range of domains, that “it's just a tool,” should hopefully receive its final death knell thanks to the superb extensibility and porous nature of this supreme coding environment. In the opening words of Larry Ayer's GNU Emacs and XEmacs, “What sets Emacs apart from other editors is the extent to which the 'guts' of the program are exposed to the user.” And that's really what free software should be about, revealing shared code to all by way of license, development model and design.

GNU Emacs, in common with a few other very good things, is best appreciated through experience rather than cold-blooded description. Thanks to its sheer extensibility, and the long gestation of such shared code works, it has become all things to all people, and thus increasingly difficult to pin down. Extendibility and customisation is by way of suitably self documenting Emacs Lisp (elisp) files. Emacs grows and grows in highly modular fashion; a portable, vast architecture composed of collective code modules. In short Emacs offers a totally integrated and readily configurable environment for all manner of common and uncommon coding, text-processing and computing tasks.

GNU Emacs can be used to write and edit texts such as this one, to test, write and run code, edit web pages transparently across servers, update and publish blog entries, organise thoughts and notes in new ways and as an entry point for manipulation of the all powerful Unix shell. The list can readily be extended.

Eminently customisable, iterating over both the real world and potential uses of GNU Emacs would easily occupy a vast volume. Interface is one category which could well be used to classify such extensions; both as interface to the underlying OS and interface to tasks. In the first instance, we have shell access and, even eshell, a command shell running on top of Emacs. GNU Emacs provides a non-visual interface to integrated browsing and mail functionalities for disabled users, and also offers up new interfaces for editing, managing and playing sound files for those less enamoured of the GUI. We know well of GNU Emacs as interface to code, as superlative IDE (Integrated Development Environment), yet perhaps receiving less attention is Emacs as the interface to various interpreters, opening up a vast new realm of live coding. Lisp by way of SLIME is an obvious example, but we can also interface to the increasingly popular Smalltalk-like multimedia environment, SuperCollider, using SCEL (SuperCollider Emacs). If we view operating system as primarily interface, looking both ways to embrace lowly code and high level task, Emacs can well be viewed as a prime example of a seriously advanced OS.

The list goes on, with new interfaces always ahead on the horizon of an open field of possibilities, matching, embracing and furthering new technologies as they arise; the other side of the interface coin, new undreamed of ways of working within an increasingly networked environment. Witness the tight integration of ad-hoc notetaking, automated information gathering and wiki publishing, within a wholly textual environment of Emacs extensions, or modes, such as Planner-rdf and SimpleWikiEditMode. And serious newcomers, such as del.icio.us, the social bookmarks network, have even received recent attention, with a custom delicious-el mode.

In relation to other comparable text editors with IDE leanings such as vi, though without straying into the fiery terrain of flame and holy war which such comparisons provoke, at first glance the sheer bulk, scale and cathedral-like structure of GNU Emacs would appear to sit uneasily with the Unix philosophy; small pluggable apps which do one thing well. GNU Emacs does all things well and if not, why not extend it. Under such terms it's more readily apparent that the modular architecture of such extension code which can simply be hot slotted live into place appears to have more in common with the Unix way. Emacs is far from monolithic on closer inspection, and can rather be considered as overarching framework, as much more than an OS, pushing further integration-wise than the often brittle, finegrained shell. The comical Church of Emacs, espoused by the alt.religion.emacs newsgroup back in the day, presents a holy trinity of OS, computer language and editor which well embeds the fascination and sheer magic of shared code works.

Though GNU Emacs basics are best left to the excellent online GNU manual, the works of O'Reilly and friends, and of course embedded tutorial and help, with Emacs providing a great example of self-documenting code, it's worth explaining usable entry points for the beginner and basic operation to make plain our arguments. And although historic variants, such as XEmacs, and the plain old GNU model under X can make use of mouse and menus, our pure GNU Emacs, with an -nv option appended if under glorious X, is a keystroke only affair, with Meta or Alt key, written as M- with accompanying keypress, in concert with CTRL, as C-, doing most of the fretwork. Again it's a question of speed and flexibility. The CTRL key is used for most common tasks, such as working with files, with really obvious operations bound to a single CTRL and keystroke option, for example C-p which moves us to the previous line. Next up are less common Meta single keystrokes, and then we have C-x followed by further keystrokes, for example C-x C-f to retrieve a file, C-c again followed by other keyings and M-x command-name-in-full all in descending order of importance.

Before blindly walking into the thicket of dense, interactive tutorial, accessed by way of C-h t under most installs or failing that M-x help-with-tutorial, one keystroke well worth remembering is C-g, which should get you out of all manner of recursive minibuffer nastiness. Such tutorial material makes plain basic operation, along with key notions of buffer, temporary files for editing, and practically treats of modes, frames and split screen methods. Customisation with .emacs file specifying peculiarities and personality, macros wrapping up sequences of keystrokes, as well as extension are little treated here. Access to shell, file management under Dired, diary keeping, and a host of other features which make of GNU Emacs such a rich experience can be gleaned from embedded help accessed with C-h.

To round out an overview of Emacs, best experienced through use and practise, it's worth mentioning major modes which seriously alter the appearance and use of Emacs. Major modes are mutually exclusive and are most often used for proper indentation, highlighting and attention to syntax for code in almost every language under the sun. Major modes, as we'll see, are what turns Emacs into such a sensitive IDE. At the same time, modes such as picture mode for ASCII image creation, make for a pretty funky editing experience. Minor modes, which, in contrast, can be mixed and matched, are more concerned with toggling individual features. For example, the commonly used M-x auto-fill-mode switches on or off simple word wrapping.

Digging deeper into the thousand or so Emacs code extensions shows not only an historical embedding, with Emacs reaching out octopus-like to embrace all aspects of common computing and popular culture, but also within the contemporary frame how Emacs can be used to talk, process and deal with all manner of textual data, all manner of protocols as this vast code edifice comes to resemble a veritable tower of babel.

At the same time as exposing this history, the story of GNU Emacs, obviously wrapped up with the GNU project and with the very notion of free computing, makes for interesting reading. Emacs is quite simply an historic beast, laying claim to the title of first program offered up and coded within the GNU project kicked off by our hero Richard Stallman, or RMS in shortened login form.

The Emacs commune, under which the software was made freely available as long as user/coders agreed to “give back all extensions they made, so as to help EMACS improve,” morphed into the practical GPL subroutine, and at the same time RMS's Emacs-centred experience with corporations and copyright also lie at the foundation of the GPL. GNU Emacs is the result of an historic fork which also further contains RMS' earlier split with the corporate world of code marking his departure from MIT.

In a bare outline of the facts the story seems simple, but it's only when one reads the protagonist's own stories that things take a darker, very different turn. Emacs was born in the days when live interactive editing, with the effects of a command actually visible on screen, would have been enough to make any hacker's heart skip a beat.

We're way back in the world of the Incompatible Timesharing System (ITS) within the environs of the MIT AI lab, and the accompanying supremely clunky TECO ([paper] Tape Editor and COrrector) editor, hacked in 1972 to allow for live updates of the on screen display (the famed CTRL/R or real time edit mode).

Stallman kicked off his commune-led addition of new features, coded as custom macros for TECO in 1974, and within a few years these efforts had snowballed. Emacs (stemming from Editor MACroS) was born of an attempt to collect and organise these macros into a single application with documentation and extension the main watchwords. Splits, forks and factions spawned a wave of Emacsen (the plural term), coded in Lisp and C, yet always with an eye on Lisp as extension language. Based on James Gosling's self-titled Gosling Emacs, GNU Emacs development commenced in 1984. Parallel efforts such as Lucid Emacs diverged and continue to do so to the present day in the guise of XEmacs.

Under the covers of such a grand story, and it can be argued that no other app boasts such a twisting and tortuous history, the split between a free software Emacs and the Lucid version, which as XEmacs now offers near identical functionalities and code base, can be seen as marking and defining GNU. Both sides of the dispute tell differing stories, with Lucid claiming that their work on Emacs was always released under the GPL, and with copyright assigned to the Free Software Foundation (FSF), whilst Stallman argues that complex corporate legal issues turned the GPL under Lucid's Emacs into a one way street. In the words of RMS, “it is not GNU software, because we can't use XEmacs in the GNU system: using it would mean paying a price in terms of our ability to enforce the GPL.”

Yet there's more to such a split than this, and we simply need to look back a bit further to uncover the bitter roots of the GNU project's struggle with the corporate - examining in detail the historical frictions between the hallowed hacker grounds of MIT and any commercial entity, and pinning down to a single instance which Levy, in the essential history Hackers: Heroes of the Computer Revolution, recounts with decent romantic aura.

The violins are very much to the foreground as Levy in his epilogue paints a loving portrait of RMS in the guise of the last hacker as the MIT AI lab is symbolically dismantled around him. It's the sad story of a vastly changing landscape of computing with the emergence of defensive proprietary systems, of bullying big business enforcing its own limited view of the world at all levels of hardware and software. Yet, ironically the context here is that of the Lisp machine, the magical landscape of Genera.

The Lisp Machine episode recounted here marks the first split between RMS and the dog eat dog world of commercial ethics so distant from a hacker ethos which Levy's work expounds and expands on so well. And it's a story which marks, and is marked, by a changing world with the rise of smaller machines signalling an end of timesharing itself, incompatible or otherwise. This meant that programmers could ply their trade outside of co-operative hacker hothouses like MIT, thus becoming less steeped in the codes and hacker ethics in which free software is deeply rooted. Within this context, Stallman experienced at first hand how the outside world was negatively impinging on a community embracing shared values within a kind of anarchy based on mutual trust and respect.

It's a complex story intertwining economics, politics, historical narrative and personality clash - boiling down to key hacker Richard Greenblatt's ambitions for his Lisp machines, as opening a schism between the AI lab and a growing commercial sector. For RMS it was the very downfall of the lab and it both marred and marked his departure.

Back in the day, the MIT Lisp machines were part of a well funded research project at the lab kicked off by Greenblatt, the dishevelled creature of Weizenbaum's description. It was the ultimate hacker tool and toy; a hardware playground hardwired around core creative coding language Lisp.

CONS and CADR machines, the first and second prototypes named after the key instructions to manipulate Lisp's cell-like list structures, were created by 1977 and formed a significant and historic achievement. Yet given an AI hungry environment, with ideal language Lisp engaged in a hardware-led embrace, commercial dissemination of the machine and environment was quite simply inevitable. Greenblatt bowed to this necessity, yet simply couldn't envision relinquishing the hacker ethic in the face of market forces. He wanted to root the Lisp Machine business model within the culture of the MIT lab which had so nurtured the project, giving something back to the very environment which had spawned key work on language and the core hardware design.

Yet, lacking both people and management skills Greenblatt was railroaded by fellow investor and former AI lab admin Russell Noftsker, ironically the one who had originally hired Stallman.

Fanning growing concern amongst others involved in project that a garage model of development and manufacture was unrealistic, that the longed for dissemination of admirable product wouldn't happen within an anarchistic hacker-led, industry autonomous model, Noftsker and others dumped Greenblatt in favour of forming a new company, Symbolics. Stallman refers to the episode in no uncertain terms as “Stabbing in the back, clearly a real businessman.”

Greenblatt persevered in forming Lisp Machines Inc (LMI) and the battleground was set for the two opponents in a hacker's deathmatch heralding the end of an era, with both companies hiring away key coders from the AI lab. Yet, with Symbolics machines installed at the AI lab itself, RMS was able take action against his identified villain using the only weapon he knew: code, to wreak revenge, and in the process insert himself deeply into issues of property in relation to software. In a process repeating in an opposing and less morally cogent manner that of Lucid and GNU Emacs, he took it upon himself to reverse engineer Symbolic's code for LMI's use, singlehandedly recoding the work of a team of creme de la creme coders who had healthy recourse to discussion and debate. Raising arguments of property, issues of sharing and common ownership, a codebase that originally belonged to MIT was split three ways, dividing loyalties, ambitions and above all source.

RMS was solely working for the common good as Symbolics appeared to drain the lab by focusing attention and thus coded improvements on a single proprietary product; an appalling one way funnelling which the GPL sets out to remedy.

Unfortunately, such an heroic coding effort, which Symbolics bowed down and praised on technical merit if not on legal terms, branding Stallman a thief, could not be kept up. His 1983 departure from MIT labs was marked by these words:

“I'm the last survivor of a dead culture, and I don't really belong in the world anymore. And in some ways I feel I ought to be dead.” GNU was born from such miserable ashes.

It's clear that the Emacs' commune lies at the beginnings of GPL, and that Emacs provides an entry point into code, exposing code in the same manner enacted by the license.

At the same time shared code in the form of extensions and configuration files makes evident the concerns and beauty of free software; modularity is the key here, informing also the choice of a Unix-like OS by the Free Software movement.

Modular components can be worked on by all and sundry and customised according to particular needs and interests. Indeed, GNU Emacs, with a long history of shared code makes the necessity of open code more evident than any other app or project. And the ease of extension, by way of simple elisp, also promotes the idea of the user as coder which is central to free software. Within the text of the wonderfully titled “Epistemologically Multiple Actor-Centred Systems: or, EMACS at work!” author Yuwei Lin argues coherently that “history shows how communal sharing and problem-solving strengthen software functionality and innovation.”

And, as we've seen, the story of the GPL is very much the story of GNU Emacs, yet there's one further twist in this giallo-like tale; namely Gosling Emacs. Code-wise Gosling very much contributed to the first GNU Emacs, and at that time, back in 1985, its author James Gosling allowed for free distribution of the code.

Yet again, in the same mistaken view that commercial enterprise would broaden much needed uptake, Gosling sold the rights to UniPress and the heat was on for Stallman to relinquish the code base. Stallman was later able to replace these parts of the code, but the episode again left an unsavoury taste in our hero's mouth. In his own words, “My later dealings with him personally showed that he was every bit as cowardly and despicable as you would expect from that history.” Yet, thanks to this episode we have the GPL, designed to work in exactly this instance, preventing once free code being locked down by greed or simple mistaken ambition.

Though it may prove daunting for those embarking on their first GNU steps, it can easily be argued that Emacs heavily embeds the recent history of creative computation, through both offering up visible roots within its core culture and also embracing emblematic code and sub-applications within its vast cathedral-like structure. And, at the same time we can read within both code and shared extensions, of which Emacs can boast over a thousand accumulated over its lengthy history, how creative computing culture interlocks with popular culture and counterculture, particularly with reference to games and amusements within the program. M-x insert-zippyism provides a good starting point, offering up the self-referential associative wordplay of a cartoon character spawned in the '70s. M-x psychoanalyze-pinhead takes things one step further, kicking off a free running conversation between ELIZA-style psychoanalyst program and good old Zippy. Coded by key hacker Joseph Weizenbaum at the good old MIT labs ELIZA stands out as an essential document within the early AI scene. It was one of the first absurdist takes on the Turing test and can equally well be read as dadaist text. At the same time M-x life, and M-x life-mode brings us deeper into MIT lab land with Joseph Conway's Game of Life which marks out relations to the viral, the cellular, and a healthy return to the Turing machine; the very base of computation. And we can well stress the importance of such seemingly trivial pursuits within the history of contemporary culture; in common with the computer virus, the Game of Life was first explored in the speculative pages of Scientific American.

Other code, located within a play directory beneath the standard Emacs distribution in /usr/local/share is also well worthy of attention, though perhaps with less historic import. Puzzles such as hanoi.el and game such as pong nevertheless do occupy some position and remain engaging. Perhaps more intriguing, in undoing the very functionality of a text editor and disarming intent are functions such as M-x zone, which allows the Emacs session to literally zone out when idle. You'll see your precious text or code disintegrate and play all manner of weird tricks. The wonderful M-x zone-leave-me-alone puts an end to this upsetting behaviour.

Martin Howse

Good stuff On May 4th, 2007 Anonymous says:

Unless your distribution differs from my own, the `-nv' you have listed as an option should be changed to `-nw'. I noticed it immediately since I frequently use it.

However, without regard to this infinitely minor typo, an excellent and very enjoyable sermon. Good to see the Church of Emacs continues.

A very good representation of the ethos emacsian, from what I have seen.

Multics Emacs On May 5th, 2007 Anonymous says:

This article misses the most important development in Emacs history: Bernie Greenberg's Multics Emacs. It was the first Emacs to be implemented in Lisp (no one had considered doing it before and most didn't think it would be practical), and paved the way for all future Emacs implementations. You can find more information here:


  • the_church_of_emacs.txt
  • Last modified: 2020-03-02 04:25
  • by nik