#lispygopher — Public Fediverse posts

@screwlisp

FYI, I have finally published the actual source of my 2014 essay "Whither Original Thought" to my web site. It links to the audio from your radio show a month ago when I had read it aloud for the first time.

https://nhplace.com/kent/Writing/Whither-Original-Thought.html

#Philosophy #Programming #OriginalThought #literacy #education #thought #legitimacy #LispyGopher #invention #originality

@screwtape

This will be very rambly and informal and free-format and approximate, but someone might like it...

TECO has been around a long time. It was certainly around when I arrived on the MIT scene 1977-ish. But probably a long time before.

You asked what people used as a screen editor and I have to laugh. TECO was not really a screen editor, but was the implementation substrate for original Emacs. I'll tell the story I know.

TECO had commands that were single character (mostly, though some composed) and you did a set of commands and then could ask to see what you did. Usually, because it also worked on a paper terminal (which recorded everything you typed onto reams of paper), you saw maybe one line of context and then made some change. Some people did really long lives with entire defuns on one line. But it kind of didn't matter. c was the command to move foward. d to delete a character. 3c-4d would go forward 3 characters and delete 4 characters backward. You ended your command with Esc Esc (which echoed as $$) so 3c-4d$$ would show you the edited line and then you'd do more. A single Esc was a command separator or terminator, but two caused it to go.

You could put "macros" (really just strings of commands) in a thing called a q-register (really just a variable, except primitive Teco had no variables). The q-registers were so-called because they were named q0, q1, etc. and also qA, qB, ... qZ. You could put something in them with u. 5uA puts 5 into qA. Some commands were modifiable with @ or : (like in format strings in CL). So while ifoo$ would insert foo into the buffer at the current point, :i05c-4d$ would not insert anything in the buffer but would instead insert '5c-4d' into q0. So once you have strings in q registers you could execute them with m, as in m0 which would execute my sample string from above.

At some point, they changed it on glass (non-paper) screens to show you the buffer as edited, but still it was not doing the WYSIWYG thing. You saw part of a buffer with /\ as a cursor. So /\foo if the cursor was before foo. And Steele suggested that if there was a q-register assigned to each key, you could have it run that macro on hitting that key, which was the origin of emacs ^R (control-R) mode, ^R being the command that would get you into it. R for "real-time" mode. Stallman implemented it. I don't know who thought up the naming, probably Stallman.

The key bindings were on specially named new q-registers that had dots in their names. I think q^RA, q^RB, etc. where ^R was a control-R character. For control-A, q^R.A, for meta-A, q^R..A, etc. and for c-m-A q^R...A, so that allowed binding all the keys.

And at that point you had a realtime mode that was emacs-like. People could have init files that loaded up any of the q-registers with their own bindings, and there were library formats created so people could pre-load complicated definitions.

There was a lot of competition for whose library bindings would win out. Emacs was not the only early offering. Whole other packagings were available from various people. But eventually there was a mostly-consensus on a lot of it, and the rest became libraries on that.

TECO, especially the MIT variant, looks a bit like line noise since nearly every character was a command. But fortunately in libraries the style was to include code on the first half of the line and use the last half of the line as a comment explaining it. Here's a pointer to a library I wrote in TECO that tried to emulate some of the Lisp Machine's mail reader Zmail. If you want to see how the language worked by just kind of letting it roll past you.

https://pdp-10.trailing-edge.com/mit_emacs_170_teco_1220/01/emacs/zbabyl.emacs.html

#LispyGopher #TECO #history

https://anonradio.net:8443/anonradio

#lispyGopher #climate #live on the hour (but you would listen to @northernlights the hour before (#liveNow) as well rihgt @SDF

I don't have internet.

#music #happyBirthday @etherdiver Tales of Ether Space ambiently
#unix_surrealism https://merveilles.town/@prahou/112004528913520839 @prahou
@kentpitman https://netsettlement.blogspot.com/2018/11/plutocratic-denial.html climate crisis poetry from 2018 @Reiddragon #cognitiveSystems #EricSandewall #artificialIntelligence #book #lisp https://www.ida.liu.se/ext/aica/
#gopher #phloggersGarage #irc

Since I was slack today, please join me in discussing *next* week's #lispygopher #climate in this thread:
Candidate topics:
#VHDLISP fortnight: The thrilling conclusion
#gopherMOO and the internet of the future
#Cyberspace, #programming, the climate and #China From people I know
#crypto with #CommonLisp #ironclad
A #music'al investigation of @timnewsham

@mdhughes @rat @pkw @gnemmi @northernlights at everyone

#lispygopher #archived (scroll down) @SDF https://aNONradio.net
#climate
(let ((*print-circle* t))
"I'm going to read some of @kentpitman 's toot on repitition")
in climate messaging and the everything's-fine double-talk that happens
#lisp I've been consumed with #exploratoryProgramming of #vhdl generation for the past week, check my
#gopher gopher://tilde.club/0/~screwtape/synthember-100days-tooffload/036-vhdl-fortnight-1.org
https://gopher.tildeverse.org/tilde.club/0/~screwtape/synthember-100days-tooffload/036-vhdl-fortnight-1.org
#music @jessica https://mastodon.heavymusic.rocks/@jessica/111378490412073350

