Stefan Monnier
Michael Sperber
Skip Abstract Section
Abstract
While Emacs proponents largely agree that it is the world’s greatest text editor, it is almost as much a Lisp machine disguised as an editor. Indeed, one of its chief appeals is that it is programmable via its own programming language. Emacs Lisp is a Lisp in the classic tradition. In this article, we present the history of this language over its more than 30 years of evolution. Its core has remained remarkably stable since its inception in 1985, in large part to preserve compatibility with the many third-party packages providing a multitude of extensions. Still, Emacs Lisp has evolved and continues to do so.
Important aspects of Emacs Lisp have been shaped by concrete requirements of the editor it supports as well as implementation constraints. These requirements led to the choice of a Lisp dialect as Emacs’s language in the first place, specifically its simplicity and dynamic nature: Loading additional Emacs packages or changing the ones in place occurs frequently, and having to restart the editor in order to re-compile or re-link the code would be unacceptable. Fulfilling this requirement in a more static language would have been difficult at best.
One of Lisp’s chief characteristics is its malleability through its uniform syntax and the use of macros. This has allowed the language to evolve much more rapidly and substantively than the evolution of its core would suggest, by letting Emacs packages provide new surface syntax alongside new functions. In particular, Emacs Lisp can be customized to look much like Common Lisp, and additional packages provide multiple-dispatch object systems, legible regular expressions, programmable pattern-matching constructs, generalized variables, and more. Still, the core has also evolved, albeit slowly. Most notably, it acquired support for lexical scoping.
The timeline of Emacs Lisp development is closely tied to the projects and people who have shaped it over the years: We document Emacs Lisp history through its predecessors, Mocklisp and MacLisp, its early development up to the “Emacs schism” and the fork of Lucid Emacs, the development of XEmacs, and the subsequent rennaissance of Emacs development.
- Alan Bawden. 1999. Quasiquotation in Lisp. In Proceedings of the ACM SIGPLAN Workshop on PEPM Partial Evaluation and Semantics-Based Program Manipulation PEPM ’99, Olivier Danvy (Ed.). San Antonio, Texas, USA (Jan.), 4–12. nonarchival http://people.csail.mit.edu/alan/ftp/quasiquote- v59.ps.gz (retrieved 4 March 2020) https://web.archive.org/ web/20170515044951/http://people.csail.mit.edu/alan/ftp/quasiquote- v59.ps.gzGoogle Scholar
- Brian Berliner. 1990. CVS II: Parallelizing software development. In USENIX Winter 1990 Technical Conference, Vol. 341. 352. non-archival https://docs.freebsd.org/44doc/psd/28.cvs/paper.pdf (retrieved 3 March 2020) https://web.archive.org/ web/20190128051609/https://docs.freebsd.org/44doc/psd/28.cvs/paper.pdfGoogle Scholar
- Matthew Birkholz. 1993. Emacs Lisp in Edwin Scheme. Technical Report A.I. Memo No. TR-1451. Massachusetts Institute of Technology (Sept.). non-archival ftp://publications.ai.mit.edu/ai- publications/1000- 1499/AITR- 1451.ps.Z (retrieved 3 March 2020) https://web.archive.org/web/2017*/ftp://publications.ai.mit.edu/ai- publications/1000- 1499/AITR- 1451.ps.ZGoogle Scholar
- Per Bothner. 2002. JEmacs - The Java/Scheme-based Emacs. Free Software Magazine (March). non-archival http: //jemacs.sourceforge.net/JEmacs- FSM.html (retrieved 4 March 2020) https://web.archive.org/web/20190924233555/http: //jemacs.sourceforge.net/JEmacs- FSM.htmlGoogle Scholar
- Per Bothner. 2020. The Kawa Scheme language. non-archival https://www.gnu.org/software/kawa/index.html (retrieved 4 March 2020) https://web.archive.org/web/20200108175853/https://www.gnu.org/software/kawa/news.htmlGoogle Scholar
- Robert J. Chassell. 2018. An Introduction to Programming in Emacs Lisp (Emacs version 26.1 ed.). Free Software Foundation, Boston, Massachusetts. non-archival https://www.gnu.org/software/emacs/manual/html_mono/eintr.html https: //web.archive.org/web/20181214081848/https://www.gnu.org/software/emacs/manual/html_mono/eintr.html 2018-12-14.Google Scholar
- William Clinger. 1985. The Revised Revised Report on Scheme. Technical Report AI Memo No. 848. MIT (Aug.). non-archival https://dspace.mit.edu/handle/1721.1/5600 (retrieved 4 March 2020) https://web.archive.org/web/20150919023621/https: //dspace.mit.edu/handle/1721.1/5600Google Scholar
- William D. Clinger. 1998. Proper Tail Recursion and Space Efficiency. In Proceedings of the ACM SIGPLAN 1998 Conference on Programming Language Design and Implementation (Montreal, Quebec, Canada) (PLDI ’98). ACM, New York, NY, USA, 174–185. Google ScholarDigital Library
- Clojure [n.d.]. The Clojure Programming Language. Web site. non-archival https://clojure.org/ (retrieved 6 March 2020) https://web.archive.org/web/20200218082557/https://clojure.org/Google Scholar
- Marcus Crestani. 2005. A New Garbage Collector for XEmacs. Master’s thesis. Universität Tübingen. non-archival http://crestani.de/xemacs/pdf/thesis- newgc.pdf (retrieved 4 March 2020) https://web.archive.org/web/20190921060916/ http://crestani.de/xemacs/pdf/thesis- newgc.pdfGoogle Scholar
- Linda G. DeMichiel and Richard P. Gabriel. 1987. The Common Lisp Object System: An Overview. In European Conference on Object-oriented Programming on ECOOP ’87 (Paris, France). Springer-Verlag, Berlin, Heidelberg, 151–170. Google ScholarCross Ref
- Jake Edge. 2016. Removing support for Emacs unexec from Glibc. Web article. Jan. 2016. non-archival https://lwn.net/ Articles/673724/ (retrieved 6 March 2020) https://web.archive.org/web/20191101083505/https://lwn.net/Articles/673724/ LWN.net.Google Scholar
- Nic Ferrier. 2013. Hatching a plan to add namespaces to EmacsLisp. Blog post. June 2013. non-archival http://nic.ferrier.me. uk/blog/2013_06/adding- namespaces- to- elisp (retrieved 12 March 2020) https://web.archive.org/web/20190921040559/ http://nic.ferrier.me.uk/blog/2013_06/adding- namespaces- to- elispGoogle Scholar
- Matthew Flatt and PLT. 2018. The Racket Reference (v.7.0 ed.). PLT (Aug.). non-archival https://docs.racket- lang.org/ reference/index.html (retrieved 3 Sept. 2018) https://web.archive.org/web/20180930065049/http://docs.racket- lang.org/ reference/index.htmlGoogle Scholar
- FSF. 2020a. GNU Guile 3.0.0 Reference Manual. Free Software Foundation (Jan.). non-archival https://www.gnu.org/ software/guile/manual/ (retrieved 15 Jan. 2020) https://web.archive.org/web/20200304160710/https://www.gnu.org/ software/guile/manual/Google Scholar
- FSF. 2020b. Using the GNU Compiler Collection (GCC). Free Software Foundation, Chapter Labels as Values. nonarchival https://gcc.gnu.org/onlinedocs/gcc/Labels- as- Values.html (retrieved 6 March 2020) https://web.archive.org/ web/20191021235120/https://gcc.gnu.org/onlinedocs/gcc/Labels- as- Values.htmlGoogle Scholar
- Richard P. Gabriel. 1999. Letter to Chris DiBona and Tim O’Reilly. Web page. non-archival https://www.dreamsongs. com/DiBona- OReillyLetter.html (retrieved 18 Aug. 2018) https://web.archive.org/web/20190104032051/https://www. dreamsongs.com/DiBona- OReillyLetter.htmlGoogle Scholar
- Richard P. Gabriel, Nickieben Bourbaki, Matthieu Devin, Patrick Dussud, David N. Gray, and Harlan B. Sexton. 1990. Foundation for a C++ Programming Environment. In Proceedings of C++ at Work. (Sept.). In this paper, the authors describe the architecture of the nascent C++ development environment Lucid had been working on. The architecture was based on a set of lightly coupled separate tools integrated by a kernel. These tools produce annotations that can be displayed and analyzed by a UI.Google Scholar
- GMP 2020. The GNU Multiple Precision Arithmetic Library. non-archival https://gmplib.org/ (retrieved 3 March 2020) https://web.archive.org/web/20200225023116/https://gmplib.org/Google Scholar
- James Gosling. 1981. Unix Emacs. Carnegie-Mellon University. https://archive.org/details/bitsavers_cmuGosling_4195808Google Scholar
- Bernard S. Greenberg. 1996. Multics Emacs: The History, Design and Implementation. April 1996. non-archival https://multicians.org/mepap.html (retrieved 6 March 2020) https://web.archive.org/web/20200102215120/https://www. multicians.org/mepap.htmlGoogle Scholar
- Philip Greenspun. 2003. 10th rule of programming. Sept. 2003. non-archival http://philip.greenspun.com/bboard/qand- a- fetch- msg?msg_id=000tgU (retrieved 6 March 2020) https://web.archive.org/web/20170919102254/http://philip. greenspun.com/bboard/q- and- a- fetch- msg?msg_id=000tgUGoogle Scholar
- Bastien Guerry and Lars Magne Ingebrigtsen. 2013. Re: lexicons. Aug. 2013. non-archival https://lists.gnu.org/archive/ html/emacs- devel/2013- 08/msg00078.html (retrieved 30 Aug. 2019) https://web.archive.org/web/20190918090610/https: //lists.gnu.org/archive/html/emacs- devel/2013- 08/msg00078.htmlGoogle Scholar
- Barry Hayes. 1997. Ephemerons: A New Finalization Mechanism. In Proceedings of the 12th ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages, and Applications (Atlanta, Georgia, USA) (OOPSLA ’97 ). ACM, New York, NY, USA, 176–183. Google ScholarDigital Library
- Christopher T. Haynes and Daniel P. Friedman. 1987. Embedding Continuations in Procedural Objects. ACM Trans. Program. Lang. Syst. 9, 4 (Oct.), 582–598. Google ScholarDigital Library
- Pertti Kellomäki. 1993. PSD - a Portable Scheme Debugger. SIGPLAN Lisp Pointers VI, 1 (Jan.), 15–23. Google ScholarDigital Library
- Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Lopes, Jean-Marc Loingtier, and John Irwin. 1997. Aspect-oriented programming. In European Conference on Object-Oriented Programming. 220–242. Google ScholarDigital Library
- Bil Lewis, Dan LaLiberte, Richard Stallman, and GNU Manual Group. 2018. GNU Emacs Lisp Reference Manual (3.1 ed.). Free Software Foundation, 51 Franklin St, Fifth Floor, Boston, MA 02110-1301. non-archival https://www.gnu. org/software/emacs/manual/elisp.html (retrieved 3 March 2020) https://web.archive.org/web/20200122091452/https: //www.gnu.org/software/emacs/manual/elisp.htmlGoogle Scholar
- LibJIT 2020. GNU LibJIT. Project web page. non-archival https://www.gnu.org/software/libjit/ (retrieved 6 March 2020) https://web.archive.org/web/20191222233941/https://www.gnu.org/software/libjit/Google Scholar
- Lightning 2020. GNU Lightning. Project web page. non-archival https://www.gnu.org/software/lightning/ (retrieved 6 March 2020) https://web.archive.org/web/20191222201436/https://www.gnu.org/software/lightning/Google Scholar
- John McCarthy. 1960. Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I. Commun. ACM 3, 4 (April), 184–195. Google ScholarDigital Library
- MIT. 2014. MIT/GNU Scheme. Massachusetts Institute of Technology. non-archival https://www.gnu.org/ software/mit- scheme/documentation/mit- scheme- user/index.html (retrieved 24 Dec. 2014) https://web.archive.org/web/ 20141224003823/https://www.gnu.org/software/mit- scheme/documentation/mit- scheme- user/index.html Version 9.4.Google Scholar
- Richard Mlynarik. 2019. Personal communication. Email. Aug. 2019. Mlynarik responded to an email from Michael Sperber about the authorship of the union implementation. Mlynarik wrote about the philosophical differences he had with Richard Stallman over the use of type-safe abstractions in Emacs Lisp. He wrote: Actually having a real C structure representing the base Lisp object implementation was MASSIVELY helpful in debugging, since GDB started with at least a clue about what was in them.Google Scholar
- David Moon et al. 1978. Emacs Lore. Mailing list excerpt. July 1978. non-archival https://ban.ai/multics/doc/emacs.lore.txt (retrieved 6 March 2020) https://web.archive.org/web/20200306154734/https://ban.ai/multics/doc/emacs.lore.txtGoogle Scholar
- David A. Moon. 1974. MACLISP Reference Manual. Project MAC — M.I.T., Cambridge, Massachusetts (April). non-archival http://www.softwarepreservation.org/projects/LISP/MIT/Moon- MACLISP_Reference_Manual- Apr_08_1974.pdf (retrieved 3 March 2020) https://web.archive.org/web/20200102200158/http://www.softwarepreservation.org/projects/LISP/ MIT/Moon- MACLISP_Reference_Manual- Apr_08_1974.pdf Revision 0.Google Scholar
- Dan Murphy. 2009. The Beginnings of TECO. IEEE Annals of the History of Computing 31, 4 (Oct), 110–115. Google ScholarDigital Library
- Matthias Neubauer and Michael Sperber. 2001. Down with Emacs Lisp: Dynamic Scope Analysis. In International Conference on Functional Programming. Florence, Italy (Sept.), 38–49. Google ScholarDigital Library
- Kazuhito Ohmaki. 2002. Open source software research activities in AIST towards secure open systems. In 7th IEEE International Symposium on High Assurance Systems Engineering. (Oct), 37–41. Google ScholarCross Ref
- Kent M. Pitman. 1983. The Revised Maclisp Manual. Technical Report Technical Report 295. Laboratory for Computer Science, MIT, Cambridge, Massachusetts. non-archival http://www.maclisp.info/pitmanual/ (retrieved 3 March 2020) https://web.archive.org/web/20181108211218/www.maclisp.info/pitmanual/ Saturday Morning Edition.Google Scholar
- Kent M. Pitman. 2001. Condition Handling in the Lisp Language Family. In Advances in Exception Handling Techniques, A. Romanovsky, C. Dony, J.L. Knudsen, and A. Tripathi (Eds.). Lecture Notes in Computer Science, Vol. 2022. Springer. non-archival http://www.nhplace.com/kent/Papers/Condition- Handling- 2001.html (retrieved 4 March 2020) https: //link.springer.com/chapter/10.1007%2F3- 540- 45407- 1_3Google Scholar
- Kent M. Pitman. 2005. Common Lisp HyperSpec. non-archival http://www.lispworks.com/documentation/HyperSpec/ Front/index.htm (retrieved 4 March 2020) https://web.archive.org/web/20200114180058/http://www.lispworks.com/ documentation/HyperSpec/Front/index.htmGoogle Scholar
- Christopher Rhodes, Jan Moringen, and David Lichteblau. 2014. Generalizers: New Metaobjects for Generalized Dispatch. In European Lisp Symposium. 20–27. non-archival https://research.gold.ac.uk/9924/ (retrieved 3 March 2020) https: //arxiv.org/abs/1403.2765Google Scholar
- Peter Seibel. 2009. Coders at Work: Reflections on the Craft of Programming. Apress (Sept.).Google Scholar
- Richard Stallman. 1994. Why you should not use Tcl. Sept. 1994. non-archival https://vanderburg.org/old_pages/Tcl/war/ 0000.html (retrieved 3 March 2020) https://web.archive.org/web/20200108104230/https://vanderburg.org/old_pages/Tcl/ war/0000.html Newsgroup posting.Google Scholar
- Richard Stallman. 2002. My Lisp Experiences and the Development of GNU Emacs. Speech transcript. Oct. 2002. non-archival https://www.gnu.org/gnu/rms- lisp.en.html (retrieved 3 March 2020) https://web.archive.org/web/ 20200217150413/https://www.gnu.org/gnu/rms- lisp.en.html International Lisp Conference.Google Scholar
- Richard Stallman. 2003. Re: A plea for dynamically loadable extension modules. July 2003. non-archival https: //lists.gnu.org/archive/html/emacs- devel/2003- 07/msg00425.html (retrieved 26 May 2019) https://web.archive.org/web/ 20190925063202/https://lists.gnu.org/archive/html/emacs- devel/2003- 07/msg00425.htmlGoogle Scholar
- Richard Stallman. 2005. Re: Real constants. July 2005. non-archival https://lists.gnu.org/archive/html/emacs- devel/2005-07/msg00882.html (retrieved 26 July 2019) https://web.archive.org/web/20190918080041/https://lists.gnu.org/archive/ html/emacs- devel/2005- 07/msg00882.htmlGoogle Scholar
- Richard Stallman. 2012a. Re: CL package serious deficiencies. Feb. 2012. non-archival https://lists.gnu.org/archive/ html/emacs- devel/2012- 02/msg00350.html (retrieved 26 July 2019) https://web.archive.org/web/20190918064247/https: //lists.gnu.org/archive/html/emacs- devel/2012- 02/msg00350.htmlGoogle Scholar
- Richard Stallman. 2012b. Re: CL package serious deficiencies. Feb. 2012. non-archival https://lists.gnu.org/archive/ html/emacs- devel/2012- 02/msg00272.html (retrieved 26 July 2019) https://web.archive.org/web/20190918064231/https: //lists.gnu.org/archive/html/emacs- devel/2012- 02/msg00272.htmlGoogle Scholar
- Richard Stallman. 2012c. Re: CL package serious deficiencies. Feb. 2012. non-archival https://lists.gnu.org/archive/ html/emacs- devel/2012- 02/msg00283.html (retrieved 26 July 2019) https://web.archive.org/web/20190918064231/https: //lists.gnu.org/archive/html/emacs- devel/2012- 02/msg00283.htmlGoogle Scholar
- Richard Stallman. 2018a. GNU Emacs Lisp Reference Manual. Free Software Foundation, Chapter Why Text Properties are not Intervals. non-archival https://www.gnu.org/software/emacs/manual/html_node/elisp/Not- Intervals.html (retrieved 3 March 2020) https://web.archive.org/web/20191224141917/https://www.gnu.org/software/emacs/manual/ html_node/elisp/Not- Intervals.htmlGoogle Scholar
- Richard M. Stallman. 1981. EMACS: The Extensible, Customizable Self-documenting Display Editor. In Proceedings of the ACM SIGPLAN SIGOA Symposium on Text Manipulation (Portland, Oregon, USA). ACM, New York, NY, USA, 147–156. Google ScholarDigital Library
- Guy L. Steele. 1984. Common Lisp the Language (1st ed.). Digital Press, 313 Washington Street Newton, MA, United States.Google Scholar
- Guy L. Steele, Jr. and Richard P. Gabriel. 1993. The Evolution of Lisp. In The Second ACM SIGPLAN Conference on History of Programming Languages (Cambridge, Massachusetts, USA) (HOPL-II ). ACM, New York, NY, USA, 231–270. Google ScholarDigital Library
- Sam Steingold. 1999. Load Emacs-Lisp files into Common Lisp. non-archival https://sourceforge.net/p/clocc/hg/ci/default/ tree/src/cllib/elisp.lisp (retrieved 4 March 2020) https://web.archive.org/web/20190925063736/https://sourceforge.net/p/ clocc/hg/ci/default/tree/src/cllib/elisp.lispGoogle Scholar
- Li-Cheng Tai. 2001. The History of the GPL. Web page. July 2001. non-archival http://www.free- soft.org/gpl_history/ (retrieved 36 May 2019) https://web.archive.org/web/20191015034917/http://www.free- soft.org/gpl_history/Google Scholar
- The Unicode Consortium. 2011. The Unicode Standard. Technical Report Version 6.0.0. Unicode Consortium, Mountain View, CA. non-archival http://www.unicode.org/versions/Unicode6.0.0/ (retrieved 3 March 2020) https://web.archive. org/web/20180801000000*/http://www.unicode.org/versions/Unicode6.0.0/Google Scholar
- Walter F. Tichy. 1985. RCS - A System for Version Control. Software Practice&Experience 15, 7, 637–654. Google ScholarDigital Library
- Andrew Tolmach and Andrew W. Appel. 1990. Debugging Standard ML without reverse engineering. In Conference on Lisp and Functional Programming. 1–12. Google ScholarDigital Library
- Daniel Weinreb and David Moon. 1981. Lisp Machine Manual (third ed.). Massachusetts Institute of Technology, Cambridge, Massachusetts (March). non-archival http://www.bitsavers.org/pdf/mit/cadr/chinual_3rdEd_Mar81.pdf (retrieved 6 March 2020) https://web.archive.org/web/20200103040539/http://www.bitsavers.org/pdf/mit/cadr/chinual_3rdEd_Mar81. pdfGoogle Scholar
- Daniel L. Weinreb. 1979. A Real-Time Display-oriented Editor for the LISP Machine. Technical Report. MIT EECS Department (Jan.). In his Undergraduate thesis, Daniel Weinreb describes the ZWEI user interface, its interaction with the Lisp machine, its implementation strategies and engineering trade-offs, and the future of the system.Google Scholar
- John Wiegley. 2019. Simple library for asynchronous processing in Emacs. Github project. non-archival https: //github.com/jwiegley/emacs- async (retrieved 6 March 2020) https://web.archive.org/web/20190925224033/https:// github.com/jwiegley/emacs- asyncGoogle Scholar
- Ben Wing, Bil Lewis, Dan LaLiberte, and Richard Stallman. 1998. XEmacs Lisp Reference Manual (version 3.3 ed.) (April). non-archival https://www.xemacs.org/Documentation/21.5/html/lispref.html (retrieved 4 March 2020) https://web. archive.org/web/20160504192740/https://www.xemacs.org/Documentation/21.5/html/lispref.html For XEmacs Version 21.0.Google Scholar
- Jamie Zawinski. 2007. Emacs Timeline. Oct. 2007. non-archival https://www.jwz.org/doc/emacs- timeline.html (retrieved 6 March 2020) https://web.archive.org/web/20200212221812/https://www.jwz.org/doc/emacs- timeline.htmlGoogle Scholar
Index Terms
- Evolution of Emacs Lisp
Recommendations
Down with Emacs Lisp: dynamic scope analysis
ICFP '01: Proceedings of the sixth ACM SIGPLAN international conference on Functional programmingIt is possible to translate code written in Emacs Lisp or another Lisp dialect which uses dynamic scoping to a more modern programming language with lexical scoping while largely preserving structure and readability of the code. The biggest obstacle to ...
Comments