Category: People

Articles that talk about people

Remembering
Michael Levin (1940-2025)

L-R: Michael Levin, Lowell Hawkinson, Ed Fredkin. 16 August 2016. Courtesy of Mark David.

Michael I. Levin died on 14 August 2025. He played important roles in the original LISP 1.5 project and the follow-on LISP 2 project. Later he cofounded Gensym, which developed a real-time expert system. He had a lifelong interest in teaching, perhaps influenced by his parents, who were both school teachers. This account was pieced together from my email connections with him between 2005 and 2017, my research on the LISP 1.5 and LISP 2 projects, a 2019 interview by his cousin Alan Kadin, and a 2009 resume. It only covers Levin’s professional career, although an important part of his life was following the teaching of Chögyam Trungpa.

Levin was born in Paterson, New Jersey and grew up in nearby Totowa. He did well in school and applied to five colleges, choosing M.I.T. and enrolling in fall 1958. He majored in mathematics but was attracted to computer science, taking a graduate course by Marvin Minsky in his sophomore year. Minsky proposed a problem—providing an effective definition of “Random Sequence”—that engaged Levin and apparently provided a topic for his undergraduate thesis. He also coauthored a technical report with Minsky and Roland Silver entitled “On the effective definition of ‘Random sequence'” (AI Memo 36 revised; undated).

Apparently even before he graduated (in 1962), Levin had joined McCarthy’s Lisp project. His first publication was “Arithmetic in LISP 1.5” (AI Memo 24, April 1961), which noted it was an excerpt from the upcoming LISP 1.5 Programmer’s Manual. A version of that manual was released on July 14, 1961; its preface notes “This manual was written by Michael Levin starting from the LISP I Programmer’s Manual by Phyllis Fox.” But the final August 17, 1962 version simply states “This manual was written by Michael I. Levin.” There was another significant change between the two versions: the former said “The compiler was written by Robert Brayton with the assistance of David Park” while the latter said “The compiler and assembler were written by Timothy P. Hart and Michael I. Levin. An earlier compiler was written by Robert Brayton.” Apparently Brayton’s compiler, which was written in assembly language, was more difficult to maintain than the Hart-Levin compiler, which was written in Lisp (see “The New Compiler”, AI Memo 39) and could compile itself (after being “bootstrapped” using the interpreter). In 2013, he mentioned to me that one of his contributions to the compiler was converting a class of tail-recursive calls to iteration, a transformation that became much more well known in the 1970s. See this recent explanation of how Levin’s PROGITER function worked.

In 1962 McCarthy left M.I.T. but continued his work at Bolt Beranek & Newman (BBN); Levin joined him there. In 1963 McCarthy moved to Stanford to found an AI Laboratory. Levin may have briefly worked with McCarthy there, but by 1963 he was at M.I.T. working on a system for proof checking, as evidenced by his report “Primitive Recursion” (AI Memo 55, July 1963). Also he and his colleague Tim Hart wrote “LISP Exercises” (AI Memo 64, January 1964), intended to be used with the first chapter of The LISP 1.5 Programmer’s Manual. Perhaps they were teaching a course? Later in 1964, as the hardware for M.I.T.’s Multics operating system was being designed, Levin wrote: “Proposed Instructions on the GE 635 for List Processing and Push Down Stacks” (AI Memo 72, September 1964). Tom Van Vleck, creator of Multicians.org, told me:

I was at a big meeting where the 645 was presented to many users of the Project MAC facilities, mostly CTSS at the time. Corby led the presentation and multiple others covered various aspects. Ted Glaser talked about the associative memory and paging.

Many folks had questions. Mike raised the issues in his memo. … Ted Glaser responded, and Mike responded to that, and it was clear that the issue had many details that would have to be resolved. Mike kept asking for commitments that the presenters weren’t ready to talk about. Finally, Ted said, “We can’t do it that way, it would overload the busses.”

It was possible that Ted was making this up to end the discussion… but Ted was incredibly smart, and thought faster than anybody, and who was going to argue with a blind genius?

In any event Levin’s LISP instructions were not added to the 645.

Around this time discussions at M.I.T. and Stanford began on a follow-on language, eventually named LISP 2. Looking back in 1978, McCarthy noted:

As a programming language LISP had many limitations. Some of the most evident in the early 1960s were ultra-slow numerical computation, inability to represent objects by blocks of registers and garbage collect the blocks, and lack of a good system for input-output of symbolic expressions in conventional notations. All these problems and others were to be fixed in LISP 2.

The project expanded beyond what either of the AI labs could take on and moved to the Systems Development Corporation (SDC) in Santa Monica, California. SDC was experienced at software development, but not at Lisp, so Information International, Inc. (III) was brought in as a subcontractor. III, founded by Ed Fredkin, employed a number of experienced M.I.T. Lisp programmers, including Levin and Lowell Hawkinson.

One defining feature of LISP 2 was a syntax based on Algol 60, designed by Levin: “Syntax of the New Language” (AI Memo 68, May 1964). But by 2012, he told me:

An important idea for LISP II, which I emphasized from the beginning, but which was never implemented, and was eventually shown not to be needed, was the source language translator. This had its roots as a pedagogical device used by John McCarthy to show that there is a formal analogy between LISP and Gödel numbering. It was important to Gödel’s proof of the incompleteness of arithmetic to show that a language of logical theorems and proofs could be mapped into the domain of non-negative integers. McCarthy wanted to emphasize that LISP had the same theoretical foundation as Gödel’s proof, only with the difference that the mapping was easy and intuitive rather than being humanly intractable.

Although Levin changed his mind about the importance, I think it had an impact through the paper “The LISP 2 Programming Language and System,” (FJCC 1966) planting the idea of Algol-like languages with dynamic data structures.

Levin was also thinking about the runtime requirements for the new language at this time: “New Language Storage Conventions” (AI Memo 69, May 1964). Around this time, it appears he moved to Santa Monica to work more closely with the SDC team, and wrote a series of technical reports probably best studied in context at this web site dedicated to the project.

Levin returned to M.I.T. in 1965, apparently as an instructor, thinking about mathematical logic: “Topics in Model Theory” (AI Memo 78, May 1965; revised as AI Memo 92, January 1966). His resume notes: “Developed and taught graduate course entitled Mathematical Logic for Computer Scientists“. The resultant book was published as an M.I.T. LCS report (TR 131, June 1974). The book caught the eye of famous logician Stephen Cole Kleene, who noted in a footnote of a 1978 paper:

It was pointed out to me in Oslo on June 13, 1977 by David MacQueen that computer scientists have developed the theory of working with the expressions of a given formal language as a generalized arithmetic to the extent that it is not necessary to reduce the language to the simple arithmetic of the natural numbers by a Gödel numbering or indexing. Cf. Levin 1974, Scott 1976. (An early example of generalized arithmetic is in IM § 50.)

(in the interview by Alan Kadin, Levin joked: “During my time at Stanford, I studied a book by Stephen Cole Kleene, Introduction to Metamathematics. As far as I know, I may be the only person who carefully read this entire book.)

In addition to BBN and III, Levin worked for Composition Technology, where he said he implemented the world’s first typesetting program.

