Personal tools
You are here: Home → Projects → LISP → Common Lisp family
Navigation
Log in


Forgot your password?
 
Document Actions

Common Lisp family

by Paul McJones — last modified 2024-08-17 13:23

 

Previous: UtiLisp - Up: LISP - Next: EuLisp

 

 

Specification

"Summer: Symbolics greets the idea of a 'standardizing' with much support. Noftsker in particular deems it desirable to have a common dialect on the Vax through which potential LispMachine customers can be exposed to Lisp. Moon pushes for a name, which by default seems to be heading for CommonLisp. GLS produces the 'Swiss Cheese' edition of the Spice Lisp manual." [Jon L White: Roots of "Yu-Shiang Lisp", 24 August 1982]
  • Guy L. Steele Jr., "with major contributions by Scott E. Fahlman, Richard P. Gabriel, David A. Moon, and Daniel L. Weinreb." Common Lisp Reference Manual. Spice Project, Department of Computer Science, Carnegie-Mellon University. Swiss Cheese Edition is still titled "Spice Lisp Reference Manual" and is co-authored by Scott E. Fahlman; subsequent editions adopt Common Lisp name and sole main author; starting with Excelsior Edition the major contributors are noted.
    • Swiss Cheese Edition. "Full of Holes — Very Drafty". Annotated by David Moon and Dan Weinreb. Gift of the author. 13 August 1981. PDF
      • Guy L. Steele Jr. Votes on the First Draft Common Lisp Manual. Spice Project, Department of Computer Science, Carnegie-Mellon University, 18 November 1981. Gift of the author. PDF
    • Flat Iron Edition. 26 February 1982. "Still a Few Odd Wrinkles Left." Annotated by, and gift of, the author. PDF
    • Colander Edition. 29 July 1982. "Even More Holes Than Before — But They're Smaller!" Herbert Stoyan collection on LISP programming, Computer History Museum. PDF
    • Laser Edition. 16 November 1982. "Supposed to be Completely Coherent." Herbert Stoyan collection on LISP programming, Computer History Museum. PDF
    • Excelsior Edition. 5 August 1983. "Suitable For Framing Or Wrapping Fish!" Clark Weissman papers, Lot X6720.2013, Computer History Museum. PDF

      See also: Spice Lisp User's Guide. 9 November 1983.

    • Mary Poppins Edition. 29 November 1983. "Practically Perfect in Every Way." Herbert Stoyan collection on LISP programming, Computer History Museum. PDF

      See also: Spice Lisp User's Guide. August 28, 1984.

  • Guy L. Steele Jr. Common LISP: the Language. Digital Press, 1984, 465 pages.

    The published version of the Common Lisp Reference manual. The title page notes "with contributions from Scott E. Fahlman, Richard P. Gabriel, David A. Moon, and Daniel L. Weinreb."

  • Daniel G. Bobrow, Linda G. DeMichiel, Richard P. Gabriel, Sonya E. Keene, Gregor Kiczales, and David A. Moon. Common Lisp Object System Specification. Technical Document 88-002R of X3J13. Lisp and Symbolic Computation, Volume 1, Number 3-4, February, 1989.
  • Guy L. Steele, Jr. Common Lisp: the Language, Second Edition. Digital Press, 1990, 1029 pages.
  • Kent M. Pitman et al. Information Technology - Programming Language - Common Lisp (formerly ANSI X3.226-1994 (R1999)).
  • Kent Pitman. Common Lisp HyperSpec, version 7.0. LispWorks Ltd., 2005. Online at www.lispworks.com

 

