L. Peter Deutsch developed PDP-1 LISP at M.I.T.:
"I wrote PDP-1 Lisp because I had a strong mathematical bent, I'd become intrigued with the Lisp language as a result of having somehow picked up a copy of the original Lisp 1.5 Programmer's Manual at MIT, and I wanted to have an interactive Lisp implementation to play with rather than having to submit card decks at the M.I.T. Computation Center. (Bear in mind that I was in high school at the time -- 1960-1964.) I'd ingratiated myself with the folks at the TX-0 (and later PDP-1) lab at M.I.T., so I had pretty free access to the machine there." [L. Peter Deutsch, quoted in lisp_doc.txt accompanying Bob Supnik's Software Kit]
Describes Basic PDP-1 LISP in detail, including full PDP-1 assembly language source code.
Documentation and listing.
"A program has been written for the PDP-1 providing a subset of the features of the LISP interpreter for the IBM 709/7090. This program, which contains no known bugs, will run on any PDP-1 with automatic divide. On machines with more than 4K of memory, it must be run in memory field 0.
It is assumed that the reader is familiar with 709 LISP in general and with the LISP 1.5 Programmer's Manual in particular."
"The editor described here is implemented within the PDP-l and SDS 940 time-sharing LISP systems, but can be used with minor changes within any LISP system which includes the capabilities of LISP 1.5. It was begun by the author in 1965 and later extended by Bobrow and Teitelman at BBN."
James Markovitch's transcription of the paper tapes of the source code for Bernie Cosell's LISP implementation of ELIZA with the DOCTOR script, which in turn was based on Joseph Weizenbaum's 1966 CACM paper.
The first LISP at Bolt Beranek and Newman Inc. was influenced by L. Peter Deutsch's Basic PDP-1 LISP:
"... my PDP-1 Lisp implementation, as you probably know, was extensively rewritten at BB&N to become the conceptual predecessor of BBN-Lisp, which in turn engendered Interlisp" [L. Peter Deutsch, quoted in lisp_doc.txt accompanying Bob Supnik's Software Kit]
"Bobrow and Murphy started with the LISP 1.5 definition and looked at Deutsch's code for the PDP-1b, but their implementation had a completely new code base for what they called BBN-LISP. [Bobrow et al. February 1966] Murphy says,
`. . . one of the things we did was build a timesharing LISP system on the PDP-1 — that is, a multi-user system for which the primary (and only) interface language was LISP. It was both the command language and the programming language, a la JOSS and such systems of that day.'
In their PDP-1b implementation of LISP, Bobrow and Murphy grappled with issues of supporting a large LISP memory on a machine with a small physical memory. [Bobrow and Murphy 1967]
In particular, Murphy implemented a software-based virtual memory and demand paging system[Dan Murphy in Origins and Development of TOPS-20] within his LISP implementation, and Bobrow and Murphy studied its performance. [Bobrow and Murphy 1968]"
[Walden and Nickerson, A Culture of Innovation: Insider Accounts of Computing and Life at BBN, 2011]
Dan Murphy had an extensive archive of old sources for BBN LISP (and many other things including TENEX, TELCOMP, and TECO), but the disk pack containing them fell victim to an overzealous sysadmin in 1987. He still has a set of files in LISP and PDP-10 assembly language. [Personal communication to Paul McJones, 10 March 2005.]
This report describes the LISP system for a PDP-1 with 8392 18-bit words of 5 microsecond core memory and 92,312 words on a drum with an average access time of 16.5 milliseconds. It describes the internal structure including paging and binding techniques. Section III defines all the standard functions; Section IV gives the source code of all the standard functions implemented in LISP.
"This report describes the LISP system implemented at BBN on the SDS 940 Computer. This LISP is an upward compatible extension of LISP 1.5 for the IBM 7090, with a number of new features which make it work well as an on-line language. These new features include tracing, and conditional breakpoints in functions for debugging and a sophisticated LISP oriented editor. The BBN 940 LISP SYSTEM has a large memory store (approximately 50,000 free words) utilizing special paging techniques for a drum to provide reasonable computation times. The system includes both an interpreter, a fully compatible compiler, and an assembly language facility for inserting machine code subroutines."
"This document describes the BBN-LISP system currently implemented on the SDS 940."
"Abstract: In an ideal list-processing system there would be enough core memory to contain all the data and programs. Described in this paper are a number of techniques that have been used to build a LISP system utilizing a drum for its principal storage medium, with a surprisingly low time penalty for use of this slow storage device. The techniques include careful segmentation of system programs, allocation of virtual memory to allow address arithmetic for type determination, and a special algorithm for building reasonably linearized lists. A scheme for binding variables is described which is good in this environment and allows for complete compatibility between compiled and interpreted programs with no special declarations."
Describes BBN LISP on a Digital Equipment Corporation PDP-1 with a core memory of 16K 18-bit words (5 microseconds access time) and a drum memory of 88K words (17 milliseconds average access time).
"Abstract: The problem of the use of two levels of storage for programs is explored in the context of a LISP system which uses core memory as a buffer for a large virtual memory stored on a drum. Details of timing are given for one particular problem."
Discusses BBN LISP on the SDS 940, which had 16K of 24-bit core memory and 1M words of drum memory (17 milliseconds average access time).
TENEX and TOPS-20 were popular operating systems for running LISP. See especially Origins and Development of TOPS-20 for extensive background on the PDP-6, PDP-10, LISP, and more.
"The system described here is organized in a novel manner compared to most other theorem-proving systems. It has a great deal of specific knowledge about integers and arrays of integers, yet it is not 'special-purpose', since this knowledge is represented in procedures which are separate from the underlying structure of the system. It also incorporates some knowledge, gained by the author from both experiment and introspection, about how programs are often constructed, and uses this knowledge to guide the proof process. It uses its knowledge, plus contextual information from the program being verified, to simplify the theorems dramatically as they are being constructed, rather than relying on a super-powerful proof procedure. The system also provides for interactive editing of programs and assertions, and for detailed human control of the proof process when the system cannot produce a proof (or counter-example) on its own."
See also: Interlisp-D.
Larry Masinter notes: "This is a pretty early version of Interlisp-10, around 1974. I think we maintained Interlisp-10 until well-after Interlisp-D was going, so maybe 6-10 years later. The .mac files are PDP-10 assembly language."
Rindfleish notes: "This version of Interlisp should be both TENEX and TOPS20 compatible. It came at a time when lots of work was going on to port Interlisp to other environments, including the VAX and the new personal Lisp machines (Dolphins, etc.). This means little was changing in the TENEX/TOPS20 version." Rindfleisch also has tape images containing various .sav files created from these files.
Masinter notes: "The TWENEX files seem to have come from Sumex, or at least, there are a lot of sumex-specific files there. The file dates are 1984, the latest seems to be 7-Dec-84. I used 'type a' FTP for the source files and 'type I' retrieval for the binary files, since the PDP-10 is a 9-bit-byte / 36-bit-word machine."
"Acknowledgements and Background: INTERLISP (formerly BBN LISP) has evolved from a succession of LISP systems that began with a LISP designed and implemented for the DEC PDP-1 by D.G. Bobrow and D.L. Murphy at Bolt, Beranek and Newman in 1966, and documented by D.G. Bobrow. An upwards compatible version of this LISP was implemented for the SDS 940 in 1967, by Bobrow and Murphy. This system contained the seeds for many of the capabilities and features of the current system: a compatible compiler and interpreter, uniform error handling, an on-line LISP oriented editor, sophisticated debugging facilities, etc. 940 LISP was also the first LISP system to demonstrate the feasibility of using software paging techniques and a large virtual memory in conjunction with a list-processing system. DWIM, the Do-What-I-Mean error correction facility, was introduced into the system in 1968 by W. Teitelman, who was also responsible for documentation for the 940 LISP system. ..."
"In order to implement the INTERLISP System (as described in The INTERLISP Reference Manual by W. Teitelman, et al.) on some physical machine, it is only necessary to implement the INTERLISP Virtual Machine, since Virtual Machine compatible source code for the rest of the INTERLISP System can be obtained from publicly available files."
"This report describes briefly a set of display primitives that we have developed at PARC to extend the capabilities of InterLisp[1]. These primitives are designed to operate a raster-scanned display and concentrate on facilities for placing text carefully on the display and for moving chunks of an already-created display.
...
Our implementation of these primitives involves two computers: InterLisp is executed on MAXC, and communicates with a program called Chat which maintains the frame buffer that drives a 808 by 606 point raster display."
1. INTRODUCTION [Missing]
2. Using INTERLISP
3. DATA TYPES, STORAGE ALLOCATION, GARBAGE COLLECTION, OVERLAYS
4. FUNCTION TYPES AND IMPLICIT PROGN
5. PRIMITIVE FUNCTIONS AND PREDICATES
6. LIST MANIPULATION AND CONCATENATION
7. PROPERTY LISTS AND HASH LINKS
8. FUNCTION DEFINITION AND EVALUATION
9. THE INTERLISP EDITOR
10. ATOM, STRING, ARRAY, AND STORAGE MANIPULATION
11. FUNCTIONS WITH FUNCTIONAL ARGUMENTS
12. VARIABLE BINDINGS, PUSH DOWN LIST FUNCTIONS, AND THE SPAGHETTI STACK
13. NUMBERS AND ARITHMETIC FUNCTIONS
14. INPUT/OUTPUT FUNCTIONS
15. DEBUGGING - THE BREAK PACKAGE
16. ERROR HANDLING
17. AUTOMATIC ERROR CORRECTION - THE DWIM FACILITY
18. THE COMPILER AND ASSEMBLER
19. ADVISING
20. PRINTSTRUCTURE, INTERSCOPE, AND HELPSYS
21. MISCELLANEOUS
22. THE PROGRAMMER'S ASSISTANT AND LISPX
23. CLISP - CONVERSATIONAL LISP
Appendix 1. Transor
Appendix 2. The INTERLISP Interpreter
Appendix 3. Control Characters
This web page explains how Lenat's source code for AM, Eurisko, and Traveller were discovered at saildart.org afgter Lenat's death, and links to GitHub repositories that have been set up for AM and Eurisko.
"Interlisp (and BBN-Lisp before it) introduced many radical ideas into Lisp programming style and methodology. The most visible of these ideas are embodied in programming tools, such as the spelling corrector, the file package, DWIM, CLISP, the structure editor, and MASTERSCOPE.
The origins of these ideas can be found in Warren Teitelman's PhD dissertation on man-computer symbiosis. In particular, it contains the roots of structure editing (as opposed to "text" or "tape" editing, breakpointing, advice, and CLISP." [Steele and Gabriel 1993]
"One of the most innovative of the language extensions introduced by Interlisp was the spaghetti stack. The problem of retention (by closures) of the dynamic function-definition environment in the presence of special variables was never completely solved until spaghetti stacks were invented." [Steele and Gabriel 1993]
Influenced by BBN-LISP and then INTERLISP, Mats Nordström and his colleagues at the University of Uppsala in Sweden developed a series of Lisp implementations written in Fortran.
"LISP 1.5 INTERPRETER WRITTEN IN FORTRAN
A simple Lisp 1.5 interpreter has been written in Fortran by Mats Nordström at Uppsala University. The system follows closely the definition of eval given in the Lisp 1.5 User' Manual; in particular, it uses an A-list (rather than a linear stack for variable bindings). Some 'modern' features have been included, such as nospread lambdas and implicit progns.
The interpreter is oriented toward interactive use, but with minor modifications it can be used in batch mode. It is intended for those who want to implement Lisp quickly and provisionally for a new computer, and for tutorial purposes in teaching interpreters and Lisp implementation.
The program is carefully commented and documented. Educational and research institutions can obtain a copy free of charge by writing to the following address: Mats Nordström, Datalogilaboratoriet, Sysslomansgaten 25, S-752 23, Uppsala, Sweden."
[SIGPLAN Notices, Volume 6, Number 5, July 4, 1971, page 6 (News section)] ACM DL
The original motivation was to be able to run Lisp programs on computers elsewhere in Sweden via a remote processing capability; the portability allowed these systems to be ported to various computers at Uppsala and elsewhere. Lisp F1 was compatible with Lisp 1.5 with extensions from BBN Lisp; it was written in Fortran IV and ran on IBM computers. Its development began in January 1970, and it was usable by September 1970; subsequent work increased its performance. Lisp F3 was compatible with INTERLISP, and thus could run many INTERLISP packages such as EDIT, MAKEFILE, BREAK, ADVISE and TRACE. Its development began in 1976. For more detail, see chapter 4 of Herbert Stoyan's book [Online at informatik.uni-erlangen.de via archive.org].
Lisp F2 was a modification of Lisp F1 developed at Clarkson College of Technology (now Clarkson University). It ran on an IBM System/360 Model 44 under 44MFT, a local variant of IBM's PS44 or 44PS through 1976, and then on an IBM 360 model 65 under OS/360 MVT.
Nordström produced a final version, Lisp F4, in the early 1980s; see below.
[What is the relationship, if any, between Nordström's FORTRAN implementations and INTERLISP/360-370?]
Nordström supplied to McBride what is believed to be the final snapshot of Lisp F4, from August 22, 1983, with permission to distribute it. McBride includes Nordström's original code absolutely complete and untouched including documentation, Fortran source code, lisp code, etc. -- see the file lispf4.orig in the archive.
(Most of these items are from Stoyan.)
CP-6 was an operating system for the Honeywell 6000 series.
In the mid 1970s at Uppsala University, an implementation of BBN-Lisp/INTERLISP was created for the IBM 360/370; it also ran on compatible computers such as Siemens and some Japanese ones. The main implementor was Jaak Urmi, after consultation with Warren Teitelman. Jim Goodwin moved from BB&N to the research group at Uppsala.
"Jaak Urmi, of Uppsala University in Sweden, who is implementing an INTERLISP for the IBM 370, visited PARC and engaged in a length)ydiscussion about the INTERLISP Virtual Machine with several PARC scientists (Bobrow. Deutsch, Moore, Teitelman). The result was a much greater degree of agreement between his implementation on INTERLISP as it is currently implemented. Should this implementation become available in the United States, transporting existing INTERLISP programs to the 370 implementation will be much easier." [Teitelman 1976]
"CONCLUSIONS
We have learned that in spite of the limitations of the hardware, i.e., the small number of general registers, 16-bit data paths and ALU, and the limited amount of microcode memory, a viable single-user Interlisp machine can be and has been implemented. We believe that with the addition of another 128K words of memory, and even at current prices ($60K—S70K) , Interlisp—1l provides a cost effective alternative to the large time sharing systems. A very small project at BBN spends $10K per year for computer time for one Interlisp programmer working half time. ..."
"I think the right thing to do, when thinking about the history of Interlisp, is to distinguish between INTERLISP, a teletype/interactive terminal timesharing system application, and Interlisp-D, a single user, window/mouse/keyboard, personal workstation system based on a single virtual machine.
INTERLISP ran on Tenex, Tops-20, VAX. There was a 'Jericho' port at BBN. There were discussions of ports to IBM System/360, but I don't think they were real.
INTERLISP programs could generally be ported to Interlisp-D with no changes to source code. Interlisp-D programs were binary compatible; it was possible to suspend and save the state of one of the virtual machines on one workstation (make a 'sysout') and restart it on another. In fact, the software build process consisted of us running a kernel Lisp loader that fired up an initial image, that then used Lisp code to load the rest of the system.
'Alto Lisp' was an interim step in the evolution between INTERLISP and Interlisp-D.
Interlisp-D ran on Dorado (Xerox 1132), Dolphin (Xerox 1100), Dandelion (Xerox 1108), Dandetiger (Xerox 1109), and Daybreak (Xerox 1186), all microcoded machines. The Dandelion and Daybreak used the same microcode, but the other machines were independent. The Dorado and Dolphin implementations had an Alto/BCPL operating system "boot loader", and some kernel OS functions like disk access were implemented in BCPL. The Dandelion and Daybreak machines had microcoded boot loaders.
There was a port of the byte-code interpreter to C started by Fuji Xerox and finished at PARC. The result was a version of Interlisp-D that ran on Suns and Unix. This implementation was later ported to Linux.
At some point during the evolution of Interlisp-D, a full implementation of Common Lisp was included; Interlisp and Common Lisp code shared the same runtime."
[Larry Masinter. Personal communication to Paul McJones, June 9, 2005; update from Nick Briggs, August 31, 2020.]
In 1992, Daniel G. Bobrow, Richard R. Burton, L. Peter Deutsch, Ronald M. Kaplan, Larry Masinter, and Warren Teitelman received the ACM Software System Award:
"For their pioneering work in programming environments that integrated source-language debuggers, fully compatible integrated interpreter/compiler, automatic change management, structure-based editing, logging facilities, interactive graphics, and analysis/profiling tools in the Interlisp system."
This describes the Kyoto release, which was followed by the Lyric and final Medley releases.
"These notes are intended to accompany the Guy L. Steele book, Common Lisp: the Language, which represents the current standard for Common Lisp."
A version of this paper was included in the revised version of SSL-80-4 revised.