Other Lisps — Software Preservation Group (original) (raw)

Document Actions

LISPITO for IBM 1620 (National Politechnic Institute, Mexico)

DECUS PDP-8 LISPs

Lisp 1.6 for IBM 1130 (Boston Latin School)

"The basic structure of 1130 Lisp 1.6 is a composite of many features from four Lisp systems: 7090 Lisp, as described in the LISP 1.5 Programmer's Manual; Maclisp, developed at Project MAC at the Massachusetts Institute of Technology (MIT); Multics Lisp, developed on the Multics system at MIT; and Stanford A.I. Lisp, developed at the Stanford Artificial Intelligence Laboratory at Stanford University." [Steele, 1130 Lisp 1.6 User's Guide]

Source code

Documentation

CIMAS LISP (National University of Mexico)

"M. Magidin and I wrote an interpreter of Lisp for the B6700 in 1972 which was used mostly in education in several universities." [Raymundo Segovia, personal communication, May 2010]

MTS LISP (Michigan Terminal System, University of Michigan)

The Lisp interpreter was written by Bruce Wilcox in order to run the Reitman-Wilcox Go Program. The compiler was written by Carole Hafner.

ECSD LISP (Edinburgh Computer Science Department)

Edinburgh Computer Science Department Lisp, or ECSD LISP, was implemented by N. H. Shelness. It was written in the IMP programming language and ran on the EMAS operating system. The Wikipedia IMP article contains links to a variety of information about IMP, including compilers targetted at modern platforms.

Source code

This version contains the annotation "Updated by R.D. Eager University of Kent MCMLXXXII".

Documentation

Harvard LISP

"The LISP shell is based on a Harvard LISP interpreter, running under UNIX on the Yale GEM system." [Ellis, 1980]

"Its roots are in a PDP-11 Lisp system which originally came from Harvard." [Foderaro et al. The Franz Lisp Manual]

Source

Documentation

PDP-11 LISP (Massachusetts Institute of Technology)

"My first experience with Lisp was when I read the Lisp 1.5 manual in high school. That's when I had my mind blown by the idea that there could be a computer language like that. The first time I had a chance to do anything with Lisp was when I was a freshman at Harvard and I wrote a Lisp interpreter for the PDP-11. It was a very small machine — it had something like 8k of memory — and I managed to write the interpreter in a thousand instructions. This gave me some room for a little bit of data. That was before I got to see what real software was like, that did real system jobs." [Stallman, My Lisp Experiences and the Development of GNU Emacs]

COINS Lisp for VAX/VMS (University of Massachussets Amherst)

"CLisp (which was short for COINS Lisp, COINS being the department acronym at the time) didn't have any relation to the C Language (it was a Lisp-1 written in native VAX/VMS Macro-32 assembler and was the first Lisp written for the VAX architecture, predating VaxLisp). It also had no relation to the current CLISP (ANSI Common Lisp), which came later. CLisp faded quickly into obscurity when Lisp in our department moved heavily and early to TI Explorers and CLTL1.

BTW, when we decided we had to develop COINS Lisp ... for VAX/VMS (UMass Amherst had one of the earliest VAX/780 machines delivered--I think it was unit #4 or 5), we needed to move Lisp applications to the new VAX from ALISP ...

Anyway, when the VAX arrived, we looked initially at LISP F3 (FORTRAN-based Interlisp dialect) to see if it could be made feasible, but performance and capability were just not there. The VAX architecture was enough different to make porting PDP dialects difficult. COINS Lisp started from an skeletal representation/evaluator base that George Carrette had written at MIT. COINS Lisp took advantage of the CISC instructions and data representations provided by the VAX architecture (e.g., array representations and indexing instructions, native string representations and instructions, etc.), and it ran very efficiently for that era. The initial DVMT (Distributed Vehicle Monitoring Testbed), a pioneering multi-agent environment was written in COINS Lisp. (GRASPER was also migrated from ALISP to COINS Lisp: fortunately no longer requiring the AVL-tree "graph paging" with the larger virtual-memory on the VAX.)" [Dan Corkill, personal communication, September 3, 2010]

"The code that George provided (very graciously, after a brief conversation with him at MIT) was in the Spring of 1978. (I wish I'd kept better notes and, more importantly the code from those days. The CS Department maintained archival backups for a very long time (over 20 years), but then stopped maintaining them. As I recall, George's code consisted of a basic interpreter, BBOP and low-bit fixnum type tagging, Lisp-1 dynamic binding, and a stop & copy GC (no compiler, as I recall). All this was written entirely in MACRO32 assembly language. It might have been a very early prototype [of VAX NIL], but I'm wondering if it was more of a experimentation vehicle for VMS & MACRO32? (Could it have been a hand translation of some other Lisp interpreter or an environment for playing with some of the Lisp implementation techniques of the era?) In any event, George's generosity of sharing the basic interpreter was what I needed to get buy-in in the Department to build our own system rather than waiting for someone else to do a high-performance Lisp for the VAX. It didn't take long after we had COINS Lisp ready (with its compiler) to entice users of ALISP to port their code over to COINS Lisp." [Dan Corkill, personal communication, September 10, 2012]

Lisp-1 systems (such as Scheme) have a single namespace for functions and values, while Lisp-2 systems (such as Common Lisp) have separate namespaces for functions and values. [See Gabriel and Pitman, Technical Issues of Separation in Function Cells and Value Cells, 2001.]

3-Lisp

"3-lisp is a dialect of Lisp designed and implemented by Brian C. Smith as part of his PhD thesis Procedural Reflection in Programming Languages (what this thesis refers to as 'reflection' is nowadays more usually called 'reification'). A 3-lisp program is conceptually executed by an interpreter written in 3-lisp that is itself executed by an interpreter written in 3-lisp and so on ad infinitum. This forms a (countably) infinite tower of meta-circular (v.i.) interpreters. Reflective lambda is a function that is executed one tower level above its caller. Reflective lambdas provide a very general language extension mechanism." [Danilov 2022]

Source code

Papers

Second implementation

Although the original work was done using Maclisp, as described in [Smith 1982], a second version was implemented in Interlisp at Xerox Palo Alto Research Center.

GLISP (Stanford University and University of Texas)

"GLISP is a large package built on InterLisp that provides a conversational environment in which object-oriented systems can be constructed. It manages context and provides a graphical interface that frees the knowledge system programmer from many low-level programming concerns. GLISP is compiled into LISP using a knowledge base of object descriptions, treating LISP objects and objects in Al representation languages uniformly. This makes program code independent of the data representation used, and permits changes of representation without changing code. Abstract data types and inheritance of properties and behavior from multiple superclasses are supported.

A GLISP Display Inspector/Editor, GEV, was developed as a knowledge-based interactive editor for use on a Lisp machine with an high-resolution display. GEV uses GLISP structure descriptions to interpret and intelligently display LISP data, allowing the user to select objects with a mouse and focus attention on objects of interest.

GLISP was built by Professor Gordon Novak of the University of Texas while a visiting faculty member at Stanford. GLISP is fully implemented for the major dialects of LISP and is available over the ARPANET. The technology transfer has been successful, and GLISP is now widely used. ..." [Final Report, Heuristic Programming Project, Stanford University, March 1986]

Source code

Documentation

Papers

LispKit Lisp (Oxford University)

"LispKit is the portable implementation technique for a purely functional programming language, LispKit Lisp. The implementation consists of a small virtual machine, and a corpus of language support software, itself written in LispKit Lisp. It is the size and simplicity of the virtual machine which gives the implementation its portability.

The language is a dialect of the Lisp language and shares two of the most powerful features of that language: the universal structured type, the list; and s-expression syntax which is both expressive and easily manipulated by program. It differs from full Lisp in that all LispKit programs must be written in a functional style, since there are no language primitives for updating data structures. The absence of destructive assignment greatly improves the intelligibility of programs, and is held to improve programmer productivity, by simplifying the creation and maintenance of correct programs.

...

Generally speaking, sub­expressions are evaluated only if their values become necessary in the evaluation of a larger expression. This means that infinite values - for example the list of all the numbers, or of all the digits in the decimal expansion of an irrational number - may be handled in a natural way."

[Henderson et al. 1983]

Documentation and source

"The principal text both on the LispKit implementation, and on the LispKit Lisp dialect, and a useful introduction to this manual, is_Functional Programming: Application and Implementation_ ... . It describes a virtual machine and a language slightly different from those described in this manual, but familiarity with the system described in the book will help in an understanding of the current system, especially so if it is intended to make any changes to the virtual machine or to the system support software." [Henderson et al. 1983]

Additional implementations

PicoLisp

PicoLisp is a minimalist Lisp (dynamic binding, interpreted, three datatypes: atoms, symbols, and lists) with a rich library (including persistent objects, Prolog-like declarative language, and template-based abstract GUI) supporting its use as a general application server. It was created by Alexander Burger starting in the late 1980s; Jon Kleiser contributed the OpenGL library.

http://home.picolisp.com/

Source

Documentation

Papers

muLISP

Albert O. Rich and David R. Stoutemyer developed a series of microcomputer LISP implementations serving as an implementation language for a series of computer algebra applications, namely muSIMP, muMATH, and DERIVE. A version of muLISP was distributed for a time as Microsoft LISP.

"A Brief History of muLISP

muLISP-80 represents the culmination of 4 years of effort into designing a general purpose LISP system. It was developed almost entirely on microcomputers for microcomputers. The original interpreter was completed in 1977 by Albert O. Rich using LISP 1.5 as a guide. It was intended solely for use in mechanical theorem proving, specifically for the propositional and predicate calculus of formal logic. This system, now called muLISP-77, worked quite well for this purpose, although somewhat slowly.

Through the foresight of David R. Stoutemyer, it became apparent that the potential uses for a microcomputer LISP were tremendous. In particular the possibility of implementing for the first time a symbolic mathematics system on a microcomputer was set as a goal. Influenced by the invaluable suggestions of Martin Griss and Peter Deutsch, joint work by Rich and Stoutemyer yielded a greatly enhanced and robust LISP system. It included infinite precision arithmetic, streamed disk file I/O, and a powerful function body evaluation mechanism. This was released in June of 1979 as muLISP-79 by The Soft Warehouse, a partnership set up by Stoutemyer and Rich to facilitate the widespread distribution of the software.

The success of muLISP-79 and its companion product — the muSIMP/muMATH-79 [tm] Symbolic Math system — encouraged further work on improving the systems. The need for greater code density and faster loading capability resulted in the addition of a pseudo-code compiler and interpreter for the muLISP-80 system. A major effort went into making the documention for muLISP-80 of the same high caliber as the software. The clarity and completeness of this manual is due in large part to the persistence of Joan H. Rich.

Currently work is being done to make muLISP available for other popular micro and minicomputers. The advent of the 16 bit micro-processors will make possible the greatly improved performance and data space sizes required to satisfy the needs of ever larger AI research efforts. We intended to fulfill those needs.”
[Rich 1980]

Documentation

P-Lisp

"I co-wrote the manual for an Apple II lisp called P-Lisp, built mainly by Steven Cherry (also at Penn), who formed a company called GNOSIS to sell it." [Jeff Shrager, Personal communication, 14 April 2024]

Documentation

Source and executable code

Clojure for JavaVM and CLR and ClosureScript for Javascript

Clojure is a Lisp dialect designed by Rich Hickey for programming the kind of information systems that are often written in Java or C++ — "systems that acquire, extract, transform, maintain, analyze, transmit and render information—facts about the world.” [Hickey 2020] Hickey began working on Clojure in 2005, and released the first version in 2007.

Clojure emphasizes functional programming — side-effect free transformations from data to data, where the data is similar to Lisp s-expressions, but extended with vectors (constant-time access), maps (hashed and sorted), keywords, and metadata. It is a Lisp-1, with a single resolution mechanism for symbols in the function position and elsewhere. The seq abstraction generalizes lists and vectors, and has a lazy implementation. The data structures are persistent and immutable: update operations return an entire new version, and the old versions remain in existence. Polymorphism is supported with multimethods, types, records, and protocols.

Clojure is hosted on the Java Virtual Machine, and provides tight interoperability with Java. A compatible implementation, ClosureScript, is hosted on JavaScript. A compatible implementation on the Common Language Runtime (the execution engine of Microsoft's .Net Framework) is underway.

Hickey maintains tight control over the language definition, but there is an active community of contributors and users, with books, conferences, etc.

Websites

Code

Papers

« June 2025 »
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