In the early 1970s Levin went to Colorado, apparently attracted by the teaching of Chögyam Trungpa. He held several teaching and research positions there, and then in 1982 he became an associate professor of computer science at Acadia University in Nova Scotia.

Returning to Massachusetts in 1984, he joined LISP Machine, Inc. (LMI), one of the two companies that spun out of M.I.T.’s Lisp machine project. Levin designed the inference engine for PICON, LMI’s real-time expert system. By 1986 it became clear to him and several of his colleagues (including Lowell Hawkinson, with whom he’d worked at III) that LMI was failing, so they left and co-founded Gensym. Gensym’s G2 real-time expert system, similar to PICON but with a from-scratch implementation, was very successful for industrial process control. A 1996 initial public offering allowed Levin to finance his later retirement, although he also did consulting work from 1999 to 2004.

John McCarthy had a vision of a programming language for symbolic processing in artificial intelligence. Michael Levin was a central member of the team that turned that vision into a practical implementation. Throughout his career he combined effective engineering with mathematical insights.

This essay benefited from comments by Mark David, Roger Frye, and Alan Kadin. I’m also indebted to Alan for his oral history.

Robert Brayton (1933-2025) and the first Lisp compiler

Reading the Summer 2025 issue of Berkeley Engineer magazine, I was sad to note this item:

Robert Brayton died in January at the age of 91. He was a professor emeritus of electrical engineering and computer sciences and a pioneer in logic synthesis and formal verification. His career spanned multiple decades, including 26 years at the IBM Thomas J. Watson Research Center, where he led the Yorktown silicon compiler team and helped create one of the most advanced logic synthesis systems of its time. There, he also co-developed the sparse tableau methodology, which remains a foundational technique in modern circuit simulation. Brayton later joined the faculty at UC Berkeley, where he co-authored numerous influential papers and books and helped develop multilevel logic synthesis, which is widely used in the design and verification of complex logic systems and is a core component of Electronic Design Automation (EDA).

Robert K. Brayton (1933-2025)
Robert K. Brayton (1933-2025)

In addition to these impressive accomplishments, while earning his Ph.D. in Mathematics at M.I.T. Brayton worked in John McCarthy’s Artificial Intelligence project on the design and implementation of Lisp. The 1960 LISP I Programmer’s Manual by McCarthy et al. [1] says: “The compiler was written by Brayton with the assistance of [David] Park.” But by 1978, when he wrote his paper for the first History of Programming Languages Conference, McCarthy asserted that Brayton’s compiler was “unsuccessful”.

Kazimir Majorinc, while researching the early history of Lisp, contacted Brayton by email for his version of the story and presented it in his talk “Who wrote the first Lisp compiler?” [2] Brayton described McCarthy’s HOPL comment as “unfair” and said this slightly edited version of Fred Blair’s 1970 remark [3] is “much more accurate” [Brayton’s edits in brackets]:

The first Lisp compiler was written by Robert Brayton with the assistance of David Park, in SAP for the 704. That compiler was started in [1958] and was [fully] working in [1961] by which time Brayton left MIT. During that interval of time a Lisp compiler written in Lisp was implemented by Klim Maling but that compiler was apparently dropped. [I am not sure it ever worked fully.] The argument advanced was that Brayton’s, being written in assembly language, would obviously be faster. Difficulties in maintenance developed when Brayton left the project. After Brayton and Maling, Timothy Hart and Michael Levin wrote a compiler in Lisp which was distributed with the 704 Lisp 1.5 system.

Herbert Stoy’s bibliography [4] attributes two compiler-related documents to Brayton, and after he donated his Lisp collection [5] to the Computer History Museum in 2010 I was able to scan those documents, neither of which identifies the author or date. They seem to be describing a compiler written in Lisp, so presumably they were written by either Klim Maling or Hart and Levin. [6, 7]

McCarthy was clearly very interested in the compiler. One of his first memos about programming languages was “Proposal for a Compiler,” written in 1957 and sketching ideas for languages like Algol and Lisp (neither of which existed yet) on a foundation not unlike Fortran (just being released). [8] Later (probably 1959) he wrote a memo giving code sequences to be generated for various Lisp constructs. [9] In any case, it seems likely that Brayton’s remarks to Majorinc best capture what really happened.

References

  • [1] J. McCarthy, R. Brayton, D. Edwards, P. Fox, L. Hodes, D. Luckham, K. Maling, D. Park and S. Russell. LISP I Programmer’s Manual. Computation Center and Research Laboratory of Electronics, Massachusetts Institute of Technology, March 1, 1960. www.softwarepreservation.org
  • [2] Kazimir Majorinc. Who wrote the first Lisp compiler? Slides for talk at Hacklab Mama, Zagreb, November 17, 2012. PDF at kazimirmajorinc.com
  • [3] Fred W. Blair. Structure of the Lisp Compiler. IBM Research, Yorktown Heights, circa 1970. www.softwarepreservation.org
  • [4] Herbert Stoyan. Lisp bibliography, 1997. www.softwarepreservation.org
  • [5] Herbert Stoyan collection on LISP programming, Computer History Museum, Lot X5687.2010. 105 linear feet, 160 boxes. Catalog at CHM
  • [6] Anonymous. Compiler. MIT, Cambridge, undated (circa 1959). www.softwarepreservation.org
  • [7] Anonymous. The Compiler in LISP. MIT, Cambridge, undated (circa 1959). www.softwarepreservation.org
  • [8] J. McCarthy. Memo to P. M. Morse: A Proposal for a compiler. Memo CC-56, Computation Center, Massachusetts Institute of Technology, December 13, 1957, 19 pages. www.softwarepreservation.org
  • [9] J. McCarthy. Notes on the Compiler. Memo 7, Artificial Intelligence Project, RLE and MIT Computation Center. Undated, 2 pages. www.softwarepreservation.org

John Allen (1937-2022) and Anatomy of LISP

When I began researching the history of LISP in 2005 [1], one of the first people I got in touch with was John Allen. Not only had he helped create Stanford LISP 1.6, written an influential book on the LISP language and its implementation (Anatomy of LISP), but also he and his wife, Ruth Davis, had organized (and funded!) the 1980 LISP conference [2] and founded The LISP Company, which produced TLC Lisp for Intel 8080- and 8086-based microcomputers. By the time I got in touch with him he was busy preparing a talk for another LISP conference [3], but told me:

in 1964 i got interested in lisp and wrote to mit. tim hart responded, sending the distribution tape and wished my luck. i needed it because the mit tape was for a machine related, but not identical, to the one i had at work. so to make a long story short, i got the tape converted and running.

what i have is a november 1964 listing of the tape’s contents. that includes the source card-images for lisp 1.5 plus the initial lisp library written in lisp. that includes bunches of test cases, the compiled compiler and other random crap. the listing does have some of my comments related to the conversion, but the original text is quite clear.

i was planning to bring it along when i go to stanford june 19-22, and would be willing to let someone scan it if desired. i’ve got other crap around in random piles, boxes, and “archives.”

I gave a 5-minute pitch at the conference for my LISP history project, but did not catch up with John. I tried to stay in touch with periodic emails, and ran into John and Ruth in person at John McCarthy’s 2012 Stanford memorial. But somehow we could never coordinate to scan his listing and other items from his “archives”.

