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 programminghttps://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/ .

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 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. http://webhome.cs.uvic.ca/~vanemden/Publications/FOPLasHLPL.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/

GTL is a LISP 2 implementation

A few months after my article “The LISP 2 Project” was published, I learned from Paul Kimpel that the language GTL includes a “non-standard” version of LISP 2. GTL stands for Georgia Tech Language. It is an extension of the Burroughs B 5500 Algol language, and its implementation extends the Burroughs Algol compiler. There is a new data type, SYMBOL, whose value can be an atomic symbol, a number, or a dotted pair. There is a garbage collector, and a way to save and restore memory using the file system. GTL was designed by Martin Alexander at the Georgia Institute of Technology between 1968 and 1969. The source code is available as part of the Burroughs CUBE library, version 13, and the manual is available via bitsavers.org; see here for details.

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-LISPMACLISP, 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 BarnettHerbert 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.

Miscellaneous Lisp updates

Recently I made some long-delayed updates to History of LISP.  In the Lisp I/1.5 for IBM 704, 709, 7090 section, I added links to the excellent work by Andru Livisi (here) and Dave Pitts (here) for running LISP on emulators.

In the Other Lisp 1.5 implementations, I added a mention of LISP 1.5 for IBM M44. The M44 was an experimental machine that served as a testbed for some of the earliest virtual machine research.

In the Other Lisps section I added Lisp 1.6 for IBM 1130 (Boston Latin School), which was the first Lisp of Guy L. Steele Jr., who went on to work on MacLispSchemeNILCommon Lisp, and Connection Machine Lisp.  I also added PDP-11 LISP (Massachusetts Institute of Technology), which was the first Lisp of Richard M. Stallman, who went on to work on MacLispLisp Machine Lisp, and Emacs Lisp.

In the Embedded Lisps section I added XLISP.

I made various additions in other sections including Scheme and Common Lisp.

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.

L. Peter Deutsch’s PIVOT program verification system

L. Peter Deutsch in his office at Xerox PARC, around 1972.PIVOT, the program verification system written in BBN-Lisp by L. Peter Deutsch and described in his PhD thesis, “An interactive program verifier” is a recent addition to the Software Preservation Group web site.

Deutsch is a computer scientist who made important contributions to interactive implementations of Lisp and Smalltalk. While he was in high school, he implemented the first interactive Lisp interpreter, running on a DEC PDP-1 computer. While still in high school, he worked with Calvin Mooers on the design of TRAC, and implemented the language on a PDP-1 at BBN. Then Deutsch enrolled at the University of California at Berkeley, where he soon joined Project Genie, one of the earliest timesharing systems. Meanwhile, at BBN, Deutsch’s original PDP-1 Lisp became the “conceptual predecessor” of BBN-Lisp, running first on the PDP-1, then the SDS-940 (running the Project Genie timesharing system), and finally the PDP-10 running BBN’s own TENEX. After several of the BBN-Lisp creators, including Deutsch, moved to Xerox PARC, BBN-Lisp became INTERLISP. By this time, Deutsch had received his bachelor’s degree at Berkeley, and with other Project Genie alumni had co-founded Berkeley Computer Corporation, which built a large timeshared computer (the BCC-500) but then went bankrupt. While working at PARC, Deutsch also attended graduate school at Berkeley, carrying out the research on program verification that produced the PIVOT system.

Deutsch was kind enough to donate his only source listing of PIVOT to the Computer History Museum (Lot number X7485.2015), and to allow scans of the listing and his thesis to be posted on the SPG web site.

50th Anniversary of LISP 1.5 Programmer’s Manual

Cover of LISP 1.5 Programmer's Manual
I just noticed that August 17 was the 50th anniversary of the LISP 1.5 Programmer’s Manual by John McCarthy, Paul W. Abrahams, Daniel J. Edwards, Timothy P. Hart, and Michael I. Levin. On that day in 1962 it was published as a bound report of the Computation Center and Research Laboratory of Electronics of the Massachusetts Institute of Technology. It was also published by MIT Press — perhaps simultaneously — and is still in print. A second edition was released in 1965; the only difference that I see comparing tables of contents is the addition of Appendix I: LISP for SHARE distribution.

This was of course the first book on LISP. It is a reference manual rather than a textbook, but many people managed to learn LISP from it, and a number of people managed to implement LISP from it. Today ACM’s Digital Library lists 327 citations for it, and Google lists about 23,900 hits. I’m pleased to say that #1 on Google is the authorized PDF at my History of LISP archive at the Computer History Museum.

Through the generosity of several people, the History of LISP archive includes not only the book but also several versions of the underlying source code:

If you’re resourceful and you’d like to actually run the system described in this book, you don’t need an IBM 7090 or a time machine; the SIMH simulator package and the files and information here are sufficient; scroll down until you find “Running Lisp 1.5 in the SIMH IBM 7094 emulator.”

