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: community.computerhistory.org/scc/projects/LISP/index.html#ZetaLisp_ => www.softwarepreservation.org/projects/LISP/maclisp_family/#ZetaLisp_ 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: community.computerhistory.org/scc => www.softwarepreservation.org; 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: community.computerhistory.org/scc = www.softwarepreservation.org, 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: community.computerhistory.org/scc => www.softwarepreservation.org, 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: community.computerhistory.org/scc => www.softwarepreservation.org, etc.; 2 Jan 2016: http://groups-beta.google.com/group/comp.lang.lisp/browse_frm/thread/67b1cabdf271870c => https://groups.google.com/forum/#!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: community.computerhistory.org/scc => www.softwarepreservation.org.]

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: community.computerhistory.org/scc => softwarepreservation.org. Note the Software Collection Committee was renamed the Software Preservation Group.]

Dave Pitts is making progress running Fortran II

I have been negligent in reporting impressive progress made by Dave Pitts emulating IBM 7090 software. As Leif Harcke posted to alt.folklore.computers and bit.listserv.ibm-main on 2 February 2005:

Dave has developed his “asm7090” cross-assembler to the point where it can assemble the core of IBSYS from MAP source. The resultant IBSYS image will run the Fortran II(?) compiler on a modified version of Paul Pierce’s “s709” 700/7000 series emulator. The object code produced by the Fortran compiler does not run under IBSYS, however.

The cross-assembler and emulator are written in C, and build under Linux. Presumably they are easy to port to other POSIX-compliant systems. Details on the project are available here:

http://www.cozx.com/dpitts/ibm7090.html

If anyone is interested in helping out, Dave could use a hand debugging the emulation and getting IBSYS and other related system tools working.

Today, Dave told me:

With the current version of the emulator, 2.0.4, I’ve been able to run the following:

1. FORTRAN IV – Compile and run both Primes and Laplace programs.
2. COBOL – Compile and run the hello world program.
3. FORTRN II – Compile the Primes program. The exec doesn’t work, I get a checksum error loading the runtime (bad tape??).
4. MAP assembler – I’ve only run the assembler, didn’t try to run output.
5. FAP assembler – I’ve only run the assembler, didn’t try to run output.

My current IBSYS tape has the nucleus assembled with my ASM7090 cross assembler. Also, I re-assembled the COBOL compiler with ASM7090 and put on the tape.

I know that Leif Harcke has been hacking on the FORTRAN II. I think he’s stuck at the same point as I am. I’ve been trying to get the FORTRAN II parts to assemble with ASM7090 to replace the tape image with a NOPed checksum test.

Update 12/25/2016: Updated URL for Dave Pitts.

Update 1/2/2016: Updated URL for Leif Harcke and links to usenet groups.

Systems Manual for 704 Fortran and 709 Fortran

In January, Peter Capek told me that while cleaning up a file cabinet in his home he’d come across:

… a detailed description of the FORTRAN compiler, dated in 1960, and explicitly distinguishing between the 704 and 709 versions, but covering both. It looks like it was typed and what I have is probably not an original, but likely one of very few copies. It’s a couple of hundred pages, and describes each section of the compiler, including table structure, in considerable detail.

Peter very kindly made me a photocopy of this 264-page document, which is a wonderful complement to the actual source code. I hope soon to be able to provide web access to this and the other Fortran documents I’ve come across.

Peter is a frequent contributor to alt.folklore.computers and supplied information for Frank da Cruz’s “The Columbia University Computer Center in 1965” article.

Historic software at bitsavers.org

Although the majority of items at Al Kossow’s bitsavers.org are scanned copies of manuals, he also has software in source and/or executable form for a variety of machines (scroll down to “The Software Archive”) . Some of the oldest include MIT’s TX-0 and DEC’s PDP-1.

His manual collection also includes scanned copies of source code listings for some historic machines, including MIT’s Whirlwind and The University of Illionois’ ILLIAC I (scanned from hardcopies belonging to Wayne Lichtenberger).

Al notes that David Green is writing a simulator for the version of the ILLIAC built at the University of Sydney.

Updated TX-0, PDP-1, and ILLIAC I URLs following changes at bitsavers.org.

Fortran II source in Paul Pierce’s collection

Last Friday, Bob Abeles posted a comment here saying:

The IBSYS tapes on Paul Pierce’s site contain the source for FAP, FORTRAN II, FMS (version that ran under IBSYS), plus lots of other goodies. I wrote a program several years ago that extracts the sources. I’ll try to dig it up this weekend and will post a followup next week.