Papers

  • Archive of email to COMMON-LISP@SU-AI.ARPA, December 1981 to November 1984.
  • Larry Masinter and Bill vanMelle. Report on Common Lisp to the Interlisp Community. Email message, circa December 1981, 8 pages.
    • Computer History Museum: gift of Larry Masinter, Lot X6058.2011. PDF
    • Text file from SUMEX-AIM INTERLISP, <lisp>comlisp.report.1. Text file

    "In a fit of optimism that usually does not characterize him, Gabriel approached the Xerox Interlisp group, and received a warmer welcome than he did in Berkeley, but he left with only an indication that someone, probably Bill VanMelle, would attend the meetings, mostly as an observer." [Steele and Gabriel 1993]

  • Jon L White. Re: CL History. Email to Richard P. Gabriel and Guy L. Steele, 14 August 1984, resending early Common Lisp planning discussions by Jon L and others from 1981-1982. Posted by Arun Welch to comp.lang.lisp, 20 October 1994, Message-ID <WELCH.94Oct20153410@thor.oar.net>. Online at saildart.org Online at CMU AI Repository Online at groups.google.com
  • Guy L. Steele, Jr. An overview of COMMON LISP. Proceedings of the 1982 ACM symposium on LISP and functional programming, Pittsburgh, Pennsylvaniam, August 1982, pages 98-107. ACM DL
  • Herbert Stoyan. Common LISP - a Survey and a Critique. Rundbrief der Fachgruppe Kűnstliche Intelligenz in der Gesellschaft fűr Informatik. Number 28, November 1982, pages 11-20. PDF at fb-ki.gi.de
  • Richard P. Gabriel and Larry M. Masinter. Performance of Lisp systems. Proceedings of the 1982 ACM symposium on LISP and functional programming, Pittsburgh, Pennsylvania, pages 123-142. ACM DL
  • Rodney A. Brooks and Richard P. Gabriel. A critique of Common LISP. Proceedings of the 1984 ACM Symposium on LISP and functional programming, Austin, Texas, pages 1-8. ACM DL
  • Masayuki Ida. A Common Lisp Subset Proposal. Special Interest Group Report, Information Processing Society of Japan, 13 November 1985. Online at id.nii.ac.jp
    • Masayuki Ida. COMMON LISP CORE: A Common Lisp subset proposal. August 1986. PDF at prof-ida.com
  • Richard P. Gabriel. Performance and Evaluation of Lisp Systems. The MIT Press, Cambridge, Massachusetts, 1985. PDF at www.dreamsongs.com / The MIT Press
  • Archive of email to quinquevirate@SU-AI.ARPA, December 1985 to May 1990.
  • For archives of cl-iteration@SU-AI.ARPA, cl-object-oriented-programming@SU-AI.ARPA, cl-subsets@SU-AI.ARPA, cl-windows@SAIL.STANFORD.EDU, and cl-natural-languages@sail.stanford.edu see http://ml.cddddr.org
  • Jon L White. Reconfigurable, retargetable bignums: a case study in efficient, portable Lisp system building. Proceedings of the 1986 ACM conference on LISP and functional programming, Cambridge, Massachusetts, pages 174-191. ACM DL
  • S.E. Fahlman. Common Lisp. Annual Review of Computer Science, Volume 2, June 1987, pages 1-19. Online at annualreviews.org
  • Linda G. DeMichiel and Richard P. Gabriel. The Common Lisp Object System: An Overview. Proceedings ECOOP 1987, June 1987, Lecture Notes in Computer Science, Volume 276, Springer, pages 151-170. SpringerLink / Online at ecoop.org via Internet Archive / Online at dreamsongs.org
  • C. Queinnec and J. Chailloux, editors. Proceedings of the First International Workshop on Lisp Evolution and Standardization. February 22-23, 1988, Paris, France. Published by IOS, Amsterdam, 1988.
  • Takayasu Ito and Taiichi Yuasa. Some Non-standard Issues on Lisp Standardization. Proceedings of the First International Workshop on LISP Evolution and Standardization, February 22-23, 1988, Paris France, Published by IOS, Amsterdam, 1988, pages 11-20. PDF
  • Larry Masinter. Common LISP Cleanup. Proceedings of the First International Workshop on LISP Evolution and Standardization, February 22-23, 1988, Paris France, Published by IOS, Amsterdam, 1988, pages 21-24. Computer History Museum: gift of Larry Masinter, Lot X6058.2011. PDF of preprint
  • Kent M. Pitman. Interactions in Lisp. Proceedings of the First International Workshop on Lisp Evolution and Standardization, February 22-23, 1988, pages 45-49. Online at www.nhplace.com
  • Proceedings of the First CLOS Users and Implementors Workshop, October 3-4, 1988, Palo Alto. PDF at prof-ida.com
  • Linda G. DeMichiel. Overview: The Common Lisp Object System. Lisp and Symbolic Computation, Volume 1, Number 3-4, February, 1989, pages 227-244. DOI / Online at dreamsongs.com
  • Masayuki Ida. What We Have Done with Common Lisp in Japan During 1984 – 1989. Invited paper, Europal'90, March 1990. PDF at prof-ida.com
  • Masayuki Ida, Tahshi Kosah, and Keisuke Tanah. An Overview of Yy and YyonX: A CLOS based Window Tool Kit and its Implementation. Europal'90, March 1990, pages 245-252. PDF at prof-ida.com
    • Masayuki Ida, Keisuke Tanaka, Takashi Kosaka, and Yukio Ohta. An Overview of Yy. and YYonX: A CLOS based Window Tool Kit and its Implementation. Technical Report No. 90-004, Computer Science Research Laboratory, Information Science Research Center, Aoyama Gakuin University, 25 February 1991. PDF at prof-ida.com
  • Richard P. Gabriel, Jon L. White, and Daniel G. Bobrow. CLOS: Integrating Object-Oriented and Functional Programming. Commun. ACM, Volume 34, Number 9, 1991, pages 28-38. ACM DL / Online at dreamsongs.com
  • Henry G. Baker. Critique of DIN Kernel Lisp Definition Version. Lisp & Symbolic Computation, Volume 4, Number 4, March 1992, pages 371-398. Online at www.pipeline.com via archive.org

    "The last ten years have seen both a boom and and bust for the Lisp language. From its inception in 1958 until its commercialization in 1980, Lisp was content to live a life of academic obscurity, servicing the needs of Artificial Intelligence, theorem proving and symbolic algebra researchers. In this role, Lisp could explore many new ideas and quickly absorb new ideas from the programming language 'mainstream'. However, when AI became a business, Lisp was drawn to the money like a moth to the flame. Lisp quickly sought to become 'industrial strength', and ANSI Common Lisp was the result. Unfortunately, 'industrial' quickly became 'rust belt', as the newly standardized Common Lisp could not quickly grow and adapt to the new, more "open" environment.

    In Lisp's quest for industrial respect, it abandoned its traditional customers. Symbolic algebra developers (e.g., Maple, Mathematica) forsook Lisp for the more portable and efficient C. Logicians gave up Lisp for Prolog and ML. Vision researchers, seeking the highest performance from parallel computers, dropped Lisp in favor of C, Fortran (!) and various fringe parallel languages. AI companies were forced to move their expert systems into C, C++, Ada and Cobol (!) because of the large size, poor performance and poor integration of Common Lisp systems. Academicians teaching undergraduates chose Scheme and ML for their small size, portability and clean semantics."

  • JoAnne Yates and Wanda J. Orlikowski. Knee-jerk Anti-LOOPism and other E-mail Phenomena: Oral, Written, and Electronic Patterns in Computer-Mediated Communication. MIT Sloan School Working Paper #3578-93 Center for Coordination Science Techincal Report #150, July 1993. Online at ccs.mit.edu
  • Wanda J. Orlikowski and JoAnne Yates. Genre Repertoire: Norms and Forms for Work and Interaction. MIT Sloan School Working Paper #3671-94, Center for Coordination Science Technical Report #166, March 1994. Online at ccs.mit.edu

    "Most of the work [designing Common Lisp] was carried out by E-mail discussion. These discussions were captured in file archives. One research at the Sloan School at MIT has used these archives to study computer-mail-based decision-making and interaction. [Steele and Gabriel 1993]

  • Masayuki Ida, editor. In a stream from the singular space to a distributed world: From the transcript of ICERL'91 [International Workshop on the Cooperative Extension and Refinement of LISP, 1991]. Technical Report No. 94-007, Computer Science Research Laboratory, Information Science Research Center, Aoyama Gakuin University, Japan, 5 November 1994. PDF at prof-ida.com
  • John C. Mallery, Howard E. Shrobe, Robert Laddaga, Thomas F. Knight, Kalman Reti, Paul Robertson, Andrew J. Blumberg, Susan Felshin, and Patrick H. Winston. Modernizing Common Lisp: Recommended Extensions. Email to x3j13@ai.sri.com. Artificial Intelligence Laboratory, Massachusetts Institute of Technology, July 7, 1999. Online at lists.tunes.org
  • Masayuki Ida. The History of Lisp Standardization during 1984 – 1990. Proceedings of the 2002 International Lisp Conference, San Francisco, California, October 2002. PDF

    "CLtL1 was the output of a hastily united group of MacLisp successors, who felt InterLisp group was stronger than they were. They did not dream of international matters or even of commercial interests. Most of them thought it is just a US academic research matter: most of them did not know how to make international standards, or even American national standards."

  • Kent M. Pitman. Common Lisp: the untold story. Talk at Lisp50@OOPSLA, the 50th Anniversary of Lisp workshop, Monday, October 20, 2008.
  • Daniel Weinreb. Common Lisp Implementations: A Survey. Version 8, February 14, 2010. Online at common-lisp.net/~dlw via archive.org

    "There has been a new wave of interest in Common Lisp over the last few years. This paper is a November, 2007 (updated February, 2010) survey of Common Lisp implementations that are currently being actively maintained. It also provides references to writings about why Lisp is interesting and important, Lisp textbooks, and useful Lisp resources including repositories of available libraries."

 