Update 2024/05/08: Updated link to http://www.sonoma.edu/users/l/luvisi/.

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”

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

Herbert Stoyan Collection finding aid and catalog online at CHM

In July 2010 I wrote about the collection of Lisp and artificial intelligence documents that Herbert Stoyan donated to the Computer History Museum. Today I’m glad to be able to announce that the finding aid is online at CHM and the Online Archive of California. Additionally, more detailed descriptions about the items in the collection has been added to CHM’s online catalog, which can be searched here. (For example, try searching for MACLISP.) I’ve added scanned copies of many items from the collection to the History of LISP web site (which is also hosted by the CHM). I’m open to suggestions for scanning additional items from this collection. Also, if you have historical Lisp items that are not in the Stoyan collection, please consider donating them to CHM.

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

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

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

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

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

Update 2024/05/08: Updated various URLs.

LISP historical archive web site reorganized

The History of LISP web site launched back in 2005 as a single web page running some 40 pages when printed; it covered many of the best known Lisp implementations. Over the years, the web site approximately doubled in size, leading several people to politely suggest breaking it up into smaller units. I’ve finally taken the time to do that. The organization roughly follows that used by Steele and Gabriel in their 1992 HOPL II talk, and I’m still making minor adjustments. It would be nice if a web site dedicated to historical archives would have stable URLs, but I think the new organization will be appreciated by people mostly interested in one or two specific implementations. I have not changed the URL of any “content” (PDF or archive file).

Thanks again to the many people down through the years who have patiently answered my questions, supplied copies of source code and documents, and allowed me to post copies.

Update 2024/05/08: Updated the URL for Steele’s and Gabriel’s HOPL II slides.

SDC: Q-32 Lisp, Lisp 2, and three more; Lisp 1.5 Primer

Lisp’s birth and infancy was at MIT, but it began spreading to other places when John McCarthy went to Stanford and other project members graduated and moved on. At about this time, a project began to develop a new language, Lisp 2, that would extend Lisp to include ALGOL-like syntax, type-checking, and numeric, string, and array data types. The project was a joint development of two “think tanks”, Information International, Inc. (III) System Development Corporation (SDC) in Santa Monica, California.

The host computer for the Lisp 2 project was the AN/FSQ-32/V, a one-of-a-kind prototype built by IBM for the Air Force as a potential replacements for the SAGE AN/FSQ-7. Before the Lisp 2 project began, an innovative compiler-only implementation of Lisp 1.5 on the Q-32 was done by Robert Saunders and his colleagues.

Through the kindness of Jeff Barnett, who was one of central contributors at SDC, the History of LISP web site now includes scanned copies of the Lisp 2 source code (with annotations by Jeff) and a number of documents, including the complete TM-3417 series documenting a planned (but not completed) port to the IBM System/360. A few other early memos were previously available online as MIT Project Mac memos. Additional memos will be soon be available via the Stoyan collection.

After the Lisp 2 project was terminated, the Q-32 at SDC was replaced with an IBM System/360. The researchers still wanted to use Lisp, so Jeff Barnett and Bob Long implemented a Lisp 1.5 for the System/360. Again, Jeff loaned a copy of the original manual and also wrote new notes.

Speech understanding was a major research area for many people at SDC, including Jeff. As building blocks for the speech research, he worked on two more Lisp or Lisp-like systems:

  1. A small Lisp for the Raytheon 704 used for speech capture and low-level processing.
  2. The Crisp Lisp 2-like system for the IBM System/370.

Jeff has provided modern notes for both, and for Crisp both the original documentation as well as slides from a recent talk he gave.

Finally, another offshoot of the Lisp 2 project is the book LISP 1.5 Primer by Clark Weissman. It began as a tutorial to help SDC researchers learn Lisp, and in 1967 was published as a book by Dickenson Publishing Company, Inc., of Belmont, California. The book has long been out of print and the copyright reverted to Clark; he has given his permission for a PDF of the book to be posted on the History of LISP web site.

Update 200/11/26: Updated URLs to reflect reorganization of http://www.softwarepreservation.org/projects/LISP/.

Update 2024/05/08: Corrected some URLs to match History of LISP reorganization.

Herbert Stoyan’s Lisp collection at CHM

Last winter Herbert Stoyan very generously donated to the Computer History Museum the extensive collection of Lisp and AI materials he assembled in the course of his extensive study of Lisp and its history: manuals, technical reports, papers, books, listings, magnetic media, and even two Scheme chips.

