Emacs

From Wikipedia, the free encyclopedia
Jump to: navigation, search
Not to be confused with eMac.
Editing multiple Dired buffers in GNU Emacs

Emacs /ˈmæks/ and its derivatives are a family of text editors that are characterized by their extensibility. The manual for the most widely-used variant, GNU Emacs, describes it as "the extensible, customizable, self-documenting, real-time display editor".[1] Development of the first Emacs began in the mid-1970s and continues actively as of 2014. Emacs has over 2,000 built-in commands and allows the user to combine these commands into macros to automate work. The use of Emacs Lisp, a variant of the Lisp programming language, provides a deep extension capability.

The original EMACS was written in 1976 by Richard Stallman and Guy L. Steele, Jr. as a set of Editor MACroS for the TECO editor.[2][3][4][5] It was inspired by the ideas of the TECO-macro editors TECMAC and TMACS.[6]

The most popular, and most ported, version of Emacs is GNU Emacs, which was created by Stallman for the GNU Project.[7] XEmacs is a common variant that branched from GNU Emacs in 1991. Both of the variants use Emacs Lisp and are for the most part compatible with each other.

Emacs is, along with vi, one of the two main contenders in the traditional editor wars of Unix culture.

History[edit]

Editing C source code in GNU Emacs
Editing and compiling C++ code from GNU Emacs

Emacs development began during the 1970s at the MIT AI Lab, whose PDP-6 and PDP-10 computers used the Incompatible Timesharing System (ITS) operating system that featured a default line editor known as Tape Editor and Corrector (TECO). Unlike most modern text editors, TECO used separate modes in which the user would either add text, edit existing text, or display the document. One could not place characters directly into a document by typing them into TECO, but rather one had enter a character ('i') in the TECO command language telling it to switch to input mode, enter the required characters, during which time the edited text was not displayed on the screen, and finally enter a character (<esc>) to switch the editor back to command mode. (A similar technique was used to allow overtyping.) This behavior is similar to that of the program ed.

Richard Stallman visited the Stanford AI Lab in 1972 or 1974 and saw the lab's "E" editor, written by Fred Wright.[8] He was impressed by the editor's intuitive WYSIWYG (What You See Is What You Get) behavior, which has since become the default behavior of most modern text editors. He returned to MIT where Carl Mikkelsen, a hacker at the AI Lab, had added to TECO a combined display/editing mode called "Control-R" that allowed the screen display to be updated each time the user entered a keystroke. Stallman reimplemented this mode to run efficiently and then added a macro feature to the TECO display-editing mode that allowed the user to redefine any keystroke to run a TECO program.[5]

E had another feature that TECO lacked: random-access editing. TECO was a page-sequential editor that was designed for editing paper tape on the PDP-1 and typically allowed editing on only one page at a time, in the order of the pages in the file. Instead of adopting E's approach of structuring the file for page-random access on disk, Stallman modified TECO to handle large buffers more efficiently and changed its file-management method to read, edit, and write the entire file as a single buffer. Almost all modern editors use this approach.

The new version of TECO quickly became popular at the AI Lab and soon accumulated a large collection of custom macros whose names often ended in "MAC" or "MACS", which stood for "macro". Two years later, Guy Steele took on the project of unifying the overly diverse macros into a single set.[9] Steele and Stallman's finished implementation included facilities for extending and documenting the new macro set.[5] The resulting system was called EMACS, which stood for "Editing MACroS" or, alternatively, "E with MACroS". Stallman picked the name Emacs "because <E> was not in use as an abbreviation on ITS at the time."[10] An apocryphal hacker koan alleges that the program was named after "Emack & Bolio's", a popular Cambridge ice cream store.[citation needed] The first operational EMACS system existed in late 1976.[11]

Stallman saw a problem in too much customization and de facto forking and set certain conditions for usage.[citation needed] He later wrote:[11]

"EMACS was distributed on a basis of communal sharing, which means all improvements must be given back to me to be incorporated and distributed."