I had looked through Paul’s Yale SHARE tapes, but had not thought of looking at the IBSYS tapes. Sure enough, pr130-3.bcd, when converted with Paul’s bcd2txt, contains source code for something that calls itself “32K 709/7090 FORTRAN” and that consists of sections one through six with comments corresponding exactly to Backus’s descriptions (see for example Backus et al., “The FORTRAN Automatic Coding System”, Proceedings of the Western Joint Computer Conference, Los Angeles, California, February 1957 and John Backus, “The history of FORTRAN I, II, and III”, Proceedings of the First ACM SIGPLAN Conference on History of Programming Languages, Los Angeles, California, 1978″).

This is very exciting. Given the progress running IBSYS Fortran IV and Cobol on Rob Storey’s 7094 emulator, we may be able to run Fortran II!

Update: 7 Jan 2015: Updated URL for Rob’s progress posting.

IBM 7094 Emulator now runs Fortran IV compiler

I expect most Dusty Decks readers are aware of alt.folklore.computers, but it’s worth noting Rob Storey’s recent post IBM 7094 Emulator now runs Fortran compiler. As I posted in June, Rob has written a IBM 7094 emulator. Through the work of James Fehlinger, the emulator can load and execute the compiler, and then execute the result, at least for a “hello, world” program.

Rob suggested others might want to get additional programs running on the emulator, and suggested several that are available. Leif Harcke suggested CTSS (M.I.T.’s Compatible Time Sharing System), using the tapes available from Paul Pierce’s collection. I mentioned this to Tom Van Vleck; he took a look at the tapes and lent his enthusiastic support. Rob is happy to make the necessary “hardware modifications” (known as RPQ’s) to the emulator if someone will supply him with a specification.

Updated 23 Mar 2006: Leif Harcke’s URL changed; 7 Jan 2015: Rob’s and Tom’s alt.folklore.computer URLs changed.

As you sow so shall you reap

The effort in creating this weblog was quickly rewarded in the form of comments and email from readers. First Micah Nutt, son of Roy Nutt, commented that his family has possession of Roy’s collection of business documents and memorabilia, including some Fortran-related microfiche mentioned by Daniel N. Leeson. Micah told me:

The fiche I have is most likely the same as the set my father donated to the IBM library in 1982 for the 25th anniversary of FORTRAN. The contents appear to be the specifications, flowcharts, mathematical analysis and source code for FORTRAN along with (at least part of) the user’s manual. The documents are a mix of hand written and machine based (some with hand written edits and notes). There are 23 micro fiche with 50 pages per (most are full). I actually have two identical sets.

I plan on investigating preserving these originals and also obtaining them in digital form.

I’m hoping Micah will post an article about his father, who, among other things, created the SAP assembler for the IBM 704, participated in the original Fortran team while on loan to IBM from United Aircraft Corporation, and co-founded Computer Sciences Corporation.

After further discussion with Alicia Cutler at the Smithsonian National Museum of American History, it turns out that while her institution does not have the resources to scan the Fortran II listing, it is possible to set up an intermuseum loan with the Computer History Museum, so we will be able to digitize the listings here in Mountain View, California. Alicia sent me photocopies of a few sample pages, which I scanned and OCR’ed. The accuracy was not very encouraging; it’s going to take a lot of work to get a machine readable version.

Tom Van Vleck recently attended a Multics Reunion and Dinner honoring Professor Fernando J. Corbató; he came back with suggestions for more people to talk to and some software preservation gossip. In particular, the history of early operating systems deserves its own thread, which I hope to start soon.

Last but not least, Leif Harcke got in touch with me after seeing this weblog, and has passed along many useful facts as well as impressing me with his enthusiasm for software history. In particular, he commented:

The microfilm in Micah’s possession probably contains the source to the Fortran I compiler. IBM and SHARE distributed most of their detailed software documentation on microfilm back in the day. Norm Hardy refers to the Fortran I source on microfilm in his essay Fortran at Livermore.

Regarding the Fortran II listing at the Smithsonian, he said:

Fortran II was a strange beast; it ran under the Fortran Monitor System (FMS). FMS could either run the machine stand-alone, or it could run under IBSYS. Fortran II was link-compatible with the FAP assembler, the IBM product which superseded UA-SAP. You can get the Fortran II operator’s guide from Al Kossow’s Bitsavers site:
http://www.bitsavers.org/pdf/ibm/7090/C28-6066-6_FORTRANII_oper.pdf

I’m not sure the compiler itself will be of any use without the FMS monitor and the FAP assembler.

Leif has written a disassembler for the IBM 704, and helped me get started decoding the mysteries of Paul Pierce‘s SHARE tapes. I will post more about that soon.

Updated 23 Mar 2006, 2 Jan 2016: Leif Harcke’s URL changed.

Introduction