Books

  • Richard P. Gabriel. Performance and Evaluation of Lisp Systems. The MIT Press, 1985. PDF at dreamsongs.com
  • David S. Touretzky. COMMON LISP: A Gentle Introduction to Symbolic Computation.The Benjamin/Cummings Publishing Company, Inc., 1990. Online at cmu.edu

 

Implementations - open source

See also:

 

CMU Common Lisp (CMUCL)

"CMUCL was developed at the Computer Science Department of Carnegie Mellon University. The work was a small autonomous part within the Mach microkernel-based operating system project, and started more as a tool development effort than a research project. The project started out as Spice Lisp, which provided a modern Lisp implementation for use in the CMU community. CMUCL has been under continual development since the early 1980's (concurrent with the Common Lisp standardization effort). Most of the CMU Common Lisp implementors went on to work on the Gwydion environment for Dylan. The CMU team was lead by Scott E. Fahlman, the Python compiler was written by Robert MacLachlan." [CMUCL credits]

  • Sources:
  • David B. McDonald, editor. User's Guide for CMU Common Lisp on the IBM RT PC under Mach. Department of Computer Science Carnegie Mellon University, 16 October 1986. PDF

    "Companion to Common Lisp: The Language"

  • D. McDonald, editor. CMU Common Lisp User's Manual: Mach/IBM RT PC edition. CMU-CS-87-156, Carnegie Mellon University, September 1987.
  • Robert A. MacLachlan, editor. CMU Common Lisp User's Manual. Carnegie Mellon University.
    • CMU-CS-91-108, 1991.
    • CMU-CS-92-161, July 1992, 145 pages. PDF
  • Robert MacLachlan. The Python compiler for CMU Common Lisp. LFP '92: Proceedings of the 1992 ACM conference on LISP and functional programming, January 1992, pp 235–246. ACM Digital Library

 

Steel Bank Common Lisp (SBCL)

"Steel Bank CL (SBCL) forked from CMU CL in December, 1999. The fork was initiated by William Newman. The system is named after the industries where Andrew Carnegie and Andrew Mellon, respectively, made fortunes.

The original goal of the fork was to produce a version of CMU CL that was easier to build and to maintain. After the fork, SBCL diverged from CMU CL, and as can be seen in this survey there are significant differences between their feature sets these days. While SBCL and CMU CL still share a lot of common code, few changes to one system are ported over to the other. Due to this and the different development philosophies, it can be expected that the implementations will continue to diverge.

The CLOS implementation is based on PCL, but has been substantially modified. The compiler generates reasonably good machine code: good for low-level number crunching as well." [Weinreb 2010]

 

Rutgers Common Lisp for TOPS-20 on DECSYSTEM-20

Charles L. Hedrick and J. Storrs (Josh) Hall developed a Common Lisp for the DECSYSTEM-20 running TOPS-20 at Rutgers University during 1983-1985. This system was based on Carnegie-Mellon's Spice Lisp, but used an assembly language kernel whose "interior design is sort of a cross between the Spice machine and Elisp, the Rutgers extended-addressing version of UCI Lisp" [Hedrick 1985]. The Spice system code, which is the portion of the runtime written in Lisp, was used with only minor modifications to deal with representation dependencies. The Spice compiler was modified to generate code for the DECSYSTEM-20.

The version of the kernel and Lisp code exhibited here contains bug fixes and improvements by Björn Victor, Per-Erik Martin and others at Uppsala University, Sweden, and also by Peter Samson at Systems Concepts, San Francisco, California.

