The Revised MacLisp Manual goes online

MIT’s MacLisp played a key role in Lisp history, but its documentation often lagged the system as developers concentrated on adding features and improving performance. Around the time that Lisp machine development eclipsed PDP-10 MacLisp, this final MacLisp document was published:

  • Kent M. Pitman. The Revised MacLisp Manual. “Saturday Morning Edition”, M.I.T. Laboratory for Computer Science Technical Report MIT-LCS-TR-295, June 1, 1983.

This has been out of print for many years, but Kent just made available an updated, hypertext “Sunday Morning Edition”.

If you are interested in more MacLisp history, including earlier manuals, source code, and more, see the MacLisp family of the Lisp website at the Computer History Museum.

Update 1/1/2016: Corrected URL for MacLisp family.

BBC Radio observes Fortran’s 50th birthday

This week’s episode of BBC Radio’s Digital Planet show includes a short segment on the 50th anniversary of Fortran. The presenter, Gareth Mitchell, interviewed me last week and about 4 minutes of that interview are included.

If you’re interested, the show will be broadcast at various times December 18 and 19 (today and tomorrow); local schedules are available at this web page:

For one week only, starting today, an MP3 of the entire half-hour show can be downloaded from this web page:

The Fortran segment starts at about 19m38s into the show.

Update 2: With the permission of BBC Radio, I’ve added the audio of the Fortran segment to the Memoirs and user stories section of the CHM Fortran web site:

  • Gareth Mitchell, presenter. Fortran is 50. Digital Planet programme, BBC Radio World Service, December 18, 2007, 6′:40″. MP3 (7.6 megabytes)

    Mitchell interviews Paul McJones on the occasion of the 50th birthday of Fortran; additional commentary by Bill Thompson; produced by Helena Selby.

Update: A BBC reorganization removed the download link from the page above; in a comment below, Derek Mahar notes the episode download site is now and this download itself is

Computer History Museum videos coming to YouTube

The Computer History Museum has just launched a partnership with YouTube to provide a ComputerHistory “channel”. Right now it has 23 videos from various events and lectures at the museum; if you subscribe (via the orange button), you’ll be notified when more are uploaded. In the mean time, the museum maintains a calendar of past events with links to video, where available.

Update 1/1/2016: Updated URL for CHM past events.

C++ Historical Sources Archive

Observant audience members at Bjarne Stroustrup’s HOPL-III C++ talk this past weekend may have noticed on the last slide a mention of the C++ Historical Sources Archive at the Computer History Museum. This is a project Bjarne and I have been working on in the background for a year or two. Bjarne convinced the appropriate authorities at AT&T to approve releasing the Cfront source code, and then dug up listings, documentation, and/or machine-readable source for Cfront releases E, 2.0, and 3.0. Willem Wakker kindly supplied a copy of release 1.0. We have also tracked down some early libraries including libg++, COOL, LEDA, Array_Alg, STL, InterViews, ET++, and more. We would be very interested also in early applications written in C++ (especially pre-1990).

