Lilith and Modula-2
#HackerNews #Lilith #Modula2 #ProgrammingHistory #TechInnovation #SoftwareDevelopment
#ProgrammingHistory
🐢💾 Oh joy, someone unearthed a Jurassic relic from the primordial ooze of programming history: the first C compiler source code! Now you can bask in the glory of 1972 tech while pretending it’s a groundbreaking find instead of a dusty artifact only relevant to vintage nerds and digital archaeologists. 🚀✨
https://github.com/mortdeus/legacy-cc/tree/master/last1120c #Ccompiler #JurassicTech #VintageNerds #DigitalArchaeology #ProgrammingHistory #HackerNews #ngated
Everyone talks about the Mother of All Demos. But you never hear about the Father of All Demos.
And isn't that really the problem with society? Too many demos are growing up in broken homes.
Does Visual Studio Rot the Mind? (2005) — https://charlespetzold.com/etc/DoesVisualStudioRotTheMind.html
#HackerNews #VisualStudio #MindRot #SoftwareDevelopment #TechDebate #ProgrammingHistory
Discovering Errors in Donald Knuth's Taocp — https://glthr.com/discovering-errors-in-donald-knuths-taocp
#HackerNews #DiscoveringErrors #DonaldKnuth #Taocp #ProgrammingHistory #TechErrors #ComputerScience
🖥️ Welcome to the Aztec C Online Museum, where you can explore the dusty relics of a bygone era in programming and bask in the glory of long-forgotten compilers! 🤓 It's like a time capsule of 'cutting-edge' 1980s tech, lovingly preserved by Bill Buckels, because who wouldn't want to spend their free time on ancient C programming tools? 🙃
https://www.aztecmuseum.ca/index.htm #AztecCOnlineMuseum #programminghistory #vintagecomputing #technostalgia #BillBuckels #HackerNews #ngated
El nombre Python no viene de la serpiente, sino de "Monty Python's Flying Circus". Guido van Rossum era fan del grupo cómico y buscaba un nombre corto, único y ligeramente misterioso. Las referencias a sketches de Monty Python abundan en la documentación. 🎭
LISP (1958) introdujo el recolector de basura, funciones como datos de primera clase y muchas otras características "modernas". La mayoría de innovaciones en lenguajes de programación ya existían hace 60+ años. 🔄
#ProgrammingHistory #LISP #FunctionalProgramming #Innovation
LISP (1958) introdujo el recolector de basura, funciones como datos de primera clase y muchas otras características "modernas". La mayoría de innovaciones en lenguajes de programación ya existían hace 60+ años. 🔄
#ProgrammingHistory #LISP #FunctionalProgramming #Innovation
Learning a bit about Donald E. Knuth:
"While studying physics at Case, Knuth was introduced to the IBM 650, an early commercial computer. After reading the computer's manual, Knuth decided to rewrite the assembly and compiler code for the machine used in his school because he believed he could do it better."
Because he believed.
Woah.
Taken from "Programming Languages: History and Future" from 1972 by Jean E. Sammet.
#ProgrammingHistory
Humans created robots to teach humans how to program robots... and it worked! 🤖
The 1984 game ChipWits, which inspired countless developers, has released its original source code after 40 years. Like digital archaeology, they rescued the code from ancient 5.25" disks!
Making history accessible, one FORTH at a time 😼
📚 The library and magazine collection are steadily growing with your assistance 🌐 You can search it here: https://plus.cobiss.net/cobiss/si/en/colib/rmlj
#computermuseum #computerhistory #slovenia #ljubljana #softwareheritage #digitalheritage #nostalgia #programminghistory #museo #retrocomputing #zxspectrum #vintagecomputer #vintagecomputing #informatica #elettronica #microprocessore #library
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.)
Take a journey on our chronological spiral staircase, where each step represents a different part of programming history. Share your favorite!👋
#computermuseum #computerhistory #slovenia #ljubljana #softwareheritage #digitalheritage #nostalgia #nostalgie #nostalgi #programminghistory #vintage #vintagecomputer #vintagecomputing #retro #europee #retrocomputing #developers #python #ruby
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
The Neural Network Revolution: Why AI Will Make Traditional Databases Obsolete
https://rajiv.com/blog/2023/05/12/the-neural-network-revolution-why-ai-will-make-traditional-databases-obsolete/
#NeuralNetworks #DatabaseEvolution #InformationStorage #AI #DataManagement #NoSQL #RelationalDatabases #MindMapping #ProgrammingHistory #LargeLanguageModels #LLM
It seems like a lot of old programming language examples show carriage-return or newline being placed *before* the output string (e.g. "\nhello world"); I've seen this with Mumps and Forth examples. When did this change and why? #ProgrammingHistory
Client Info
Server: https://mastodon.social
Version: 2025.04
Repository: https://github.com/cyevgeniy/lmst