Category: People

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.

Update 2014/05/10: community.computerhistory.org/scc => www.softwarepreservation.org; 2016/01/02: changed link for “Building 28” and John’s Turing Lecture; 2021/09/25: changed link for “Building 28” again; 2024/05/08: updated links for SSEC and System R recovery paper.

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 2016/1/2/ and 2016/12/29: Updated URL’s for George Michael‘s web site. He passed away in 2008.

Update 2024/05/08: Updated Columbia URL to https.

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 MV 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).

Update 2024/05/07: Changed MW to MV [Mountain View?].

Tom Van Vleck had suggested I contact Jean Sammet. Jean has published extensively on programming languages and their history. (Her book, Programming Languages: History and Fundamentals, has been called the definitive work on early computer language development.)

I eventually found a current email address for her; today she responded that she didn’t know where to find the Fortran source, but suggested I contact Fran Allen and J.A.N. Lee.

I ran across an article “The Fortran I Compiler” by David Padua in Computing in Science and Engineering, Volume 2, Number 1, (January/February 2000). It begins, “The Fortran I compiler was the first demonstration that it is possible to automatically generate efficient machine code from high-level languages. It has thus been enormously influential. This article presents a brief description of the techniques used in the Fortran I compiler for the parsing of expressions, loop optimization, and register allocation.”

I contacted David to see if by any chance he knew of someone with a copy of the source code. He didn’t but he and his colleague Sam Midkiff suggested contacting retired IBMers Fran Allen or Marty Hopkins.

At the suggestion of Tom Van Vleck, I sent Doug McIlroy an email asking if he’d run across the Fortran ‘Tome’ while at Bell Labs in the 1950s. He replied:

I was at MIT when the first Fortran came out, and I don’t recall seeing the source there. When I joined Bell Labs in 1958, we had Fortran II. We had the source; in fact Dolores Leagus had worked with IBM on adapting the compiler to use a full 32K-word memory, and had subjected the compiler to the BESYS operating system (the compiler was a standalone program as it came from IBM). If you can find her (she retired about the same time I did) she might know where to look.

I myself used the Fortran source only after we got the 7094, and I know that had been altered significantly, for it used 709 opcodes that didn’t exist on the 704.

Another document that come with Fortran, which everybody got to know was the “stop book”. The compiler did not issue diagnostics. Instead it halted. The machine operator would record the IC from the console lights. The stop book told what the cause of each stop was, often very cryptically: “trouble in the tag table, or some other cause”. You should try to collect that, too. One of the things Dolores did was to replace the halt instructions by system calls, so the stop could be recorded automatically.

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

In a response to Software Collection Committee chairman Bernard L. Peuto’s request for suggestions for “10 software preservation candidates for testing our processes”, Dick Sites mentioned:

I once saw and read part of the original handwritten Fortran I documentation in a basement of the Sloan building at MIT in 1965. Backus might know if any copies still exist.

When Software Collection Committee member and museum chairman Len Shustek asked, “Was what you saw source code, user-manual material, or internal design documents?”, Dick replied:

It was a Xerox copy of hand-written internal design documents. It was in the 1620 mod II room in the basement of the Sloan building on the MIT campus, 100 Memorial Drive circa spring 1966. I have always regretted not having the foresight (and money) to make a complete copy back then. As I remember, it described the overall compiler design and optimizing algorithms. I remember a fairly neat but slightly small handwriting with hand-drawn boxes and arrows for some of the algorithms. I don’t remember whose names were on it.

I’m pretty sure it was Fortran I dated circa 1957, but it could have been Fortran II. It was not describing a 1620 compiler; it just happened to be in that room. I’m not sure whether the document mentioned the target computer, but I recognized it as the IBM 704 or perhaps 709. I don’t have a clear memory of how much paper there was, but it was perhaps 50-150 pages.

Len responded:

I think I may have found what it was: In his “History of Fortran I, II, and III” article in the 10/98 issue of “Annals of Computing History”, Backus says of the April 1957 release, “Shortly after the distribution of the system, we distributed — one copy per installation — what was fondly known as the ‘Tome’, the complete symbolic listing of the entire compiler plus other system and diagnostic information, an 11×15 inch volume about four or five inches thick”. Does that sound right?

I suppose it’s impossible still to be in the basement at Sloan? The good news is that as of April 1958 there were 26 installations of Fortran at 704 sites, and if each if them was given a ‘Tome’, then one or more might have survived. Somewhere.

Dick replied:

No, not right. What I saw was HANDWRITTEN. It was not a computer listing. It was not source code. It was not an IBM manual. It was not computer paper. It was not four or five inches thick. It was not an IBM 704 or 709 installation. It was a Xerox copy (not reduced from larger paper) of handwritten documentation on 8.5×11″ white paper, perhaps 1/2″ thick at most.

Irv Ziller, who was the first person to join John Backus on the Fortran team, responded to my inquiry regarding the source code for the original Fortran compiler by saying, “I do not have the source code, however I recall material being sent to the Smithsonian to become part of their collection.”

John Backus initiated and led the project that designed and implemented Fortran, the first high-level programming language.

I hadn’t talked to John for many years*, but tonight I called him up to say hello, and to see if he had a copy of the original Fortran compiler source code. He didn’t but suggested I contact Irv Ziller, who was the first person to join John’s Fortran project.

* In 1974 I worked for John Backus at IBM San Jose Research (before the Almaden Research Center was built) .