The Flavors code was adapted for Common Lisp from Spice Lisp Flavors by Torbjörn Åhs and Björn Victor at Uppsala University. Spice Lisp Flavors was adapted by Steven Handerson from Symbolics Flavors. Symbolics Flavors was designed by Howard Cannon and David Moon.

Source code
  • Charles L. Hedrick and J. Storrs (Josh) Hall. Common Lisp for TOPS-20 on DECSYSTEMS-20. Rutgers University, 1983-1985. Modifications and additions by Björn Victor and others at Uppsala University, Sweden, 1985-1997. Distributed by permission of Charles L. Hedrick, July 28, 2005.
Documentation
  • Charles L. Hedrick. Tops-20 Common Lisp Red Pages. Rutgers University
    • Swiss Cheese Edition (very drafty), 1983, 23 pages. PDF
    • 1985, 26 pages. PDF
  • Daniel Weinreb and David Moon. Flavors: Message Passing in the Lisp Machine. A.I. Memo No. 602, Artificial Intelligence Laboratory, Massachusetts Institute of Technology, November 1980. Online at dspace.mit.edu
  • David Moon and Daniel Weinreb. Introduction to Flavors. 1985. PDF

    "This document is adapted from text written primarily by David Moon and Daniel Weinreb which appeared in the Lisp Machine Manual, fourth edition, chapter 20, copyrighted by the Massachusetts Institute of Technology."

  • Steven Handerson and Jim Muller. Spice Lisp Flavors. Spice Lisp Project, 1985. PDF
  • See also: [Wholey, Fahlman, and Ginder 1983].

    Stoyan includes a document with these authors and title as Spice Document S226, 1983.

Papers
  • See also: [Cannon 2007].
  • David Moon. Object-oriented programming with flavors. Conference Proceedings on Object-oriented Programming Systems, Languages and Applications, Portland, Oregon, 1986, pages 1-8. ACM DL

 

Clozure Common Lisp

"In 1984, Coral Software began the development of a Common Lisp for the Macintosh, called Coral Common Lisp (CCL). Three years later, CCL 1.0 was released. It ran on a 1 MB Macintosh Plus.

Subsequently, Coral entered into a marketing relationship with Franz, under which CCL was renamed to Macintosh Allegro Common Lisp (MACL). That didn't last long, and in late 1988, Coral was acquired by Apple, who released the Lisp under the name Macintosh Common Lisp (MCL).

In 1994, in the midst of switching from the 68K to the PowerPC CPU for its Macintosh line, Apple transferred MCL to Digitool. Digitool completed the PowerPC port and released a PowerPC version of MCL around 1995.

Erann Gat (now known as Ron Garret) of JPL wanted to develop a small-footprint Lisp for use on PowerPC-based robots and flight systems. A source license for MCL was acquired from Digitool, and in 1998, Gary Byers ported a version of the MCL compiler and runtime to VxWorks and LinuxPPC. In 2001, Digitool agreed to open source the work that had been done at JPL, and OpenMCL was born.

In 2007, Alice Hartley of Digitool announced that the code for the original MCL would be released under an open source license. Largely in order to avoid confusion with this newly open sourced version of MCL, OpenMCL was renamed to Clozure CL. As a bonus, this makes the name of the primary implementation package and the default installation directory name ("ccl") meaningful again.” [Clozure CL History]

 

MCL (Macintosh Common Lisp)

"Open source version of the Macintosh Common Lisp development environment. Works on Intel and PPC computers with MacOSX 10.4 and up, including MacOSX 10.6 'Snow Leopard'.

...

Thanks to Digitool for releasing MCL as open source and to Clozure for updating it to work on Intel and Snow Leopard." [Project home page]

See history of Clozure Common Lisp above.

 

Kyoto Common Lisp (KCL)

"A new player from Japan – Kyoto Common Lisp (KCL) – provided a bit of a spoiler: KCL has a compiler that compiles to C, which is compiled by the C compiler. This Lisp was licensed essentially for free, and the Common Lisp companies suddenly had a surprising competitor." [Steele and Gabriel 1993]

"Kyoto Common Lisp (KCL) is a highly portable and implementation of Common Lisp originally developed at Kyoto University in Japan. KCL conforms to CLtL1."

  • Sources: free but requires a license. Online at CMU Artificial Intelligence Repository
  • Taiichi Yuasa and Masami Hagiya. Kyoto Common Lisp Report. Research Institute for Mathematics Sciences, Kyoto University, August 1985, 87 pages. PDF / PostScript
  • T. Yuasa. Design and Implementation of Kyoto Common Lisp. Journal of Information Processing, Volume 13, Number 3, 1990, pages 284-295. PDF / PostScript

 

Austin Kyoto Common Lisp (AKCL)

"Austin Kyoto Common Lisp (AKCL) is a collection of ports, bug fixes and improvements to KCL written by Bill Schelter. {A}KCL generates C code which it compiles with the local C compiler."

"To build AKCL, one must also have in place the sources for KCL. At the time one builds AKCL, one automatically merges AKCL changes with the KCL sources, which are left unmodified, in accordance with the KCL license."

 

ECoLisp / ECL / ECL-Spain / ECL / Embeddable Common Lisp (Università di Pisa)

"ECL (Embeddable Common-Lisp) is an interpreter of the Common-Lisp language as described in the X3J13 Ansi specification, featuring CLOS (Common-Lisp Object System), conditions, loops, etc, plus a translator to C, which can produce standalone executables.” [https://common-lisp.net/project/ecl/main.html]

"Embeddable Common Lisp, a member of the KCL Family, is a Common Lisp implementation initially developed by Giuseppe Attardi, maintained for many years by Juan Jose Garcia-Ripoll and currently maintained by Daniel Kochmański. ECL is the successor to EcoLisp.” [https://www.cliki.net/ECL]