Then in 2022 Ruth contacted me with the sad news that John had died in March of that year. Remembering our long correspondence regarding John’s LISP materials, she invited me to help her sort through John’s papers:

I have come across a PDP-1 notebook with a THOR manual (I think), some tapes containing I know not what, some copies of handwritten lecture notes (I think) of Dana Scott and Georg Kreisel. And I haven’t made it to the closet yet. I am throwing out a lot, and I may not have the right sensibilities to know what may be of interest.

I jumped at the chance, and spent an afternoon with her, bringing home several boxes of materials including the 1964 LISP 1.5 listing. Also she told me she’d discovered the copyright release for John’s famous book Anatomy of LISP and would be happy for an electronic edition to be posted online. That suggested an opportunity: ACM had included Anatomy in their 2006 Classic Books collection, but at that time the copyright status was not clear and an electronic edition could not be included, as was possible for many of the books in the collection. John wrote the book using Larry Tesler’s PUB document compiler, and many drafts were preserved in Bruce Baumgart’s SAILDART archive. John’s original plan was to adapt PUB’s output to a phototypesetter to achieve “book quality” output, but that did not work out so the book was published from pages printed on a Xerox XGP printer, at a low 192 dots/inch. Bruce Baumgart very generously did some work to recreate a bitmap-based PDF from SAILDART files, but it was still at 192 dpi and the content didn’t quite match the published version. So Ruth and I offered a clean, scanned PDF to ACM, and after verifying the rights they added this PDF to the website. [4]

The Computer History Museum accepted Ruth’s donation of the LISP 1.5 listing, some Stanford PDP-1 timesharing system documents (TVEDIT, RAID, and THOR), John’s Alvine LISP editor manual, John’s 1971-1972 lecture notes for the E123A course he taught at UCLA, three early MDL/MUDDLE documents, some ECL documents from Harvard, some early theorem proving reports (John implemented a theorem prover with David Luckham [5]), reports by Christopher Stratchey, Dana Scott, and Peter Wegner, an early 1979 version (by Harold Abelson and Robert Fano) of Structure and Interpretation of Computer Programs, and the four magnetic tapes Ruth had mentioned. (Al Kossow has promised to digitize the tapes; I suspect one contains John’s theorem prover; two may contain other LISP code.)

John Allen was a passionate computer scientist and educator. He held programming or research positions at Burroughs Sierra Madre, UC Santa Barbara, and GE Research (Goleta) in the early 1960s and at HP Labs and Signetics in the 1970s, as well as programming and research positions at Stanford from 1965 to about 1975, interspersed with teaching assignments at UCLA, UC Santa Cruz, and San Jose State. He also periodically taught part-time at Santa Clara University from 1984 to 2005. I wish I could have gotten to know him better.

[1] Paul McJones. Archiving LISP History, Dusty Decks blog, 22 May 2005. https://mcjones.org/dustydecks/archives/2005/05/22/40/

[2] Ruth E. Davis and John R. Allen, co-organizers. Conference Record of the 1980 LISP Conference. Later reissued as: LFP ’80: Proceedings of the 1980 ACM conference on LISP and functional programming. https://dl.acm.org/doi/proceedings/10.1145/800087

[3] John Allen. History, Mystery, and Ballast. International Lisp Conference, Stanford University, 2005. https://international-lisp-conference.org/2005/speakers.html#john_allen

[4] John Allen. Anatomy of LISP. McGraw-Hill, Inc., 1978. Part of ACM’s Classic Books Collection. ACM Digital Library (open access)

[5] John Allen and David Luckham. An interactive theorem proving program. In Machine Intelligence 5, B. Meltzer and D. Michie, Eds., Edinburgh. U. Press, Edinburgh, 1970, pp. 321- 336.

P.S. After some study of the Georg Kreisel notes that Ruth mentioned, I believe they correspond to this item:

57. Kreisel, G. Intuitionistic Mathematics. Lecture delivered at Stanford University, 1962?, 270 pp. [Mimeographed].

in this Kreisel bibliography:

The Archivists at Stanford’s Green Library agreed, and happily accepted a donation of the notes, which became Addenda 2024-122 to the Georg Kreisel papers (Collection SC0136): https://oac.cdlib.org/findaid/ark:/13030/kt4k403759/ .

Jack Schwartz and SETL

In April 2020, just as the Covid pandemic began, Annie Liu, a professor at Stony Brook University, emailed me to chat about programming language history. She suggested that Python, with its antecedents SETL, ABC, and C, would be a good topic for historical study and preservation. I mentioned that I’d considered SETL as an interesting topic back in the early 2000s, but unfortunately had not acted. After a few more rounds of email with her, I began looking around the web and Annie introduced me to several SETL people. Starting with these people, a few other personal contacts, and some persistence, I was soon in touch with much of the small but friendly SETL community, who very generously pored through their files and donated a wide variety of materials. The result is an historical archive of materials on the SETL programming language, including source code, documentation, and an extensive set of design notes that is available at the Software Preservation Group web site:

http://www.softwarepreservation.org/projects/SETL/ 

In addition, the digital artifacts and some of the physical artifacts are now part of the Computer History Museum’s permanent collection.

The SETL programming language was designed by Jack Schwartz at the Courant Institute of Mathematical Sciences at New York University. Schwartz was an accomplished mathematician who became interested in computer science during the 1960s. While working with John Cocke to learn and document a variety of compiler optimization algorithms, he got the idea of a high-level programming language able to describe such complex algorithms and data structures. [1] It occurred to him that set theory could be the basis for such a language since it was rich enough to serve as a foundation for all of mathematics. As his colleagues Martin Davis and Edward Schonberg described it in their biographical memoir to him: [2]

The central feature of the language is the use of sets and mappings over arbitrary domains, as well as the use of universally and existentially quantified expressions to describe predicates and iterations over composite structures. This set-theoretic core is embedded in a conventional imperative language with familiar control structures, subprograms, recursion, and global state in order to make the language widely accessible. Conservative for its time, it did not include higher-order functions. The final version of the language incorporated a backtracking mechanism (with success and fail primitives) as well as database operations. The popular scripting and general purpose programming language Python is understood to be a descendent of SETL, and its lineage is apparent in Python’s popularization of the use of mappings over arbitrary domains.

Schwartz viewed SETL first as a specification language allowing complex algorithms and data structures to be written down, conveyed to other humans, and executed as a part of algorithm development or even as a component of a complete prototype system. Actual production use would typically require reprogramming in terms of data structures closer to the machine such as arrays and lists. Schwartz believed that SETL programs could be optimized “by a combination of automatic and programmer-assisted procedures.” [3, page 70] He wrote several memos about his ideas for SETL [4, 5], and began assembling a project team — mostly graduate students. A series of design notes and memos called the SETL Newsletter was launched. [6] Malcolm Harrison, another NYU professor, had designed an extensible LISP-like language called BALM; in the first SETL Newsletter he sketched a simple prototype of SETL as a BALM extension. [7]

