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

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

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: =>]

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

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

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.

Tom Van Vleck

Tom Van Vleck and I met at Tandem in 1981. Tom is the creator and maintainer of, which “presents the story of the Multics operating system for people interested in the system’s history”. Since Tom was at MIT in the 1960s, I thought he might have heard of the “Tome”, so I sent him an email. He hadn’t heard of it, but he suggested several leads for me to follow: Jean Sammet, Lynn Wheeler , the IBM folks I’d worked with in the 1970s, Doug McIlroy (“Bell Labs probably got a copy and may even know where in the Labs it was”), and Frank da Cruz, who maintains Columbia University Computing History (for example, see John Backus).

Bob Bemer

Bob Bemer joined IBM in 1949 and has an interesting web site documenting his long career, including leading the development of FORTRANSIT, the second Fortran compiler, for the IBM 650.

Using Google, I came across Bob Bemer’s Who Was Who in IBM’s Programming Research? — Early FORTRAN Days which reproduced an IBM Programming Research Newsletter from January 1957 with short descriptions of the Fortran team members, including the sentence “Hal [Harold Stern] is currently working on “TOME” describing FORTRAN internally.”

I contacted Bob to see if perhaps he had saved a copy of the “Tome”. Unfortunately, he did not. He went on to say, “Later I took over FORTRAN introductory chores, mainly via Dave Hemmes. I called Hemmes’ s widow today (lives in Sunnyvale), and she said that he personally destroyed all of his historical material before he died about six years ago.”

The Smithsonian

Based on Irv Ziller’s recollection that historic Fortran materials had been sent to the Smithsonian Institution, I looked at their web site and found this page describing the Division of Information Technology & Society, which is part of the National Museum of American History and whose collections include the Computer History Collection. My attempts to establish communication with the staff of this Division got off to a slow start. Later, I learned that they were consumed with the creation of a major new exhibition, “The Price of Freedom”, to open November 11, 2004.

Update 1/2/2016: Updated Smithsonian URLs.

Software Collection Committee

The first meeting of the Software Collection Committee of the Computer History Museum was held November 19th. The purpose of the committee is to help the museum, whose mission statement is “To preserve and present for posterity the artifacts and stories of the information age”, bootstrap its software activities. Expected activities include establishing standards for categorization, preservation, etc., testing these standards on some representative software, establishing priorities for software to collect, etc. The committee was launched partly as a response to a workshop on Preserving Classic Software moderated by Grady Booch and held October 16-17.

The discussion of what software would be worth collecting first was quite interesting — people proposed various criteria, but clearly age and historical significance are key. At this meeting, or shortly thereafter, I began thinking about the first Fortran compiler, and my friend Alex Stepanov reinforced this interest. Fortran was arguably the first higher-level programming language, and its compiler was the first optimizing compiler.