The long and complex history of ECL is described in this section of the manual.

Source code
Papers about ECL
  • Giuseppe Attardi. The Embeddable Common Lisp. ACM Lisp Pointers 8(1), 1995, 30-41. ACM Digital Library

 

ManKai Common Lisp (MKCL)

"ManKai Common Lisp is a member of the KCL Family through its ECL branch. MKCL is a quite complete ANSI Common Lisp implementation, mainly developed by Jean-Claude Beaudoin at the moment.

MKCL features, in its permanent configuration, a number of significant extensions like multi-threading, FFI and Unicode support, along with a good set of prepackaged libraries: CFFI, Babel, alexandria, FiveAM, Bordeaux-Threads, ASDF, SLIME and more." [MKCL at CLiki]

 

GNU Common Lisp (GCL)

"GCL is the product of many hands over many years. The original effort was known as the Kyoto Common Lisp system, written by Taiichi Yuasa and Masami Hagiya in 1984. In 1987 new work was begun by William Schelter, and that version of the system was called AKCL (Austin Kyoto Common Lisp). In 1994 AKCL was released as GCL (GNU Common Lisp) under the GNU public library license. The primary purpose of GCL during that phase of its existence was to support the Maxima computer algebra system, also maintained by Dr. Schelter. It existed largely as a subproject of Maxima.

After the passing of Dr. Schelter in 2001, it was decided that GCL should be actively maintained and improved. GCL is currently maintained by a team of 12 developers across the world coordinated via the gcl-devel mailing list." [GCL History]

 

GNU CLISP

"CLISP is a Common Lisp implementation by Bruno Haible, then of Karlsruhe University, and Michael Stoll, then of Munich University, both in Germany. It supports the Lisp described in the ANSI Common Lisp standard plus many extensions.

CMUCL's CLOS implementation is derived from the PCL reference implementation written at Xerox PARC. Its implementation of the LOOP macro was derived from code from Symbolics, which was derived from code written at MIT. The CLX code is copyrighted by Texas Instruments Incorporated. " [CLISP Common Lisp Summary]

 

BBN Butterfly Common Lisp

See Butterfly Lisp in Parallel Lisps section.

 

SPUR Lisp

See SPUR Lisp, which was a Common Lisp derived from Spice Lisp and extended with features to support concurrency on the SPUR multiprocessor workstation at the University of California at Berkeley.

 

Corman Common Lisp

Corman Common Lisp was originally a commercial product, but Roger Corman stopped developing it and released under an open source MIT license in 2015. He had previously released the source for his Macintosh product, PowerLisp.

"Corman Lisp is particularly focused on Windows on the Intel archicture. It features a native code compiler for Intel processors, 80x86 assembler and disassembler, incremental linker and multi-window text editor. It is fully integrated with the Win32 API, and all the Windows API functions are readily available from Lisp.

Corman CL was designed and implemented by Corman Technologies, since 1995. Previously they developed PowerLisp for the Mac, but Corman CL was a complete rewrite for Windows. (PowerLisp is no longer developed or supported). They have developed and maintained Corman CL continuously, with new major releases approximately every 18 months (and minor updates more often). The CLOS implementation was originally from Art of the Metaobject Protocol Closette, and then extensively rewritten to add missing Common Lisp features and to improve performance." [Weinreb 2010]

  • PowerLisp for Macintosh (includes source): www.cormanlisp.com/PowerLisp.html via archive.org
    "PowerLisp 2.02 is being released with complete source code (the entire product, including editor, can be built from scratch). This product is free for personal use. For commercial use, please contact us at admin@cormanlisp.com. A more complete license is being developed and will be posted here when available."
  • Corman Lisp github.com/sharplispers/cormanlisp

 

Poplog Common Lisp

"Poplog is an integrated toolkit providing a highly extendable collection of languages and tools for teaching, research and development. It is described on Wikipedia here. By default it includes incremental compilers for three powerful AI programming languages which can be used interactively both when learning to program and when developing software:

  • Pop-11--the core language -- used to implement itself and the others;
  • Common Lisp; and
  • Prolog;

as well as

  • Standard ML, a widely used functional language."
[What is Poplog?]

Source code
Documentation
Papers and implementation documentation
  • Aaron Sloman. The Evolution of POPLOG and Pop-11 at Sussex University. In: POP-11 Comes of Age: The Advancement of an AI Programming Language, Ed. J. A.D.W.Anderson, Ellis Horwood, pp 30-54, 1989. PDF and HTML at cs.bham.ac.uk
  • R. Smith, A. Sloman and J. Gibson. POPLOG's two-level virtual machine support for interactive languages, In: D. Sleeman and N. Bernsen, editors. Research Directions in Cognitive Science Volume 5: Artificial Intelligence, Lawrence Erlbaum Associates, 1992, pages 203-231. Online at cs.bham.ac.uk

 

CLiCC (The Common Lisp to C Compiler)

From the APPLY project, which also participated in EuLisp.

"CLiCC is a Common Lisp to C Compiler. It generates C-executables or modules from Common Lisp application programs. CLiCC is intended to be used as an addon to existing Common Lisp systems for generating portable applications. CLiCC supports a strict and very large subset CL0 (Common Lisp0) of Common Lisp + CLOS.

CLiCC is not a Common Lisp system. The generated C code, although human readable, is not primarily intended to be maintainable in C, hence, CLiCC is not a translator. The target language is a subset of C. CLiCC is adaptable to generate ANSI- or K&R-C. A standard C compiler, e.g. the GNU gcc, can be used on the target machine to generate stand alone executables or linkable modules.