Over the following years the SETL Newsletters chronicled a long and confusing series of SETL implementations implemented with various versions of BALM and also with LITTLE, a low-level systems programming language.

  • BALMSETL (1971-1972) consisted of a runtime library of procedures corresponding to the various SETL operations, and a modification of BALM which replaced the standard BALM syntactic forms with calls to the appropriate procedures in the library. This runtime library used a hash-based representation of sets (earlier prototypes had used lists).
  • SETLB (spring 1972) consisted of a preprocessor (written in Fortran) that translated a simplified subset of SETL to BALMSETL. BALM was converted from producing interpretative code for a generalized BALM machine to producing CDC 6600 machine code.
  • SETLB.2 (1973?) was based upon a version of the BALM interpreter written in LITTLE, plus the SETL Run Time Library. It offered a limited capability for variation of the semantics of subroutine and function invocation by the SETLB programmer.
  • SETLA (1974?)’s input language was closer to SETL, but it still used the BALMSETL-based runtime library and BALM-based name scoping.
  • SETLC (1975?) consisted of a lexical scanner and syntactic analyzer (written in LITTLE), tree-walking routines (written in BALM) that built BALM parse trees), a translator that emitted LITTLE from the parse trees (written in BALM), and the LITTLE compiler. The generated LITTLE code used the SETL Run Time Library.
  • SETL/LITTLE (1977-1978?) consisted of a SETL-to-LITTLE translator, a runtime library, and a LITTLE-to-CDC 6600 machine code compiler (all written in LITTLE).

The final system (the only one for which source code is available) was ported to the IBM System/370, Amdahl UTS, DECsystem-10, and DEC VAX. There was also a sophisticated optimizer, itself written in SETL, which however was too large and slow to use in production. Work stopped around the end of 1984 as Schwartz’s focus moved to other fields such as parallel computing and robotics and many of the graduate students received their degrees. A follow-on SETL2 project produced more SETL Newsletters but no system.

Other SETL implementations

Starting in the mid 1970s, SETL-influenced languages were implemented at other institutions including Akademgorodok in Novosibirsk, and then at NYU itself. After a 30-year gestation period, GNU SETL was released in 2022. See https://www.softwarepreservation.org/projects/SETL/#Dialects for more.

Aftermath

Many reports and theses were written and papers were published. Perhaps the most well-known result was the NYUAda project, which was an “executable specification” for Ada that was the first validated Ada implementation. The project members went on to found AdaCore and GNAT Ada compiler.

Acknowledgements

In addition to Annie Liu, many people helped me on this project; see https://www.softwarepreservation.org/projects/SETL/#Acknowledgments .

References

[1] John Cocke and Jacob T. Schwartz. Programming Languages and Their Compilers. Preliminary Notes. 1968-1969; second revised version, Apri1 1970. Courant Institute of Mathematical Sciences, New York University. PDF at software preservation.org

[2] Martin Davis and Edmond Schonberg. Jacob Theodore Schwartz 1930-2009: A Biographical Memoir. National Academy of Science, 2011. PDF at nasonline.org

[3] Jacob T. Schwartz. On Programming: An Interim Report on the SETL Project. Installment 1: Generalities; Installment 2: The SETL Language, and Examples of Its Use. Computer Science Department, Courant Institute of Mathematical Sciences, New York University, 1973; revised June 1975. PDF at softwarepreservation.org

[4] Jacob T. Schwartz. Set theory as a language for program specification and programming. Courant Institute of Mathematical Sciences, September 1970, 97 pages.

[5] Jacob T. Schwartz. Abstract algorithms and a set theoretic language for their expression. Computer Science Department, Courant Institute of Mathematical Sciences, New York University. Preliminary draft, first part. 1970-1971, 16+289 pages. PDF at softwarepreservation.org

[6] SETL Newsletter. #1-#217, November 1970 – November 1981; #220-#233, April 1987 – November 1988. Online at software preservation.org

[7] M. C. Harrison. BALM-SETL: A simple implementation of SETL. SETL Newsletter #1, 5 November 1970. PDF at softwarepreservation.org

Update 23 July 2025

Updated URL for reference [2].

Remembering Maarten van Emden

Maarten van Emden died on January 4, 2023, at the age of 85.[1] He was a pioneer of logic programming, a field he explored for much of his career. I was not in his field, and only got to know him starting in 2010, so this is a personal, but not professional, remembrance of a very dear friend.

Maarten van Emden, 26 February 2011

His life

Maarten was born in Velp, the Netherlands, but his family soon moved to the Dutch East Indies, where his botanist father was working on improving tea plants. In 1942 the Japanese invaded. Maarten’s father escaped to join the resistance, but Maarten, his younger sister, and his mother were sent to a detention camp. As the war came to a close, his father was able to rescue and reunite the family. Over the next few years they returned to the Netherlands, with a brief return to the newly-formed Indonesia, followed by boarding school in Australia for Maarten. They were finally reunited in the Netherlands in 1954, where Maarten began his final year of high school. After graduating in 1955, he went to national flight school (Rijksluchtvaartschool). He did a year of military service, including flight training, and then joined KLM Royal Dutch Airlines. But KLM was adopting DC-8 jets for transatlantic service, whose speed, capacity, and ease of operation led to the need for fewer pilots. Maarten took advantage of a company program to enroll part-time in an engineering curriculum at the University of Delph. Later he was laid off by KLM and finished a master’s degree as a full-time student. He then enrolled in the PhD program administered by the University of Amsterdam with research at the Mathematisch Centrum (now CWI), and also made several visits to the University of Edinburgh. His 1971 dissertation was An Analysis of Complexity and his advisor was Adriaan van Wijngaarden. Maarten was awarded a post-doctoral fellowship by IBM, which he spent at the Thomas J. Watson Research Center in Yorktown Heights, NY during the 1971-1972 academic year, before returning to Edinburgh for a research position under Donald Michie in the Department of Machine Intelligence.  In 1975 he accepted a professorship at the University of Waterloo, and in 1987 he moved to the University of Victoria.

Programming

Maarten was one of 15 individuals recognized as Founders of Logic Programming by the Association for Logic Programming.[2] His work began with an early collaboration with Bob Kowalski[3] and continued throughout his career with collaborations and individual projects to explore many aspects of the field. Underlying his interest in logic programming was a fascination with programming and programming languages of all sorts.[4] His first language was Algol 60, which he taught himself using McCracken’s new book[5] when his university suddenly switched from Marchant calculators to a Telefunken TR-4 computer for the numerical methods course.[6] Moving on to the MC he was surrounded by ALGOL experts (his advisor van Wijngaarden was a member of the ALGOL 60 Committee and the instigator of the infamous ALGOL 68). Maarten was originally attracted to Edinburgh after hearing about the POP-2 timesharing system of Burstall and Popplestone; it was only later that he realized he’d initially used POP-2 as if it was ALGOL rather than a rich functional programming language. During his post-doc at IBM he learned APL and Lisp. Fred Blair was implementing a statically-scoped Lisp for the SCRATCHPAD computer algebra group.[7] And William Burge, who had worked with Burstall and Landin, was spreading the gospel of functional programming.[8] Ensconced in Edinburgh in 1972, he became an early convert to Kowalski’s logic programming, which he noted could be traced back as early as Cordell Green’s paper at the 4th Machine Intelligence workshop.[9] But Maarten’s first impression of Preliminary Prolog was not positive — the frequent control annotations seemed to detract from the logic. Nevertheless, he and Kowalksi began writing short programs to explore the ideas. And when David Warren returned from a visit to Marseille with a box of cards containing Final Prolog as well as his short but powerful WARPLAN program, things changed. The language no longer needed the control annotations, and Warren quickly ported its Fortran-coded lowest layer to the local DEC-10. WARPLAN served as a tutorial for all sorts of programs in the new language. Maarten was surprised that his friend Alan Robinson, the inventor of resolution logic, wouldn’t give up Lisp for logic programming.[10] At Waterloo, he advised Grant Roberts, who built Waterloo Prolog for the IBM System /370, and another series of students who built  several Prologs for Unix. At Victoria, he wrote a first-year textbook for science and engineering students based on C:

