For a number of years Bob has been involved in volunteer activities at the Computer History Museum, and recently he organized his thoughts on how museums can use the web to present technology, in the form of this article: “Museums in the Computer Age: meeting the challenge of technology“. Bob invites comments on the article via email at bobpatrick@mac.com.

In a recent oral history I conducted for the Computer History Museum, Don put into context his work designing SQL in collaboration with Ray Boyce. Don described the pre-relational database management systems, Ted Codd’s development of the relational model, various implementation projects at IBM culminating in System R, which was the first RDBMS to support SQL. Don went on to describe other pioneering relational systems, including Ingres and Oracle. He also described his subsequent work on text processing, DB/2, and XQuery.

For further historical information about Don and his work, see:

• Burt Grad, Moderator. RDBMS Workshop: Technology Through 1983, Computer History Museum, June 12, 2007. http://www.computerhistory.org/collections/accession/102658267
• Donald D. Chamberlin, OH 329. Oral history interview by Philip L. Frana, 3 October 2001, San Jose, California. Charles Babbage Institute, University of Minnesota, Minneapolis. http://www.cbi.umn.edu/oh/display.phtml?id=317
• Paul McJones, editor. The 1995 SQL Reunion: People, Projects, and Politics. Technical Note 1997-018, Systems Research Center, Digital Equipment Corporation, August 1997.
  http://www.hpl.hp.com/techreports/Compaq-DEC/SRC-TN-1997-018.html

This book applies the deductive method to programming by affiliating programs with the abstract mathematical theories that enable them to work. Specification of these theories, algorithms written in terms of these theories, and theorems and lemmas describing their properties are presented together. The implementation of the algorithms in a real programming language is central to the book. While the specifications, which are addressed to human beings, should, and even must, combine rigor with appropriate informality, the code, which is addressed to the computer, must be absolutely precise even while being general.

The roots of the book go back many years. In 1976 Alex had two important revelations: an essential part of programming is to find the most general form of each algorithmic component and, as he wrote a few years ago, “Our ability to restructure certain computations to be done in parallel depends on the algebraic properties of operations. For example, we can re-order a + (b + (c + d)) into (a + b) + (c + d) because addition is associative.” Much of his subsequent career, including his development of the C++ Standard Template Library, can be described as pursuing the consequences of these ideas.

I met Alex in early 2003, shortly after each of us joined Adobe Systems. As I mentioned in an earlier post, we discovered a common connection, to John Backus. Our first collaboration was co-chairing a company-wide internal engineering conference in 2004. After that I began attending the course on Foundations of Programming that Alex was teaching at Adobe. In 2005, I joined Alex in the Software Technology Lab, which was led by our colleague Sean Parent. In 2007, Alex invited me to work with him on converting his course notes into a book. We soon concluded that a fresh start was necessary. About two years later, Elements of Programming was complete.

The code in the book can be downloaded from the companion web site.

Here are summaries of the contents (corresponding to the six videotapes):

1. Taylor’s childhood, education, military service in the US Navy during the Korean War, and his first positions after graduating from college: teaching at a prep school in Florida, and systems engineering at The Martin Company in Orlando, Florida; managing research at NASA and at ARPA IPTO.
2. The ARPANET project, the founding of the graphics work at the University of Utah; his own brief stay at the University of Utah; the founding and early history of the Xerox PARC Computer Science Laboratory (CSL); Xerox’s purchase of Scientific Data Systems (SDS), and CSL’s MAXC, Alto, and EARS projects.
3. More on the Alto system and what it influenced (including TCP/IP); the Future Day held by PARC for Xerox executives; the Dorado project.
4. His departure from Xerox; the founding of the DEC Systems Research Center (SRC); the Firefly, Alpha Demonstration Unit, Autonet, AN2, and Petal projects; the founding of the DEC Paris Research Laboratory and its collaboration with SRC; the nearby DEC Western Research Laboratory (WRL) and its Titan project; a recap of the commercialization of Ethernet.
5. Wes Clark, his TX-2 work, his LINC work, and his suggestion of decentralizing control for the ARPANET via a small computer (IMP) at every host; Taylor’s work in Vietnam at the end of his ARPA tenure; his approach to research management, including recruiting, interviewing, and performance appraisals.
6. More on research management: informal celebrations, and the importance of a college intern program; reminiscences about people who worked at Xerox PARC CSL or DEC SRC or both.

Faithful readers of this blog know that a good way to prepare for this event is to visit the History of Lisp web site at the Computer History Museum, which contains source code, manuals, and hyperlinks for many versions of Lisp starting with McCarthy’s Lisp 1.5.

Update 4: It was necessary to revise the schedule because of severe health issues preventing John McCarthy from attending in person. Pascal Costanza says McCarthy will be able to participate via live telephone interview.

Update 3: Now www.lisp50.org lists the Invited Speakers but notes “Title, abstracts, biographies and schedule will be announced here and at the Lisp50 blog in the coming days and weeks.”

Update 2: www.lisp50.org seems to be the URL for Lisp50@OOPSLA, but the Invited Speakers section still says “to be announced”.

Update 1: JonL White notes that the Association of Lisp Users is holding its “celebratory 50th Anniversary” conference at MIT in the spring of 2009, with Guy Steele as Program Chair and Dan Weinreb as General Chair; Dan sent out an “extremely unofficial pre-announcement” in February.

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 (www.softwarepreservation.org) and a new chairman (Al Kossow, the Museum’s Software Curator and the creator of www.bitsavers.org).

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.

Please let me (paul at mcjones dot org) know if you observe any problems with this blog. Thanks!

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

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

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

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

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

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

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

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

This version of Interlisp should be both TENEX and TOPS20 compatible. It came at a time when lots of work was going on to port Interlisp to other environments, including the VAX and the new personal Lisp machines (Dolphins, etc.). This means little was changing in the TENEX/TOPS20 version.

There are links to these files here.

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

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

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

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

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)