The original Emacs, like TECO, ran only on the PDP line of computers. Its behavior was sufficiently different from that of TECO that it could be considered a text editor in its own right, and it quickly became the standard editing program on ITS. Mike McMahon ported Emacs from ITS to the Tenex and TOPS-20 operating systems. Other contributors to early versions of Emacs include Kent Pitman, Earl Killian, and Eugene Ciccarelli. By 1979, Emacs was the main editor used in MIT's AI lab and its Computer Science lab.[12]

Other early implementations[edit]

Programmers wrote many Emacs-like editors for other computer systems in the following years. These included EINE ("EINE Is Not EMACS") and ZWEI ("ZWEI Was EINE Initially"), which were written for the Lisp machine by Mike McMahon and Daniel Weinreb, and Sine ("Sine Is Not Eine"),[13] which was written by Owen Theodore Anderson. Weinreb's EINE was the first Emacs written in Lisp. In 1978, Bernard Greenberg wrote Multics Emacs almost entirely in Multics Lisp at Honeywell's Cambridge Information Systems Lab. Multics Emacs was later maintained by Richard Soley, who went on to develop the NILE Emacs-like editor for the NIL Project, and by Barry Margolin. Many versions of Emacs, including GNU Emacs, would later adopt Lisp as an extension language.

James Gosling, who would later invent NeWS and the Java programming language, wrote Gosling Emacs in 1981. The first Emacs-like editor to run on Unix, Gosling Emacs was written in C and used Mocklisp, a language with Lisp-like syntax, as an extension language.

GNU Emacs[edit]

Main article: GNU Emacs
GNU Emacs running in a text console

Richard Stallman began work on GNU Emacs in 1984 to produce a free software alternative to the proprietary Gosling Emacs. GNU Emacs was initially based on Gosling Emacs, but Stallman's replacement of its Mocklisp interpreter with a true Lisp interpreter required that nearly all of its code be rewritten. This became the first program released by the nascent GNU Project. GNU Emacs is written in C and provides Emacs Lisp, also implemented in C, as an extension language. Version 13, the first public release, was made on March 20, 1985. The first widely distributed version of GNU Emacs was version 15.34, released later in 1985. Early versions of GNU Emacs were numbered as "1.x.x", with the initial digit denoting the version of the C core. The "1" was dropped after version 1.12, as it was thought that the major number would never change, and thus the numbering skipped from "1" to "13".[14]

GNU Emacs was later ported to Unix. It offered more features than Gosling Emacs, in particular a full-featured Lisp as its extension language, and soon replaced Gosling Emacs as the de facto Unix Emacs editor. Markus Hess exploited a security flaw in GNU Emacs' email subsystem in his 1986 cracking spree in which he gained superuser access to Unix computers.[15]

GNU Emacs development was relatively closed until 1999 and was used as an example of the "Cathedral" development style in The Cathedral and the Bazaar. The project has since adopted a public development mailing list and anonymous CVS access. Development took place in a single CVS trunk until 2008 and today uses the Bazaar DVCS. Work is underway to move development to Git.

Richard Stallman has remained the principal maintainer of GNU Emacs, but he has stepped back from the role at times. Stefan Monnier and Chong Yidong have overseen maintenance since 2008.[16] As of early 2014, GNU Emacs has had 579 developers throughout its history.[17]

XEmacs[edit]

Main article: XEmacs
XEmacs 21.5 on GNU/Linux

Lucid Emacs, based on an early alpha version of GNU Emacs 19, was developed beginning in 1991 by Jamie Zawinski and others at Lucid Inc. One of the best-known early forks in free software development occurred when the codebases of the two Emacs versions diverged and the separate development teams ceased efforts to merge them back into a single program.[18] Lucid Emacs has since been renamed XEmacs and remains the second most popular variety of Emacs, after GNU Emacs.[citation needed] XEmacs development has slowed, with the most recent stable version 21.4.22 released in January 2009, while GNU Emacs has implemented many formerly XEmacs-only features. This has led some users to proclaim XEmacs' death.[19]

Forks of GNU Emacs[edit]