It is indeed true that object-oriented programming represents a great advance. It is also true that polymorphism in object-oriented programming does away with many if-statements and switch statements; that iterators replace or simplify many loops. But experience has shown that introducing objects first does not lead to a first course that produces better programmers; on the contrary. It is as much necessary as in the old days to make sure that students master variables, functions, branches, loops, arrays, and structures.

[11], page xi

In the acknowledgements of the book, he wrote:

I had the good fortune to grow up in three distinctive programming cultures: the Mathematical Centre in Amsterdam, the Lisp group in the IBM T.J. Watson Research Center, and the Department of Machine Intelligence in the University of Edinburgh. Though all of these entities have ceased to exist, I trust I am not the only surviving beneficiary.

If this book is better than others, it is due to my choice of those who were, often without knowing it, my teachers: H. Abelson, J. Bentley, W. Burge, R. Burstall, M. Cheng, A. Colmerauer, T. Dekker, E. Dijkstra, D. Gries, C. Hoare, D. Hoffman, N. Horspool, B. Kernighan, D. Knuth, R. O’Keefe, P. Plauger, R. Popplestone, F. Roberts, G. Sussman, A. van Wijngaarden, N. Wirth.

[11], page xi

Getting to know Maarten

As different as we were, Maarten and I had a few things in common: fathers who piloted B-24 bombers in WWII, a charismatic mutual friend named Jim Gray, attendance at the 1973 NATO Summer School on Structured Programming, books named Elements of Programming, and a fascination with the early development of programming languages. Jim Gray had been an informal mentor for me at UC Berkeley as I worked on CAL Snobol and Cal TSS. Then he left Berkeley for IBM Research in Yorktown, and made friends with Maarten. Jim soon decided he couldn’t tolerate life on the east coast, but before leaving he encouraged Maarten and his wife Jos to drive across the country and visit him in California, where he would show them around. They took him up on the offer, and during a brief stay in fall 1972 at Jim’s home in Berkeley I met Maarten, but didn’t make much of an impression on him (although he later told me Jim had mentioned the “great programmers on Cal TSS”). The next summer both Maarten and I attended the NATO Summer School on Structured Programming at Marktoberdorf, but neither of us remembered encountering the other. Maarten mentioned the summer school in his remembrance of Dijkstra.[12]

In 1974 I caught up with Jim Gray again, joining IBM Research in San Jose (before Almaden). The next summer Maarten visited Jim, although I didn’t learn of it until much later:

“After I returned to Europe Jim and I kept writing letters. In the summer of 1975 I was in a workshop in Santa Cruz and Jim came up in a beautiful old Porsche.  I was at the height of my logic programming infatuation. Jim was rather dismissive of it. Nothing of what he told me about System R  turned me on; the relationship died with that meeting. How I wish I could talk to him now about the mathematics of RDBs, which I started working on recently.”

[Maarten van Emden, personal communication, September 3, 2010]

Maarten left three technical reports with Jim, who passed them along to me.[13] [14] [15] I looked at them, and then put them aside for the next 35 years. In the fall of 2010 I had retired and was spending more time on software history projects. I’d been following Maarten’s blog; a recent pair of articles about the Fifth Generation Computer System project and the languages Prolog and Lisp[16] [17] prompted me to contact him about a project I was contemplating: an historical archive of implementations of Prolog.[18] That began a friendship carried out mostly through some 2000 emails and almost 400 weekly video calls, plus one in-person visit when Maarten visited the Bay Area in early 2011. I will always remember his charming manners, gentle humor, wide-ranging interests, and intriguing stories.

Acknowledgements

Thanks to Maarten’s daughter Eva van Emden for information about his life.

For more of his writing, see:

Update 23 July 2025

Replaced broken link with local copy of reference [15].

Update 1 January 2024

Shortly after I wrote my post, Maarten’s colleagues wrote this article for the Association of Logic Programming: In Memoriam: Maarten van Emden.

Maarten’s web site at UVic has moved to http://maarten.vanemden.com/

References

[1] Eva van Emden. Maarten van Emden Obituary. The Times Colonist, January 10, 2023. https://www.legacy.com/ca/obituaries/timescolonist/name/maarten-van-emden-obituary?pid=203621344
[2] ALP Awards. Association for Logic Programming. https://www.cs.nmsu.edu/ALP/the-association-for-logic-programming/alp-awards/
[3] M. H. van Emden and R. A. Kowalski. The Semantics of Predicate Logic as a Programming Language. Journal of the ACM, Vol. 23, No. 4, 1976, pp. 733-742. https://www.doc.ic.ac.uk/~rak/papers/kowalski-van_emden.pdf
[4] Maarten van Emden. The Early Days of Logic Programming: A Personal Perspective. Association for Logic Programming Newsletter, August 2006. https://dtai.cs.kuleuven.be/projects/ALP/newsletter/aug06/nav/articles/article4/article.html
[5] Daniel McCracken. A Guide to ALGOL Programming. John Wiley and Sons, 1962. https://archive.org/details/mccracken1962guide
[6] Maarten van Emden. On Finding a Discarded Copy of “A guide to Algol Programming.” 1993 email to Frank Ruskey. https://web.archive.org/web/20050906222954/http://csr.uvic.ca:80/~vanemden/other/guideAlgol.html
[7] J. H. Griesmer and R. D. Jenks. SCRATCHPAD/1: An interactive facility for symbolic mathematics. In Proceedings of the second ACM symposium on Symbolic and algebraic manipulation (SYMSAC ’71). Association for Computing Machinery, New York, NY, USA, 42–58. https://doi.org/10.1145/800204.806266
[8] William Burge. Recursive Programming Techniques. Addison-Wesley 1975. https://archive.org/details/recursiveprogram0000burg
[9] Cordell Green. Theorem-Proving by Resolution as a Basis for Question-Answering Systems. Machine Intelligence 4, Bernard Meltzer and Donald Michie, editors, Edinburgh University Press, Edinburgh, Scotland, 1969, pages 183–205. https://www.kestrel.edu/people/green/publications/theorem-proving.pdf
[10] Maarten van Emden. Interview with Alan Robinson, inventor of resolution logic. June 8, 2010. https://vanemden.wordpress.com/2010/06/08/interview-with-alan-robinson-inventor-of-resolution-logic/
[11] M. H. van Emden. Elements of Programming. Andromeda Research Associates, Ltd. Third edition, 2009, page ix. https://abazu.vanemden.com/4EOP/EOP.html
[12] Maarten van Emden. I remember Edsger Dijkstra (1930 – 2002). August 2008. https://vanemden.wordpress.com/2008/05/06/i-remember-edsger-dijkstra-1930-2002/
[13] Robert Kowalski. Predicate Logic as Programming Language. Department of Computational Logic, University of Edinburgh, Memo No. 70, November 1973. https://www.doc.ic.ac.uk/~rak/papers/IFIP74.pdf
[14] M. H. van Emden and R. A. Kowalski. The semantics of predicate logic as a programming language. School of Artificial Intelligence, University of Edinburgh, MIP-R-103, February 1974. https://www.doc.ic.ac.uk/~rak/papers/kowalski-van_emden.pdf
[15] M. H. van Emden. First-order predicate logic as a high-level program language. School of Artificial Intelligence, University of Edinburgh, MIP-R-106, May 1974. PDF
[16] Maarten van Emden. Who Killed Prolog? A Programmer’s Place blog, August 21, 2010. https://vanemden.wordpress.com/2010/08/21/who-killed-prolog/
[17] Maarten van Emden. The Fatal Choice. A Programmer’s Place blog, August 31, 2010. https://vanemden.wordpress.com/2010/08/31/the-fatal-choice/
[18] Paul McJones, editor. Prolog and Logic Programming Historical Sources Archive. https://www.softwarepreservation.org/projects/prolog/

