See also: Lisp F1 by Mats Nordström and his colleagues at the University of Uppsala.
The Univac M-460 was a military version of Univac 490. The LISP system was written by Timothy P. Hart and Thomas G. Evans at Air Force Cambridge Research Laboratories. The system was bootstrapped from Lisp 1.5 on the IBM 7090 using a cross-compiler and a small amount of machine language code for the lowest levels of the Lisp implementation. See:
"This article describes the process used to implement LISP 1.5 on the Univac M 460 (an early military version of the Univac 490). This machine, which has been available to us on an open-shop basis, has 32000 registers of 30-bit, 8 microsecond memory. It has an instruction set which is quite convenient for LISP, e.g., it is possible to load an index register (of which, incidentally, there are seven) from either the left or right half of the word addressed by the same index."
Includes LISP source code of interpreter.
The AN/FSQ-32/V was a military computer with 48-bit words; only one was built and it belonged to System Development Corporation, in Santa Monica, California. The LISP system was written by Robert Saunders, with assistance from Tim Hart, Dan Edwards, Mike Levin, John McCarthy, and Steve Russell.
"The Q-32 implementation was the first LISP that did not run on an interpreter: all code was compiled before execution. Someone subsequently wrote an interpreter for it, but I have no idea why other than for the fun and instruction of doing it. [As stated in Berkeley and Bobrow], the LISP was developed on Stanford's 709/90 system, compiled there, and taken to Santa Monica as machine instructions on magnetic tape. Some fundamental code (e.g. CONS, and later the garbage collector) was done in machine language on the Q-32 itself."
[Robert A. Saunders, personal communication to Paul McJones, May 6, 2005.]
This paper says "Assistance was also given by D. Edwards and M. Levin of the Massachusetts Institute of Technology, and Prof. J. McCarthy and S. Russell of Stanford University. Computer time on the Stanford 7090 and PDP-1 was used in conjunction with Stanford's contract with Advanced Research Projects Agency for research in time sharing and artificial intelligence." However Saunders now says "The Stanford PDP-1 played no role whatever in the Lisp port. I am at a loss to explain any claim to the contrary. All the work was done on the 709/90/94 system, using punched cards." Russell concurs. [Personal communication to Paul McJones, 5/16/2005]
"This document is a reference manual for the Q-32 LISP system in operation under the Time-Sharing System (TSS) on the AN/FSQ-32 computer. It describes the working of the LISP system, and contains descriptions of all currently available and installed functions, except for input-output and library functions given in TM-2337/l02/00."
"This document supplements TM-2337/101/00 by describing the input-output, file-handling and library functions of Q-32 LISP 1.5 Mod. 2.5."
"This document supplements TM-2337/10l/00 by describing the input-output, file-handling, and library functions ot Q-32 LISP 1.5 Mod. 2.6. It also describes differences between Mod. 2.6 and the previous Mod. 2.5 described in TM-2337/102/00 dated 9 August 1965."
Gives Q-32 holiday schedule through the end of 1967, and announces a change to LISP and LISPED: "Both the LISP and LISPED programs have been modified as of April, 1967, to utilize pseudo-addresses to represent 'small' integers and 'small' positive octals."
When was the Q-32 decommissioned?
"There now exists a version of LISP 1.5 on the Dartmouth Time-Sharing System. It resides under the name 'EVAL.' EVAL is a modification of LISP 1.5 developed for the IBM 7090 at M.I.T. It is similar enough to the M.I.T. version that an adequate referne manual is:
LISP 1.5 Programmer's Manual
By J. McCarthy et al.
M.I.T. Press" [Hobbs 1966]
"The IBM M44/44X was an experimental computer system from the mid-1960s, designed and operated at IBM's Thomas J. Watson Research Center at Yorktown Heights, New York. It was based on an IBM 7044 (the 'M44'), and simulated multiple 7044 virtual machines (the '44X'), using both hardware and software. Key team members were Dave Sayre and Rob Nelson. This was a groundbreaking machine, used to explore paging, the virtual machine concept, and computer performance measurement. It was purely a research system, and was cited in 1981 by Peter Denning as an outstanding example of experimental computer science." [Wikipedia, IBM M44/44X]
"A LISP 1. 5 system has been constructed for the M44 digital computer operated on a time-shared basis by IBM at the Thomas J. Watson Research Center at Yorktown Heights, New York. Because the technical details of M44 LISP are fully described in the User's Manual and System Manual, this report merely briefly summarizes the salient characteristics of the system. The details will be found in these two manuals. Complete listings of the system are in the possession of cognizant technical personnel at the Air Force Cambridge Research Laboratory.
M44 LISP was produced by a bootstrapping technique using the Q32 computer at the System Development Corporation at Santa Monica, California. The system itself contains a bootstrapping facility. M44 LISP has attempted to combine the best features of the LISP 1.5 systems operating on the IBM 7094, the Univac M-460, and the Q32, but it most closely resembles the Q32 system. The facilities for operating upon list structures and upon numerical quantities are quite similar among existing systems, and have been copied in M44 LISP. The basic library of LISP functions as specified in the LISP 1.5 Manual is available within M44 LISP, though certain functions peculiar to the 7094 system have been omitted."
LISP 1.5 was implemented on the IBM 7030 (STRETCH) computer at The MITRE Corporation by Roland Silver and Paul Heckel. The MATHLAB symbolic mathematics system ran on this computer as well as on CTSS at MIT P roject MAC. [Engelman 1965]
MBLISP was a Lisp 1.5 dialect developed by Harold V. McIntosh and his students at RIAS (Martin Baltimore) and the Quantum Theory Project (University of Florida).
"The programming experience which I gained in writing FLT [McIntosh 1962] was actually put to use in creating a LISP interpreter. I had become aware of LISP through acquaintance with some of John McCarthy's programming assitants, and the MIT Industrial Liaison Program, and we had even used LISP 1 in a RIAS summer institute rather successfully for a number of symbolic programs. A brief resumé of this institute was described in [McIntosh 1963]. LISP documentation was nonexistent at that time, so that our understanding of LISP was rather empirical. In the light of the preparation of FLT, it seemed that writing a LISP interpreter would be a simple matter, and in fact the only way to gain an adequate understanding of the structure of LISP. Such was the case; MBLISP was planned for about a month, written in two weeks, more thoroughly debugged over the ensuing six months, and extended in various ways for several more years, and has served as a training medium for a considerable number of students." [McIntosh 1972]
"This volume is intended to be an introduction to LISP programming. In addition, the last section constitutes a revision of the HANDBOOK OF LISP FUNCTIONS (RIAS technical report 61-11)."
"A pattern-driven symbolic manipulation language and its preprocessor (an interpreter) are presented."
"One of the students who had attended McIntosh’s 1961 Lisp summer school was Peter Conrad, my sophomore year roommate at Yale. Through this connection, I ended up attending McIntosh’s 1962 offering in Gainesville, probably funded entirely out of his own pocket. In preparation for this, I read a primer on Lisp that he and his students had written a year or two earlier[10], and then I began writing simple recursive Lisp functions for set-theoretic operations — before I had ever seen other than a picture of a computer.
During the next academic year at Yale, I built a Lisp interpreter, YULISP, for the IBM 709. Among other things, it had a rather sophisticated relocating garbage collector, perhaps the first instance of this kind of garbage collector. I also began work on a compiler version of YULISP. (All this was much to the detriment of my academic studies.)
I spent August of 1963 at Uppsala University as a guest of Prof. Per-Olov Lowdin, a quantum theorist, mathematician, and friend of Harold McIntosh. The central event of this visit was a talk on Lisp I presented in a grand old lecture hall at the university. At age 20, I was rather ill-prepared to deliver such a public lecture, but perhaps I planted a seed or two of interest in one or two Swedes.
Over the next couple of years, I continued to work under the mentorship of Harold McIntosh, first at the University of Florida in Gainesville and then at the Instituto Politecnico Nacional in Mexico City (where Adolfo Guzmán was a student and where Bob Yates was also to be found). At the Instituto Politecnico, I taught Lisp and continued implementing Lisps, both the YULISP compiler version for the IBM 709 and a just-for-fun interpreter for the CDC 160-A, a tiny paper tape machine." [Lowell Hawkinson, quoted in McJones 2012]
"Hawkinson & Yates LISP. While I was in Mexico City (September 1963 – September 1964), I had the opportunity to work with Lowell and become familiar with his plans for his next LISP version (again for the IBM 7090). The extensions consisted in incorporating integers, floating point numbers and arrays as basic objects (like atoms and lists) in the LISP language in a very efficient manner and this LISP was a compiler instead of an interpreter which made it much faster still. Towards the middle of 1964, we worked together and got the compiler running on the IBM 709 at the Politecnico. I went back to finish my bachelor’s degree at Johns Hopkins and Lowell remained 7-8 months more and was able to finish the garbage collector (which collected both lists and arrays — an innovation at that time). Lowell sent me a card deck and I continued work on the compiler at Bell Labs (Holmdel). However, Bell Labs wanted me to do the garbage collector for their Snobol4 project (Griswold) and then I went to Stanford for my doctorate. I essentially abandoned the Hawkinson-Yates LISP system and never had any more contact with it." [Robert Yates, quoted in McJones 2012]
"The first version was written in MBLISP, a LISP dialect which differs from LISP in a number of technical details, but which had a sufficient amount of pushdown list and free storage space available to be able to execute reasonably complicated examples. As an interpreter–interpreting a CONVERT interpreter for a slow machine–it was decidedly slow. The Q-32 version using a faster machine with a Lisp compiler gave a much better performance. One of the programs analyzed a group of order 16, defined as a semi-direct product C8:C2 of cyclic groups of order 8 and 2, respectively. It was possible to obtain the group table in about three minutes at times when the time-sharing competition was not intense which meant about a second per group product, a figure several hundred times as fast as for MBLISP in the 709.
The Q-32 Lisp has a limited pushdown list available, which prevented the execution of quite a number of programs, since CONVERT is highly recursive. However, the latest experience has been with yet another LISP processor, a compiler, constructed for the CENAC by Lowell Hawkinson and Robert Yates, and which they are presumably continuing to develop. It is unique in having an excellent array and floating-point numerical capability, as well as being very carefully organized in all other aspects. As a result it is one of our current vehicles for the CONVERT programs." [Guzmán and McIntosh 1966]
"In September of 1966, a project sponsored by Professor W. W. Bledsoe was begun to develop a LISP 1.5 interpreter system for the Control Data 6000 computer series. The completion of the system is announced with the publishing of this document." [Morris and Singleton, 1967]
"LLL now possesses a working implementation of UT LlSP for the 7600's. UT LlSP was originated and developed on CDC 6000 series equipment at the University of Texas at Austin and is now considered the standard LISP implementation on 6000 equipment all over the world.
The enclosed pages are preliminary versions of chapters of a reference manual now in preparation at the University of Texas. Some editing has been done to make them conform to usage at LLL. Although the reference manual is incomplete at the time of this writing, the information content is complete and accurate for use at LLL. Those chapters missing primarily cover material that is highly system-dependent and relevant only to the 6000 version.
UT LISP was developed under a SCOPE-like operating system, and as much of its original code as possible has been retained in the 7600 implementation. Therefore, LlSP is structured to run normally in batch mode, although excellent interactive capability has been incorporated. LlSP uses CDC display code internally and converts to 6-bit ASCII on input and output. A code translation table has been included as an appendix to the manual."
"The implementing of LISP 1.5 on CD 3600 was performed at: the Kjeller Computer Installation, Kjeller, Norway, as the main part of the author's thesis work for his M.A. degree. As several installations have asked me to make a LISP 1.5 interpreter for the IBM System 360, I have started to do this at the University of Waterloo, Waterloo, Ontario, Canada."
"In the 1966 academic year, Jerry Bolce wrote a Waterloo version of LISP, a language that was important to artificial intelligence. Bolce's version was known as LISP 1.5 [Peter James Ponzo, Computer science at Waterloo: a history to celebrate 25 years, 1967-1992, University of Waterloo, 1992]." [https://cs.uwaterloo.ca/40th/Chronology/1960.shtml]
"ACKNOWLEDGMENTS: I wish to thank Mr. Jan Kent for his experience and guidance in the initial design and implementation of the interpreter. ..."
"INTRODUCTION: Lisp /360 is an interpretative Lisp 1.5 system written at the University of Waterloo. It has been modelled after the Lisp 1.5 program on the IBM 7090 (1) although many ideas have been borrowed from the CDC 3600 Lisp interpreter (2). ..."
"REFERENCES:
1. John McCarthy et al., Lisp 1.5 Programmer's Manual, Cambridge, Massachusetts, MIT Press, 1962.
2. Jan Kent, An Interpretive System for the Programming of Recursive Functions on a Digital Computer, Thesis in Mathematics, University of Oslo (1966).
..."
Apparently based on Waterloo LISP/360. See also: [Fitch 1978] under Standard LISP.
"These routines were developed by R I Berns A C Hearn and J G Kent from code originally written for LISP on the 7090 and modified for the IBM System 360 by F Blair and J Griesmer."
The preface (by Rod Frederickson) ends with: "Since the last edition of this manual, Messrs. Kent and Berns have completed the LISP 1.5 Assembler and Compiler. Information on these processors is included in this paper."
"This manual is intended to provide the LISP 1.5 user with a reference manual for the LISP 1.5 interpreter, assembler, and compiler on the Campus Facility 360/67. ...
...
The particular implementation to which this reference manual is directed was started by Mr. J. Kent while he was at the University of Waterloo. It is modeled after his implemention of LISP 1.5 for the CDC 3600.
Included in this edition is information on the use of the time-shared LISP system available on the 360/67 which was implemented by Mr. Robert Berns of the Campus Computer Facility staff."
Describes the version of the MLISP preprocessor for a LISP 1.5 system running on an IBM System/360 Model 67; see also [Smith 1969] for a version running on Stanford LISP 1.6 for the PDP-6/10.
Cited by the LISP/360 Reference Manual (1972 edition) as "soon to be published".
"This manual is a reference for the modified version of Stanford LISP/360 used at the UIC Computer Center."
"The version of LISP currently offered at CERN is the Stanford LISP/360 with the Utah modifications of 1975. It is offered only on the IBM system. The present long write-up is the complete documentation, and consists of:
1. The Standford [sic] LISP/360 manual (pages i-vi and 1-58) and
2. The Utah appendix (pages Al-A16) which can be considered as an update to the Stanford manual."This copy is missing pages 32 and 57 of the Stanford LISP/360 section, which follows the Utah appendix.
Abstract: The design and implementation of the NPS LISP programming system is described. NPS LISP is an interactive version of LISP 1.5, a sophisticated list processing and symbol manipulation computer language. NPS LISP was implemented in PL/I for operation under the CP/CMS time-sharing system on the IBM 360/67 computer. It is an interpretive system patterned after 7090 LISP. Most of the features of 7090 LISP are included in NPS LISP.
Appendix C is a source code listing.
"The R.P.I. LISP interpreter for the System/360/50 was written in 1965 by William Lehrman for the degree of Master of Electrical Engineering. The garbage collector, arithmetic features, and print program were written by Jonathan Millen. The compiler was written by Jack Gelb and Jonathan Millen, the authors of several lesser functions and this manual. Mel Sabel wrote the self-relocation routine and the I/O modules to allow LISP to operate through teletypes. The authors gratefully acknowledge the encouragement and advice of Professors Dean Arden and Jack Hollingsworth of R.P.I."
"In the late 1960's, Eric Norman of the University of Wisconsin - Madison developed a LISP 1.5 dialect for the Univac 1100 series of mainframes ... .
The LISP system developed by Norman consisted of approximately 5,000 lines of Univac assembly language for the interpreter and about 1,000 lines or so of LISP for the compiler. Several interesting applications were developed under or ported to Univac LISP including: Planner (an early planning language designed by Carl Hewitt of MIT; MLISP (an Algol 60-like dialect of LISP); Fuzzy (a system that worked with Fuzzy Logic); and several LISP utilities such as a Pretty Print package, a Math Library, a source Editor, and a Debugger. The original source code for all of the above items -- including the full interpreter and compiler -- are contained herein and are discussed in some detail." [Jack Harper, http://www.frobenius.com/univac.htm via archive.org]
"At the time, the Computing Center here at Wisconsin had decided to purchase a Univac 1108. It couldn't be delivered yet, though. What we had was a remote card reader and printer to an 1108 up in Minneapolis. Just about all the interpreter was developed that way. That is, I submitted a deck of cards at night and picked up the listings the next day. When the 1108 arrived on campus, LISP was already running on it." [Eric Norman, personal communication to Paul McJones, May 2005]
"I first thought that it was a newer version of what I received from Eric in 1972, but quickly realized that it is, in fact, older than that. I first thought it newer because it contains more information and is better written.
However, it contains nothing on strings (which were later added to the system), DefSpec (to allow uses to implement their own special forms - later added), and many others (e.g., date/time functions, things like MANIFEST etc etc etc). In addition, the Lisp example code in the document says that it is running on Lisp v6.2, whereas the document that I have had since 1972 speaks of v7.72.
This older document is very nice and I have no idea why Norman abandoned it sometime before 1972 (when I received the tape from him). Possibly, he thought it too long or too complicated or something - and cut it up into two separate documents - the "Primer" and the "Reference" that I received then. This document is, in my view, much better." [Jack Harper, personal communication to Paul McJones, August 7, 2012]
"It is an early document because it does not talk about string objects at all (added to the system later). ... Eric clearly designed the system to maximize the efficient use of memory. For example, not only did he pack two Lisp pointers into a single 36-bit word of core, but he limited pointers to 17-bits so that he marked cons cells during garbage collection simply by complementing the contents in a single machine instruction, meaning that he did not need a separate MARK field (other than that single bit) in a cons cell. ...
In addition, he used BIBOP memory management where he divided the Lisp space into hordes of (128-word) pages that each held only a single type of data. Therefore, he could take a pointer and with a couple of logic instructions could tell the type of object pointed to - without a TYPE field in the cells. Again, he was doing everything he could to maximize memory use traded off with a bit more processing. ...
Back "in the day", very few 1108s had the full 262,144 word memory size - memory was the most expensive part of a computer then. For example, Lisp/1100 started up with a default heap size of only 12,800 36-bit words (or 200 128-word BIBOP pages - the program size was about 14,000 words and the stack(s) was 3,072 - thus, to run Lisp/1100 required just over 30,000 words of core - you could, if needed, grow core at runtime on-the-fly). Thus, the reason for Eric's extreme emphasis on efficient memory management.
I also found it interesting, from the document, that he put the hooks in for a parallel garbage collector (which answers some questions for me about some oddities in the code), but he never implemented that - probably because, to my knowledge, he never had access to a dual-processor UNIVAC ...
The Lisp/1100 system was fairly typical for its time: Deep binding with an a-list for example; the Compiler never allocated simple objects (e.g., integers) on the stack (all Lisp objects live in the heap); etc. ...
I worked inside (and as a user) of Eric's gorgeous Lisp for many years and only found (and corrected) one bug. The AND function (really a special form) is supposed to evaluate its arguments from left to right and to immediately exit on the first argument that evaluates to nil and leave the rest unevaluated. His original AND evaluated all arguments in any case - I found that problem with some Lisp code where one of the arguments had a side-effect that incorrectly happened with a previous argument that evaluated to nil."
[Jack Harper, personal communication to Paul McJones, August 7, 2012]
"The system was started and then an octal dump was taken of memory that shows the Lisp system in all of its radiant glory...
If you know the system, various things leap out of the octal - the BIBOP pages, atomic symbols (with print names in the 6-bit UNIVAC "fielddata" character set, page tables, etc :)
I have no idea if this might be of any use to you.
It might - if nothing else, to show the "young whippersnappers" out there what we old guys had to live with "back in the day" :)
I spent years of my younger life staring at such printouts at 0200 in the cold raised floor computer room slowly getting more and more pasty colored from the fluorescent lights :)"
[Jack Harper, personal communication to Paul McJones, August 10, 2012]
"The program which has evolved into Maryland LISP was begun in 1969 by Eric Norman of the Univerity of Wisconsin. Several basic implementation decisions made in the writing of Wisconsin LISP remain in Maryland LISP, though there have been many changes and extensions. The bulk of the code for Maryland LISP's control structures, as well as the compiler, prettyprinter, debugger, and micro-Planner programs are revised versions of routines written at Wisconsin.
Wisconsin LISP arrived at the University of Maryland in 1974 and was modified and adapted by, among others, Chuck Rieger and Milt Grinberg. Mache Creeger added the string functions, random-access file I/O, the text editor intertace, ASCII character I/O, an implementation of Stanford MLISP, the Suspend-Resume Package, the contingency routines, and numerous other extensions. Phil Agre added the sequential file I/O functions, a new garbage collector, the virtual memory option, the assembler, the array, matrix, and bignum packages, and the core aumping and mail routines.
The authors wish to thank numerous individuals for their efforts, advice, and criticisms. Primary among these are Chuck Rieger, Hanan Samet, Milt Grinberg, Phil London, Steve Small, Rich Wood, and Gyorgy Fekete." [Agre 1978]
"ULISP is another PDP-11 Lisp, modelled after the Univac 1100 Lisp by Norman (see section 2.1.10). It was written by Robert Kirby at the University of Maryland [Kirby 1977]. Along with some forgotten operating systems, ULISP could be run under Sixth Edition Unix, thus making it the first Unix Lisp system. The dialect bears some resemblance to LISP 1.5, but includes more primitive datatypes, including both single and double precision floats.
The basic pointer is a 16-bit value. Like the Univac Lisp, the data area of ULISP is divided into pages, of 1024 bytes each, each dedicated to a single type. The page table contains one-byte codes for each type; the codes themselves are all even numbers, to allow use of the type code for dispatching tricks. Car is stored first in memory, then cdr, but the pointer to a cons cell actually points at the cdr and uses a predecrement addressing mode to address the car." [Shebs 1988]
"Originally, I named the PDP-11 Lisp implementation VLISP for "Vision" since it was being created for the University of Maryland College Park Image Processing Lab. The Lab changed names later but its emphasis was mostly on image processing rather than computer vision, which was my primary interest. Vrije Universiteit Amsterdam (Free University Amsterdam) wrote me that they also had a VLISP, which I assumed was named after "Vrije". Although I had already produced a technical report using "VLISP", Prof. Azriel Rosenfeld, who was my advisor and employer, and I decided to change my VLISP name. Although I considered PPLISP for picture processing, I chose ULISP for the University of Maryland, hoping that the name would not conflict with the name of any of several other Lisp implementations, which were being written around that time." [Kirby, personal communication, 20 Feb 2024]
"ALISP [was] a native Lisp for the CDC Cyber 7200 that was written by Kurt Konolige when he was an undergrad at Amherst College (the "A" in ALISP) around 1975-1976 (before he started grad school at UMass). (The first version of John Lowrance's GRASPER system, which eventually became GRASPER-CL at SRI, was written in ALISP. I wrote the AVL-tree-based "graph paging" substrate for GRASPER, mostly from midnight-5AM when we could get some reasonable space/cycles on the time-shared Cyber.) Following CDC ALISP lineage for a moment, ALISP was eventually replaced with work on a native Common Lisp that was headed by Richard Hudson." [Dan Corkill, personal communication, September 4, 2010]
"ALISP is a timesharing and batch LISP 1.5 system operating on the CDC Cyber-74 installation at UMASS. It is similar to the ALISP system previously operating on UMASS timesharing with the CDC 3600/3800. ... ALISP runs under KRONOS or NOS operating systems on CDC 6600 series computers."
"This document constitutes a reference manual for GRASPER 1.0, a programming language extension that provides graph processing capabilities. ... GRASPER 1.0 was developed as a data base support facility for the VISIONS system."
GRASPER 1.0 ran ALISP on the CDC Cyber-74 installation at the University of Massachusetts Computing Center. Another version based on LISP F3 ran on the VAX 780 of the Computer and Information Science Research Lab at the University of Massachusetts.
"I created LISP 7/16 in the era of minicomputers to perform some experiments for my PhD research. We had acquired an Interdata 7/16 minicomputer and a digital signal processing board from Bell Labs that was attached to the computer. I was doing speech synthesis, and I wanted a HLL to control the synthesizer (implemented on the Digital signal board using a collection of second-order-sections.) Since LISP was my preferred programming language, I chose to create the language interpreter. We subsequently provided Interdata the language interpreter in exchange for a Interdata control board that let us build a more sophisticated floppy disk based OS for the computer.
I implemented a classic garbage collector and CONS in assembly language and used McCarthy's two-page definition of the LISP interpreter (*) found in his book to complete the design." [Thomas Kaczmarek, personal communication, 20 July 2024]
(*) See [McCarthy 1962, Appendix B]