NIL (programming language)

(Redirected from NIL lisp)

New Implementation of LISP (NIL) is a programming language, a dialect of the language Lisp, developed at the Massachusetts Institute of Technology (MIT) during the 1970s, and intended to be the successor to the language Maclisp.[1] It is a 32-bit implementation,[2] and was in part a response to Digital Equipment Corporation's (DEC) VAX computer. The project was headed by Jon L White,[3] with a stated goal of maintaining compatibility with MacLisp while fixing many of its problems.

Nil
ParadigmsMultiparadigm: functional, procedural
FamilyLisp
Designed byJon L White
DevelopersJon L White,
Guy L. Steele Jr.,
Richard P. Gabriel
First appeared1979; 45 years ago (1979)
Typing disciplinedynamic, strong
Implementation languageVAX assembly
PlatformVAX
OSVAX/VMS
Influenced by
Lisp, Maclisp
Influenced
Common Lisp,[1] T

History

edit

The Lisp language was invented in 1958 by John McCarthy while he was at Massachusetts Institute of Technology (MIT).[4] From its inception, Lisp was closely connected with the artificial intelligence (AI) research community, especially on PDP-10 systems. The 36-bit word size of the PDP-6 and PDP-10 was influenced by the usefulness of having two Lisp 18-bit pointers in one word: "The PDP-6 project started in early 1963, as a 24-bit machine. It grew to 36 bits for LISP, a design goal."[5] Lisp was used as the implementation of the programming language Micro Planner that was the foundation for the famous AI system SHRDLU. Lisp, in particular Maclisp (so named because it originated at MIT's project MAC) was also used to implement the Macsyma computer algebra system. In the 1970s, as AI research spawned commercial offshoots, the performance of extant Lisp systems became a growing problem.

Partly because of garbage collection (Lisp would use stop-and-copy garbage collection of its single heap for memory allocation[2]) and partly because of its representation of internal structures, Lisp became difficult to run on the memory-limited stock computer hardware of the day. This led to creating Lisp machines: dedicated hardware for running Lisp environments and programs. An alternative was to use the more powerful commodity hardware which was becoming available, especially the Digital Equipment Corporation (DEC) VAX.

NIL was an implementation of Lisp developed at MIT in the mid to late 1970s, and intended to be a modern successor to Maclisp that was able to run on stock hardware,[1] in contrast to Lisp Machine Lisp for the Lisp machines.[2] "Originally designed as the first modern Lisp dialect on stock hardware after the development of Lisp machine Lisp at MIT, it went on to become one of the main influences on the design of Common Lisp." (pg 63/294 of [2]) Since the users of the Macsyma program represented a large potential user base for NIL, it was necessary that NIL would be a large, complex system, and that speed would be imperative. For example, high-speed bignums was a requirement to support Macsyma, since NIL would be a failure with slow bignums.[6] Consequently, NIL ended up with a large base of VAX assembly language. These requirements led to a very aggressive and complex optimization strategy which was applied prematurely, with negative results on the final system.[7]

Concurrent with the effort to write NIL, a research group at Stanford University and Lawrence Livermore National Laboratory headed by Richard P. Gabriel were investigating the design of a Lisp to run on the S-1 Mark IIA supercomputer, S-1 Lisp. That Lisp was never fully functional, but was a test bed for implementing advanced compiler methods in a Lisp. Eventually the S-1 and NIL groups began collaborating.

Although unsuccessful in meeting its goals as a used language, NIL was important in several ways. First, it brought together Jon L. White, Guy L. Steele Jr., and Richard P. Gabriel, who were later to define Common Lisp.[1] Second, Jonathan Rees worked on part of the NIL project during a year away from Yale University. On returning to Yale, he was hired by the computer science department to write a new Lisp, which became the optimizing, native code Scheme system named T. In part, NIL begat this name, since "T is not NIL".[7]

1958 1960 1965 1970 1975 1980 1985 1990 1995 2000 2005 2010 2015 2020
 LISP 1, 1.5, LISP 2(abandoned)
 Maclisp
 Interlisp
 MDL
 Lisp Machine Lisp
 Scheme  R5RS  R6RS  R7RS small
 NIL
 ZIL (Zork Implementation Language)
 Franz Lisp
 Common Lisp  ANSI standard
 Le Lisp
 MIT Scheme
 XLISP
 T
 Chez Scheme
 Emacs Lisp
 AutoLISP
 PicoLisp
 Gambit
 EuLisp
 ISLISP
 OpenLisp
 PLT Scheme  Racket
 newLISP
 GNU Guile
 Visual LISP
 Clojure
 Arc
 LFE
 Hy
 Chialisp

Quotes

edit

The genesis & eventual failure of this kind of project is always clearly visible (in hindsight) in the shibboleths of the early discussions. One key tip-off phrase is always something of the form, "We'll throw out all the old cruft, start over fresh, and just Do Things Right."

— Olin Shivers[7]

References

edit
  1. ^ a b c d Steele, Guy L. Jr.; Gabriel, Richard P. "The evolution of Lisp" (PDF). Retrieved 2017-08-05.
  2. ^ a b c d Gabriel, Richard P. (May 1985). Performance and evaluation of Lisp systems (PDF). MIT Press; Computer Systems Series. ISBN 978-0-262-07093-5. LCCN 85015161.
  3. ^ Pitman, Kent M. "Brief History of the Lisp Language". Archived from the original on 2006-10-10. Retrieved 2006-10-12.
  4. ^ McJones, Paul. "History of LISP". Retrieved 2006-10-12.
  5. ^ Hurley, Peter J. Stevens, Jack; Johnson, Lum (eds.). "The History of TOPS or Life in the Fast ACs". Google Groups. Retrieved 2018-11-28.
  6. ^ Weinreb, Dan. "Dan Weinreb on NIL". PaulGraham.com. Retrieved 2018-11-28.
  7. ^ a b c Shivers, Olin. "Olin Shivers: History of T". PaulGraham.com. Retrieved 2018-11-28.

Bibliography

edit
  • Brent T. Hailpern, Bruce L. Hitson. S-1 Architecture Manual. Technical Report 161 (STAN-CS-79-715), Department of Electrical Engineering, Stanford University, January 1979.
  • G. Burke. Introduction to NIL. Laboratory for Computer Science, Massachusetts Institute of Technology, March 1983.
  • G.S. Burke, G.J. Carrette, C.R. Eliot. NIL Notes for Release 0.259, Laboratory for Computer Science, Massachusetts Institute of Technology, June 1983.
  • G.S. Burke, G.J. Carrette, C. R. Eliot. NIL Reference Manual. Report MIT/LCS/TR-311, Laboratory for Computer Science, Massachusetts Institute of Technology, Cambridge, Massachusetts, 1983.

Papers

edit
  • Steven Correll. S-1 uniprocessor architecture (sma-4). Volume I, Chapter 4, The S-1 Project 1979 Annual Report, Lawrence Livermore Laboratory, Livermore, California, 1979.
  • Jon L. White. Nil: A perspective. Proceedings of 1979 Macsyma Users' Conference, Washington, D.C., June 1979.
  • Rodney A. Brooks, Richard P. Gabriel, Guy L. Steele Jr. S-1 Common Lisp Implementation. Proceedings of the 1982 ACM symposium on LISP and functional programming, Pittsburgh, 1982, pages 108 – 113. ACM DL
  • Rodney A. Brooks, Richard P. Gabriel, Guy L. Steele Jr. An optimizing compiler for a lexically scoped LISP. Proceedings of the 1982 Symposium on Compiler Construction, Boston, June 1982, pages 261–275. ACM DL
  • Mark Smotherman. S-1 Supercomputer (1975–1988). Web site, last updated April 24, 2004. http://www.cs.clemson.edu/~mark/s1.html