A documentary about Alain Colmerauer

Alain Colmerauer – photo from his web site http://alain.colmerauer.free.fr

It’s called An idea crazy enough…..Artificial Intelligence and it’s being developed by Colmerauer‘s friends at Prolog Heritage via a crowd-funded project at Ulele.

Colmerauer died 12 May 2017; the hoped-for tribute this fall has evolved:

The project is a film to portray Alain Colmerauer’s life and work – his contribution to Logic Programming and Constraints Logic Programming – all brought to life through interviews with some of the key participants of his time, complemented by images and documents from the archives. In fact that was the best solution to invite witnesses in this period of sanitary difficulties.

Alain Colmerauer documentary, Ulule

A 20 Euro contribution gets you an invitation to an exclusive preview of the film online; a 50 Euro contribution gets you the invitation, your name in the credits as a donor, and a digital version of the documentary.

Colmerauer’s web site: http://alain.colmerauer.free.fr

Prolog Heritage: http://www.prolog-heritage.org

Prolog and Logic Programming Historical Sources Archive: http://www.softwarepreservation.org/projects/prolog/

Liz Bond Crews; Desktop Publishing Meeting

May 2017 Desktop Publishing Pioneers meeting, Computer History Museum. Liz Bond Crews is third from left in the front row. © Douglas Fairbairn Photography; courtesy of the Computer History Museum

On May 22 and 23, 2017, the Computer History Museum held a two-day meeting with more than 15 pioneering participants involved in the creation of the desktop publishing industry. There were a series of moderated group sessions and one-on-one oral histories of some of the participants, all of which were video recorded and transcribed.

Building on this meeting, three special issues of the IEEE Annals of the History of Computing were published, telling the stories of people, technologies, companies, and industries — far too much for me to cover here, so I will provide these links:

Last but not least, I had the pleasure of interviewing Liz Bond Crews, who worked first at Xerox and then Adobe to forge relationships and understanding between the purveyors of new technology (laser printers and PostScript) and the type designers, typographers, and designers who adopted that technology. An edited version of that interview appears in the third special issue of Annals:

The LISP 2 Project

“The LISP 2 Project” appears in the October-December 2017 issue of IEEE Annals of the History of Computing (open access).

I first heard about LISP 2 around 1971, from a 1966 conference paper included in the reading for a U.C. Berkeley seminar on advanced programming languages. The goal of LISP 2 was to combine the strengths of numerically-oriented languages such as ALGOL and FORTRAN with the symbolic capabilities of LISP. The paper described the language and its implementation at some length, but by 1971 it was pretty clear that LISP 2 had not caught on; instead, the original LISP 1.5 had spawned a variety of dialects such as BBN-LISP, MACLISP, and Stanford LISP 1.6.

In 2005 I began a project to archive LISP history  and kept encountering people who’d been involved with LISP 2, including Paul Abrahams, Jeff Barnett, Lowell Hawkinson, Michael Levin, Clark Weissman, Fred Blair, Warren Teitelman, and Danny Bobrow. By 2010 I had been able to scan LISP 2 documents and source code belonging to Barnett, Herbert Stoyan, and Clark Weissman. In 2012, after writing about Hawkinson and others in an extended blog post “Harold V. McIntosh and his students: Lisp escapes MIT,” I decided to try to tell the story of the LISP 2 project, where so many interesting people’s paths had crossed. My sources included original project documents as well as telephone and email interviews with participants, and several participants were kind enough to provide feedback on multiple drafts. I let the article sit in limbo for five years, but last year after I published another anecdote in the Annals, editor Dave Walden encouraged me to submit this one.

On December 28, 2017, as the article was about to go to press, Lowell Hawkinson died suddenly from an accident.

Lowell Hawkinson, 1943 – 2018

Lowell Hawkinson passed away at the age of 74 on December 28, 2017 as a result of an accident. Lowell was a pioneer in LISP implementation and artificial intelligence. He co-founded Gensym Corporation in 1986 and served as its CEO through 2006. This obituary gives more details of his life and accomplishments.

I first got in touch with Lowell in 2010 because of my interest in archiving LISP history. We exchanged emails (and had one phone conversation), and over the years I wrote several blog posts and a journal article about work involving him:

Although my interactions with Lowell were brief, his kindness and modesty were manifest. He will be deeply missed by his family and friends.

Harold V. McIntosh, 1929-2015

Update 5/21/2019: Genaro J. Martínez, Juan C. Seck-Tuoh-Mora, Sergio V. Chapa-Vergara, and Christian Lemaitre recently published a paper “Brief Notes and History [of] Computing in Mexico during 50 years” centered around McIntosh’s accomplishments. arXiv:1905.07527 [cs.GL] DOI

Update 3/31/2019: Here are photos from a November 2017 memorial held for McIntosh at the Faculty of Computer Science of the Institute of Science at Autonomous University of Puebla, Puebla, Mexico.

Update 1/5/2017: For more on McIntosh’s professional career, see these obituaries at Physics Today and Journal of Cellular Automata.

Harold V. McIntosh, 1929-2015Harold V. McIntosh died November 30, 2015 in Puebla, Mexico. He was an American mathematician who became interested in what is now known as computer algebra to solve problems in physics, leading to his early adoption of the programming language LISP and to his design of the languages CONVERT (in collaboration with Adolfo Guzmán) and REC. His early education and employment was in the United States, but he spent the last 50+ years in Mexico, and received a Ph.D. in Quantum Chemistry at the University of Uppsala in 1972.