My name is Paul McJones. I am using this weblog to discuss historic computer software and hardware among other topics. For several months I’ve been studying the early history of Fortran, and trying to track down the source code for the original Fortran compiler. Although I just set up this weblog recently (June-July 2004), I’ve created back-dated entries to document my quest in chronological order, starting here.

I welcome suggestions for additional topics, and also would like to invite others to contribute articles on the history of early programming languages, operating systems, database management systems, and applications.

If you like this web log, you might be interested in the System R website documenting the history of the System R relational database research project, which gave birth to the SQL query language.

Paul McJones (photo by Kelly Castro)

Peter Zilahy Ingerman

I learned that Peter Zilahy Ingerman, PhD, was the donor of the Fortran II listing at The Smithsonian. Peter published a number of books and papers in the area of programming languages and compilers.

I called Peter and had a very pleasant conversation. It turned out he’d donated the Fortran materials to The Smithsonian a number of years ago, and did not remember that specific item I was interested in, but he volunteered to travel from his home in New Jersey to Washington if that would help.

Peter is very interested in the history of computing, and has created a very detailed UNIVAC I/II emulator, a machine that Peter wrote software for between 1957 and 1963. Peter told me of a UNIVAC web page maintained by Allan Reiter.

Update 1/2/2016: Updated URL for Allan Reiter’s UNIVAC web page.

George A. Michael

I followed a link from Frank da Cruz‘s IBM 704 page at Columbia to George Michael’s 704 page, which is part of his Stories of the Development of Large Scale Scientific Computing. I sent an email asking if George or his colleagues remembered the Fortran “Tome”.

George replied:

1. I do not recall any book called the “Tome,” although I was one of the first users of the original Fortran. We had four 704s but if the “Tome” existed, I never saw it.
2. One of our programmers, Bob Hughes worked with the original Fortran development team. I interviewed him and the interview is posted on our web site http://www.computer-history.info/Page1.dir/pages/Hughes.html

I will call him to check on the existence of the “Tome” and if he (still) has a listing of the original Fortran. But I’m not overly hopeful. In any event, I’ll let you know what results I get.

Bob, who was listed as one of the authors of the original 1956 IBM Fortran manual, said this in his interview with George:

“I worked on what they called the “first-level” documentation. And I made the biggest mistake of my life by not bringing a copy of that home. Now you understand why I missed making my first million dollars.”

So I’m guessing he didn’t bring a copy of the “Tome” back to LLNL.

Update 1/2/2016 and 12/29/2016: Updated URL’s for George Michael‘s web site. He passed away in 2008.

Rob Storey

Earlier I had learned that Paul Pierce’s web site contains images of a number of system tapes for old IBM mainframes. Paul provides some utilities he wrote for making sense of these old tapes, which were written on 7-track drives, with 6-bit BCD characters and 36-bit words.

Tonight I came across Rob Storey’s emulation web site. He’s written file utility programs BCD2IAS, IASMERGE, and FILEBROW that greatly simplify the process of reading, converting, and correcting the tape and card images from Paul Pierce’s web site.

I played with them for a while, and was able to view some of the Fortran IV compiler sources. More work will be necessary to create “fix records” for errors that BCD2IAS can’t detect by itself — it looks like there are occasional missing characters from blocked fixed-length lines, causing the source code to “drift” cyclicly to the left. But the result will be source code for the IBM 7090 Fortran IV compiler!

The bad news is that this compiler shares little if any source code from the original IBM 704/709 Fortran/Fortran II compiler (in particular, it did not contain the sophisticated code optimization components).

Rob’s web site also features an IBM 7094 emulator. (Paul Pierce’s web site has an IBM 709 emulator.)

Update 7 Jan 2015: Updated URL for Rob Storey’s emulation web site.

The Smithsonian redux

Every so often I try again to communicate with the Smithsonian. Eventually, I was able to make contact with Alicia Cutler, a Specialist in the Collection of Computers & Mathematics. She ran a search for me in their internal catalog, which produced a 12-page listing of documents related to Fortran. Three of them jumped out at me:

page 7, FORTRAN VOL I, 1959, “This is a FORTRAN program listing for the 704. Well documented.”

page 5, FORTRAN VOL II, “This is a FORTRAN program for the IBM 704, the title of which states “FORTRAN Editor Information”. Well documented”

page 5, FORTRAN VOL. III, 1959, “This is a FORTRAN program listing for the IBM 704. Well documented.”

I asked Alicia for more information on these three, and she replied, “I’ve looked over the documentation and have discovered that these three volumes relate to FORTRAN II, not FORTRAN. There is a letter from A.L. Harmon in May of 1959 stating that these are the SAP listings for the final FORTRAN II. It was split into three volumes but all together it is 1321 pages.”

Eureka!