CLiCC itself is a Lisp application. It has been developed using Franz Allegro Common Lisp 4.1. However, it does not require Allegro to run. Other Lisp systems including CLISP, GCL (AKCL) or CMU Common Lisp will do. The forthcoming release 0.6.5 will run under Allegro 4.3 as well. Moreover, CLiCC should compile itself to C. Unfortunately, this is impossible at present. As this bug is not yet fixed, release 0.6.2 has to be used in order to produce a stand alone compiler. " [Project page via archive.org]

 

ThinLisp

By Jim Allard at Gensym, later released as open source.

"ThinLisp is an open source Lisp to C translator for delivering commercial quality, Lisp-based applications. It implements a subset of Common Lisp with extensions. ThinLisp itself is written in Common Lisp, and so must run on top of an underlying Common Lisp implementation such as Allegro, MCL, or CMU Lisp. The C code resulting from a translation can then be independently compiled to produce a small, efficient executable image."

ThinLisp is not a typical Lisp implementation in that it does not implement a garbage collector or many of the other run-time development features of other Lisps. ThinLisp is designed for producing high quality deliverable C libraries and executables from Lisp sources. Originally designed for real-time control applications, ThinLisp stresses run-time performance at the expense of some development time conveniences. This is exactly the opposite design philosophy from many Lisps, but that's what makes this one thin!

ThinLisp is the current generation (4th) of a series of Lisp to C translators used to deploy a large Lisp system (1 million lines) built starting around 1990." [README]

 

Armed Bear Common Lisp (ABCL)

"Originally started to be a scripting language for the J editor, it now supports JSR-223 (Java scripting API): it can be a scripting engine in any Java application. Additionally, it can be used to implement (parts of) the application using Java to Lisp integration APIs.” [Project home page]

"ABCL was originally the extension language for the J editor, which was started in 1998 by Peter Graves. Sometime in 2003, a whole lot of code that had previously not been released publically was suddenly committed that enabled ABCL to be plausibly termed an emergent ANSI CommonLisp implementation candidate.

From 2006 to 2008, Peter manned the development lists, incorporating patches as made sense. After a suitable search, Peter nominated Erik Hülsmann to take over the project.

In 2008, the implementation was transferred to the current maintainers, who have strived toimprove its usability as a contemporary Common Lisp implementation." [User Manual]

 

XCL

Peter Graves.

"XCL is a new native-code implementation of Common Lisp. It features a kernel written in C++ and an optimizing compiler written in Lisp with backends for x86 and x86-64.

XCL runs on Linux, FreeBSD (tested only on x86, but it might work on x86-64 too), and 32-bit Windows." [README]

 

Implementations - commercial

 

Allegro CL. Franz Inc.

"Allegro Common Lisp was originally called Extended Common Lisp, first released in 1985. It is written in itself, and we used Franz Lisp (another dialect of Lisp that Franz used to sell in the 80's) to bootstrap the new implementation.

The compiler and runtime system were written from scratch, but some of the interpreter came from CMU's Spice Lisp. Our CLOS implementation was originally based on Xerox PCL. The interpreter and CLOS implementations were rewritten over the first few years of the product's life. An extensive history of Franz, Inc. can be found at http://franz.com/about/company.history.lhtml. The principal founders of Franz were Fritz Kunze, John Foderero, and Richard Fateman. John Foderero, the original primary architect at Franz, is still there as Chief Scientist." [Weinreb 2010]

 

Control Data Corporation Common Lisp

"Following CDC ALISP lineage for a moment, ALISP [at University of Massachusetts Amherst] was eventually replaced with work on a native Common Lisp that was headed by Richard Hudson." [Dan Corkill, personal communication, September 4, 2010]

"The Lisp/VE team was led by Richard L. Hudson and consisted of David M. Hart, Susan E. Lander, Andy Podgurski, Mali Anand, and Joanne Pommers. the compiler and runtime was written by the Lisp/VE team primarily in Lisp and a language called Cybil (Cyber Implementation Language). It leveraged a lot of the CMU Spice Lisp code to implement many of the Common Lisp functions and libraries. It faithfully implements the Common Lisp dialect and was available commercially as part of CDC's Cyber 180, the last machine CDC built." [Richard L. Hudson, personal communication, September 10, 2012]

"I think it was also the first full implementation of Pitman's condition system (I recall Susan exchanging a lot of question/clarification emails with Kent during that time.)" [Dan Corkill, personal communication, September 10, 2012]

  • Anonymous [Richard L. Hudson]. LISP for NOS/VE Language Definition: Usage Supplement. Publication Number 60486213, Control Data Corporation, Preliminary version, March 1985. Computer History Museum, Herbert Stoyan Collection on LISP Programming, Accession number 102720188. PDF
  • Anonymous [Richard L. Hudson]. LISP for NOS/VE Language Definition: Usage Supplement. Publication Number 60486213, Control Data Corporation, Revision B, December 1989. Gift of Richard L. Hudson. PDF

 

Data General COMMON LISP

"Implementation Strategy