McIntosh was born in Colorado in 1929, the oldest of four sons of Charles Roy and Lillian (Martin) McIntosh. He attended Brighton High School in Brighton, near Denver. In 1949 he received a Bachelor of Science in physics from the Colorado Agricultural and Mechanical College, and in 1952 he received a Master of Science in mathematics from Cornell University. He did further graduate studies at Cornell and Brandeis, but stopped before receiving a Ph.D. to take a job at the Aberdeen Proving Ground. Two years later, he moved to RIAS (Research Institute for Advanced Studies), a division of the Glenn L. Martin Company. Around 1962 he accepted a position in the Physics and Astronomy department and the Quantum Theory Project at the University of Florida. After two years at the University of Florida, McIntosh accepted an offer at CENAC (Centro Nacional de Calculo, Instituto Politecnico Nacional) in Mexico. Over the next years, McIntosh worked in various positions in Mexico at Instituto Politecnico Nacional, Instituto Nacional de Energía Nuclear, and, from 1975 on, Universidad Autónoma de Puebla.

McIntosh was widely regarded for his research, writing and teaching; for details, see Gerardo Cisneros-S.: “La computación en México y la influencia de H. V. McIntosh en su desarrollo” (PDF). He organized several special summer programs in the early 1960s that introduced a number of students to higher mathematics and computer programming (see here for example). He also had a lifelong interest in flexagons, which he shared with his students. A symposium in his honor was held a month before he died.

Other resources

Harold V. McIntosh: CELLULAR AUTOMATA MISCELLANEA. Web site at cinvestav.mx

1961 Annual report of RIAS. PDF at ubalt.edu

Paul McJones. The First International LISP Conference (1963). Dusty Decks blog, April 23, 2012

Paul McJones. Harold V. McIntosh and his students: Lisp escapes MIT. Dusty Decks blog, July 6, 2012

Paul McJones, editor. History of Lisp : Other Lisp 1.5 implementations : MBLISP. Online at softwarepreservation.org

Celebration of late Prof. Harold V. McIntosh achievements. Faculty of Computer Science of the Institute of Science at Autonomous University of Puebla, Puebla, Mexico, November 29, 2017. Online at uncomp.uwe.ac.uk

Acknowledgements

José Manuel Gómez Soto for notifying me of McIntosh’s death and supplying the link to this obituary; Robert Yates, Lowell Hawkinson, and Adolfo Guzmán Arenas for their contributions to “Harold V. McIntosh and his students: Lisp escapes MIT”; and Genaro Juarez Martinez for informing me about the memorial celebration.

Oral history of Bjarne Stroustrup

Update 5/14/2015: Here is a short video that was made for the Fellow Award Ceremony.

Update 4/9/2015: A video of the interview is now available. It’s searchable via the synchronized transcript.

In February I had the honor of conducting an oral history of Bjarne Stroustrup for the Computer History Museum, on the occasion of his being one of three 2015 Fellow Awards Honorees (the other two being Evelyn Berezin and Charles Bachman).

Programming languages have emerged over the last fifty or so years as one of the most important tools allowing humans to convert computers from theoretical curiosities to the foundation of a new era. By inventing C++ and working tirelessly to evolve, implement, standardize, and propagate it, Bjarne has provided a foundation for software development across the gamut from systems to applications, embedded to desktop to server, commercial to scientific, across CPUs and operating systems.

C was the first systems programming language to successfully abstract the machine model of modern computers. It contained a simple but expressive set of built-in types and structuring methods (structs, arrays, and pointers) allowing efficient access to both the processor and the memory. C++ preserves C’s core model, but adds abstraction mechanisms allowing programmers to maintain efficiency and control while extending the set of types and structures.

While several of the individual ideas in C++ occurred in earlier research or programming languages, Bjarne has synthesized them into an industrial-strength language, making them available to production programmers in an coherent language. These ideas include type safety, abstract data types, inheritance, parametric polymorphism, exception handling, and more.

In addition to its synthesis of earlier paradigms, C++ pioneered a thorough and robust implementation of templates and overloading. This has enabled the field of generic programming to advance from early research to sufficient maturity for inclusion in the C++ standard library in the form of STL. Additional generic libraries for graphs, matrix algebra, image processing, and other areas are available from other sources such as Boost.

By combining efficiency and powerful abstraction mechanisms in a single language, and by achieving ubiquity across machines and operating systems, C++ has replaced a variety of more specialized languages such as C, Ada, Smalltalk, and even Fortran. Programmers need to learn fewer languages; platform providers need to invest in fewer compilers. Even newer languages such as Java and C# are clearly influenced by the design of C++.

C++ has been the major focus of Bjarne’s career, and he has had unprecedented success at incremental development of C++, keeping it stable enough for use by real programmers while gradually evolving the language to serve the broadest possible audience. As he evolved the language, Bjarne took on many additional roles in order to make C++ successful: author (books, papers, articles, lectures, and more), teacher, standardization leader, and marketing person.

Bjarne started working on C with Classes, a C++ precursor, in 1979; the first commercial release of C++ was in 1985; the first standard was in 1998, and a major revision was completed in 2011. C++ was mature enough by 1993 to be included in the second History of Programming Languages conference, and a follow-on paper focusing on standardization appeared in the third HOPL conference in 2007.

I hope you enjoy reading the oral history as much as I did interviewing Bjarne.

See also: C++ Historical Sources Archive, Dusty Decks, 11 June 2007.

Update 1/30/2016: Updated URL for C from http://cm.bell-labs.com/cm/cs/cbook/index.html to https://9p.io/cm/cs/cbook/index.html.

Update 9/10/2024: Updated several more URLs.

Dr. John E. L. Peck, 1918-2013

Dr. John E. L. Peck (1918-2013)
Dr. John E. L. Peck (1918-2013)
Dr. John E. L. Peck, whose work on ALGOL 68 was described in a recent post, passed away on November 6, 2013. His family has provided this obituary:

John, born August 14, 1918 in Pietermaritzburg, South Africa, passed away peacefully with his family by his side on November 6, 2013. He is predeceased by his wife Dornacilla of 61 years, and lovingly remembered by his sons, Edward (Phyllis) and Nigel (Susan); his twin daughters Lenny (George) and Gwenda; his sister Gwenyth; grandchildren Justin (Kristina), Linstead (Randi), Shannon, Tanya and Vernon; great-grandson Isaac; nieces and nephews, Elizabeth, Brian, Richard, Louise, Deborah, Sheryl, Ross, Janene, Randa, Dahl and Fraser; relatives, good friends and colleagues from around the world. John was the first Head of the University of Calgary Mathematics Dept. and founded UBC’s Department of Computer Science – his contributions to computer science were significant internationally. He was a key member of the international community that pioneered the field of Computer Science beginning in the early 60s. He was an avid outdoorsman who enjoyed alpine climbing, skiing and cycle touring. He also had a strong love of music playing pipe organ, piano and classical recorder. He enjoyed a full and rich life and will be greatly missed. A Celebration of his Life will be held Saturday, December 7, 2013 at 10:00am at Victory Memorial Park Funeral Centre, 14831 28th Avenue, Surrey, BC. In lieu of flowers, please consider making a donation to the charity of your choice.

Condolences may be offered at www.victoryfuneralcentre.ca

Harold V. McIntosh and his students: Lisp escapes MIT

