jnpna repost from sachac emacs summary, golden nuggets of vintage computing:
"Kent Pitman #demo 1977-1984 #MIT #ITS #DDT #TECO #EMACS #LISP #maclisp
PeerTube
Lispy Gopher Climate w/ screwlispKent Pitman #demo 1977-1984 #MIT #ITS #DDT #TECO #EMACS #LISP #MACLISP
Public Lispy Gopher Climate sunday Morning in Europe stream - 5/3/2026, 7:06:00 AM
Kent PitmanAs 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
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
Björn Victor
Paolo AmorosoThis 1983 paper reported on the experience with implementing the same applications on three different Lisp systems: Maclisp on a DEC-20, Franz Lisp on a VAX 11/780, and Interlisp-D on a Dolphin workstation. Despite the graphical environment the poor performance of the Dolphin hardware, one of the slowest Xerox D machines, made the Interlisp-D experience worse than other systems.
BITNACHTI wonder: Has #maclisp ever been ported to the Mac?
Some random trivia about the implications of this change you cite, and then about some related things...
I arrived on scene with MACLISP in 1977. As an undergrad, I managed to get assigned a desk and console in an office with Guy Steele and JonL White (who wrote this announcement). Having such folks, and others, handy made it easy to ask questions. I wrote The Revised Maclisp Manual (later webbed at https://maclisp.info/pitmanual) a couple years later in order to share what I'd learned.
In '77, DEFUN worked exactly like what you show here, but with some nuance that may have been there from the beginning or may have been added later:
One of the important but easy-to-overlook things about DEFUN, as described there, is that when you compile a DEFUN in MACLISP, it puts the compiled definition in the SUBR or LSUBR property, and when you compile DEFUN FEXPR, it puts the compiled definition in the FSUBR property. So you could write DEFUN and it would work either interpreted or compiled. This is because when you funcalled something, it looked for a definition in any of the SUBR, LSUBR, or EXPR property. But had you used DEFPROP, there was a complex philosophical problem because really the compiled version of (DEFPROP (LAMBDA ...) EXPR) had to willfully turn into (DEFPROP <compiled-lambda> SUBR) or (DEFPROP <compiled-lambda> LSUBR), even though the definition CLEARLY asked for a particular property. DEFUN hid such implementation detail, which was just semantically messy. Much of MACLISP was similarly messy.
The biz about SUBR vs LSUBR, for those who don't know is that there was a thing called a LEXPR which was obtained by (LAMBDA N-ARGS ..body..) where the argument received a number of args and you had to call the ARG function (it was function-like but really a special form) to get the particular arg. That was how you could receive variable numbers of args before &keywords were invented (and also how &keywords were implemented at the low level in Maclisp even after the DEFUN& macro arrived on the scene). A function like (LAMBDA (X Y) ...) compiled to a SUBR but a function like (LAMBDA X ...) compiled to an LSUBR. Except any function of -- if memory serves -- 5 or more args got compiled as an LSUBR even if it had a fixed number of args. Again if memory serves, this was an issue of the SUBR function call sequence needing to use registers and only a fixed number of registers were allocated for args, so if the number of args exceeded that number, the LSUBR calling sequence was used.
MACLISP did not worry excessively about whether compiled code and interpreted code had precisely the same semantics, so the fact that
(DEFPROP FOO (LAMBDA X X) EXPR)
(PRINT (IF (GET 'FOO 'EXPR) 'YES 'NO))
printed a different value interpreted and compiled was not something that surprised many experienced programmers.
Of course, there were other compiled/interpreted differences like that interpreted (LAMBDA (X) (F X)) would special-bind X, while compiled it would not. This is short of saying the X was lexical. There were no closures. But the binding was not available to called functions like F in compiled code even though it was in interpreted code.
The realizations that these various language features mattered at all, and needed to be consistent, were gradual. MACLISP was as much a testbed for new ideas as a language itself. It was a big deal thing (and even very controversial) that Common Lisp had lexical variables.
(Insert obligatory reminder that MACLISP is nothing to do with the modern macintosh. This was long before Apple existed. Project MAC at MIT was something quite unrelated.)
Nils M HolmThere is now a hardcover edition of LISP from Nothing, because some people asked. See http://t3x.org/lfn/
Nothing new inside, just a hardcover version of the same book about minimal LISP and LISP in the age of mainframe computers.
#LISP, #eval, #MACLISP, #mainframes, #punchcards, #teletypes, #retrocomputing
Nothing new inside, just a hardcover version of the same book about minimal LISP and LISP in the age of mainframe computers.
#LISP, #eval, #MACLISP, #mainframes, #punchcards, #teletypes, #retrocomputing
My recollection is that the comma operated as whitespace in MACLISP until backquote became a built-in. It let you write things like (SETQ XPOS (1, 2)) and feel more like you were writing a coordinate pair. But as you see here, it also let you get the feel of assembly language, where you might have written
MOVE 3,1