Other forks, less known than XEmacs, include:

  • Meadow - a Japanese version for Microsoft Windows[20]
  • SXEmacs - Steve Youngs' fork of XEmacs[21]
  • Aquamacs - a version which focuses on integrating with the Apple Macintosh user interface

Various Emacs editors[edit]

The mg tiny Emacs-like editor in OpenBSD 5.3. Editing Ruby source code
Zmacs, an Emacs for Lisp machines

Emacs editors that are not based on GNU Emacs source code have proliferated, some as projects aimed at producing small versions of Emacs. GNU Emacs was initially targeted, in the 1980s, at computers with a 32-bit flat address space and at least 1 MiB of RAM. Such computers were considered high end at the time, and this left a need for smaller reimplementations. In more recent times, small clones have been designed to fit on software installation CDs. Other projects aim to copy Emacs but with a different dialect of Lisp or a different programming language altogether. Although not all are still actively maintained, these clones include:

  • MicroEMACS, which was originally written by Dave Conroy and further developed by Daniel Lawrence and which exists in many variations.
  • mg, originally called MicroGNUEmacs and, later, mg2a, a public-domain offshoot of MicroEMACS intended to more closely resemble GNU Emacs. Now installed by default on OpenBSD.
  • NotGNU,[22] a small, fast, freeware implementation for DOS, Win16, Win32 and Linux by Julie Melbin.
  • JOVE (Jonathan's Own Version of Emacs), Jonathan Payne's non-programmable Emacs implementation for UNIX-like systems.
  • Perfect Writer, a CP/M implementation that was included circa 1982 as the default word processor with the very earliest releases of the Kaypro II and Kaypro IV. It was later provided with the Kaypro 10 as an alternative to WordStar.
  • Freemacs, a DOS version that uses an extension language based on text macro expansion and fits within the original 64 KiB flat memory limit.
  • MINCE (MINCE Is Not Complete Emacs), a version for CP/M and later DOS, from Mark of the Unicorn. MINCE evolved into Final Word, which eventually became the Borland Sprint word processor.
  • Zile. Zile is a recursive acronym for Zile Is Lossy Emacs.[23]
  • Zmacs, for the MIT Lisp Machine and its descendants, implemented in ZetaLisp.
  • Climacs, a Zmacs-influenced variant implemented in Common Lisp.
  • QEmacs,[24] a small editor by Fabrice Bellard with UTF-8 capability that can quickly edit files as large as hundreds of MiB in size.
  • Epsilon,[25] an Emacs clone by Lugaru Software. Versions for DOS, Windows, Linux, FreeBSD, Mac OS X and O/S 2 are bundled in the release. It uses a non-Lisp extension language with C syntax and used a very early concurrent command shell buffer implementation under the single-tasking MS-DOS.
  • PceEmacs is the Emacs-based editor for SWI-Prolog.
  • EmACT, a 1986 fork of MicroEmacs by Christian Jullien. EmACT[26] source code is available at SourceForge.
  • Amacs, a commercial Apple II ProDOS version of Emacs implemented in 6502 assembly by Brian Fox.
  • Hemlock (editor), originally written in Spice Lisp, then Common Lisp. A part of CMU Common Lisp. Influenced by Zmacs. Later forked by the LispWorks and Clozure CL projects.

Editors with Emacs emulation[edit]

  • Yi, an editor that is written and extensible in Haskell and has an emulation mode for Emacs.
  • Joe's Own Editor has an emulation mode for Emacs when invoked as jmacs.
  • JED has an emulation mode for Emacs.
  • Eclipse (IDE) provides a set of Emacs keybindings.
  • The Cocoa text system understands many Emacs navigation bindings. This is possible because the native UI uses the Command key (equivalent to Super) instead of the Control key.

Features[edit]

Emacs is primarily a text editor and is designed for manipulating pieces of text, although it is capable of formatting and printing documents like a word processor. Emacs provides commands to manipulate words and paragraphs, syntax highlighting for making source code easier to read, and "keyboard macros" for performing user-defined batches of editing commands.

GNU Emacs is a "real-time display" editor, as its edits are displayed onscreen as they occur. This is standard behavior for modern text editors but EMACS was among the earliest to implement this functionality as opposed to having to issue a separate command to insert new edits into the existing text as in vi.

General Architecture[edit]

Almost all of the functionality in Emacs, including basic editing operations such as the insertion of characters into a document, is achieved through scripts in a dialect of the Lisp programming language known as Emacs Lisp (Elisp), layered on a relatively small and stable core of basic services and platform abstraction written in the C programming language. In this Lisp environment, variables and functions can be temporarily modified without the need to recompile or restart Emacs.

Emacs operates on buffers containing text with additional attributes; every buffer maintains its own point (cursor location) and mark (another location, delimiting the selected region together with the point), the name of the file it is visiting (if applicable) and the set of active modes (exactly one major mode and any number of minor modes), which control editor behaviour through variables. Elisp code can be executed interactively through named commands, which can be bound to key presses or accessed by name; some commands evaluate arbitrary code from buffers (e.g. eval-region or eval-buffer).

Buffers are displayed in windows, which are tiled portions of the terminal screen or the GUI window (called a frame in Emacs terms; multiple frames are possible). Unless configured otherwise, windows include scroll bars, line numbers, a header line at the top (usually displaying the buffer title or filename) and a mode line at the bottom (usually listing the active modes and point position of the buffer).

Multiple windows can be opened for the same buffer, for example to see different parts of a long text, and multiple buffers can share the same text, for example to take advantage of different modes.

Customizability[edit]

  • Keystrokes can be recorded into macros and replayed to automate complex, repetitive tasks. This is often done on an ad-hoc basis, with each macro discarded after use, although macros can be saved and invoked later.
  • At startup, Emacs executes an Emacs Lisp script named .emacs (init.el is also executed on more recent versions) from the user's home directory. This personal customization file can be arbitrarily long and complex, but typical content includes:
    • Setting global variables or invoking functions to customize Emacs behaviour, for example (set-default-coding-systems 'utf-8)
    • Key bindings to override standard ones and to add shortcuts for commands that the user finds convenient but don't have a key binding by default
    • Loading, enabling and initializing extensions (only a few are loaded by default)
    • Configuring event hooks to run arbitrary code at specific times, for example to compile source code after saving a buffer (after-save-hook)
    • Executing arbitrary files, usually to split an overly long configuration file into manageable and homogeneous parts (~/.emacs.d/ and ~/elisp/ are traditional locations for these personal scripts)
  • The customize extension allows the user to set configuration properties such as the color scheme interactively, from within Emacs, in a more user-friendly way than by setting variables in .emacs: it offers search, descriptions and help text, multiple choice inputs, reverting to defaults, modification of the running Emacs instance without reloading, and other conveniences. The customized values are saved in .emacs automatically.
  • Themes, affecting the choice of fonts and colours, are defined as elisp files and chosen through the customize extension.

Portability[edit]

Emacs uses a layered architecture, with a Turing complete language running on top of a smaller central core. Because about three-fourths of the stock Emacs distribution (1270 kLOC as of 2013-09-19) is written in the Elisp extension language [1], and the set of features implemented in Elisp code are automatically present once the C core which implements the Elisp interpreter has been ported (aka temacs at 299 kLOC), porting Emacs—including the stock Elisp plus a large variety[citation needed] of third-party Elisp extensions—to a new platform is considerably less difficult than porting a project consisting of native code only. Theoretically, only the core must be ported to the new platform; once the core is ported, the portions implemented in the language above that take minimal (but not zero [2]) work to bring over.

Self-documenting[edit]

The first Emacs contained a "help" library that included documentation for every command, variable and internal function. Because of this, Emacs proponents described the software as "self-documenting" in that it presents the user with information on its normal features and its current state. Each function includes a documentation string that is displayed to the user on request, a practice that subsequently spread to programming languages such as Lisp and Java. This help system can take users to the actual code for each function, whether from a built-in library or an added third-party library.

Emacs also has a built-in tutorial. Emacs displays instructions for performing simple editing commands and invoking the tutorial when it is launched with no file to edit. The tutorial is by Stuart Cracraft and Richard Stallman.

Culture[edit]

Church of Emacs[edit]

Main article: Editor war
Richard Stallman as St IGNUcius, a saint in the "Church of Emacs"

The "Church of Emacs", formed by Richard Stallman, is a parody religion created for Emacs users.[27] While it refers to vi as the "editor of the beast" (vi-vi-vi being 6-6-6 in Roman numerals), it does not oppose the use of vi; rather, it calls proprietary software anathema. ("Using a free version of vi is not a sin but a penance."[28]) The Church of Emacs has its own newsgroup, alt.religion.emacs,[29] that has posts purporting to support this parody religion. Supporters of vi have created an opposing "Cult of vi", argued by some Emacs users to be an attempt to "ape their betters".

Stallman has jokingly referred to himself as St IGNUcius, a saint in the Church of Emacs.[30]

Regarding vi's modal nature, some Emacs users joke that vi has two modes – "beep repeatedly" and "break everything". vi users enjoy joking that Emacs's key-sequences induce carpal tunnel syndrome, or mentioning one of many satirical expansions of the acronym EMACS, such as "Escape Meta Alt Control Shift" (a jab at Emacs's reliance on modifier keys).[31] As a poke at Emacs' extensive programmability, vi advocates have been known to describe Emacs as "a great operating system, lacking only a decent editor".

"Emacs pinky"[edit]

Many heavy Emacs users have experienced a repetitive strain injury[32] called "Emacs pinky" because of Emacs' strong dependence on Control and Meta keys and because of the position of the Control key in the modern keyboard layout, which is based on the Model M version of the IBM PC keyboard.

This problem has been addressed through both software and hardware. Software-side methods include:[33]

  • Customizing the key layout with ergoemacs-mode (ErgoEmacs keybinding).[34]
  • Customizing the key layout so that the Control key is transposed with the caps lock key.[35] Similar techniques include defining the caps lock key as a Control key or transposing the Control and Meta keys.
  • God-mode, which provides an approach similar to vim's with a mode for entering Emacs commands without modifier keys.
  • Evil-mode, an advanced Vim emulation layer.
  • Emacs' built-in "Viper-mode" that allows use of the vi key layout for basic text editing and the Emacs scheme for more advanced features.[36]
  • StickyKeys, which turns key sequences into key combinations.[37]
  • Giving a dual role to a more-comfortably accessed key such as the Space bar so that it functions as a Control key when pressed in combination with other keys. Keyboards with a greater number of keys adjacent to the space bar, such as Japanese keyboards, allow thumb control of other modifier keys too like Meta or Shift.[38]
  • Driving Emacs through voice input.
  • Software, such as xwrits, that reminds the user to take regularly scheduled breaks.

Hardware solutions include special keyboards such as Kinesis's Contoured Keyboard, which places the modifier keys where they can easily be operated by the thumb, or the Microsoft Natural keyboard, whose large modifier keys are placed symmetrically on both sides of the keyboard and can be pressed with the palm of the hand.[32] Foot pedals can also be used.

The "Emacs pinky" is a relatively recent development. The Space-cadet keyboard on which Emacs was developed had oversized Control keys that were adjacent to the space bar and were easy to reach with the thumb.[citation needed]

Vim advocates often cite Emacs pinky as a reason to switch, although some Vim users transpose their mode change key with the caps lock key for similar reasons.[39]

Terminology[edit]

The word "emacs" is sometimes pluralized as emacsen, by analogy with boxen and VAXen.[40]

See also[edit]

Notes[edit]

References[edit]

  1. ^ "GNU Emacs Manual". GNU Emacs Manual. FSF. Retrieved 24 November 2012. 
  2. ^ Bernard S. Greenberg. "Multics Emacs: The History, Design and Implementation". 
  3. ^ "GNU Emacs FAQ". 
  4. ^ Jamie Zawinski. "Emacs Timeline". 
  5. ^ a b c Adrienne G. Thompson. "MACSimizing TECO". 
  6. ^ "A history of Emacs". XEmacs Internals Manual. 2006-12-11. Retrieved 2007-08-22. 
  7. ^ Allombert, Bill. "Debian Popularity Contest". Editors report. Debian. Retrieved 22 November 2011. 
  8. ^ Arhur Samuel (March 1980). "Essential E". Retrieved 2011-08-01. 
  9. ^ "EMACS vs. vi: The endless geek 'holy war'". ""EMACS as such actually started out as a standards project," emails Guy Steele" 
  10. ^ Richard M., Stallman. "The EMACS Full-Screen Editor". Retrieved 2007-09-14. 
  11. ^ a b Stallman, Richard (March 26, 1981). EMACS: The Extensible, Customizable, Self-Documenting, Display Editor (Technical report). MIT AI Lab. AI Memo 519a. Retrieved 2011-01-07. 
  12. ^ Leigh Klotz (2007-08-29). "email quoted in "Be Careful What You Joke About"". The New York Times. Retrieved 2010-05-01. 
  13. ^ Owen Theodore Anderson (January 1979). "The Design and Implementation of a Display-Oriented Editor Writing System". Retrieved 2012-09-09. 
  14. ^ "A History of Emacs". 
  15. ^ Stoll, Clifford (1988). "Stalking the wily hacker". Communications of the ACM 31 (5): 484–497. doi:10.1145/42411.42412 
  16. ^ "Re: Looking for a new Emacs maintainer or team". gnu.org Mailing List. Retrieved 2008-02-23. ; see also "Stallman on handing over GNU Emacs, its future and the importance of nomenclature"
  17. ^ "Ugliest…repository…conversion…ever". "twenty-nine years of continuous development by no fewer than 579 people" 
  18. ^ Stephen J., Turnbull. "XEmacs vs. GNU Emacs". Retrieved 2012-10-02. 
  19. ^ "XEmacs is Dead. Long Live XEmacs!". 
  20. ^ FrontPage - Meadow Wiki
  21. ^ "SXEmacs Website". Sxemacs.org. 2009-10-11. Retrieved 2009-11-08. 
  22. ^ "NotGNU Emacs Editor (Author's Official Download Site)". Notgnu.org. 2004-01-15. Retrieved 2009-11-08. 
  23. ^ "Zile home page". 
  24. ^ "QEmacs Homepage". Fabrice.bellard.free.fr. Retrieved 2009-11-08. 
  25. ^ "Lugaru Software Homepage". 
  26. ^ Christian Jullien. (1986). "EmACT on sourceforge". Christian Jullien. Retrieved 31 December 2011. 
  27. ^ Saint IGNUcius - Richard Stallman
  28. ^ All about Linux: The unabridged selective transcript of Richard M Stallman's talk at the ANU
  29. ^ alt.religion.emacs newsgroup
  30. ^ Saint IGNUcius - Richard Stallman
  31. ^ satirical expansions of EMACS
  32. ^ a b "How To Avoid The Emacs Pinky Problem". Xahlee.org. Retrieved 2009-11-08. 
  33. ^ Repeated Strain Injury
  34. ^ "ErgoEmacs". Retrieved 2014-04-28. 
  35. ^ "Moving The Ctrl Key". EmacsWiki. Last edited 2009-09-26 17:40 UTC by asdf (diff). Retrieved 2009-11-08. 
  36. ^ "Viper Mode". EmacsWiki. Last edited 2009-07-19 22:39 UTC by AaronHawley (diff). Retrieved 2009-11-08. 
  37. ^ BayleShanks (2009-10-07). "Sticky Modifiers". EmacsWiki. Retrieved 2009-11-08. 
  38. ^ "Home". At home modifier. Retrieved 2011-11-30. 
  39. ^ "VimとEmacsのあいだで小指痛を叫んだけもの" (in Japanese). 2007-10-14. 
  40. ^ "VAXen". Catb.org. Retrieved 2009-11-08. 

External links[edit]