In today’s wired world, people will start experimenting with an interesting new programming language shortly after it appears on a hosting service. But things took longer in the early days of Lisp. McCarthy’s famous paper[1] on Lisp was presented at a conference in May 1959 and published in CACM in April 1960, by which time a system with an interpreter and compiler was running on MIT’s IBM 704; the paper notes “A programmer’s manual[2] is being prepared.” Gradually copies of Lisp were requested by other IBM installations (the system was ported to the 709 and then the 7090). Modifications were often required to adapt it to a particular hardware configuration or operating environment and it was several years before Lisp was adapted to other kinds of computers. Without the internet or “social networking”, the propagation of ideas depended even more heavily on people. The physicist Harold V. McIntosh was one of the first to spread Lisp beyond MIT.

Continue reading “Harold V. McIntosh and his students: Lisp escapes MIT”

Remembering Jim Gray

Jim Gray’s professional contributions to the theory and practice of transactions, databases, and scientific applications of large databases, coupled with his teaching, mentoring, and warm friendships made a tremendous impact on the world. When he failed to return from sailing his 40-foot sloop Tenacious around the Farallon Islands on January 28, 2007, it was a devastating blow to family, friends, and colleagues alike. Despite a series of extremely thorough searches by the Coast Guard, by his friends, and by his family, no trace of him or his boat were ever found, which meant he could not be declared legally dead at that time. The ambiguous loss suffered by his wife and family meant his disappearance was especially difficult to recover from. After the legally-mandated five-year waiting period, a court recently granted a petition by his wife Donna Carnes to have Jim declared dead as of January 28, 2012. As Donna indicates in this NY Times interview, the waiting followed by the court order have led to a sense of closure for her.

I recently wrote a summary of Jim’s life and career for the updated ACM Turing Award web site; it includes links to related articles from the 2008 Tribute held for him at U.C. Berkeley and also photographs supplied by Donna.

Jim Gray with former colleagues of the CAL Timesharing project at U.C. Berkeley, Golden Gate Park, April 1974

Here I’ll note a few of my personal memories of working with Jim, who I met at the University of California in the late 1960s, when he was a computer science graduate student, and I was an engineering undergraduate and part-time employee of the campus computer center. Jim served as an informal advisor to me on course work, and he was also my manager for a time on the CAL Timesharing System project. Jim was a knowledgeable, patient and enthusiastic advisor. There were few boundaries between Jim’s professional and social life. I will never forget going walnut picking with Jim, who stood on the roof of his VW bus to reach the walnuts, and then easily repaired the dent in the roof by pushing upward from below.

Franco Putzolu, Jim Gray, and Irv Traiger at IBM San Jose Research, circa 1977

Jim and I worked together again a few years later at IBM San Jose Research (now IBM Almaden). After working with John Backus (whom Jim had introduced me to) on functional programming for about 15 months, I joined Jim on the System R team. By then Jim was well into his work on the transaction abstraction — creating a unified approach to the interrelated problems of concurrency control and crash recovery — which led to his 1998 ACM Turing Award. I took over some of the transaction management code, designed the crash recovery component, and wrote a multiprocess debugger which we used to test and debug the lock manager. As always, Jim was an enthusiastic and generous collaborator; I’m very proud of being a coauthor with him and six of our System R colleagues of the paper “The Recovery Manager of the System R Database Manager”.

I don’t suppose I’ll ever stop encountering subjects causing me to say to myself, “If only I could talk to Jim about this.”

Update 2024/05/08: Updated URL for tribute.

The First International LISP Conference (1963)

If you thought the 1980 LISP Conference was the first Lisp conference, you were wrong. The 1980 conference was organized by Ruth E. Davis and John R. Allen and was held at Stanford University, with sponsorship by Stanford, Santa Clara University, and The LISP Company. It led to the biennial ACM-sponsored Lisp and Functional Programming Conference. But more than 16 years earlier, the First International LISP Conference was held at Universidad Nacional Autónoma de México (UNAM) in Mexico City, from December 30 to January 4, 1964. No proceedings was published for the conference, but I have been able to assemble some information about it.

Continue reading “The First International LISP Conference (1963)”

Edgar Daylight on Dijkstra

The latest addition to the “Papers on the history of ALGOL” section of the History of ALGOL web site is this paper about Dijkstra’s involvement in proposing and implementing the recursive procedure as an ALGOL 60 language construct:

  • Edgar G. Daylight. Dijkstra’s Rallying Cry for Generalization: The Advent of the Recursive Procedure, Late 1950s–Early 1960s.

In a section on Future Work near the end of the paper, Daylight notes, “Research contributions of Gödel, Carnap, Turing and Tarski have been studied and documented over and over again by logicians and philosophers themselves. Computer scientists, by contrast, have yet to commence with similar work concerning the ideas of their fathers: Dijkstra, McCarthy, Hoare and others. This, in turn, explains my motivation to write this paper.” Daylight, who is a post-doctorate researcher in the history of computing, has set up the blog-style web site Dijkstra’s Rallying Cry for Generalization as a way to report on his ongoing research into Dijkstra’s writings, including the E. W. Dijkstra Archive at the University of Texas and additional materials Dijkstra’s family donated. Daylight is off to a good start. He welcomes suggestions for improving his blog, and notes he’ll be adding photographs of Dijkstra soon.

In that spirit, I offer the following photograph, taken at the 1973 Marktoberdorf Summer School, of instructor Dijkstra and student McJones. Dijkstra’s subsequent trip report (EWD385) mentions my friend Dave Redell (who took the photograph) and me because we served as “intelligent terminals” in an “interactive programming session”.

E. W. Dijkstra and Paul McJones at Marktoberdorf Summer School, 1973

Don Chamberlin and the origin of SQL

Tonight Don Chamberlin will receive a 2009 Fellow Award of the Computer History Museum “for his fundamental work on structured query language (SQL) and database architectures”. The other awardees for 2009 are Robert R. Everett (M.I.T. Whirlwind and SAGE) and Federico Faggin, Marcian (Ted) Hoff, Stanley Mazor and Masatoshi Shima (Intel 4004).

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:

Update 2018/04/21: updated URL at Charles Babbage Institute.

Update 2023/02/28: updated URLs for 2009 CHM Fellow Awards and SRC-TN-1997-18

Update 2024/05/08: updated URL for SRC-TN-1997-18 again.

Bob Taylor recognized by The University of Texas

Last month, Bob Taylor (the subject of a recent oral history) was recognized by The University of Texas. Bob received the Graduate School Outstanding Alumnus Award, a $100,000 Presidential Endowed Fellowship was established in his name, and he gave the first in a series of lectures in the UT Graduate School’s Centential celebration. Since this is also the 40th anniversary of the first tests of the ARPAnet, it was a fitting time for Bob’s achievements to be honored.

The lecture was in the form of an interview by New York Times technology reporter John Markoff, who noted:

The Internet has many fathers, but few deserve the label more than Robert W. Taylor.

Authors M. Mitchell Waldrop (The Dream Machine) and Michael A. Hiltzik (Dealers of Lightning: Xerox PARC and the Dawn of the Computer Age) shared their views as well. J Strother Moore and Gary Chapman (who each worked with Bob in the past and now have UT positions) served as masters of ceremony.

The announcement for the lecture includes links to news stories about Bob, as well as the famous 1968 paper by Licklider and Taylor, “The Computer as a Communication Device“. The recap of the lecture includes links to a video and photographs.

Update 2024/05/08: Updated URLs via the Internet Archive Wayback Machine; the video and photographs appear to be lost.