From 974e24fbf761d8f83ca8d2ce20b10d28cab323a4 Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Wed, 28 Oct 2026 19:55:19 -0400 Subject: [PATCH 01/10] Update the timeline. Where possible replace references to documents with references to the item in the Interlisp Bibliography. Several items mentioned are currently missing from the Bibliography. When added we'll continue to update. --- content/en/history/timeline/_index.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/content/en/history/timeline/_index.md b/content/en/history/timeline/_index.md index 51946eac2..22acbeb13 100644 --- a/content/en/history/timeline/_index.md +++ b/content/en/history/timeline/_index.md @@ -6,7 +6,7 @@ aliases: - /medley/history/timeline/ --- -This timeline started with Teitelman’s [History of Interlisp](/documentation/History_of_Interlisp.pdf). The [Bibliography](/bibliography/) has a wealth of additional historical information. +This timeline started with Teitelman’s [History of Interlisp](/history/bibliography/DVGRZ62H/). The [Bibliography](/bibliography/) has a wealth of additional historical information. ## 1960s @@ -32,7 +32,7 @@ In 1965, there were very few tools for developing Lisp programs, and those that ### 1966 -- MIT EE Dept PDP-36 [LISP manual](http://bitsavers.org/pdf/mit/rle_pdp1/memos/pdp36_lisp_may66.pdf) +- MIT EE Dept PDP-36 [LISP manual](/history/bibliography/6M8ISEUL/) Teitelman started at Bolt, Beranek and Newman in Cambridge. At the time, BBN’s computer was a DEC PDP-1, and Daniel Murphy had written a version of Lisp 1.5 for it using ideas from Deutch’s work. This Lisp was really just a toy – single user, slow, small address space, but Teitelman started with Break and Prettyprint from MIT on his pursuit of a Lisp programming environment. @@ -42,11 +42,11 @@ Teitelman started at Bolt, Beranek and Newman in Cambridge. At the time, BBN’s In 1967, BBN purchased an SDS 940 computer from Scientific Data Systems and began work building a time-sharing system on it. The SDS 940 had a larger address space and the ability to support a paging system. BBN was awarded an ARPA contract to provide a LISP system that could be distributed to other ARPA sites for doing A.I. research. (ARPA = Advanced Research Projects Administration of the Department of Defense.) -- [Improvements to the 940 LISP Library](http://www.bitsavers.org/pdf/sds/9xx/940/ucbProjectGenie/940_LISP_Memo_2_Apr67.pdf) +- [Improvements to the 940 LISP Library](/history/bibliography/6M8ISEUL/) Advising was a means of allowing the user to treat a particular function as a black box without knowing what was inside the box, wrap “advice” around it that could operate before the function ran, potentially changing its input parameters, after it ran, possibly changing its value, or { PrettyPrint which printed out a nicely formatted representation of Lisp programs, using indentation to indicate depth of structure. A Trace facility was also available which modified specified functions to print on the terminal their input parameters on entry and their value on exit. You could think of this as a special case of Advising. There was also a Break package which enabled the user to cause program execution to halt at the entry point to specific functions. The user could then examine the value of the function’s input parameters, and even change them, then cause the function to run, and again gain control so as to examine the value that the function returned or side effects of the function’s operation. The user could change input parameters and re-execute the function, or manually specify the desired value and have it be returned to the caller as though it had been the value produced by that function. -Teitelman memo to [SDS 940 LISP Users](http://www.bitsavers.org/pdf/sds/9xx/940/ucbProjectGenie/940_LISP_Memo_2_Apr67.pdf). +Teitelman memo to [SDS 940 LISP Users](/history/bibliography/6M8ISEUL/). ### 1968 @@ -98,7 +98,7 @@ Around the ARPAnet, Interlisp continued to use the DEC PDP-10 as its principal p ### 1973 -- "[Interlisp Reference Manual, Acknowledgements and Background](http://bitsavers.trailing-edge.com/pdf/xerox/interlisp/Interlisp_Reference_Manual_1974.pdf)" (PDF). 1973. +- "[Interlisp Reference Manual, Acknowledgements and Background](/history/bibliography/SYGUERKE/)" (PDF). 1973. ### 1974 @@ -128,7 +128,7 @@ In 1979, PARC began the design of the Dorado, a high performance personal workst ## 1980s -- Teitelman & Masinter, IEEE Computer, “[The Interlisp Programming Environment](https://larrymasinter.net/interlisp-ieee.pdf)” April 1981. +- Teitelman & Masinter, IEEE Computer, “[The Interlisp Programming Environment](/history/bibliography/7T3AV4PM/)” April 1981. - [1983 Stanford University Medical Experiment Computer](https://github.com/Interlisp/history/tree/master/1980s/1983-sumex-lisp) ### 1982 From 1a4d78a1a100385b4b0b41e241a55b0ee15dfa31 Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Thu, 29 Oct 2026 07:45:21 -0400 Subject: [PATCH 02/10] Start updating timeline with glossary links. First step, update glossary to allow linking to individual items. --- content/en/history/glossary/_index.md | 84 +++++++++++++-------------- content/en/history/timeline/_index.md | 2 + 2 files changed, 44 insertions(+), 42 deletions(-) diff --git a/content/en/history/glossary/_index.md b/content/en/history/glossary/_index.md index d88c0ae84..b1fc5e045 100644 --- a/content/en/history/glossary/_index.md +++ b/content/en/history/glossary/_index.md @@ -13,76 +13,76 @@ For general computer terminology and lore see [The Hacker's Dictionary](https:// ## Vocabulary and relationships -AltoLisp +AltoLisp : An experimental microcoded implementation of Interlisp on an Alto personal computer. -Break package +Break package : The Interlisp subsystem that comprises the debugger (also known as break window) and other debugging facilities. Named after the `BREAK` function and breakpoints. -Briefing Blurb +Briefing Blurb : One of the several documents that introduced Xerox PARC newcomers to the computing and network environment of the Computer Science Laboratory. Written in an upbeat style, their titles followed a pattern that included the expression "Briefing Blurb" such as *The Alto-Dolphin-Dorado Briefing Blurb: Exploring the Ethernet with Mouse and Keyboard* and *The Briefing Blurb: Exploring the Ethernet with Mouse and Keyboard*. -Carol, Fugue, Harmony, Intermezzo, Koto, Lyric, Medley +Carol, Fugue, Harmony, Intermezzo, Koto, Lyric, Medley : Named releases of Interlisp-D. All are obsolete except Medley. -Common Lisp +Common Lisp : The subject of a 10-year standards process to converge multiple dialects of the Lisp language. Strong influences from many Lisp dialects, including Interlisp. -Common Lisp the Language +Common Lisp the Language : Book by Guy Steele with two editions: - CLtL1 – edition 1, 465 pages - CLtL2 – second edition, 1029 pages -Common Lisp dpANS +Common Lisp dpANS : The ANSI Standard for Common Lisp. Starting with the Lyric release of Interlisp-D and then the Medley release, the implementation of Medley included implementations of Common Lisp (CLtL 1) as well as the Interlisp dialect in a single development environment; this was made possible by using the (Common Lisp) “package” feature to allow both dialects to be intermixed. -Dfasl +Dfasl : A compiled form of Medley Interlisp files with the extension ".dfasl". -Display +Display : Denotes a program or system with a Graphical User Interface or a full screen character interface, as opposed to a line oriented interface like a teletype. In expressions like "display oriented editor" or "display editor". -DLISP +DLISP : By Warren Teitelman: a first attempt at building a “Display” (GUI) with Interlisp running on MAXC (a PDP-10 clone) connected by Ethernet to a Xerox Alto acting as a graphics terminal. -Dorado Lisp +Dorado Lisp : The reimplementation of the AltoLisp microcode on the Dorado – a research prototype. -Fugue +Fugue : An obsolete named release of Interlisp-D. -Harmony +Harmony : An obsolete named release of Interlisp-D. -Intermezzo +Intermezzo : An obsolete named release of Interlisp-D. -Interlisp +Interlisp : A GitHub “organization” with ~20 repositories, see : Both a language and, in some cases, the implementation of that language. Usually used with some other wording or refinement. -Interlisp: The Language and its usage +Interlisp: The Language and its usage : A book by Steve Kaisler which describes Interlisp of the 1970s & 80s. -Interlisp.org +Interlisp.org : The project's Internet domain name, used for its websites and email addresses. - – the address of the main web site - – the address of a service that lets you run Medley - - the project's general information email address -Interlisp-10 +Interlisp-10 : The first implementation of Interlisp for the Digital Equipment Corporation (DEC) PDP-10 / Tenex. -Interlisp-360 +Interlisp-360 : Implemention of Interlisp for the IBM-360. -Interlisp-D +Interlisp-D : What Dorado Lisp became. The D stood for both “Display” and “D-machine”. An implementation of - Interlisp the language @@ -94,80 +94,80 @@ Interlisp-D personal workstation. Each D-machine had its own microcode with different configurations and micro-instructions. -Interlisp-VAX +Interlisp-VAX : Implementation of Interlisp for Digital Equipment Corporation VAX systems. -Koto +Koto : An obsolete named release of Interlisp-D. -Lcom +Lcom : Used as a file ending, xxx.lcom, for compiled Medley files. -Lyric +Lyric : An obsolete named release of Interlisp-D. -Medley +Medley : The final named release of Interlisp-D. -Medley 1.0, Medley 2.01, Medley 3.5 numbered releases of Interlisp-D +Medley 1.0, Medley 2.01, Medley 3.5 numbered releases of Interlisp-D : At some point the name Interlisp-D was retired and Medley used to name the software. -Maiko +Maiko : An implementation of the functions of the D-machine microcode, but written in C for the Sun Microsystems SPARC processor workstation, initially developed by Fuji Xerox. Subsequently ported to little-endian processors and other operating systems. -Package +Package : The term Package has several different meanings depending on the context: - Informally, a collection of utilities or submodule in Interlisp (the "break package", q.v.; the "file package", a facility for managing code changes; the "record package", a record data type; and so on) - A feature of Commmon Lisp symbol support; the package system allows the combining of Interlisp symbols (written with `IL:` prefix) and Common Lisp symbols (written with a `LISP:` prefix). -SDL +SDL : Structured Design Language. -Sysout +Sysout : A file containing the saved state of Interlisp virtual memory. -X11 +X11 : The X Window System. ### Organizations -BBN +BBN : [Bolt, Beranek, and Newman](https://en.wikipedia.org/wiki/Raytheon_BBN), a Cambridge, Mass. consulting firm which sponsored the creation of BBN Lisp, Interlisp's immediate ancestor, as well as the Tenex operating system. -Xerox PARC or just PARC +Xerox PARC or just PARC : Palo Alto Research Center, which continued in collaboration with BBN on (renamed) Interlisp. PARC developed the Alto and Dorado. Now part of SRI International. -SRI International +SRI International : A non-profit scientific R & D institute, headquertered in Menlo Park, California. -Xerox Electro-Optical Systems (XEOS) +Xerox Electro-Optical Systems (XEOS) : A former Xerox division supporting government customers. -Xerox Artificial Intelligence Systems (XAIS) +Xerox Artificial Intelligence Systems (XAIS) : The former Xerox division working to commercialize Xerox workstations running Interlisp-D. -Rank Xerox +Rank Xerox : Xerox's European subsidiary, a joint venture of Xerox Corp. and the Rank Organization, which sold Interlisp-D workstations in Europe. -Fuji Xerox +Fuji Xerox : Xerox's Japanese subsidiary, owned jointly by Rank Xerox and Fujifilm Corp., responsible for selling and supporting Interlisp-D systems in Japan. -Envos +Envos : Company founded in 198x to take on the Lisp business from Xerox. Closed within 10 months and folded back into Xerox. -Venue +Venue : Company founded by John Sybalsky, former Xerox and Envos employee, which obtained a license to create and distribute derivative works of Maiko and Medley. -Medley Interlisp Project +Medley Interlisp Project : Began late 2010’s with Nick Briggs getting Maiko to run on macOS. The group expanded and began holding weekly online meetings in 2020. Subsequently ported Maiko (and therefore Medley) to Linux, Windows, and other operating system. Maintains a mailing list for developers and interested users, sponsors the maintenance of an exhaustive bibliography and the very website where you're reading this. -InterlispOrg +InterlispOrg : A [California-registered](https://rct.doj.ca.gov/Verification/Web/Details.aspx?result=c7aa8cb2-16ec-458a-be56-41f963365258) non-profit organization (DBA Interlisp.org) Established August 2021. 501c3 EIN 87-2528093 California registered charity CT0278267. The Board of Directors consists of Larry Masinter, President; Ron Kaplan, Treasurer; and Herb Jellinek, Secretary. diff --git a/content/en/history/timeline/_index.md b/content/en/history/timeline/_index.md index 51946eac2..5e5e0216d 100644 --- a/content/en/history/timeline/_index.md +++ b/content/en/history/timeline/_index.md @@ -8,6 +8,8 @@ aliases: This timeline started with Teitelman’s [History of Interlisp](/documentation/History_of_Interlisp.pdf). The [Bibliography](/bibliography/) has a wealth of additional historical information. +Terms linked to the [Glossary](/history/glossary/) are defined there. + ## 1960s Through the 1960s, the languages of programming were primarily Fortran and assembly. Lisp enabled expressing recursion simply. Lisp also provided the ability to modify a program as it was running, since Lisp programs were themselves data—the same as other list structures used to represent program data. This made Lisp an ideal language for writing programs that themselves constructed programs or proved things about programs. As an area of Artificial Intelligence, programs writing programs was something of great interest to those working on applying AI to programming. From cd605732488712fa1db4b2c6472aeb8b6f9b76fa Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Thu, 29 Oct 2026 23:47:44 -0400 Subject: [PATCH 03/10] First set of updates to timeline, linking in glossary items. These updates map in the terms that are defined and the usage is the same between the two. --- content/en/history/glossary/_index.md | 2 +- content/en/history/timeline/_index.md | 28 +++++++++++++-------------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/content/en/history/glossary/_index.md b/content/en/history/glossary/_index.md index b1fc5e045..3272a0394 100644 --- a/content/en/history/glossary/_index.md +++ b/content/en/history/glossary/_index.md @@ -63,8 +63,8 @@ as a graphics terminal. : An obsolete named release of Interlisp-D. Interlisp -: A GitHub “organization” with ~20 repositories, see : Both a language and, in some cases, the implementation of that language. Usually used with some other wording or refinement. +: A GitHub “organization” with ~20 repositories, see Interlisp: The Language and its usage : A book by Steve Kaisler which describes Interlisp of the 1970s & 80s. diff --git a/content/en/history/timeline/_index.md b/content/en/history/timeline/_index.md index 5e5e0216d..392760dbb 100644 --- a/content/en/history/timeline/_index.md +++ b/content/en/history/timeline/_index.md @@ -36,7 +36,7 @@ In 1965, there were very few tools for developing Lisp programs, and those that - MIT EE Dept PDP-36 [LISP manual](http://bitsavers.org/pdf/mit/rle_pdp1/memos/pdp36_lisp_may66.pdf) -Teitelman started at Bolt, Beranek and Newman in Cambridge. At the time, BBN’s computer was a DEC PDP-1, and Daniel Murphy had written a version of Lisp 1.5 for it using ideas from Deutch’s work. This Lisp was really just a toy – single user, slow, small address space, but Teitelman started with Break and Prettyprint from MIT on his pursuit of a Lisp programming environment. +Teitelman started at Bolt, Beranek and Newman in Cambridge. At the time, [BBN](/history/glossary/#bbn)’s computer was a DEC PDP-1, and Daniel Murphy had written a version of Lisp 1.5 for it using ideas from Deutch’s work. This Lisp was really just a toy – single user, slow, small address space, but Teitelman started with Break and Prettyprint from MIT on his pursuit of a Lisp programming environment. - http://www.softwarepreservation.org/projects/LISP/bbnlisp/BBN-LISP-System_Feb1966.pdf#page=49 @@ -46,7 +46,7 @@ In 1967, BBN purchased an SDS 940 computer from Scientific Data Systems and bega - [Improvements to the 940 LISP Library](http://www.bitsavers.org/pdf/sds/9xx/940/ucbProjectGenie/940_LISP_Memo_2_Apr67.pdf) -Advising was a means of allowing the user to treat a particular function as a black box without knowing what was inside the box, wrap “advice” around it that could operate before the function ran, potentially changing its input parameters, after it ran, possibly changing its value, or { PrettyPrint which printed out a nicely formatted representation of Lisp programs, using indentation to indicate depth of structure. A Trace facility was also available which modified specified functions to print on the terminal their input parameters on entry and their value on exit. You could think of this as a special case of Advising. There was also a Break package which enabled the user to cause program execution to halt at the entry point to specific functions. The user could then examine the value of the function’s input parameters, and even change them, then cause the function to run, and again gain control so as to examine the value that the function returned or side effects of the function’s operation. The user could change input parameters and re-execute the function, or manually specify the desired value and have it be returned to the caller as though it had been the value produced by that function. +Advising was a means of allowing the user to treat a particular function as a black box without knowing what was inside the box, wrap “advice” around it that could operate before the function ran, potentially changing its input parameters, after it ran, possibly changing its value, or call PrettyPrint, which printed out a nicely formatted representation of Lisp programs, using indentation to indicate depth of structure. A Trace facility was also available which modified specified functions to print on the terminal their input parameters on entry and their value on exit. You could think of this as a special case of Advising. There was also a [Break package](/history/glossary/#break-package) which enabled the user to cause program execution to halt at the entry point to specific functions. The user could then examine the value of the function’s input parameters, and even change them, then cause the function to run, and again gain control so as to examine the value that the function returned or side effects of the function’s operation. The user could change input parameters and re-execute the function, or manually specify the desired value and have it be returned to the caller as though it had been the value produced by that function. Teitelman memo to [SDS 940 LISP Users](http://www.bitsavers.org/pdf/sds/9xx/940/ucbProjectGenie/940_LISP_Memo_2_Apr67.pdf). @@ -94,7 +94,7 @@ The **File Package** was added in 1971. This was essentially a “make” for Li ### 1972 -In 1972, Danny Bobrow and Warren Teitelman left BBN and went to the newly formed Xerox Palo Alto Research Center – PARC. BBN continued to provide the low-level support for the Lisp system, i.e., compiler, garbage collector, and all of the operating system interface, while the Lisp-based center of activity for the various packages and utilities moved to PARC. Both sites continued to be supported by ARPA, and to indicate this partnership and shared responsibility, BBN-LISP was renamed to be **Interlisp**. +In 1972, Danny Bobrow and Warren Teitelman left BBN and went to the newly formed Xerox Palo Alto Research Center – [PARC](/history/glossary/#parc). BBN continued to provide the low-level support for the Lisp system, i.e., compiler, garbage collector, and all of the operating system interface, while the Lisp-based center of activity for the various packages and utilities moved to PARC. Both sites continued to be supported by ARPA, and to indicate this partnership and shared responsibility, BBN-LISP was renamed to be **[Interlisp](/history/glossary/#interlisp)**. Around the ARPAnet, Interlisp continued to use the DEC PDP-10 as its principal platform. @@ -106,7 +106,7 @@ Around the ARPAnet, Interlisp continued to use the DEC PDP-10 as its principal p By 1974 a number of impressive extensions to Interlisp had been developed by Larry Masinter. These included a much more sophisticated version of Interlisp’s **iterative statement**, as well as a **Record** package that enabled a user to label various components of a list structure and refer to them by name, thereby eliminating the CADADRs and CDADDRs that made Lisp programs so difficult to read. The Record package also had the advantage that the user could change a record definition, and the program would automatically adopt the new structure. For example, if PERSON were defined as (RECORD PERSON (FIRSTNAME LASTNAME TITLE)), the expression (X:TITLE) would translate to (CADDR X). If the user later changed the definition of PERSON to (RECORD PERSON (FIRSTNAME INITIAL LASTNAME TITLE)), all expressions involving TITLE would automatically be retranslated to use CADDDR. -- [Interlisp-10 sources from 1974](https://github.com/Interlisp/history/tree/master/1970s/1974-sources) +- [Interlisp-10](/history/glossary/#interlisp-10) sources from 1974 ([GitHub](https://github.com/Interlisp/history/tree/master/1970s/1974-sources)) **Masterscope** would analyze a large program and build a database of relationships between the various components that could then be queried using a natural language front end. For example, WHO CALLS FOO AND USES MUMBLE, EDIT WHERE X IS USED FREELY AND Y IS BOUND, etc. As LISP programs became larger and more complex and were being built by teams of programmers, rather than a single programmer, functionality such as that provided by Masterscope was invaluable in understanding, maintaining, and extending programs. @@ -122,11 +122,11 @@ The fact that the manual was machine readable, and heavily indexed, meant Interl In 1976, Dan Ingalls gave a presentation at PARC in which he demonstrated the first window system. Written in and for Smalltalk, the user interface and paradigm it provided for enabling the user to manage and work with multiple contexts was very compelling, and immediately inspired work to provide such a mechanism for Interlisp. At the time, although Peter Deutsch had developed a byte-coded instruction set for the Alto, it was under-powered for Lisp development. -Bob Sproull came up with the idea for what would turn out to be the first client-server window system: use the Alto as the window server and Interlisp running on the time-shared PDP-10 clone as the client. and develop a protocol for having Interlisp tell the Alto what to display, and for the Alto to tell Interlisp about mouse clicks. Bob developed the **ADIS** (for Alto Display) package and Teitelman wrote **DLISP** in Interlisp. DLISP included a window manager and windowing system that enabled overlapping windows, cut and paste, etc. J Moore implemented a text package that would support display and editing of text in windows. Teitelman demonstrated this functionality at IJCAI in 1977, and presented a paper, a Display Oriented Programmer’s Assistant. +Bob Sproull came up with the idea for what would turn out to be the first client-server window system: use the Alto as the window server and Interlisp running on the time-shared PDP-10 clone as the client. and develop a protocol for having Interlisp tell the Alto what to display, and for the Alto to tell Interlisp about mouse clicks. Bob developed the **ADIS** (for Alto Display) package and Teitelman wrote **[DLISP](/history/glossary/#dlisp)** in Interlisp. DLISP included a window manager and windowing system that enabled overlapping windows, cut and paste, etc. J Moore implemented a text package that would support display and editing of text in windows. Teitelman demonstrated this functionality at IJCAI in 1977, and presented a paper, a Display Oriented Programmer’s Assistant. ### 1979 -In 1979, PARC began the design of the Dorado, a high performance personal workstation. The availability of the Dorado also made possible building a Lisp with a native display capability, which led to the Interlisp-D project. +In 1979, PARC began the design of the Dorado, a high performance personal workstation. The availability of the Dorado also made possible building a Lisp with a native [display](/history/glossary/#display) capability, which led to the [Interlisp-D](/history/glossary/#interlisp-d) project. ## 1980s @@ -141,7 +141,7 @@ In 1979, PARC began the design of the Dorado, a high performance personal workst ### 1983 -- Chorus and Fugue Releases of Interlisp-D +- Chorus and [Fugue](/history/glossary/#fugue) Releases of Interlisp-D ### 1984 @@ -149,27 +149,27 @@ In 1979, PARC began the design of the Dorado, a high performance personal workst ### 1985 -- Harmony and Intermezzo releases -- Koto release (for Xerox 1186), some bits of Common Lisp +- [Harmony](/history/glossary/#harmony) and [Intermezzo](/history/glossary/#intermezzo) releases +- [Koto](/history/glossary/#koto) release (for Xerox 1186), some bits of [Common Lisp](/history/glossary/#common-lisp) ### 1987 -- Lyric release +- [Lyric](/history/glossary/#lyric) release ### 1988 -- Medley 1.0 release. Medley supported all Sun's running on SunOS, plus IRIX, AIX, HPUX, Ultrix, (i.e., BSD Unix) +- [Medley](/history/glossary/#medley) 1.0 release. Medley supported all Sun's running on SunOS, plus IRIX, AIX, HPUX, Ultrix, (i.e., BSD Unix) ### 1989 -- Envos formed from XAIS +- [Envos](/history/glossary/#envos) formed from [XAIS](/history/glossary/#xais) - April 10, Envos closes ## 1990s ### 1991 -- August: Venue moves to new offices [Arun Welch email] +- August: [Venue](/history/glossary/#venue) moves to new offices [Arun Welch email] - 3-byte atoms ### 1992 @@ -224,4 +224,4 @@ The classes and objects you create are the same blocks LOOPS is built out of. So ### 2020 -[Medley Interlisp project](https://interlisp.org/) begins +[Medley Interlisp project](/history/glossary/#medley-interlisp-project) begins ([interlisp.org](https://interlisp.org/)) From b6edc71e3b9ea5784abb85c92113aabacaa6da52 Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Mon, 2 Nov 2026 06:17:47 -0500 Subject: [PATCH 04/10] Update Glossary link handling, adding tool tips. --- config/_default/params.yaml | 6 + content/en/history/glossary/_index.md | 2 +- content/en/history/timeline/_index.md | 12 +- layouts/_markup/render-link.html | 26 +++ layouts/_partials/glossary-definitions.html | 47 +++++ tests/test_hugo_build.py | 186 ++++++++++++++++++++ 6 files changed, 272 insertions(+), 7 deletions(-) create mode 100644 layouts/_markup/render-link.html create mode 100644 layouts/_partials/glossary-definitions.html diff --git a/config/_default/params.yaml b/config/_default/params.yaml index d6f35c2ce..99603d4fa 100644 --- a/config/_default/params.yaml +++ b/config/_default/params.yaml @@ -184,6 +184,12 @@ ui: # Set to false to disable dark mode menu showLightDarkModeMenu: false +# Glossary tooltip configuration +glossary: + # Maximum length of automatically extracted tooltip text. + # Custom data-tooltip overrides are used verbatim after normalization. + tooltip_max_chars: 200 + # Docsy plugins configuration (0.18.0) docsy: plugins: diff --git a/content/en/history/glossary/_index.md b/content/en/history/glossary/_index.md index 3272a0394..69c3cbf32 100644 --- a/content/en/history/glossary/_index.md +++ b/content/en/history/glossary/_index.md @@ -82,7 +82,7 @@ as a graphics terminal. Interlisp-360 : Implemention of Interlisp for the IBM-360. -Interlisp-D +Interlisp-D : What Dorado Lisp became. The D stood for both “Display” and “D-machine”. An implementation of - Interlisp the language diff --git a/content/en/history/timeline/_index.md b/content/en/history/timeline/_index.md index c5f64c7e9..5db694e70 100644 --- a/content/en/history/timeline/_index.md +++ b/content/en/history/timeline/_index.md @@ -6,7 +6,7 @@ aliases: - /medley/history/timeline/ --- -This timeline started with Teitelman’s [History of Interlisp](/history/bibliography/DVGRZ62H/). The [Bibliography](/bibliography/) has a wealth of additional historical information. +This timeline started with Teitelman’s [History of Interlisp](/history/bibliography/dvgrz62h/). The [Bibliography](/bibliography/) has a wealth of additional historical information. Terms linked to the [Glossary](/history/glossary/) are defined there. @@ -34,7 +34,7 @@ In 1965, there were very few tools for developing Lisp programs, and those that ### 1966 -- MIT EE Dept PDP-36 [LISP manual](/history/bibliography/6M8ISEUL/) +- MIT EE Dept PDP-36 [LISP manual](/history/bibliography/6m8iseul/) Teitelman started at Bolt, Beranek and Newman in Cambridge. At the time, [BBN](/history/glossary/#bbn)’s computer was a DEC PDP-1, and Daniel Murphy had written a version of Lisp 1.5 for it using ideas from Deutch’s work. This Lisp was really just a toy – single user, slow, small address space, but Teitelman started with Break and Prettyprint from MIT on his pursuit of a Lisp programming environment. @@ -44,11 +44,11 @@ Teitelman started at Bolt, Beranek and Newman in Cambridge. At the time, [BBN](/ In 1967, BBN purchased an SDS 940 computer from Scientific Data Systems and began work building a time-sharing system on it. The SDS 940 had a larger address space and the ability to support a paging system. BBN was awarded an ARPA contract to provide a LISP system that could be distributed to other ARPA sites for doing A.I. research. (ARPA = Advanced Research Projects Administration of the Department of Defense.) -- [Improvements to the 940 LISP Library](/history/bibliography/6M8ISEUL/) +- [Improvements to the 940 LISP Library](/history/bibliography/6m8iseul/) Advising was a means of allowing the user to treat a particular function as a black box without knowing what was inside the box, wrap “advice” around it that could operate before the function ran, potentially changing its input parameters, after it ran, possibly changing its value, or call PrettyPrint, which printed out a nicely formatted representation of Lisp programs, using indentation to indicate depth of structure. A Trace facility was also available which modified specified functions to print on the terminal their input parameters on entry and their value on exit. You could think of this as a special case of Advising. There was also a [Break package](/history/glossary/#break-package) which enabled the user to cause program execution to halt at the entry point to specific functions. The user could then examine the value of the function’s input parameters, and even change them, then cause the function to run, and again gain control so as to examine the value that the function returned or side effects of the function’s operation. The user could change input parameters and re-execute the function, or manually specify the desired value and have it be returned to the caller as though it had been the value produced by that function. -Teitelman memo to [SDS 940 LISP Users](/history/bibliography/6M8ISEUL/). +Teitelman memo to [SDS 940 LISP Users](/history/bibliography/6m8iseul/). ### 1968 @@ -100,7 +100,7 @@ Around the ARPAnet, Interlisp continued to use the DEC PDP-10 as its principal p ### 1973 -- "[Interlisp Reference Manual, Acknowledgements and Background](/history/bibliography/SYGUERKE/)" (PDF). 1973. +- "[Interlisp Reference Manual, Acknowledgements and Background](/history/bibliography/syguerke/)" (PDF). 1973. ### 1974 @@ -130,7 +130,7 @@ In 1979, PARC began the design of the Dorado, a high performance personal workst ## 1980s -- Teitelman & Masinter, IEEE Computer, “[The Interlisp Programming Environment](/history/bibliography/7T3AV4PM/)” April 1981. +- Teitelman & Masinter, IEEE Computer, “[The Interlisp Programming Environment](/history/bibliography/7t3av4pm/)” April 1981. - [1983 Stanford University Medical Experiment Computer](https://github.com/Interlisp/history/tree/master/1980s/1983-sumex-lisp) ### 1982 diff --git a/layouts/_markup/render-link.html b/layouts/_markup/render-link.html new file mode 100644 index 000000000..caac66155 --- /dev/null +++ b/layouts/_markup/render-link.html @@ -0,0 +1,26 @@ +{{- /* + Preserve Goldmark's default link output and add a Bootstrap tooltip to + glossary links. Docsy initializes [data-bs-toggle="tooltip"] in base.js. + + Skip the glossary page itself to avoid recursively rendering its content + while the glossary-definitions partial is parsing that same content. +*/ -}} +{{- $dest := .Destination -}} +{{- $attrs := "" -}} +{{- $isGlossaryLink := or (strings.HasPrefix $dest "/history/glossary/#") (strings.HasPrefix $dest "history/glossary/#") -}} +{{- $isGlossaryPage := or (eq .Page.RelPermalink "/history/glossary/") (eq .Page.Path "/history/glossary") -}} +{{- if and $isGlossaryLink (not $isGlossaryPage) -}} + {{- $anchor := "" -}} + {{- if strings.HasPrefix $dest "/history/glossary/#" -}} + {{- $anchor = strings.TrimPrefix "/history/glossary/#" $dest -}} + {{- else -}} + {{- $anchor = strings.TrimPrefix "history/glossary/#" $dest -}} + {{- end -}} + {{- $definitions := partialCached "glossary-definitions.html" . "glossary-definitions" -}} + {{- with index $definitions $anchor -}} + {{- $attrs = printf ` data-bs-toggle="tooltip" data-bs-title="%s"` (htmlEscape .) -}} + {{- else -}} + {{- warnf "Glossary link to #%s has no extracted tooltip definition" $anchor -}} + {{- end -}} +{{- end -}} +{{ .Text | safeHTML }} diff --git a/layouts/_partials/glossary-definitions.html b/layouts/_partials/glossary-definitions.html new file mode 100644 index 000000000..9b8648024 --- /dev/null +++ b/layouts/_partials/glossary-definitions.html @@ -0,0 +1,47 @@ +{{- /* + Build a map of glossary anchor IDs to short, plain-text definitions. + + The glossary uses definition-list syntax: + + BBN + : Bolt, Beranek, and Newman... + + Hugo renders that as: + +
BBN
+
Bolt, Beranek, and Newman...
+ + An entry may provide a custom tooltip instead of using its first
: + + Interlisp-D + + The rendered content is parsed once per build by partialCached in the + render-link hook. Only the first
for each term is used, unless the + entry has a data-tooltip attribute. +*/ -}} +{{- $defs := dict -}} +{{- $maxChars := 200 -}} +{{- with site.Params.glossary -}} + {{- $maxChars = .tooltip_max_chars | default 200 -}} +{{- end -}} +{{- with site.GetPage "/history/glossary" -}} + {{- $entries := findRE `(?s)
]*>.*?` .Content -}} + {{- range $entries -}} + {{- $entry := . -}} + {{- $id := replaceRE `(?s)^
]*>.*$` "$1" $entry -}} + {{- $text := "" -}} + {{- if strings.Contains $entry "data-tooltip=" -}} + {{- $custom := replaceRE `(?s)^
]*\sdata-tooltip="([^"]*)"[^>]*>.*$` "$1" $entry -}} + {{- $text = $custom | plainify | htmlUnescape | replaceRE `\s+` " " | replaceRE `\s+([,.;:!?])` "$1" | chomp -}} + {{- else -}} + {{- $definition := replaceRE `(?s)^.*?
(.*)
$` "$1" $entry -}} + {{- $text = $definition | plainify | htmlUnescape | replaceRE `\s+` " " | replaceRE `\s+([,.;:!?])` "$1" | chomp | truncate $maxChars -}} + {{- end -}} + {{- if $text -}} + {{- $defs = merge $defs (dict $id $text) -}} + {{- else -}} + {{- warnf "Glossary entry #%s produced empty tooltip text" $id -}} + {{- end -}} + {{- end -}} +{{- end -}} +{{- return $defs -}} diff --git a/tests/test_hugo_build.py b/tests/test_hugo_build.py index 55c22fee1..d7e7dcb77 100644 --- a/tests/test_hugo_build.py +++ b/tests/test_hugo_build.py @@ -20,8 +20,11 @@ PYTEST_FORCE_HUGO_BUILD=1 pytest tests/test_hugo_build.py -v """ +import html import os import re +import subprocess +import uuid import xml.etree.ElementTree as ET from pathlib import Path from urllib.parse import urlparse @@ -257,3 +260,186 @@ def test_no_broken_internal_links(self) -> None: f"{len(broken)} broken internal links found:\n" + "\n".join(f" {page} → {link}" for page, link in broken[:20]) ) + + +class TestGlossaryTooltips: + """Timeline glossary links must expose a non-empty Bootstrap tooltip and + resolve to a rendered glossary anchor.""" + + @pytest.fixture(autouse=True) + def pages(self, production_build): + timeline_path = PROD_PUBLIC / "history" / "timeline" / "index.html" + glossary_path = PROD_PUBLIC / "history" / "glossary" / "index.html" + if not timeline_path.exists() or not glossary_path.exists(): + pytest.skip("built timeline/glossary pages not found — run hugo first") + self.timeline = timeline_path.read_text(encoding="utf-8", errors="ignore") + self.glossary = glossary_path.read_text(encoding="utf-8", errors="ignore") + self.glossary_ids = set( + re.findall(r']*>', self.glossary) + ) + + def _glossary_links(self) -> list[str]: + return re.findall( + r']*href="/history/glossary/#[^"]+"[^>]*>', + self.timeline, + ) + + def test_glossary_links_have_tooltips(self) -> None: + links = self._glossary_links() + assert links, "No glossary links found in the built timeline" + + missing_toggle: list[str] = [] + missing_title: list[str] = [] + empty_title: list[str] = [] + + for tag in links: + href = re.search(r'href="([^"]+)"', tag).group(1) + if 'data-bs-toggle="tooltip"' not in tag: + missing_toggle.append(href) + title = re.search(r'data-bs-title="([^"]*)"', tag) + if title is None: + missing_title.append(href) + elif not html.unescape(title.group(1)).strip(): + empty_title.append(href) + + assert not missing_toggle, ( + "Glossary links missing data-bs-toggle=\"tooltip\":\n" + + "\n".join(missing_toggle) + ) + assert not missing_title, ( + "Glossary links missing data-bs-title:\n" + "\n".join(missing_title) + ) + assert not empty_title, ( + "Glossary links with empty tooltip text:\n" + "\n".join(empty_title) + ) + + def test_glossary_tooltip_targets_resolve(self) -> None: + anchors = set( + re.findall(r'href="/history/glossary/#([^"]+)"', self.timeline) + ) + missing = sorted(anchors - self.glossary_ids) + assert not missing, ( + "Glossary tooltip targets not found in the built glossary:\n" + + "\n".join(missing) + ) + + def test_tooltip_max_chars_config(self) -> None: + config_path = REPO_ROOT / "config" / "_default" / "params.yaml" + config = yaml.safe_load(config_path.read_text(encoding="utf-8")) + max_chars = config.get("glossary", {}).get("tooltip_max_chars") + assert isinstance(max_chars, int) and max_chars > 0, ( + "params.yaml must define a positive glossary.tooltip_max_chars" + ) + + def test_interlisp_d_uses_custom_tooltip(self) -> None: + match = re.search( + r']*href="/history/glossary/#interlisp-d"[^>]*>', + self.timeline, + ) + assert match is not None, ( + "Timeline does not link to /history/glossary/#interlisp-d" + ) + title = re.search(r'data-bs-title="([^"]*)"', match.group(0)) + assert title is not None, ( + "Interlisp-D glossary link is missing data-bs-title" + ) + text = html.unescape(title.group(1)) + assert "D stood for both" in text, ( + "Interlisp-D should use its custom data-tooltip text" + ) + assert not text.endswith("An implementation of"), ( + "Interlisp-D tooltip still ends with the truncated first
" + ) + + def test_glossary_source_anchors_are_unique(self) -> None: + source_path = ( + REPO_ROOT / "content" / "en" / "history" / "glossary" / "_index.md" + ) + source = source_path.read_text(encoding="utf-8") + spans = re.findall(r']*>', source) + ids = [ + re.search(r'id="([^"]+)"', span).group(1) + for span in spans + ] + assert len(ids) == len(set(ids)), "Glossary source anchor IDs are not unique" + assert set(ids) == self.glossary_ids, ( + "Glossary source anchors do not match the built glossary anchors" + ) + for span in spans: + tooltip = re.search(r'data-tooltip="([^"]*)"', span) + if tooltip is not None: + assert tooltip.group(1).strip(), ( + f"Empty data-tooltip in glossary source: {span}" + ) + + def test_all_glossary_anchors_have_tooltips(self, tmp_path: Path) -> None: + probe_name = f"tooltip-probe-{uuid.uuid4().hex}" + probe_path = ( + REPO_ROOT / "content" / "en" / "history" / f"{probe_name}.md" + ) + links = "\n".join( + f"- [{anchor}](/history/glossary/#{anchor})" + for anchor in sorted(self.glossary_ids) + ) + probe_path.write_text( + "---\n" + 'title: "Glossary tooltip probe"\n' + "type: docs\n" + "weight: 9999\n" + "---\n\n" + f"{links}\n", + encoding="utf-8", + ) + try: + destination = tmp_path / "public" + result = subprocess.run( + ["hugo", "--destination", str(destination), "--logLevel", "warn"], + cwd=str(REPO_ROOT), + capture_output=True, + text=True, + ) + assert result.returncode == 0, ( + f"Hugo probe build failed (exit {result.returncode}):\n" + f"--- stdout ---\n{result.stdout}\n" + f"--- stderr ---\n{result.stderr}" + ) + probe_html = ( + destination / "history" / probe_name / "index.html" + ).read_text(encoding="utf-8", errors="ignore") + finally: + probe_path.unlink(missing_ok=True) + + links_html = re.findall( + r']*href="/history/glossary/#[^"]+"[^>]*>', + probe_html, + ) + assert len(links_html) == len(self.glossary_ids), ( + f"Expected {len(self.glossary_ids)} glossary links in the probe " + f"page, found {len(links_html)}" + ) + + missing_toggle: list[str] = [] + missing_title: list[str] = [] + empty_title: list[str] = [] + for tag in links_html: + href = re.search(r'href="([^"]+)"', tag).group(1) + if 'data-bs-toggle="tooltip"' not in tag: + missing_toggle.append(href) + title = re.search(r'data-bs-title="([^"]*)"', tag) + if title is None: + missing_title.append(href) + elif not html.unescape(title.group(1)).strip(): + empty_title.append(href) + + assert not missing_toggle, ( + "Glossary probe links missing data-bs-toggle=\"tooltip\":\n" + + "\n".join(missing_toggle) + ) + assert not missing_title, ( + "Glossary probe links missing data-bs-title:\n" + + "\n".join(missing_title) + ) + assert not empty_title, ( + "Glossary probe links with empty tooltip text:\n" + + "\n".join(empty_title) + ) From 27ceb68156ad4429c7131edebbbfadfffc098842 Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Mon, 2 Nov 2026 08:07:49 -0500 Subject: [PATCH 05/10] Fix glossary url links to point to correct location. --- layouts/_markup/render-link.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/layouts/_markup/render-link.html b/layouts/_markup/render-link.html index caac66155..f22372737 100644 --- a/layouts/_markup/render-link.html +++ b/layouts/_markup/render-link.html @@ -23,4 +23,4 @@ {{- warnf "Glossary link to #%s has no extracted tooltip definition" $anchor -}} {{- end -}} {{- end -}} -{{ .Text | safeHTML }} +{{ .Text | safeHTML }} From 7a384233bb5cc556784e1ab9e1584c9dc97a4aee Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Mon, 2 Nov 2026 08:16:27 -0500 Subject: [PATCH 06/10] Didn't get it quite right the first time... --- layouts/_markup/render-link.html | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/layouts/_markup/render-link.html b/layouts/_markup/render-link.html index f22372737..7c38754e8 100644 --- a/layouts/_markup/render-link.html +++ b/layouts/_markup/render-link.html @@ -4,6 +4,10 @@ Skip the glossary page itself to avoid recursively rendering its content while the glossary-definitions partial is parsing that same content. + + For site-root-relative links (starting with /), convert to relative paths + and apply relURL to ensure they work correctly with baseURL path prefixes + in staging/PR deployments. */ -}} {{- $dest := .Destination -}} {{- $attrs := "" -}} @@ -23,4 +27,8 @@ {{- warnf "Glossary link to #%s has no extracted tooltip definition" $anchor -}} {{- end -}} {{- end -}} -{{ .Text | safeHTML }} +{{- $link := $dest -}} +{{- if strings.HasPrefix $dest "/" -}} + {{- $link = (strings.TrimPrefix "/" $dest) | relURL -}} +{{- end -}} +{{ .Text | safeHTML }} From 89a1e74f0cf60f43df316ffee195de3bc763bd0f Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Sat, 7 Nov 2026 08:07:27 -0500 Subject: [PATCH 07/10] Step two in building out the glossary and timeline: - Started adding new glossary entries: - Advise (Advising) - DWIM - History package - Prettyprint - Spaghetti stack - Structure editor - Trace - UNDO This is the first batch of terms, in the end I expect around four PRs. These terms focus on core environment and debugging. I tried to keep glossary entries focused on what the term is, its purpose. Anything that related to dates or people I pushed back into the timeline. A couple early entries I wrote started feeling like mini-timelines. I backed off that approach. You'll see some minor updates to the timeline reflecting some of the added details I found and captured. --- content/en/history/glossary/_index.md | 24 ++++++++++++++++++++++++ content/en/history/timeline/_index.md | 26 +++++++++++++++++--------- 2 files changed, 41 insertions(+), 9 deletions(-) diff --git a/content/en/history/glossary/_index.md b/content/en/history/glossary/_index.md index 69c3cbf32..9622bab56 100644 --- a/content/en/history/glossary/_index.md +++ b/content/en/history/glossary/_index.md @@ -13,6 +13,9 @@ For general computer terminology and lore see [The Hacker's Dictionary](https:// ## Vocabulary and relationships +Advice (Advising) +: A facility for modifying an existing function without editing its definition by wrapping it with code that runs before or after the function and can inspect or change its arguments or return value. Also called advising. + AltoLisp : An experimental microcoded implementation of Interlisp on an Alto personal computer. @@ -53,12 +56,18 @@ as a graphics terminal. Dorado Lisp : The reimplementation of the AltoLisp microcode on the Dorado – a research prototype. +DWIM +: Do-What-I-Mean. An Interlisp error-recovery facility that intercepts errors such as undefined functions, unset variables, and misspellings, using heuristics and context-sensitive spelling lists to suggest or apply corrections and continue execution. + Fugue : An obsolete named release of Interlisp-D. Harmony : An obsolete named release of Interlisp-D. +History package +: An Interlisp facility that records the commands and expressions entered during a session, together with messages displayed during their execution, so they can be reviewed, replayed with substitutions, or undone. + Intermezzo : An obsolete named release of Interlisp-D. @@ -123,12 +132,27 @@ as a graphics terminal. - Informally, a collection of utilities or submodule in Interlisp (the "break package", q.v.; the "file package", a facility for managing code changes; the "record package", a record data type; and so on) - A feature of Commmon Lisp symbol support; the package system allows the combining of Interlisp symbols (written with `IL:` prefix) and Common Lisp symbols (written with a `LISP:` prefix). +Prettyprint +: A Lisp utility that prints programs with indentation and line breaks that reflect their list structure, making code easier to read and debug. + SDL : Structured Design Language. +Spaghetti stack +: An Interlisp execution stack that remains available as a structured list, allowing programs and debugging tools to search frames, inspect values in caller contexts, and perform non-local returns. + +Structure editor +: An editor that operates directly on a program's list structure rather than its printed text. Because Lisp programs are lists, commands can move through and modify a function's tree in place without leaving Lisp. + Sysout : A file containing the saved state of Interlisp virtual memory. +Trace +: A Lisp debugging facility that redefines a function so that selected information, by default its arguments and return value, is printed when the function is entered and exited. Tracing remains in effect until the function is untraced. + +UNDO +: A command in the Interlisp Programmer’s Assistant that reverses the side effects of operations recorded on its history list. It supports selective undo—reversing an earlier operation without undoing later ones—as well as undoing assignments and whole edit sessions. Undoing an operation can itself be undone. + X11 : The X Window System. diff --git a/content/en/history/timeline/_index.md b/content/en/history/timeline/_index.md index 5db694e70..d149ae7ec 100644 --- a/content/en/history/timeline/_index.md +++ b/content/en/history/timeline/_index.md @@ -30,13 +30,13 @@ Teitelman’s experience with his Ph.D. work led him to the notion of building a The term “programming environment” was meant to suggest not only the usual specifics of both a programming system and language but also more elusive and subjective considerations such as ease of use and level of interaction, “forgiveness” of errors, human engineering, and system “initiative.” The programmer’s environment influences and to a large extent determines, what sort of problems they can (and will want to) tackle, how far they can go, and how fast. If the environment is “cooperative” and “helpful”, then the programmer can be more ambitious and productive. If not, they will spend most of their time and energy “fighting” the system, which at times seems bent on frustrating one’s best efforts. -In 1965, there were very few tools for developing Lisp programs, and those that were available were very primitive. +In 1965, there were very few tools for developing Lisp programs, and those that were available were very primitive. These included [Prettyprint](/history/glossary/#prettyprint), which printed Lisp programs with indentation reflecting their list structure, and a [Trace](/history/glossary/#trace) facility, which modified functions to print their input parameters on entry and their value on exit. ### 1966 - MIT EE Dept PDP-36 [LISP manual](/history/bibliography/6m8iseul/) -Teitelman started at Bolt, Beranek and Newman in Cambridge. At the time, [BBN](/history/glossary/#bbn)’s computer was a DEC PDP-1, and Daniel Murphy had written a version of Lisp 1.5 for it using ideas from Deutch’s work. This Lisp was really just a toy – single user, slow, small address space, but Teitelman started with Break and Prettyprint from MIT on his pursuit of a Lisp programming environment. +Teitelman started at Bolt, Beranek and Newman in Cambridge. At the time, [BBN](/history/glossary/#bbn)’s computer was a DEC PDP-1, and Daniel Murphy had written a version of Lisp 1.5 for it using ideas from Deutch’s work. This Lisp was really just a toy – single user, slow, small address space, but Teitelman obtained copies of the MIT Break and Prettyprint utilities and brought them to BBN-LISP in his pursuit of a Lisp programming environment. - http://www.softwarepreservation.org/projects/LISP/bbnlisp/BBN-LISP-System_Feb1966.pdf#page=49 @@ -46,7 +46,7 @@ In 1967, BBN purchased an SDS 940 computer from Scientific Data Systems and bega - [Improvements to the 940 LISP Library](/history/bibliography/6m8iseul/) -Advising was a means of allowing the user to treat a particular function as a black box without knowing what was inside the box, wrap “advice” around it that could operate before the function ran, potentially changing its input parameters, after it ran, possibly changing its value, or call PrettyPrint, which printed out a nicely formatted representation of Lisp programs, using indentation to indicate depth of structure. A Trace facility was also available which modified specified functions to print on the terminal their input parameters on entry and their value on exit. You could think of this as a special case of Advising. There was also a [Break package](/history/glossary/#break-package) which enabled the user to cause program execution to halt at the entry point to specific functions. The user could then examine the value of the function’s input parameters, and even change them, then cause the function to run, and again gain control so as to examine the value that the function returned or side effects of the function’s operation. The user could change input parameters and re-execute the function, or manually specify the desired value and have it be returned to the caller as though it had been the value produced by that function. +[Advising](/history/glossary/#advising) was a means of allowing the user to treat a particular function as a black box without knowing what was inside the box, wrap “advice” around it that could operate before the function ran, potentially changing its input parameters, after it ran, possibly changing its value, or call PrettyPrint, which printed out a nicely formatted representation of Lisp programs, using indentation to indicate depth of structure. A Trace facility was also available which modified specified functions to print on the terminal their input parameters on entry and their value on exit. You could think of this as a special case of Advising. There was also a [Break package](/history/glossary/#break-package) which enabled the user to cause program execution to halt at the entry point to specific functions. The user could then examine the value of the function’s input parameters, and even change them, then cause the function to run, and again gain control so as to examine the value that the function returned or side effects of the function’s operation. The user could change input parameters and re-execute the function, or manually specify the desired value and have it be returned to the caller as though it had been the value produced by that function. Teitelman memo to [SDS 940 LISP Users](/history/bibliography/6m8iseul/). @@ -54,10 +54,12 @@ Teitelman memo to [SDS 940 LISP Users](/history/bibliography/6m8iseul/). Work on Demand Paging software virtual memory was focused on supporting Lisp. -Peter Deutsch wrote a **structure editor** in Lisp for editing Lisp programs. Prior to this, Lisp source was prepared and edited offline in textual form and read into the Lisp system. Peter’s editor enabled the user to edit Lisp programs without ever leaving Lisp. The editor provided operations for moving up, down, left or right in the list structure definition of a Lisp function, and to make insertions, deletions, or replacements, e.g. (-3 X) to insert X in front of the 3rd item in the current list, 2 to descend into the second item in the current list, 0 to ascend one level, etc. Other more sophisticated commands were soon added, such as a find command to search through all levels of the function being edited looking for a specified string or pattern, a mark command to mark, i.e. save, the current location, and a command to restore the context to one that had previously been marked, an ability to define macros, etc. +Peter Deutsch began a **[structure editor](/history/glossary/#structure-editor)** in Lisp in 1965; Daniel Bobrow and Warren Teitelman later extended it at BBN. Prior to the editor, Lisp source was prepared and edited offline in textual form and read into the Lisp system. By 1968 Peter’s editor enabled the user to edit Lisp programs without ever leaving Lisp. The editor provided operations for moving up, down, left or right in the list structure definition of a Lisp function, and to make insertions, deletions, or replacements, e.g. (-3 X) to insert X in front of the 3rd item in the current list, 2 to descend into the second item in the current list, 0 to ascend one level, etc. Other more sophisticated commands were soon added, such as a find command to search through all levels of the function being edited looking for a specified string or pattern, a mark command to mark, i.e. save, the current location, and a command to restore the context to one that had previously been marked, an ability to define macros, etc. The ability to edit a Lisp program in situ meant that a user could modify a running program and continue execution. For example, the user might be at a Break, evaluate the current function, identify a problem, edit the definition using the structure editor, and reevaluate the current, now modified function and go on. +- Peter Deutsch, [Preliminary Guide to the LISP Editor](/history/bibliography/zk7mfmne/) (1967) + ### 1969 Alice K. Hartley took over Dan Murphy’s role in BBN-LISP. A number of new data types were added to augment lists and numbers: arrays, strings, large numbers, floating-point numbers. @@ -68,9 +70,9 @@ Alice K. Hartley took over Dan Murphy’s role in BBN-LISP. A number of new data As Lisp users began to write larger and larger programs, performance began to be an issue. A compiler had been available for Lisp programs since the early sixties. -In 1970, Danny Bobrow and Alice Hartley designed and implemented the “spaghetti stack”. This enabled running programs to search the current execution stack, e.g., find the second occurrence up the stack of the function FOO, and return the name of the function that called FOO, to alter the normal flow of control, e.g., return from a specified stack pointer a specified value (very useful when debugging programs in order to manually bypass a known problem), and to evaluate an expression or variable in a specified context, e.g., what is the value of x as of six function calls back up the stack. +In 1970, Danny Bobrow and Alice Hartley designed and implemented the “[spaghetti stack](/history/glossary/#spaghetti-stack)”. This enabled running programs to search the current execution stack, e.g., find the second occurrence up the stack of the function FOO, and return the name of the function that called FOO, to alter the normal flow of control, e.g., return from a specified stack pointer a specified value (very useful when debugging programs in order to manually bypass a known problem), and to evaluate an expression or variable in a specified context, e.g., what is the value of x as of six function calls back up the stack. -**DWIM**, the most well known, and in some cases reviled, feature of BBN-LISP was introduced in 1970. DWIM stands for Do-What-I-Mean and embodies Teitelman’s view that people's time was more valuable/expensive than computer time. (This was a radical idea at the time.) When Teitelman first started programming in FORTRAN in 1960, he was appalled at receiving the error message, “on line 70, DIMENSION is misspelled”. If the FORTRAN compiler knew this to be the case, why didn’t it accept this and go on and compile his program? +**[DWIM](/history/glossary/#dwim)**, the most well known, and in some cases reviled, feature of BBN-LISP was introduced in 1970. DWIM stands for Do-What-I-Mean and embodies Teitelman’s view that people's time was more valuable/expensive than computer time. (This was a radical idea at the time.) When Teitelman first started programming in FORTRAN in 1960, he was appalled at receiving the error message, “on line 70, DIMENSION is misspelled”. If the FORTRAN compiler knew this to be the case, why didn’t it accept this and go on and compile his program? The BBN-LISP interpreter was modified so that rather than signal an error when an undefined function or unset variable was encountered, DWIM would use various heuristics to identify and attempt to correct the error. Spelling correction was the most common scenario. An algorithm was implemented that took advantage of the most common types of errors made by a touch typist, e.g., doubled characters, transpositions, case error, etc. @@ -82,12 +84,18 @@ DWIM could also handle the case where the user typed a number instead of ‘(‘ Spelling correction was also used in contexts besides evaluating Lisp expressions. For example, there was a spelling list of edit commands that was used to correct a mistyped editor command. When loading a file where the file name was not found, a spelling list of previously encountered file names would be used. -Another innovation introduced to BBN-LISP in 1970 was the History package. The idea was rather than simply performing the operations requested by the user, call functions, edit expressions, perform break commands, etc., and discarding that information, to have an agent that would record what the user entered so that the user could examine the history, and replay portions of it, possibly with substitutions. (The history feature of the UNIX C-shell introduced in the late 70’s was patterned after the Interlisp history package.) The history also contained any messages displayed to the user during the execution of the corresponding event, e.g., any DWIM corrections, or messages about global variables being reset or functions being redefined, etc. As with DWIM, the History package grew out of the desire to offload manual tasks to the computer. +Another innovation introduced to BBN-LISP in 1970 was the [History package](/history/glossary/#history-package). The idea was rather than simply performing the operations requested by the user, call functions, edit expressions, perform break commands, etc., and discarding that information, to have an agent that would record what the user entered so that the user could examine the history, and replay portions of it, possibly with substitutions. (The history feature of the UNIX C-shell introduced in the late 70’s was patterned after the Interlisp history package.) The history also contained any messages displayed to the user during the execution of the corresponding event, e.g., any DWIM corrections, or messages about global variables being reset or functions being redefined, etc. As with DWIM, the History package grew out of the desire to offload manual tasks to the computer. -Perhaps the most important piece of information stored in each history event was the information required to UNDO that operation. This was especially valuable in the context of editing. UNDO is functionality that every user now expects in an editor, but it was first introduced in BBN-LISP in 1970. The UNDO functionality provided in BBN-LISP still surpasses that available in today’s editors in that the user could UNDO operations out of order. For example, after performing a series of four or five editing operations, the user could realize that the information deleted in the first operation is needed, and would be able to UNDO just that operation by explicitly referring to that operation using the history package, without affecting the intervening operations. +Perhaps the most important piece of information stored in each history event was the information required to [UNDO](/history/glossary/#undo) that operation. This was especially valuable in the context of editing. UNDO is functionality that every user now expects in an editor, but it was first introduced in BBN-LISP in 1970. The UNDO functionality provided in BBN-LISP still surpasses that available in today’s editors in that the user could UNDO operations out of order. For example, after performing a series of four or five editing operations, the user could realize that the information deleted in the first operation is needed, and would be able to UNDO just that operation by explicitly referring to that operation using the history package, without affecting the intervening operations. In addition to being able to UNDO edit operations, the user could also UNDO operations that were typed in at the top level or in a Break. This was most frequently used to undo assignments. It could also be used to undo an entire edit session, rather than undoing one command at a time, sort of a revert operation for S-expressions. The user could also arrange to have functions that they defined to be undoable by storing information on the history list. +The history list stored each event’s input, value, side effects, messages, and errors, discarding the oldest events as new ones arrived. UNDO could itself be undone; the related commands REDO and USE re-ran recorded events. The July 1971 BBN-LISP TENEX Reference Manual documents UNDO. + +- Warren Teitelman, [“Automated programmering: the programmer’s assistant”](/history/bibliography/qwkix8dw/) (1972) +- [BBN-LISP, TENEX Reference Manual](/history/bibliography/jcvvquvd/) (July 1971) +- Warren Teitelman, [“History of Interlisp”](/history/bibliography/dvgrz62h/) (2008) + ### 1971 The **File Package** was added in 1971. This was essentially a “make” for Lisp. The user could specify the set of functions, global variables, property lists, etc., to be contained in a specified file, and then “make” that file. When the file was loaded in a subsequent session, this information would be recorded and available. Whenever a component known to be in a specified file was modified, the system would know that the corresponding file needed to be rewritten. A cleanup function was provided that would write out all files that contained components that had been changed. The user would be informed about any items created or modified during the course of their session that did not appear in any of the user’s files, and therefore might be lost if the user abandoned their session without saving them somewhere. The only thing missing from the File Package that would be provided in UNIX Make was the notion of dependencies. @@ -196,7 +204,7 @@ The ADVISE/advice idea and names carried through to the Aspect/J system, and on **MEDLEY** Medley provides a rich software development environment, including a debugger, a list structure editor, a file package, a compiler, text-editing facilities, and other useful tools. With any interactive computer language, the user interacts with the system through an "executive," which interprets and executes commands. Medley includes three such executives: Common Lisp, Xerox Common Lisp, and Interlisp. Medley is a programming system, containing not only a programming language but also many predefined programs and specialized programming tools. -Medley's interactive window-based *debugger* automatically appears when an error occurs. You can enter the debugger through a program execution error, a user-entered keyboard interrupt, or a programmer-specified break. When execution is halted for one of these reasons, the user can reset the system and unwind the stack, or enter the debugger. The break window is an executive window; you can perform any activity here that you can in other executive windows, including looking at the program's current state, changing data structures, evaluating expressions changing a function, and calling the editor. These break facilities, familiar to Interlisp users, are now in the common Lisp executive as well. +Medley's interactive window-based *debugger* automatically appears when an error occurs. You can enter the debugger through a program execution error, a user-entered keyboard interrupt, or a programmer-specified break. When execution is halted for one of these reasons, the user can reset the system and unwind the stack, or enter the debugger. The break window is an executive window; you can perform any activity here that you can in other executive windows, including looking at the program's current state, changing data structures, evaluating expressions changing a function, and calling the editor. These break facilities, familiar to Interlisp users, are now in the common Lisp executive as well. In Medley, TRACE is implemented as a special case of BREAK, and UNBREAK restores functions modified by BREAK, TRACE, or BREAKIN ([Medley Language Reference](/history/bibliography/zq6d9yhu/)). The *programmer's assistant*. This tracks the user's actions during a session, allowing them to be replayed, undone, or altered. The most common interaction with the programmer's assistant occurs at the top level read-evaluate-print loop or in a break, where the user types in expressions for evaluation and sees the value printed out. From f8f24caf082cc4972b9783860af895c86912ef9b Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Sat, 7 Nov 2026 12:18:46 -0500 Subject: [PATCH 08/10] Fix missing glossary link. Merge error. --- content/en/history/glossary/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/en/history/glossary/_index.md b/content/en/history/glossary/_index.md index 4584c95ab..9622bab56 100644 --- a/content/en/history/glossary/_index.md +++ b/content/en/history/glossary/_index.md @@ -19,7 +19,7 @@ For general computer terminology and lore see [The Hacker's Dictionary](https:// AltoLisp : An experimental microcoded implementation of Interlisp on an Alto personal computer. -Break package +Break package : The Interlisp subsystem that comprises the debugger (also known as break window) and other debugging facilities. Named after the `BREAK` function and breakpoints. Briefing Blurb From c18dbf87e3de68b2e77c631ba8fea018e8442abf Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Sat, 7 Nov 2026 13:16:16 -0500 Subject: [PATCH 09/10] Fix captialization of Common Lisp --- content/en/history/timeline/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/en/history/timeline/_index.md b/content/en/history/timeline/_index.md index d149ae7ec..575b8e809 100644 --- a/content/en/history/timeline/_index.md +++ b/content/en/history/timeline/_index.md @@ -204,7 +204,7 @@ The ADVISE/advice idea and names carried through to the Aspect/J system, and on **MEDLEY** Medley provides a rich software development environment, including a debugger, a list structure editor, a file package, a compiler, text-editing facilities, and other useful tools. With any interactive computer language, the user interacts with the system through an "executive," which interprets and executes commands. Medley includes three such executives: Common Lisp, Xerox Common Lisp, and Interlisp. Medley is a programming system, containing not only a programming language but also many predefined programs and specialized programming tools. -Medley's interactive window-based *debugger* automatically appears when an error occurs. You can enter the debugger through a program execution error, a user-entered keyboard interrupt, or a programmer-specified break. When execution is halted for one of these reasons, the user can reset the system and unwind the stack, or enter the debugger. The break window is an executive window; you can perform any activity here that you can in other executive windows, including looking at the program's current state, changing data structures, evaluating expressions changing a function, and calling the editor. These break facilities, familiar to Interlisp users, are now in the common Lisp executive as well. In Medley, TRACE is implemented as a special case of BREAK, and UNBREAK restores functions modified by BREAK, TRACE, or BREAKIN ([Medley Language Reference](/history/bibliography/zq6d9yhu/)). +Medley's interactive window-based *debugger* automatically appears when an error occurs. You can enter the debugger through a program execution error, a user-entered keyboard interrupt, or a programmer-specified break. When execution is halted for one of these reasons, the user can reset the system and unwind the stack, or enter the debugger. The break window is an executive window; you can perform any activity here that you can in other executive windows, including looking at the program's current state, changing data structures, evaluating expressions changing a function, and calling the editor. These break facilities, familiar to Interlisp users, are now in the Common Lisp executive as well. In Medley, TRACE is implemented as a special case of BREAK, and UNBREAK restores functions modified by BREAK, TRACE, or BREAKIN ([Medley Language Reference](/history/bibliography/zq6d9yhu/)). The *programmer's assistant*. This tracks the user's actions during a session, allowing them to be replayed, undone, or altered. The most common interaction with the programmer's assistant occurs at the top level read-evaluate-print loop or in a break, where the user types in expressions for evaluation and sees the value printed out. From bae2923414ce057e8322a4bc3e46a888aadec022 Mon Sep 17 00:00:00 2001 From: Bill Stumbo Date: Sun, 8 Nov 2026 08:10:06 -0500 Subject: [PATCH 10/10] Expand Group 1 glossary definitions --- content/en/history/glossary/_index.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/content/en/history/glossary/_index.md b/content/en/history/glossary/_index.md index 9622bab56..66642057c 100644 --- a/content/en/history/glossary/_index.md +++ b/content/en/history/glossary/_index.md @@ -14,7 +14,7 @@ For general computer terminology and lore see [The Hacker's Dictionary](https:// ## Vocabulary and relationships Advice (Advising) -: A facility for modifying an existing function without editing its definition by wrapping it with code that runs before or after the function and can inspect or change its arguments or return value. Also called advising. +: A facility for modifying an existing function without editing its definition by wrapping it with code that runs before or after the function and can inspect or change its arguments or return value. Advice can be added to and removed from a function independently, so a programmer can instrument or adapt code temporarily and leave the original definition intact. Also called advising. AltoLisp : An experimental microcoded implementation of Interlisp on an Alto personal computer. @@ -57,7 +57,7 @@ as a graphics terminal. : The reimplementation of the AltoLisp microcode on the Dorado – a research prototype. DWIM -: Do-What-I-Mean. An Interlisp error-recovery facility that intercepts errors such as undefined functions, unset variables, and misspellings, using heuristics and context-sensitive spelling lists to suggest or apply corrections and continue execution. +: Do-What-I-Mean. An Interlisp error-recovery facility that intercepts errors such as undefined functions, unset variables, and misspellings, using heuristics and context-sensitive spelling lists to suggest or apply corrections and continue execution. When a correction is uncertain, DWIM can ask the user to approve it; when the user is away, it can apply a default after a delay. DWIM can also repair some structural errors, such as a number typed in place of a parenthesis, so the computation can proceed without restarting. Fugue : An obsolete named release of Interlisp-D. @@ -66,7 +66,7 @@ as a graphics terminal. : An obsolete named release of Interlisp-D. History package -: An Interlisp facility that records the commands and expressions entered during a session, together with messages displayed during their execution, so they can be reviewed, replayed with substitutions, or undone. +: An Interlisp facility that records the commands and expressions entered during a session, together with messages displayed during their execution, so they can be reviewed, replayed with substitutions, or undone. Each recorded event also keeps the information needed to reverse its side effects, which makes the history list the basis for UNDO. The history can be searched and selectively replayed, so a user can reuse or correct an earlier operation without retyping it. Intermezzo : An obsolete named release of Interlisp-D. @@ -133,25 +133,25 @@ as a graphics terminal. - A feature of Commmon Lisp symbol support; the package system allows the combining of Interlisp symbols (written with `IL:` prefix) and Common Lisp symbols (written with a `LISP:` prefix). Prettyprint -: A Lisp utility that prints programs with indentation and line breaks that reflect their list structure, making code easier to read and debug. +: A Lisp utility that prints programs with indentation and line breaks that reflect their list structure, making code easier to read and debug. Because Lisp programs are lists, a prettyprinter can lay out nested expressions according to their depth and width instead of printing them as one long line. It is used both to display code and to produce readable listings or files. SDL : Structured Design Language. Spaghetti stack -: An Interlisp execution stack that remains available as a structured list, allowing programs and debugging tools to search frames, inspect values in caller contexts, and perform non-local returns. +: An Interlisp execution stack that remains available as a structured list rather than a contiguous array, so each frame can still be reached through the list structure. This lets programs and debugging tools search frames, inspect values in caller contexts, and perform non-local returns. Because the stack can be traversed and its frames examined, it supports debugging, error recovery, and control operations that would be difficult with a conventional call stack. Structure editor -: An editor that operates directly on a program's list structure rather than its printed text. Because Lisp programs are lists, commands can move through and modify a function's tree in place without leaving Lisp. +: An editor that operates directly on a program's list structure rather than its printed text. Because Lisp programs are lists, commands can move through and modify a function's tree in place without leaving Lisp. Editing commands select list elements, descend into sublists, and insert, delete, or replace structures, so the edit changes the program itself rather than a separate text file. This allows a running program to be inspected, modified, and re-evaluated in the same environment. Sysout : A file containing the saved state of Interlisp virtual memory. -Trace -: A Lisp debugging facility that redefines a function so that selected information, by default its arguments and return value, is printed when the function is entered and exited. Tracing remains in effect until the function is untraced. +Trace +: A Lisp debugging facility that redefines a function so that selected information, by default its arguments and return value, is printed when the function is entered and exited. Tracing can be applied to one function or several and remains in effect until the function is untraced. It gives a running account of calls and results without requiring the programmer to stop the program or insert print statements by hand. UNDO -: A command in the Interlisp Programmer’s Assistant that reverses the side effects of operations recorded on its history list. It supports selective undo—reversing an earlier operation without undoing later ones—as well as undoing assignments and whole edit sessions. Undoing an operation can itself be undone. +: A command in the Interlisp Programmer’s Assistant that reverses the side effects of operations recorded on its history list. It supports selective undo—reversing an earlier operation without undoing later ones—as well as undoing assignments and whole edit sessions. A user can also make a user-defined function undoable by recording the information needed to reverse its effects. Undoing an operation can itself be undone, and related commands can redo or reuse recorded events. X11 : The X Window System.