As part of my history project, I was looking for a document I wrote that offered specific advice on converting Maclisp and Zetalisp to Common Lisp.

I had to laugh when I found it. It's already published as part of the Sunday Morning Edition of the Pitmanual (the webbed version of the Revised Maclisp Manual, the printed version of which was the Saturday Evening Edition).

The printed version does not contain the conversion guide. It was an "extra" I through in as part of the webbing. But it's perhaps hard to find, so I thought I'd say it out loud. It's several pages that begin here:

https://maclisp.info/pitmanual/cl-conv-01-intr.html

#Lisp #Maclisp #Zetalisp #CommonLisp #KentsHistoryProject #Lisp #ComputerHistory

cc @screwlisp @larsbrinkhoff @eswenson

I couldn't find a copy of the memo named "Loop Iteration Macro" by Glenn Burke and David Moon, January 1981 (MIT/LCS/TM-169) at MIT's dSpace site, or anywhere else. So I scanned in my copy and have uploaded it to my web site.

NOTE WELL: This document was written prior to CLTL and describes a facility that was available in MACLISP and the Lisp Machine's Zetalisp. Common Lisp drew design ideas from this, but the syntax, semantics, and associated functions/macros described in this are NOT the same as what Common Lisp offers.

For example, my recollection from long ago (which I did not re-check before making this post) is that there are other differences in syntax because this earlier version of Loop was underconstrained in the ordering of the keywords in a way that let you write some expressions that the committee felt might confuse people with their results.

But also, for reasons that slip my mind, Common Lisp did not adopt the define-loop-path macro that is described starting on page 19.

http://nhplace.com/kent/History/maclisp/MIT-LCS-TM-169-Loop-Iteration-Macro.pdf

#lisp #maclisp #loop #iteration #ComputerHistory #KentsHistoryProject #lisp #LispM #Zetalisp #CommonLisp

cc @screwlisp

In going through some old papers, I ran across these very interesting documents from long ago that I can't seem to find public reference to. They seem to offer some important historical insight about the Dylan language. This is from back when Dylan was called Ralph as a working title. In those days, the still-being-designed Lisp-like language had not yet moved to an infix syntax, and it looked and acted more like Scheme with an object system similar in spirit to CLOS (the Common Lisp Object System).

My understanding is that there were some fairly deliberate choices made to NOT target the Lisp or Scheme community as users, which is part of why the move to infix. I think they wanted to appeal to a disaffected C++ crowd, but ultimately lost out to Java for that bid, and then having left the Lisp user base behind, ended up with a very small community as a result.

But I still think there could be things the Scheme community would want to glean from this snapshot of history.

I've included a scan of an email proposal I got from Dave Moon while he and I were at Symbolics, with his proposal for how to add conditions to the language. Note that Dylan did eventually go public and did have a condition system, so you could also just study that design directly. But what's useful here is to see how all that looked syntactically in a Scheme-like syntax. But, in that regard, I recommend starting by looking at the language itself.

[0] Ralph: A Dynamic Language with Efficient Application Delivery, by Andrew LM Shalit, July 25, 1991.
https://nhplace.com/kent/History/dylan/ralph-1991-07-25.pdf

[1] Ralph Conditions (part 1 of 2)
https://nhplace.com/kent/History/dylan/ralph-moon-conditions-proposal-v1.1-part-1-of-2-1991-08-14.pdf

[2] Ralph Conditions (part 2 of 2)
https://nhplace.com/kent/History/dylan/ralph-moon-conditions-proposal-v1.1-part-2-of-2-1991-08-14.pdf

cc @sigue @ramin_hal9001 @screwlisp

#DylanLang #RalphLang #ComputerHistory #Harlequin #Lisp #CommonLisp #ConditionSystem #ConditionHandling #ErrorSystem #Scheme #SchemeLang #CLOS #AppleHistory #KentsHistoryProject

I ran across and scanned an old document recently that describes the command set for TECO-based Emacs on the MIT ITS operating system in the very early 1980s, probably, although the document is not dated.

I think I either produced it, or had a hand in how it was produced. But in any case, the grouping and layout suits me in terms of describing why certain commands are related to one another, and making it easier to see why particular letters were chosen as mnemonics.

TECO was the language Emacs was originally implemented in, before it was ported to gnu. ITS was an MIT-written operating system for the Digital Equipment Corporation (DEC) PDP-10, a main frame processor whose architecture also spanned the TOPS-20 operating system (though I'm blurring some details).

http://nhplace.com/kent/History/emacs/Emacs-Command-Index.pdf

This is part of an ongoing project where I'm sifting some things in boxes at my house, trying to get rid of stuff I don't need. Some of it is getting scanned, other things just going to the trash.

#emacs #ComputerHistory #ITS #TECO #Lisp #KentsHistoryProject