Stoyan has been involved with Lisp for four decades. In the early 1970s he implemented Lisp using only Berkeley and Bobrow as a reference, and this system became the basis for all artificial intelligence work in his native East Germany. In the late 1970s he became interested in the history of Lisp, and published the book LISP – Anwendungsgebiete, Grundbegriffe, Geschichte (Akademie-Verlag, Berlin, 1980) about Lisp and its history. In 1981 he emigrated to West Germany and began a career as a university professor; by 1990 he became Professor of Artificial Intelligence of the Friedrich-Alexander-Universität Erlangen-Nürnberg. He also wrote the two-volume Programmiermethoden der Künstlichen Intelligenz (Springer, 1988) about artificial intelligence programming. (For more details, see his speaker biography from the 2007 International Lisp Conference.)

In addition to his first book, Stoyan has published a number of papers on the early history of Lisp, including:

The Herbert Stoyan Collection on LISP Programming (Lot X5687.2010) is quite large (105 linear feet, 160 boxes), and the Museum is currently in the throws of construction for the major new exhibit Revolution: The First 2000 Years of Computing. But through the combined efforts of staff and volunteers, the collection will be organized and made accessible, with portions scanned and available online. To get a taste of the depth and breadth of the collection, see Stoyan’s LISP Bibliography and searchable LISP-Museum. [Update 2015/01/10: the searchable version is no longer available.]

The arrival of this collection at CHM fulfills a dream that began for me in 2005 as I began work on History of LISP and first contacted Herbert Stoyan to timidly suggest he might contribute scans of selected items from his collection to CHM. His response — that he would be retiring in 3 years and needed to think about a permanent home for his collection — encouraged me to think that CHM might be the recipient. To get here from there, many people played important roles. At the risk of forgetting someone, I would like to thank Alex Bochannek, Grady Booch, Elizabeth Borchardt, Richard Gabriel, William Harnack, John Hollar, Paul Jabloner, Al Kossow, Karen Kroslowitz, Sara Lott, Bernard Peuto, Len Shustek, Dag Spicer, Herbert Stoyan, Kirsten Tashev, and JonL White. In addition, CHM volunteers John Dobyns and Randall Neff have labored to survey, pack, and catalog portions of the collection. (Additional volunteers would be welcome!) [Update 2015/01/10: Cataloging of the collection was completed in 2011.]

Update 2015/01/10: Stale links to Stoyan’s web sites replaced with Internet Archive Wayback Machine versions. Added link to finding aid for the Stoyan collection.

Lisp’s 50th Birthday Celebration

A celebration of the 50th anniversary of Lisp is taking place in October at OOPSLA 2008. John McCarthy will give a talk about the early history of Lisp. Also Guy Steele and Richard Gabriel will repeat their 1992 HOPL-II talk about the Evolution of Lisp.

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 6 (2024/05/08): Updated URLs for the HOPL II slides and paper.

Update 5 (2012/7/10): I updated the URLs for www.lisp50.org to use www.archive.org since the domain name seems to fallen into the hands of Japanese search engine optimizers, and I updated the hyperlink for JonL White because his ACM Author page now gives a 404 error.

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.

VLISP documents; LISP Bulletin #2 and #3

Jérôme Chailloux recently told me about the wonderful ArtInfo-MusInfo web site, which contains a variety of documents produced by a group of “painters, musicians, psychologists, pedagogues, linguists, mathematicians, poets, architects and computer scientists gathered within the Computer Science Department of the University of Vincennes” during the period 1969-1980. Although there are many fascinating documents, I was especially interested in two collections:

  • VLISP manuals and papers, including dissertations by Patrick Greussay and Jérôme Chailloux. VLISP was the precursor of Le_Lisp, and served as a testbed for some of the implementation techniques of Le_Lisp.
  • LISP Bulletin #2 and #3, edited by Patrick Greussay & Joachim Laubsch. Danny Bobrow launched the LISP Bulletin with a first issue published in the September 1969 issue of SIGPLAN Notices, but no issues followed until Greussay and Laubsch took over.

I’ve updated the VLISP and LISP Bulletin sections of the CHM LISP web site with links to these documents.

Updated 11/26/2010: Updated URLs to reflect reorganization of http://www.softwarepreservation.org/projects/LISP/.

The Revised MacLisp Manual goes online

MIT’s MacLisp played a key role in Lisp history, but its documentation often lagged the system as developers concentrated on adding features and improving performance. Around the time that Lisp machine development eclipsed PDP-10 MacLisp, this final MacLisp document was published:

  • Kent M. Pitman. The Revised MacLisp Manual. “Saturday Morning Edition”, M.I.T. Laboratory for Computer Science Technical Report MIT-LCS-TR-295, June 1, 1983.

This has been out of print for many years, but Kent just made available an updated, hypertext “Sunday Morning Edition”.

If you are interested in more MacLisp history, including earlier manuals, source code, and more, see the MacLisp family of the Lisp website at the Computer History Museum.

Update 1/1/2016: Corrected URL for MacLisp family.