In the Spring of 2025, I taught a University course titled Interactive Programming Environments. It was intended to introduce students to the style of programming encouraged by languages such as Lisp, Smalltalk, and Forth, where one does development from within the program itself, modifying it as it is running in an iterative movement toward a complete solution. I think it was moderately successful in achieving its goals, although if I taught it again, there are certainly things I would do differently. I do think that the students who took it learned a lot about technologies with which they were previously unfamiliar.

I am writing something about this course here on Lost Bits today for two reasons:

1. The course materials involved a deep dive into computing history on several different topics, and
2. Federal regulations in the United States have caused my University to dictate that I remove the course slides from my University-hosted web page.

Let’s talk about point 2 for just a moment. In 2024, the Biden administration changed the regulation interpreting the Americans for Disabilities Act in a way that levies specific requirements on "[public entities] with a total population of 50,000 or more" starting in 2026. This course was taught at the University at Buffalo, which has a student population of nearly 32,000 as of the time of this writing, and the University has declared that we must achieve compliance with this regulation by April of 2026. This regulation, while well-meaning and intended to enable vision- and reading-impaired users to access content without having to make special requests, requires that all web content provided by the institution meets certain technical guidelines which were not previously required, including specific PDF tags and document structure, with no exception for historical content. My PDF slides do not have the requisite tags, and I have determined that the time required to rebuild them to include those tags is large enough that I cannot afford it. Therefore, I am choosing to take those slides down on my University web page but republish them here so that the information continues to remain available.

The real meat here is point 1, however! In the execution of this course, I asked students to become familiar with Lisp via the Medley Interlisp Project, Smalltalk via the Squeak project, and Forth using Gforth. Because simply looking at the language of implementation does not necessarily communicate the culture or development style of the language, these introductions were divided into two parts: an overview of the programming language, its syntax, and semantics; and a historical dive into the development of the language and how it was used. Those historical dives were fun for me to put together, I believe they were interesting to the students, and importantly I believe they may be interesting to those who follow Lost Bits.

The Materials

Here are the course materials that I used for the course; this does not include the entire course, but it includes the historical aspects. In particular, the assignments and academic structure are not preserved here, and the language syntax and semantics overviews (which were live-coding presentations) are missing.

Unfortunately, in this format, the presentation itself and the discussions around the language are lost. Most of these presentations lasted for between one and two hours of in-class time.

These materials are branded as course materials from the University at Buffalo, where I taught this class, but they are authored entirely by me and are my intellectual property. I am releasing them here under the Creative Commons BY-SA license, the same as most information on this site. The slides are unchanged from their in-class usage, and require my written permission for redistribution; please feel free to cite this page as that written permission if you choose to use them.

The reference collection of each lecture is likely one of its more interesting points. I have endeavored to pull together some of the most critical references for each of these topics. In several cases I was helped tremendously by excellent publications from the SIGPLAN History of Programming Languages (HOPL) series of conferences. These conferences have hosted some truly valuable retrospectives on the development of languages that have defined computing today.

Lisp: Background and History

Slides: lisp-history.pdf

These slides walk through the early history of Lisp at MIT, then branch out into the later interactive flavors that ultimately led to Medley Interlisp (through BBN Lisp), Common Lisp (through Lisp Machine Lisps), and Emacs Lisp.

Smalltalk: Background and History

Slides: smalltalk-history.pdf

Much like the Lisp slides, these discuss the early history of Smalltalk and then follow it through to modern implementations, particularly including Squeak. There is some discussion of the Xerox Alto, Logo, and other related technologies on the way by.

Forth: Background and History

Slides: forth-history.pdf

Here we go again, but for Forth! These slide start with Chuck Moore’s personal development of Forth and bring it up through becoming an interactive tool, the creation of FIG Forth, and then modern Forth deployments.

Emacs: The Last(?) Great(?) Lisp Machine

Slides: emacs.pdf

The focus of this presentation is mostly on the history of Emacs (from TECO through Multics Emacs to Gosling and then GNU and Lucid/XEmacs), but there is some discussion at the end about elisp and its relation to Scheme and Common Lisp.

Conclusion

Maybe some day I will re-record these lectures to provide some of the additional context and discussion that was available at their initial presentation. Unfortunately (for this case), those lectures were not recorded. In the meantime, I hope that these slides and their references (which are, as previously mentioned, some of their finest work!) may be of interest to those who follow the history of computing.