Standard LISP arose from a desire to port REDUCE (see Stanford LISP 1.6 Applications) to other systems.
The report gives the date for Hearn's original Standard LISP article in SIGPLAN Notices as Volume 4, Number 9, September 1966, but the actual year was 1969.
[Is this PSL or a "wrapper" for another implementation?]
"There was an EVALQUOTE lisp called Lisp/360 which was used at Utah in the 1970s; it came from Stanford and had been heavily modified by Kevin Kay. ... there was a Standard LISP for IBM 360 based on the same code, and renamed SLISP/360. It was an EVAL system. The reason I know is because I did some of the modifications after Kevin left Utah. I used it subsequently at Leeds, and in my archives I still have the source. Also 2 Japanese, Kanada-san and a student I think, transcribed this SLISP/360 into Motorola 68K assembler, and got it to run! It had a number of terrible features, but it did support REDUCE." [J. P. Fitch, comp.lang.lisp, February 18, 1994]
"The Assembly comments indicate the following personnels: J. G. Kent, J. F. Bolce, R. I. Berns, K. R. Kay and J. Fitch."
See also: [Padget 1988] under Cambridge Lisp Papers.
"Abstract: This document describes an implementation of Standard LISP which runs on Tandem Computers Inc. NonStop II and NonStop TXP systems. It is intended to be a reference document to be used in conjunction with the "Standard Lisp Report", Marti et al, SIGPLAN Notices, Volume 14, Number 10, October 1979 (here after refered to as the Standard)."
Jed Marti developed this LISP system for the Zilog Z80 microprocessor at the University of Oregon. The implemenation included an interpreter and a compiler.
"Little Big LISP is a subset of Standard LISP [Marti et al. 1979] implemented for the Z80 microprocessor. It runs in a minimum of sixteen thousand bytes of storage-and most effectively with thirty two thous~nd or more. The system consists of the following:
- An interpreter
- A program to load precompiled object files ("fast load" files)
- A compiler for generating either fast load files or directly executable code
- A parser for a subset of RLISP [Hearn 1973]
- A function trace feature
- A small LISP structure editor"
"Abstract: This manual describes the Z80 based LISP system, UO-LISP, its data structures, built in functions, operating procedures, the compiler and optimizer, an RLISP parser, a trace package, and a structure editor."
"WELL .... we've been working on a very important project. We took on the computer algebra System called REDUCE. We put on the blinders and produced 27,000 lines of LISP. REDUCE now runs on the 8086 family of computers in less than 640k. More about REDUCE in our next issue of the newsletter."
PASLSP was a precursor to Portable Standard LISP, based on the Standard LISP definition.
"Abstract: This report describes an interim implementation of Standard LISP for the PERQ. This LISP is based upon the Standard LISP report, and a newly developing Portable Standard LISP. This interim implementation is designed to explore LISP implementations in PASCAL on the PERQ and similar machines. The system consists of a kernel, handcoded in PASCAL, with the rest of the system written in LISP and compiled to PASCAL."
"The REDUCE system for the B7000/B6000 series consists of four parts: The REDUCE algebraic processor itself, a LISP processor, a LISP compiler which converts LISP programs to an intermediate language, and an assembler which converts the intermediate language to Burroughs ALGOL. The INTEGRATOR has a fifth part which is the integrator package.
The algebraic processor, the compiler, the assembler and the integrator package are written in RLISP, a sort of LISP with ALGOL-like syntax. The LISP processor is written partly in ALGOL and partly in RLISP. All these parts are combined into a single large ALGOL program. The parts written in RLISP must first be translated to ALGOL. The algebraic processor does this translation.
The algebraic processor was largely written by Anthony Hearn, the compiler is the work of Anthony Hearn and Martin Griss, the assembler was done by John Fitch, the part of the LISP processor written in RLISP was done by John Fitch and Jed Marti. The integration package was developed at Cambridge by Arthur Norman, John Fitch, and Maryann Moore. The ALGOL portion of the LISP processor, originally an SDL program for the B1700 that was written by Fitch and Marti, was translated to ALGOL and subsequently modified by Dave Dahm." [From DOC.INSTALLATION]
In the 1980s, Burroughs Corporation distributed a tape of free (presumed to be public domain) software called tbe Higher Education Software Library, Release 2.0. Around 2013, Nigel Williams located a copy belonging to Paul Cumberworth, then of Adelaide, Australia, who is a former Burroughs employee. The tape had a creation date of 1990-07-25, which is presumed to be the date it was copied from one medium to another. Cumberworth sent the tape to Dennis Boone at Michigan State University, who imaged the tape to a SimH .tap file. Williams then supplied the .tap file to Paul Kimpel, who converted it back to a native Burroughs MCP CD-R, and then extracted files and converted them from Burroughs format (EBCDIC character codes, numeric file type information) to Windows/Unix format (ASCII character codes, filename extensions).
"Most of the files have creation dates in the 1985-86 range, with a few going back to 1979. Those later dates can be misleading, though, because the MCP source code editors recopy files when updates are saved, which gives the new file the current date. From those dates and the references mentioned above, I suspect the conversion from the B1700 to A Series MCP took place around 1980, but it could have been later than that." [Paul Kimpel, personal communication, 16 October 2022]
"It looks to me like this is the piece (or at least the main piece) that was originally written in B1700 SDL. I don't know SDL, but there's a spec for it on bitsavers. There are references in comments to things that sound B1700-ish (e.g., "Twinkle-Box lights") and SEGMENT directives that have been commented out (and are definitely SDL). The language was quite ALGOL-like, and I suspect that from a syntax perspective you could do pretty much a line-for-line conversion of SDL to Burroughs ALGOL, especially for a project like this." [Paul Kimpel, personal communication, 17 October 2022]
A portable compiler for the Standard LISP language. This became the main platform for REDUCE.
"Abstract: This manual describes the primitive data structures, facilities and functions present in the Portable Standard LISP (PSL) system. It describes the implementation details and functions of interest to a PSL programmer. Except for a small number of hand-coded routines for I/O and efficient function calling, PSL is written entirely in itself, using a machine-oriented mode of PSL, called SYSLISP, to perform word, byte, and efficient integer and string operations. PSL is compiled by an enhanced version of the Portable LISP Compiler, and currently runs on the DEC-20, VAX, and MC68000."
Originally appeared as Report UCP-82, Utah Symbolic Computation Group, Department of Computer Science, University of Utah, January 1982.
Originally appeared as Report UCP-83, Department of Computer Science, University of Utah, May 1982, 10 pages.
Ager and McDonald compared their new implementation of PSL on an IBM 3081 with the IBM Yorktown Research version of IBM's LISP/370. The PSL version was much faster and, they argued, more "mainstream".
"A version of this paper appeared in the proceedings of the 20th annual Hawaii International Conference on Systems Sciences, January 1987. It has been revised to include the work of Melenk and Neun."
Bibliography, characteristics, documentation, available packages, related projects, and information about ordering latest release. In 2008, REDUCE was made available under an open source license.
"Cambridge Lisp was developed in the period just after Lisp/370 and during the second phase of Standard Lisp, but before Portable Standard Lisp. The authors of Cambridge Lisp were individually involved in Standard Lisp and Lisp/370 and these experiences are reflected in the structure of Cambridge Lisp. As with Standard Lisp, Cambridge Lisp was borne out of a need to support algebra research but rather than following the Standard Lisp report word for word, there was a strong influence from the heavier emphasis placed on semantics by Lisp/370." [Padget 1988]
Cambridge Lisp was written in BCPL. More recently, its authors produced a C-based successor under the Codemist brand.