By the way, what was previously called the Software Collection Committee at the Computer History Museum has a new name (the Software Preservation Group), a new domain name ( and a new chairman (Al Kossow, the Museum’s Software Curator and the creator of

Remembering John Backus

As an undergraduate at the University of California at Berkeley in the late 1960s, I first learned of John Backus and his work on Fortran, BNF, and Algol. Around 1972 or 1973 I attended a talk John gave on “variable-free programming” at Berkeley. I was fascinated by programming languages (having worked on implementations of Snobol4, APL, and Lisp by that time), so I obtained and read a copy of his report “Reduction Languages and Variable-Free Programming”. In mid 1973 he mailed out a preprint of his POPL paper “Programming Language Semantics and Closed Applicative Languages“, whose margins I filled with notes.

In early 1974 I was looking for a job. My friend Jim Gray, who was then working at IBM Research in San Jose, introduced me to John, who was looking for someone to work with him on the design of his Red language and to implement an interpreter. We seemed to hit it off, and in March I accepted his employment offer. John mostly worked out of his home in San Franscisco. We discussed the possibility of locating my office in IBM’s Palo Alto Science Center, but I wound up joining the staff of IBM Research in San Jose, which was then located in the triangular Building 28 of the IBM Cottle Road Campus. John began driving down to San Jose once or twice a week in his diesel Mercedes. The only place in the area he could refuel was a truck stop in North San Jose. IBM colleagues told me I’d had an immediate positive impact: they now saw John much more than before.

For the next 15 months or so, I worked with John, discussing language features, writing various prototypes in Lisp and McG (an ISWIM-like language by W.H. Burge), reading papers on programming language semantics, and writing a report “A Church-Rosser Property of Closed Applicative Languages” that showed the operational semantics for Backus’s Red language was well-defined.

John was an inspiring person to work for and with. Despite his accomplishments (inventor of Fortran and BNF; Algol contributor; IBM Fellow) and the age difference (he started work at IBM the year after I was born), he treated me like he treated everyone: as a respected colleague. I had many suggestions for changing and extending Red, and John gave them all his complete attention. At that time, John was interested in pure functional programming, with no side-effects on storage or the external world. I advocated extending the language to allow writing complete interactive applications. John conceded the importance of this, and came up with a scheme in which one would write a function to express the complete transformation of an application on the global state. I struggled with John’s variable free style, and suggested we allow lambda variables when defining a new functional form (higher-order function), but he stuck to his guns. Gradually, I came to the conclusion that it was still too early to build a full implementation of Red, and I began spending more time talking to the System R team down the hall, who were designing one of the first relational database managers, and inventing the SQL query language and formalizing atomic transactions along the way.

John rarely wanted to talk about himself, but when asked he had interesting stories to tell. When he first joined IBM, he programmed the Selective Sequence Electronic Calculator (SSEC), a huge electromechanical machine whose programs and data were punched into a paper tape the width of regular 80-column punched cards, but many feet long. By gluing a data tape into a loop, it could be traversed multiple times. John recalled having to debug a program that would go through cycles of correct and incorrect behavior. Eventually they realized that the tape had a half-twist when it was glued into a loop, converting it into a one-sided Möbius strip.

John’s 25th service anniversary at IBM was in 1975. A recognition luncheon was planned in San Jose (at the IBM Country Club, or customer conference center), and John was asked who he’d like to attend. He named several of his current San Jose colleagues (I was honored to be included), as well as his old colleagues from the 1950s, including people from the Fortran project. The person arranging the event said, “But these people are in New York…”, and then came up with the travel expenses.

Cordial relations with John were not restricted to working hours. He and his wife Barbara invited my wife and me to dinner at their home, which turned out to be near the base of the Sutro Tower, with a beautiful view looking north from the Golden Gate bridge to the east bay. John said the only disadvantage of the location was RF interference to his stereo from the television transmitters. To combat this, he’d designed a Faraday cage by lining his equipment closet with aluminum foil. We invited John and Barbara back to our modest rental in San Jose, and they graciously accepted.

When I started at IBM, Nixon was still in office. John’s distaste for Nixon was no secret to his friends at the time. He learned he was one of seven people singled out to receive a “Presidential Prize for Innovation”, but then the plans were dropped. John later wrote that he “had been secretly planning to use the occasion to denounce Nixon and the Vietnam war. … I guess now my plan was not a gentlemanly scheme, but anyway I was relieved when the plan fell through.”

I stayed at IBM until November 1976, working on the System R recovery manager with Jim Gray, and then moved on to another job. A while later, I ran into John waiting in line for one of the West Coast Computer Faires — probably the first one, in 1977 in San Francisco. John told me he’d sent a deposit on an interesting computer called the MicroMind, from an outfit in Cambridge, MA, called ECD Corp. He was beginning to be skeptical that he would ever get a computer or his money back. I recently heard from Olin Sibert that ECD couldn’t build the machines cheaply enough, and returned all the deposits.

In 1977 John received the ACM Turing Award for “profound, influential, and lasting contributions to the design of practical high-level programming systems, notably through his work on Fortran, and for seminal publication of formal procedures for the specifications of programming languages.” John’s Turing Lecture, “Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs” was devoted to his functional programming work, and had a large impact on the growth of a branch of academic computer science studying functional programming languages. John continued to work on functional programming until he retired in 1991.

I fell out of touch with John for many years. But in 2003, an effort I became involved with at the Computer History Museum to collect and preserve historic source code led me to get in touch with John regarding the original Fortran compiler. John was still living in the same house in San Francisco, and seemed pleased to hear from me. He didn’t have any source code, but did make several suggestions; eventually I found several versions of the IBM 704 FORTRAN II compiler source code.

Around this same time, I learned that John’s idea of an algebra of programs had had a big impact on my colleague Alex Stepanov (although Alex figured out how to apply this idea while extending the “von Neumann style” in an important way). At the time, Alex and I were organizing an internal technical conference for our employer, and we invited John to give a keynote speech. Just after he graciously accepted, his wife Barbara died; understandably he canceled the speech. John decided to move to Ashland, Oregon, to be near one of his daughters. Another colleague of mine, Dick Sweet, lives in Ashland and introduced John to a new circle of friends for what turned out to be his final years.

Although many people contributed to the early development of programming languages, John Backus deserves credit for creating the first successful higher-level programming language, Fortran. Fortran provided data types (integer and floating-point numbers), a powerful data structure (the array), expressions, statements, and abstraction mechanisms (functions and subroutines). The Fortran compiler generated optimized code taking advantage of the then brand new index registers and floating-point hardware of the IBM 704. Finally, the Fortran system provided a linking loader, a subroutine library, and I/O routines. The scientific and engineering users adopted it instantly, and it became the standard against which future programming language designs were compared.

Why was John’s contribution so important? He invented a language allowing one to express numeric algorithms in a way that was abstracted from irrelevant details of particular computers but that was efficiently implementable on a broad class of computers: from the vacuum tube IBM 704 of 1954 to the fastest supercomputer of 2007 and beyond. That idea, allowing the essential details of algorithms and data structures to be expressed in an abstract and yet efficient way, is at the heart of what programming language designers have been trying to accomplish for the last 50 years. Only a handful of them have made the kind of progress John Backus and his team did.

[Edited 10 May 2014: =>; 2 Jan 2016: changed link for “Building 28” and John’s Turing Lecture.]

A report and a request from Al Kossow

Many people know of Al Kossow through his work on, which I mentioned in a previous post. I’m very pleased to mention here Al’s recent appointment as the Robert N. Miner Software Curator at the Computer History Museum. Al is off to a great start on a variety of efforts including reading old magnetic media, etc. He asked me to post this item about an important recent development:

In the spring of this year, the Computer History Museum was contacted by someone who had several SDS 900 series machines, and told us that he had the entire SDS software library from Honeywell in the early 80’s.

The donation arrived at CHM on Friday, and I’ve spent the past few days going through it. It does, in fact contain ALMOST the entire collection as it existed at Honeywell in March, 1982. Unfortunately, the 940 timesharing system software was already gone from the library by 1982. Two 940 archive tapes, a set of user programs and the off-line diagnostics have survived.

There is a very large collection of user’s manuals, program writeups, paper and magnetic tape. This is the largest software collection that has survived largely in one piece from a 60’s computer manufacturer that I’ve ever seen.

Scans of most of the program library listings are on line now at bitsavers under pdf/sds/9xx/programLibrary. I’m in the process of post-processing several dozen programming and other user’s manuals.

There are about 100 7-track tapes which will have to wait until I have a reliable way to read them. The smaller program library programs were written to 9-track tape in 1982, and those have been successfully read and a machine-readable index of their contents have been started.

Do you know anyone who may have worked for computer companies in the 60’s or 70’s that was a pack rat? The companies themselves have either disappeared or discarded this stuff literally decades ago!

This discovery has reinforced my opinion that there may still be large archives of 60’s and 70’s software in the hands of individuals, and that the most important thing to do is to get the word out that CHM is committed to the preservation of these archives, and has the facilities to recover these latent archives and keep them for posterity.

So if you are one of these people or you know one of them, please contact Al.

Update 1/2/2016: Updated several URLs.

TENEX Interlisp

Tom Rindfleisch kindly supplied a set of TENEX Interlisp files from a system dump of the SUMEX-AIM <lisp> directory as of January 31, 1982. Tom 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.

There are links to these files here.

Speaking of TENEX Interlisp, TWENEX.ORG is offering free TENEX accounts on a simulated KL10B and they seem to have a version of Interlisp installed. I plan to investigate.

[Edited 10 May 2014: =>]

Progress with Lisp 1.5 source

Rich Cornwell (some of whose work I reported on earlier) and Bob Abeles (who was the first to point out to me the existence of the Fortran II sources) have recently completed a reconstruction of the card deck for the “Bonnie’s Birthday Assembly” of Lisp 1.5 (see Pascal Bourguignon recreates machine-readable source for LISP 1.5). Rich notes:

Bob Abeles has finished proof reading Lisp-1.5 and is pretty confident that the binary matches the listing. Unfortunately it still does not run. So we need someone with more lisp experience or possible compare it to some of other versions you have listed on your Lisp site. It currently does not work correctly under sim3.6 due to card reader bug. I will get this fixed in next couple of weeks. … But after two people proofing it (Bob & me) I am pretty sure that it matches now.

It is also possible that the lisp interpreter works correctly, but my test jobs is wrong.

Rich’s files are here if you’d like to take a look.

[Edited 10 May 2014: =>,_709,_7090_.]

IBSYS Fortran II runs on a SIMH-based simulator

An upcoming release of Bob Supnik’s SIMH (Computer History Simulation system) will include IBM 704/709/7090/7094 simulation provided by Rich Cornwell. Rich has been very busy lately: implementing and debugging the simulations of the CPU, channels, controllers, and devices; tracking down and transcribing source code for diagnostics; and figuring out how to rebuild and run various diagnostics, SHARE, IBSYS, and CTSS code. He’s had great luck with the IBSYS distribution from Paul Pierce; in particular, he was able to get the code compiled by the Fortran II compiler to execute. It turns out the Fortran II compiler writes out intermediate files to tape as individual records not followed by the customary tape mark; it was necessary to tweak the simulator to handle this the way the original hardware did. Rich notes that Bob Supnik, who is also working on a 7094 simulator, was the first person to discover this. (Rich says Bob will include both Rich’s and his own 7xxx simulators in SIMH since Bob’s is specifically optimized for running CTSS while Rich’s is aimed more toward IBSYS and older 704/709 software.)

Rich’s enthusiasm inspired me to finally obtain a copy of the Smithsonian’s Fortran II listing — this is a version for the IBM 704, which does not have I/O channel — it is the machine for which the original Fortran I compiler was written. Rich is in the process of recreating the assembly language source code from which this listing was generated. He’s doing this by hand, because the quality of OCR is not high enough.

Rich has many related projects in mind, and welcomes others who would like to join in: transcribing/proofreading diagnostics and the 704 Fortran II listing, working on some remaining IBSYS language processors, getting the Lisp 1.5 interpreter to run, etc. His home page (yes, kites!) includes his email address, or contact me and I’ll put you in touch with him.

Update 1/2/2016: Updated contact information for Rich Cornwell.

A day in the life of an IBM Customer Engineer, circa 1959

I’ve added another important document to the Fortran I/Fortran II collection at the Computer History Museum:

  • Anonymous. FORTRAN I, II, and 709 : Customer Engineering Manual of Instruction. IBM Corporation, Form R23-9518-0, February 1959, 67 pages. Copy belonging to Mark Halpern. PDF

This document is filled with useful information for anyone interested in digging into the IBM Fortran I/II compiler, and provides fascinating hints about what it was like to be a customer engineer in the late 1950s. It begins with an introduction to the nature of machine language, assembly language, and higher-level languages, starting with an analogy whose exposition would not be considered quite politically correct today: “The problems involved in man’s communications with the complex computer are in many respects similar to those problems involved with his communications with another man who speaks an unfamiliar language.” The next chapter jumps right into the structure of the compiler with summaries of each of the sections (passes). This is followed by a description of the Fortran systems tape, which performed the functions we now associate with an operating system. Section 1.12.00, Service Aids, notes: “To successfully run the Fortran translator the 704 must be in in prime working order. The tape system in particular, and the drum are given a good work-out during the exeuction of the program.” It goes on to list adjustments and engineering changes that were likely to be required to run such a demanding program as the Fortran compiler. Another chapter describes the various tables used to represent the intermediate and final object program.

I was able to scan this document courtesy of Mark Halpern, whose first assignment after joining the IBM Programming Research Department in 1957 was to study and document (via flow-charts) the Fortran compiler. Mark’s memoirs were published in three parts in the Annals of Computer History starting in 1991; eprints are available online at Mark’s web site.

Postscript (March 20, 2006): I should have noted a fascinating memoir by John Van Gardner, who was one of the IBM Customer Engineers who installed IBM 704 serial number 13 at Lockheed Aircraft in Marietta, Georgia in May 1956. This memoir describes the resourceful techniques he used in 1957 to debug a hardware problem that resulted in the Fortran compiler behaving in a nondeterministic manner.

[Edited 10 May 2014: =>; 2 Jan 2016: substituted Internet Archive link for Mark Halpern’s web site.]

704 FORTRAN II listing available

I just posted a scan of the three-volume listing of the IBM 704 FORTRAN II compiler to the History of FORTRAN and FORTRAN II web site at the Computer History Museum. This listing was donated to the Smithsonian National Museum of American History by Peter Z. Ingerman. When I last reported on it, I was hoping that an intermuseum loan between NMAH and CHM could be arranged so we could scan the listing ourselves. As it turned out, David Allison helped us find a consultant, Nance Briscoe, who performed the scanning on the east coast. I want to thank them, as well as Kirsten Tashev.

This listing complements the later 32K 709/7090 FORTRAN II (scroll down a bit from here for the IBSYS distribution on 7-track tape digitized by Paul Pierce. This version runs on the bare IBM 704, whereas the later version, for the IBM 709 with its more sophisticated I/O system included a Fortran Monitor System, which had been adapted to work with IBSYS.

[Edited 10 May 2014: =>; updated URLs for bios of David Allison and Kirsten Tashev.]

ACM grants permission for full text of FORTRAN-related articles

I have the pleasure of thanking ACM for granting permission to post the full texts of five ACM-copyrighted articles to the FORTRAN/FORTRAN II web site at the Computer History Museum. Here they are; for those already in the ACM Digital Library, we also link to the canonical ACM version via its DOI (Digital Object Identifier):

  • John W. Backus. The IBM 701 Speedcoding System. Journal of the ACM, Volume 1, Number 1, January 1954, pages 4-6. PDF ACM Digital Library
  • J.W. Backus, R.J. Beeber, S. Best, R. Goldberg, L.M. Haibt, H.L. Herrick, R.A. Nelson, D. Sayre, P.B. Sheridan, H.J. Stern, I. Ziller, R.A. Hughes, and R. Nutt, The FORTRAN automatic coding system. Proceedings Western Joint Computer Conference, Los Angeles, California, February 1957, pages 188-198. PDF ACM Digital Library
  • P.B. Sheridan. The arithmetic translator-compiler of the IBM FORTRAN automatic coding system. Comm. ACM, Volume 2, Number 2, February 1959, pages 9-21. PDF ACM Digital Library
  • J. W. Backus, The history of FORTRAN I, II and III. Proceedings First ACM SIGPLAN Conference on History of Programming Languages, Los Angeles, 1978, pages 165-180. PDF ACM Digital Library
  • F.E. Allen. A Technological Review of the FORTRAN I Compiler. Proceedings National Computer Conference, 1982, AFIPS Press, pages 805-809. PDF ACM Digital Library

This is just one example of collaboration between ACM and the Computer History Museum; stay tuned for more. (Another example: ACM owns the copyright to the AFIPS Conference proceedings; expect them to show up in ACM’s Digital Library at some point.) I’d like to extend a personal thanks to Mark Mandelbaum, who is the Director of ACM’s Office of Publications, and to Rick Snodgrass, who co-chairs ACM’s History Committee, among many other activities. I first became acquainted with Rick when I lent a hand to the ACM SIGMOD Silver Anthology. Rick’s contributions to ACM’s Digital Library led to his receiving an ACM Outstanding Contributions award this year.

[Editted 10 May 2014: =>; added ACM Digital Library DOIs for AFIPS conference papers; updated SIGMOD URLs.]

FORTRAN 25th anniversary film online

I recently updated this item of the History of FORTRAN web site at the Computer History Museum to include an online copy of the video:

(Daniel N. Leeson describes this film in his article “IBM FORTRAN Exhibit and Film” in Annals of the History of Computing, Volume, 6, Number 1, January 1984, pages 41-48. He describes the production of the film in some detail, and includes a complete transcript.)

Thanks go to Micah Nutt for supplying me a DVD dub of the video, which I transcoded using Adobe Premiere Elements 2.0.

[Edited 10 May 2014: =>]

Brad Parker resurrects MIT CADR Lisp Machine source code

Brad Parker recently announced:

After a long and interesting search I uncovered a set of 9-track tapes which appear to be a snapshot of the MIT CADR Lisp machine source code from around 1980. This is not the final source code and not the last source release I will make. It is, however, the first source release.

Tom Knight and others at MIT helped me secure permission from MIT’s Patent office to release the software. I am indebted to him and the others for making this possible.

Follow the link above for a compressed tar file containing the tape images, extracted files, and extraction software, plus MIT’s license, a README, and a link to Brad’s CADR emulator.

(Via Bill Clementson via Lemonodor; see also Bill Hyde.)

I’ve added a link to Brad’s web page in the Zetalisp for Lisp Machines section of the History of LISP website at the Computer History Museum.

[Edited 10 May 2014: => and URL for Bill Clementson’s blog.]

The birth of the FORTRAN II subroutine

By comparing three versions of the memo (unsigned, but believed written by Irv Ziller) “Proposed Specifications for FORTRAN II for the 704”, dated August 28, September 25, and November 18, 1957, you can watch the design of the subroutine feature of FORTRAN II unfold. The original FORTRAN system (see here or here) had a variety of built-in library functions and allowed the programmer to write single-statement function statements, or to add additional library functions written in assembler, but there were no separately compiled FORTRAN subroutines or functions.

The first version of the memo says:

The FORTRAN II translator will accept an unlimited number of different statements. All statements presently in the system and a few others to be described below will be recognized and translated in the normal way. All others will refer to subroutines and must have the following form:

NAME ( A, B, C, I, X )

where NAME denotes the name of the desired subroutine to be executed. Enclosed in parentheses are the names of variable and/or arrays which the subroutine is to operate on and also the names of variables and/or arrays which are to receive the results produced by the subroutine. Variables may be fixed or floating point. After the subroutine has been executed the next executable statement in the FORTRAN program will be executed.

In this version, a subroutine begins with a SUB DEF statement, which also includes the name and argument list. There is a RETURN statement, but no END statement.

In the second version, SUB DEF becomes SUBROUTINE DEFINITION, and the END statement appears. An UPPER statement is added, for definining variables and arrays that will be allocated at the high end of memory, where they can be accessed from more than one subprogram.

In the third version, a subroutine call begins with the reserved word CALL. The UPPER statement becomes the COMMON statement.

By the time FORTRAN II shipped and the manual was published, a FUNCTION statement was added.

The last page of this 1959 research report by Grace Mitchell describes the changes that were required to add these features to the compiler.

In his 1978 HOPL paper (see here or here), Backus noted, “FORTRAN II was designed mostly by Nelson, Ziller, and myself. Mitchell programmed the majority of new code for FORTRAN II (with the most unusual feature that she delivered it ahead of schedule). She was aided in this by Bernyce Brady and LeRoy May. Sheridan planned and made the necessary changes in his part of section 1; Nutt did the same for section 6. FORTRAN II was distributed in the spring of 1958.”

Today the ability to build programs from separately compiled units is taken for granted, but 47 years ago this was a big thing. Recently Dennis E. Hamilton, who remembers the release of FORTRAN II, told me:

“However, the impact of small changes and improvements can be immense. The ability to build Fortran programs out of independently-compilable modules and to have the ability to decompose into functions and subroutines using Fortran or any other tool that produced compatible code (usually the assembler, in those days) had an immense impact. In Fortran I programs were one giant file and there was no modularization structure. That small change in Fortran II was earthshaking in terms of software development and, I think, the endurance of Fortran as a technical-software programming tool.

It also changed the way that computers had to operate to make software building and use work more smoothly. I think it is no coincidence that this paralleled increased interest in operating systems (called things like tape monitors, at the time) and the use of the computer for organizing the data processing workflows. (There was also a lot of resistance to operating systems in those days.)”

For much more about the FORTRAN/FORTRAN II project, visit the Computer History Museum’s History of FORTRAN web site.

[Edited 10 May 2014: =>; updated links for Backus’s HOPL paper.]

Stanford LISP 1.6; the original Standard LISP

Work on LISP spread from McCarthy’s original M.I.T. project to other projects at M.I.T. and then to other institutions as people moved on and word about the capabilities of the language spread. John Allen brought a snapshot of the M.I.T.’s PDP-6 LISP to Stanford where it evolved into Stanford LISP 1.6 through the work of Allen, Lynn Quam, and Whitfield Diffie.

At the recent International Lisp Conference, I gave a short presentation, and afterwards several LISP pioneers chatted with me. Lynn Quam volunteered to provide me with scanned copies of a number of historic documents concerning LISP 1.6: SAILON 28.1 (compare with MIT AIM-116a), SAILON 28.2, SAILON 28.3, and SAILON 28.6, as well as memos describing various library packages.

Lynn also provided a copy of Stanford AIM-90, the 1969 Standard LISP specification by Anthony Hearn. Hearn designed Standard LISP as an abstraction layer upon which his REDUCE computer algebra system was implemented. AIM-90 included a 5-page appendix of definitions to make Stanford’s LISP/360 conform to Standard Lisp. (The later Portable Standard LISP project was a from-scratch implementation.)

[Edited 10 May 2014: =, etc.]

Classic LISP books online

With the permission of The MIT Press, I have posted online copies of two classic LISP books on the History of Lisp website at the Computer History Museum:

  • John McCarthy, Paul W. Abrahams, Daniel J. Edwards, Timothy P. Hart and Michael I. Levin. LISP 1.5 Programmer’s Manual. The M.I.T. Press, 1962, second edition. PDF
  • Berkeley and Bobrow, editors. The Programming Language LISP: Its Operation and Applications. Information International, Inc., March 1964 and The MIT Press, April 1966. PDF

In addition to these I have continued to track down information about more versions of LISP, so the web site keeps growing.

I also gave a brief announcement of this project at the recent International Lisp Conference 2005, and a number of people volunteered to help me track down more information.

If I’ve neglected your favorite version of LISP, please go through your closet or basement and find those manuals, listings, mag tapes, etc.

[Edited 10 May 2014: =>, etc.]

Pascal Bourguignon recreates machine-readable source for LISP 1.5

Pascal Bourguignon encountered this item on my History of LISP web site:

  • LISP system assembly listing. “FIELD TEST ASSEMBLY OF LISP 1.5 SEPTEMBER 1961”, labeled “Bonnie’s Birthday Assembly”. M.I.T. Museum, donated by Timothy P. Hart and scanned by Jack Harper. PDF (16MB)

and promptly began reconstructing machine-readable source. This morning he announced on comp.lang.lisp his progress (he’s typed in the source, patched it and Dave Pitts’ assembler to nearly recreate the listing, and is close to running it on the emulator). As he says in a README file of his distribution:

This card deck can be assembled with asm7090-2.1.4 applying the small patch ‘asm7090.patch’ to get a listing as identical as possible. asm7090 prints ‘0’ in the generated words for symbols under different headers, so we cannot make a complete word-for-word comparison of the generated code from the listing, until we modify asm7090 in this respect.

The objective is to recover a perforation for performation image of the Source. The same columns, the same typoes should be reproduced.

If you’d like to help Pascal find the remaining errors, or have the LISP 1.5 compiler sources or LISP 1.5 application sources, you can contact Pascal at the email address in the above-mentioned README file. Please also send me email or post a comment to this entry!

[Edited 10 May 2014: =>, etc.; 2 Jan 2016: =>!topic/comp.lang.lisp/Z7HKvfJxhww]

Archiving LISP history

Based on the progress I’ve made with FORTRAN, I decided to start another effort at the Computer History Museum to track down source code and documents for the original M.I.T. LISP I/1.5 project. I have made some progress, and am assembling a LISP web site at the Museum to organize and present the materials I’ve collected so far, including:

  • LISP 1.5: Assembly listing for IBM 709/7090 standalone system, and also CTSS port. Information about various other ports and reimplementations including Univac M-460, Q-32, Univac 1108.
  • PDP-1 Lisp: links to the documentation, source code and simulators
  • MacLisp (PDP-6, PDP-10): links to documentatation and source code
  • BBN-LISP: the manual for the original PDP-1 version and the Tenex version (coming soon: preliminary specifications for the 940 version)
  • and many more.

As always, your comments are welcome. What am I missing? What facts have I gotten wrong? Please help fill in the gaps.

[Edited 10 May 2014: =>]

Historic FORTRAN documents online

My efforts to track down source code and documents from the original IBM 704 FORTRAN project have been one of the pilot projects of the Software Collection Committee at the Computer History Museum. I’m starting to assemble a web site at the Museum to organize and present the materials I’ve collected so far. I’d appreciate your comments regarding both the form and the content.

[Edited 10 May 2014: => Note the Software Collection Committee was renamed the Software Preservation Group.]