#lispyGopher show at Wed 000UTC #archived https://archives.anonradio.net/202310250000_screwtape.mp3
#climate haiku by @kentpitman
Climate resilient societies
@hayley pigeon proposal
#gopher
#gopherMOO #VR from @masinter & kmp^
#lisp
#ExploratoryProgramming #veilid
#SSB after
#mastodon
@mousebot calms me down after I got in one argument once
#futurePlans
I'll work on #usim with @amszmidt for [Nov Jan]
#redacted
Student Correction for using a chatbot leak

Show #unix_surrealism by @prahou
#music from @mxv

@screwtape

The PDP10 was a 36-bit architecture. Note well: NOT a power of 2. As I heard it, DEC was trying to make it be a lisp-friendly instruction set, so kind of an early lisp machine even though we referred to commercial vendors as "stock hardware". It had a fun instruction set. While the PDP-11w̶a̶s̶ ̶3̶2̶-̶b̶i̶t̶ ̶ was 16-bit [1], the PDP-10 was 36-bit. These OS's did not go in order. The PDP-10 (a.k.a, "the 10") was not superseded by the PDP-11 (a.k.a. "the 11"). They were different projects. While the 11 was stack-oriented, the 10 was VERY different. And the 11 was byte-oriented but the 10 wasn't; it was word-addressed with 18-bit pointers, so 256Kwords or about 1.25 MB if you're thinking 7-bit bytes of text (though mostly we didn't; we just said 256K, words was implied).

The 10 I used had a megaword of memory (4x what could be addressed), which was good because disks were slow and when a job (process) blocked, another was in memory and ready to run. And I heard Moon once say that megaword, called a "moby" cost $1M. Yikes.

But back to the word size, the 18 bits per half-word, was perfect for a cons. There were instructions to get one or the other half-word. And ASCII was 7-bit back then, so you could get 5 7-bit characters in a word, with one bit left over (sometimes wasted, sometimes used interestingly). There were ways to extract those efficiently. The first emacs originated in that environment, but not in lisp, in a language called TECO. But yeah, weird and fun 36-bit architecture. People can see here if that piques their interest: http://pdp10.nocrew.org/docs/instruction-set/pdp-10.html
The HLRZ instruction ("Half-left to right padding with zeros", I think it stood for, was the CAR function).

Howard Cannon, inventor of Flavors, the Lisp Machine / Zetalisp precursor to CLOS, had a license plate of HLRZ on his car. Probably few people in the real world understood, but it seemed cool. There were a few other instructions on the PDP10 that were directly Lisp instructions. Obviously HRRZ. I'll leave you to work that out.

Speaking of strange word sizes, Multics was a 72-bit architecture. I was told some address bits would never be non-zero because no one could ever afford that much physical memory. It was a Honeywell machine, not DEC. So I guess it's just coincidence it was twice the number of bits of the PDP-10. Multics was respected for being HIGHLY secure, long before its time, so not appreciated. Just as its primary language, PL/1, was not appreciated for its complex type casts. History is harsh to ideas that arrive too early. You can learn more about it here: https://www.multicians.org/
Dave Moon's earlier Maclisp manual (the Moonual), which predated my Revised Maclisp Manual (a.k.a. Pitmanual), was very Multics-leaning is preserved here: https://www.softwarepreservation.org/projects/LISP/MIT/Moon-MACLISP_Reference_Manual-Apr_08_1974.pdf

#Lisp #maclisp #LispyGopher

[1] Thanks to @larsbrinkhoff for correcting my memory downthread: The PDP-11 was a 16-bit, not a 32-bit machine.

@screwtape

I was doing some listening to back episodes of your Lispy Gopher show on AnonRadio, and I had a couple of supplementary remarks to add to the remarks you made about Lisp history, while recounting what you got out of my Untold Story paper. Far too detailed for on-air but this seemed a useful forum to flesh some of that out.

You asked about the back story of the lisp manual I wrote where I lost money (and got a hard life lesson in intellectual property). Yes, that was my Maclisp Manual, the Pitmanual (originally published in hardcopy at MIT, and later webbed at https://maclisp.info/pitmanual/index.html). Detailed history here: https://maclisp.info/pitmanual/history.html

Dave Moon (usually just called Moon) was a Multics Maclisp implementor and author of the first manual. Maclisp had evolved and changed a lot by time I wrote mine. I was mostly a Maclisp user, not implementor. I wrote a macro library or two. But I shared an office with Guy Steele and JonL White, Maclisp implementors, so I accumulated a lot of trivia that needed not to get lost. And I was having fun playing with Knuth's TeX. In Maclisp, I wrote a special-purpose Maclisp-manual-making language that compiled into TeX. The Pitmanual was written in that, a kind of tabular plain text, and my tool produced the TeX for the typeset book as output.

I should also note, to avoid confusion, that Maclisp was a pre-Common Lisp dialect that ran on the Digital Equipment Corporation (DEC) PDP-10, which was pretty much comparable to the DEC20 (which was really mostly a later and more commercial PDP10, though it ran a very different operating system).

Maclisp was so-named NOT because of the Apple Macintosh, which it long pre-dated, but because it was named after Project MAC (a multi-targeted acronym that meant things like Machine-Aided Cognition, Man and Computers, and other things like that if I recall). But it was an MIT project in using computation generally and had zero overlap with what Apple made. Eventually there as a lisp for the Apple MacOS system, but it was not Maclisp.

More remarks will follow as a separate attachment.

#lisp #maclisp #gopher #LispyGopher