Gordon Bell: “Out of a Closet: The Early Years of The Computer [History] Museum”

Update 1/1/2016: Gordon Bell has made an archive of materials from The Computer Museum available at http://tcm.computerhistory.org.

The institution now known as the Computer History Museum began in 1975 as a closet-sized exhibit in a Digital Equipment Corporation building, grew into The Computer Museum located on Boston’s Museum Wharf, and finally metamorphosed into its current form and location. In a fascinating technical report, Gordon Bell describes this long and interesting history, in which he and his wife Dr. Gwen Bell have played such important roles.

It was only recently, Bell notes, that “Software was finally added to list of things collected, such as the history of FORTRAN including original source code.” The FORTRAN collection to which Gordon refers is here; a catalog search of FORTRAN-related items in the museum’s archives is available here.

Bell gives a list of some two dozen “Mona Lisas” in the collection, all hardware artifacts. He concludes this section by saying “Regrettably, I omit that hard to see, hard to describe, essential software from COBOL, FORTRAN, and LISP, various Operating Systems, and on through Visicalc, and the Relational database.” I strongly agree with Bell about the importance of collecting and displaying such historic software. I’m glad to be able to point the previously-mentioned FORTRAN collection, and to similar collections for LISP, ALGOL, and C++. Others have assembled extensive collections on, for example, the Multics and Unix operating systems, PDP-10 systems and applications, and many more. Two of the earliest relational database management systems, Berkeley Ingres and IBM System R, have been preserved but are not yet easily accessible. For the most part, these collections are aimed at a more scholarly audience; I hope they will serve as source materials for future exhibits for a wider audience.

WIRED appreciates FORTRAN

WIRED‘s THIS DAY IN TECH feature for tomorrow is
Oct. 15, 1956: Fortran Forever Changes Computing’s Fortunes.

The article links to the Software Preservation Group FORTRAN web site and uses a photograph of John Backus and John Cocke from a souvenir matchbook cover from Capt. Starn’s Restaurant and Bar in Atlantic City, New Jersey, year unknown:

John Backus and John Cocke at Capt' Starn's Restaurant and Bar, Atlantic City, New Jersey

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 http://www.bbc.co.uk/radio/podcasts/digitalp/ and this download itself is http://downloads.bbc.co.uk/podcasts/worldservice/digitalp/digitalp_20071218-1232.mp3

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: community.computerhistory.org/scc => www.softwarepreservation.org; 2 Jan 2016: changed link for “Building 28” and John’s Turing Lecture.]

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: community.computerhistory.org/scc => www.softwarepreservation.org; 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: community.computerhistory.org/scc => www.softwarepreservation.org; 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: community.computerhistory.org/scc => www.softwarepreservation.org; 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: community.computerhistory.org => www.softwarepreservation.org.]

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.]

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:


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.

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:

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.

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.”


J.A.N. Lee

J.A.N. Lee has had successive careers in civil engineering and computer science, and has been active in the history of computing for many years (see for example FORTRAN’s Twenty-Fifth Anniversary). He responded to my email saying, “I have asked about the original FTN compiler several times but without any success. Two sources would seem possible — John Backus himself … and the original recipient Westinghouse-Bettis.”

In a follow-on message he said, “I found two boxes of FTN materials relating to the 25th anniversary in a cupboard yesterday and will get them out to MW as soon as possible.

Is anyone doing anything about the fact that this is the 50th anniversary year for the start of the FTN development?”

As it happens, I’d recently looked through several boxes of Fortran materials J.A.N. had already donated to the Computer History Museum. They contained among other things photocopies of essentially all the papers included in his annotated Fortran bibliography (see FORTRAN’s Twenty-Fifth Anniversary).