In order to bring up a Common Lisp system quickly, a small, internal Lisp system was used to import much of the code from the Spice project at CMU. While a good deal of the code was used as it was, some important sections were changed significantly. For example:

  1. a third pass was added to the compiler, and all code gen- eration is delayed until then,
  2. a LAP (Lisp Assembly Program) language was designed that was more appropriate for the MV machines than the Spice byte-codes originally emitted by the compiler,
  3. the source-to-source transformation capabilities of the compiler were enhanced,
  4. arrays, numbers, and I/O, among other things, were reimplemented." [Oldman 1985, page 76]

  • Guy L. Steele Jr. Data General COMMON LISP Reference Manual. Data General Corporation, March 1985. PDF

    "This documentation is based on COMMON LISP: The Language, written by Guy L. Steele, Jr., and published by Digital Press (copyright 1984 by Digital Equipment Corporation), 30 North Avenue, Burlington, MA 01803. The original work constitutes the sole specification for COMMON LISP and any departures from that standard are the sole responsibility of Data General Corporation."

  • Dan Oldman. Data General Common Lisp. Section 2.12, pages 76-80, of [Gabriel 1985].
  • See also [Shebs 1988, page 36].
  • Data General Corporation. Release Notice: OS/VS DG COMMON LISP. Revision 2.30, Model Number 30947, Part Number 085-000710-09, February 1989. PDF at gist.github.com
  • For a description of an earlier, abandoned Common Lisp project at Data General, see section 2.4 of:
    • R. Kent Dybvig. The development of Chez Scheme. In Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming (ICFP '06). Association for Computing Machinery, New York, NY, USA, 1–12. ACM Digital Library / PDF at citeseerx.ist.psu.edu

 

Digital Equipment Corporation VAX LISP

"Subject: Public Domain VAX LISP
Return-Path: <FAHLMAN@C.CS.CMU.EDU>

What we could give you is Spice Lisp, developed here for the Perq computers and in the public domain. This is essentially Common Lisp written in Common Lisp and a Common Lisp compiler, written in Common Lisp, that produces a special Lisp-oriented byte code that is executed by custom microcode on the Perq. We also have an Emacs-like text editor written in Common Lisp, and some assorted utilities and demos. There's a design document describing the internal organization and defining the byte codes.

What various manufacturers, including DEC, have done is to take our sources and modify the code generation modules of the compiler to produce native code for their machine. Most of the byte codes turn into a few native-code instructions on something like a Vax. The more complex ones turn into quick jumps to hand-coded subroutines, probably written in assembler: bignum arithmetic, building and taking apart stack frames, GC, lowest-level operating system interfaces, and so on.

To build a system, you then run the modified compiler on some system that already has a Common Lisp, compile our whole body of Lisp code, link in the hand-coded stuff, and if you've done it all right the Lisp comes up in its full glory, ready to go. It is possible to get a reasonably fast implementation by this route, though it takes a good deal of thought and tuning to get the data formats and calling conventions just right.

Veterans of our implementation effort have done this port to a new architecture in as little as six man-months ... under optimal conditions. A more realistic time scale for someone starting from scratch on this would be two good wizards working six months to get something turning over, and another six months or a year to get the thing up to full speed and product quality. That's for a straightforward port ... All of the sources add up to 3 or 4 megabytes...

Since you ask about Vaxlisp, it is the result of the same process described above, and the work was done here at CMU by DEC employees and by me as a consultant to DEC. The result is owned by DEC and we can't give it to anyone.

-- Scott" [Scott Fahlman via AIList Digest, Volume 4, Issue 117, 9 May 1986]

"The VAX LISP language is an extended implementation of the COMMON LISP language defined in COMMON LISP: The Language. In addition to the features supported by COMMON LISP, VAX LISP provides the following extensions:

  • DCL (DIGITAL Command Language) LISP command
  • Extensible editor
  • Error handler
  • Debugging facilities
  • Extensible pretty printer
  • Facility for calling out to external routines
  • Facility for defining non-LISP data structures (alien structures)
  • Facility for defining interrupt functions (that is, functions that execute asynchronously)
  • Window and graphics support for the VAXstation II workstation"
[User's Guide, Chapter 1]

The manuals in this section are a gift of Beryl Nelson to CHM.

  • VAX LISP/VMS, Software Version 2.0, May 1986.
    • Anonymous. User's Guide. PDF
    • Anonymous. System Access Programming Guide. PDF
    • Anonymous. Installation Guide. PDF
    • Anonymous. Editor Programming Guide. PDF
    • Anonymous. Graphics Programming Guide. PDF
  • VAX LISP/ULTRIX, Software Version 2.0, May 1986.
    • Anonymous. User's Guide. PDF
    • Anonymous. System Access Programming Guide. PDF
    • Anonymous. Installation Guide. PDF
  • VAX LISP instructional materials, 1984.
    • Anonymous. VAX LISP Student Workbook. Volumes I, II, and III.
    • Anonymous. VAX LISP Tests/Exercises.

 

LispWorks

"LispWorks is produced by LispWorks Ltd.

Development began in Cambridge, England in 1987 and continues there today. The various owners have been: 1987-2000 Harlequin, 2000-2004 Xanalys, and 2005-present LispWorks Ltd.

The CLOS implementation started out as a branch of PCL (Portable Common Loops)." [Weinreb 2010]

 

Lucid Common Lisp (now Liquid Common Lisp)

 

GCLISP. Gold Hill.

 

Texas Instruments Explorer Lisp

  • Anonymous. Lisp Reference. TI Part Number 2243201-0001, Texas Instruments Explorer. PDF at bitsavers.org

 

Chestnut Lisp

"I founded Chestnut and produced the first version of the Lisp-to-C translator, which covered a small subset of Common Lisp, for in-house use in 1989. Chestnut was working on A.I.-flavored applications, particularly a natural-language engine, that we wanted to code in Lisp -- but had to deliver in C, mostly for memory compactness. Since the C code would at some point be maintained, and there were Lisp-agnostic C programmers on the project, we wanted the code to be as clean and clear as possible. Soon after, we discovered that there was a significant demand for the translator itself. The company's encounter with the market, beginning in 1990, was quite a shock: We assumed that customers would adapt their Lisp code to use our Common Lisp subset, to explicitly garbage-collect, etc. We wound up implementing all of CLtL2, including CLOS, and created several translation modes, one of which was fully automatic; local variables were saved on a stack so that they could be recognized as roots for garbage collection. A good number of large Lisp projects were coming to fruition at about the same time, and had to deliver in C for various reasons: portability; to work with multilingual teams; performance and memory footprint; and general fears about Lisp as a language. Many of them became Chestnut customers.

The project benefited greatly from the work of a small group of Lisp internals experts, including several members of the ANSI Lisp (X3J13) standards committee, which had codified Common Lisp only recently. Kim Barrett wrote all of the CLOS translator; Sandra Loosemore designed the translation engine and optimization framework; Jonathan Rees wrote much of the runtime library; he and James O'Toole, both MIT grad students, wrote several very fast garbage collectors, did a good deal of optimizing, and worked on portability; Andy Latto, Dmitry Nizhegorodov, Jeff Brodie, and Rick Harris made major contributions. Jim Allard, then with Gensym Corp., had built a translator for Gensym's use that Chestnut eventually replaced, and already had a lot of good engineering ideas that were incorporated into the product.

The translator was a pricey product: the company provided customers a good deal of support, and for customers who wanted readable C code that was also fast, compact, and portable, didn't really have any competitors. Our customers' best alternative was usually to spend several million dollars, and a year or two, reimplementing their applications in C. So Chestnut was able to find a niche, which grew as the company expanded its marketing efforts and as the amount of pre-sale engineering work it needed to perform for each customer drastically fell.

The company went out of business in 1995, several years after I left. ...

Its technology was sold to Oracle for use on a single development project. It's possible that an approach by the Lisp community would persuade Oracle to release the software as open source. Or Gensym, now based in Texas, might consent to its release. It would take some legwork and luck. In its favor are the passage of time and the re-emergence of Lisp as a platform.

The closest heir to Chestnut's technology seems to be Thinlisp, about which more above. Led by Jim Allard and Ben Hyde, it starts with some of the same design philosophy as Chestnut and focuses on the engineering virtues that, in the developers' experience, were most critical to a successful "develop in Lisp, deploy in C" engine." [Bill Brodie, comp.lang.lisp, 28 January 2009]

 

Scieneer Common Lisp (SCL)

"Scieneer CL is produced by Scieneer Pty Ltd of Australia. The current version is 1.3.7. There is one primary developer.

It is a fork from CMU CL, with improvements focusing primary on high-performance scientific computing.

Scieneer Pty Ltd was formed in March 2000 to develop and support a professional Common Lisp implementation for Symmetrical Multi-Processor (SMP) systems which is a key requirement for many high performance computing and enterprise applications.

The company was founded by Douglas Crosher, who was a developer of CMU Common Lisp. He was responsible for the x86 port, the generational garbage collector, the multi-processing support, and other enhancements." [Weinreb 2010]

The Scieneer web site became unresponsive sometime after September 2017.

 

See also: http://linuxfinances.info/info/commonlisp.html via archive.org

 

Applications

 

Computer algebra

  • Axiom. Online at axiom-developer.org

    "Axiom has been in development since 1971. At that time, it was called Scratchpad. Scratchpad was a large, general purpose computer algebra system that was originally developed by IBM under the direction of Richard Jenks. The project started in 1971 and evolved slowly. Barry Trager was key to the technical direction of the project. Scratchpad developed over a 20 year stretch and was basically considered as a research platform for developing new ideas in computational mathematics. In the 1990s, as IBM's fortunes slid, the Scratchpad project was renamed to Axiom, sold to the Numerical Algorithms Group (NAG) in England and became a commercial system. As part of the Scratchpad project at IBM in Yorktown Tim Daly worked on all aspects of the system and eventually helped transfer the product to NAG. For a variety of reasons it never became a financial success and NAG withdrew it from the market in October, 2001.

    NAG agreed to release Axiom as free software. The basic motivation was that Axiom represents something different from other programs in a lot of ways. Primarily because of its foundation in mathematics the Axiom system will potentially be useful 30 years from now. In its current state it represents about 30 years and 300 man-years of research work. To strive to keep such a large collection of knowledge alive seems a worthwhile goal."

  • Maxima. Online at maxima.soureforge.net

    "Maxima is a descendant of DOE Macsyma, which had its origins in the late 1960s at MIT. It is the only system based on that effort still publicly available and with an active user community, thanks to its open source nature. Macsyma was the first of a new breed of computer algebra systems, leading the way for programs such as Maple and Mathematica. This particular variant of Macsyma was maintained by William Schelter from 1982 until he passed away in 2001. In 1998 he obtained permission to release the source code under GPL. It was his efforts and skill which have made the survival of Maxima possible, and we are very grateful to him for volunteering his time and skill to keep the original Macsyma code alive and well. Since his passing a group of users and developers has formed to keep Maxima alive and kicking. Maxima itself is reasonably feature complete at this stage, with abilities such as symbolic integration, 3D plotting, and an ODE solver, but there is a lot of work yet to be done in terms of bug fixing, cleanup, and documentation. This is not to say there will be no new features, but there is much work to be done before that stage will be reached, and for now new features are not likely to be our focus." [About Maxima]

 

Theorem provers

The Boyer-Moore theorem prover pioneered the approach (also used by ACL2) of using "home-grown dialect of Pure Lisp" as a logic language, and also uses a regular Lisp as an implementation language.

  • R. S. Boyer and J Moore. Nqthm (the Boyer-Moore theorem prover).
  • Matt Kaufmann and J Strother Moore. ACL2 (Applicative Common Lisp - A Computational Logic).

 

Previous: UtiLisp - Up: LISP - Next: EuLisp
« November 2024 »
Su Mo Tu We Th Fr Sa
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
 
Powered by Plone CMS, the Open Source Content Management System

This site conforms to the following standards: