#programminghistory — Public Fediverse posts

Boris Cherny: TI-83 Plus Basic Programming Tutorial (2004)

https://www.ticalc.org/programming/columns/83plus-bas/cherny/

#HackerNews #BorisCherny #TI83Plus #BasicProgramming #Tutorial #ProgrammingHistory #EducationTech

Back to the future: the story of Squeak, a practical Smalltalk written in itself [pdf] (1997)

http://www.vpri.org/pdf/tr1997001_backto.pdf

#HackerNews #BackToTheFuture #Squeak #Smalltalk #ProgrammingHistory #TechDocs #1997

🤯 Ah yes, the riveting saga of Common Lisp packaging: where we untangle the ancient hieroglyphics of #ASDF and #Quicklisp so you can finally figure out how to install a library from the '80s. ⚙️🕰️ Because nothing screams "modern programming" like deciphering terms minted before your parents met. 📜
https://cdegroot.com/programming/commonlisp/2025/11/26/cl-ql-asdf.html #CommonLisp #Packaging #ProgrammingHistory #ModernDevelopment #HackerNews #ngated

Extra Instructions of the 65XX Series CPU

http://www.ffd2.com/fridge/docs/6502-NMOS.extra.opcodes

#HackerNews #65XXSeries #CPU #ExtraInstructions #RetroComputing #CPUArchitecture #ProgrammingHistory

Lilith and Modula-2

https://astrobe.com/Modula2/

#HackerNews #Lilith #Modula2 #ProgrammingHistory #TechInnovation #SoftwareDevelopment

Discovering Errors in Donald Knuth's Taocp — https://glthr.com/discovering-errors-in-donald-knuths-taocp
#HackerNews #DiscoveringErrors #DonaldKnuth #Taocp #ProgrammingHistory #TechErrors #ComputerScience

@larsbrinkhoff

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.)

#Lisp #MacLisp #LispHistory #ProgrammingHistory #CommonLisp

Sean Haas of the Advent of Computing podcast ought to get more attention around here! He's 116 episodes into a unique and rather excellent history of computing. He doesn't cover the mainline of computer history, but instead follows fascinating threads of his own. He tends to avoid the political implications of the work he describes, focusing instead on technical and administrative structures.

I'm thoroughly enjoying his two-parter on the history of #Prolog.

I liked his outline of 'first principles' languages, all of them #homoiconic: #Lisp, which operates on lists; #Forth, a tiny stack language; and #Prolog, a declarative logic language. The first and last of those were both originated for natural language processing.

https://adventofcomputing.com/

#PodcastPsaturday #retrocomputing #adventofcomp #AdventOfComputing #ProgrammingHistory #QuirkyHistory #OriginalResearch #NLP