Notices by DougMerritt (log😅 = 💧log😄) (dougmerritt@mathstodon.xyz)

@Gargron
My sympathies, that must be hard.

I hope you don't get extra trouble with quarantines on your kitties!

RE: https://mastodon.social/@lobsters/115868094199968713

@anildash
It was also picked up by Lobster:
https://mathstodon.xyz/@lobsters@mastodon.social/115868094478084159

2001 - Anders Hejlsberg invents C#. C# is a relatively verbose, garbage collected, class based, statically typed, single dispatch, object oriented language with single implementation inheritance and multiple interface inheritance. Microsoft loudly heralds C#'s novelty.

2003 - A drunken Martin Odersky sees a Reese's Peanut Butter Cup ad featuring somebody's peanut butter getting on somebody else's chocolate and has an idea. He creates Scala, a language that unifies constructs from both object oriented and functional languages. This pisses off both groups and each promptly declares jihad.

Footnotes
[1] Fortunately for computer science the supply of curly braces and angle brackets remains high.
[2] Catch as catch can - Verity Stob
https://james-iry.blogspot.com/2009/05/brief-incomplete-and-mostly-wrong.html
6/6

1995 - Yukihiro "Mad Matz" Matsumoto creates Ruby to avert some vaguely unspecified apocalypse that will leave Australia a desert run by mohawked warriors and Tina Turner. The language is later renamed Ruby on Rails by its real inventor, David Heinemeier Hansson. [The bit about Matsumoto inventing a language called Ruby never happened and better be removed in the next revision of this article - DHH].

1995 - Brendan Eich reads up on every mistake ever made in designing a programming language, invents a few more, and creates LiveScript. Later, in an effort to cash in on the popularity of Java the language is renamed JavaScript. Later still, in an effort to cash in on the popularity of skin diseases the language is renamed ECMAScript.

1996 - James Gosling invents Java. Java is a relatively verbose, garbage collected, class based, statically typed, single dispatch, object oriented language with single implementation inheritance and multiple interface inheritance. Sun loudly heralds Java's novelty.
5/6

1986 - Brad Cox and Tom Love create Objective-C, announcing "this language has all the memory safety of C combined with all the blazing speed of Smalltalk." Modern historians suspect the two were dyslexic.

1987 - Larry Wall falls asleep and hits Larry Wall's forehead on the keyboard. Upon waking Larry Wall decides that the string of characters on Larry Wall's monitor isn't random but an example program in a programming language that God wants His prophet, Larry Wall, to design. Perl is born.

1990 - A committee formed by Simon Peyton-Jones, Paul Hudak, Philip Wadler, Ashton Kutcher, and People for the Ethical Treatment of Animals creates Haskell, a pure, non-strict, functional language. Haskell gets some resistance due to the complexity of using monads to control side effects. Wadler tries to appease critics by explaining that "a monad is a monoid in the category of endofunctors, what's the problem?"

1991 - Dutch programmer Guido van Rossum travels to Argentina for a mysterious operation. He returns with a large cranial scar, invents Python, is declared Dictator for Life by legions of followers, and announces to the world that "There Is Only One Way to Do It." Poland becomes nervous.

1995 - At a neighborhood Italian restaurant Rasmus Lerdorf realizes that his plate of spaghetti is an excellent model for understanding the World Wide Web and that web applications should mimic their medium. On the back of his napkin he designs Programmable Hyperlinked Pasta (PHP). PHP documentation remains on that napkin to this day.
4/6

1973 - Robin Milner creates ML, a language based on the M&M type theory. ML begets SML which has a formally specified semantics. When asked for a formal semantics of the formal semantics Milner's head explodes. Other well known languages in the ML family include OCaml, F#, and Visual Basic.

1980 - Alan Kay creates Smalltalk and invents the term "object oriented." When asked what that means he replies, "Smalltalk programs are just objects." When asked what objects are made of he replies, "objects." When asked again he says "look, it's all objects all the way down. Until you reach turtles."

1983 - In honor of Ada Lovelace's ability to create programs that never ran, Jean Ichbiah and the US Department of Defense create the Ada programming language. In spite of the lack of evidence that any significant Ada program is ever completed historians believe Ada to be a successful public works project that keeps several thousand roving defense contractors out of gangs.

1983 - Bjarne Stroustrup bolts everything he's ever heard of onto C to create C++. The resulting language is so complex that programs must be sent to the future to be compiled by the Skynet artificial intelligence. Build times suffer. Skynet's motives for performing the service remain unclear but spokespeople from the future say "there is nothing to be concerned about, baby," in an Austrian accented monotones. There is some speculation that Skynet is nothing more than a pretentious buffer overrun.
3/6

1958 - John McCarthy and Paul Graham invent LISP. Due to high costs caused by a post-war depletion of the strategic parentheses reserve LISP never becomes popular[1]. In spite of its lack of popularity, LISP (now "Lisp" or sometimes "Arc") remains an influential language in "key algorithmic techniques such as recursion and condescension"[2].

1959 - After losing a bet with L. Ron Hubbard, Grace Hopper and several other sadists invent the Capitalization Of Boilerplate Oriented Language (COBOL) . Years later, in a misguided and sexist retaliation against Adm. Hopper's COBOL work, Ruby conferences frequently feature misogynistic material.

1964 - John Kemeny and Thomas Kurtz create BASIC, an unstructured programming language for non-computer scientists.

1965 - Kemeny and Kurtz go to 1964.

1970 - Guy Steele and Gerald Sussman create Scheme. Their work leads to a series of "Lambda the Ultimate" papers culminating in "Lambda the Ultimate Kitchen Utensil." This paper becomes the basis for a long running, but ultimately unsuccessful run of late night infomercials. Lambdas are relegated to relative obscurity until Java makes them popular by not having them.

1970 - Niklaus Wirth creates Pascal, a procedural language. Critics immediately denounce Pascal because it uses "x := x + y" syntax instead of the more familiar C-like "x = x + y". This criticism happens in spite of the fact that C has not yet been invented.

1972 - Dennis Ritchie invents a powerful gun that shoots both forward and backward simultaneously. Not satisfied with the number of deaths and permanent maimings from that invention he invents C and Unix.
2/6

A Brief, Incomplete, and Mostly Wrong History of Programming Languages
James Iry; Thursday, May 7, 2009

1801 - Joseph Marie Jacquard uses punch cards to instruct a loom to weave "hello, world" into a tapestry. Redditers of the time are not impressed due to the lack of tail call recursion, concurrency, or proper capitalization.

1842 - Ada Lovelace writes the first program. She is hampered in her efforts by the minor inconvenience that she doesn't have any actual computers to run her code. Enterprise architects will later relearn her techniques in order to program in UML.

1936 - Alan Turing invents every programming language that will ever be but is shanghaied by British Intelligence to be 007 before he can patent them.

1936 - Alonzo Church also invents every language that will ever be but does it better. His lambda calculus is ignored because it is insufficiently C-like. This criticism occurs in spite of the fact that C has not yet been invented.

1940s - Various "computers" are "programmed" using direct wiring and switches. Engineers do this in order to avoid the tabs vs spaces debate.

1957 - John Backus and IBM create FORTRAN. There's nothing funny about IBM or FORTRAN. It is a syntax error to write FORTRAN while not wearing a blue tie.
1/6

Preserving code that shaped generations: Zork I, II, and III go Open Source
"Today, we’re preserving a cornerstone of gaming history that is near and dear to our hearts. Together, Microsoft’s Open Source Programs Office (OSPO), Team Xbox, and Activision are making Zork I, Zork II, and Zork III available under the MIT License. Our goal is simple: to place historically important code in the hands of students, teachers, and developers so they can study it, learn from it, and, perhaps most importantly, play it.
"...The games remain commercially available via The Zork Anthology on Good Old Games."
https://opensource.microsoft.com/blog/2025/11/20/preserving-code-that-shaped-generations-zork-i-ii-and-iii-go-open-source
https://github.com/historicalsource/zork1
And an Ars Technica article about that:
https://arstechnica.com/gaming/2025/11/microsoft-makes-zork-i-ii-and-iii-open-source-under-mit-license/

I originally beat Zork in the original PDP-10 version, arpanet-ing in to MIT to play it.

The original Zork written in the MDL dialect of Lisp was already available:

"This version of ZORK has been (slightly) changed from the original in order to run on the Confusion MDL Interpreter.
https://github.com/whitten/MDL-Zork

There's also this:
'This directory contains files related to Confusion, an MDL interpreter which, to quote its author, "Works just well enough to play the original Zork all the way through."'
http://www.ifarchive.org/indexes/if-archive/programming/mdl/interpreters/confusion/

@benjamingeer @ddrake
I haven't read it yet, but the news article points to the open access paper; at first blush they appear to care about idiomatic Rust :

Automatically Translating C to Rust
Automatic C-to-Rust translation tools are helpful, but they produce unsafe and unidiomatic code. What can be done to address these issues?
Authors: Jaemin Hong, Sukyoung RyuAuthors Info & Claims
Communications of the ACM, Volume 68, Issue 11
https://dl.acm.org/doi/10.1145/3737696

@amszmidt @screwtape @glitzersachen @mark
If your point here is that Lisp compilers were originally more sophisticated than C compilers of the time, yes, that's my memory too.

Part of that is because Lisp compilers were on 36 bit mainframes while C compilers were on 16 bit 64KB minicomputers (and a little later, on 16 bit 64KB microcomputers), so there were definite reasons pushing towards that.

However, if you are also remembering that those sophisticated Lisp compilers emitted code that ran faster than what was emitted by those unsophisticated C compilers **in the general case**, then your memory is faulty.

C is a much, much easier language to compile efficiently. And to this day, Lisp has constructs that do not have simple fast machine code equivalents. Absolutely anything at all that is dynamic, for instance. C has no such things, aside from trivial still-fast constructs like function pointers. It doesn't even have built-in hash tables.

@amszmidt @screwtape @glitzersachen @mark
> I'd even go as far that overall, Lisp has been close to "C" performance for the last 40 years.

Sorry, but that is simply not supported by the numbers from 40 years ago, in the case of general purpose programming.

It was fast *enough* for many purposes, and for certain special purposes, and okay maybe sometimes on a Lisp Machine, but all of which is a different question than general purpose on common CPUs.

@amszmidt @screwtape @glitzersachen @mark
Yeah yeah yeah.

But I'm a compiler guy. (A) Your standards of efficiency are not my standards of efficiency. (B) Today's state of the art is obviously far better than in the 1980s, and I'm old. (C) Today's CPUs are so fast that efficiency matters (to users, not compiler people) vastly less than decades ago.

Anyway I'm spread out over many disciplines, and in programming, over many programming languages, so forgive me for not knowing what is obvious to you.

I *have* been aware of Lisp's role as a "systems programming language" for Emacs, though, since the first implementation of Lisp-based Emacs. It's for completely general purposes I was wondering about, and I shouldn't even wonder about that, since I'm aware that Lisp compilation has improved dramatically over time.

There's always going to be a battle for the highest levels of efficiency, though. Today people are trying to make Rust and Zig and such as efficient *always* as C, just like people used to try to make C as efficient as programming in assembly (a goal which has largely been long surpassed).

And there will always be purposes for which being within 2x (sometimes even 20x) of C is plenty good enough, and people in that domain will wonder why the above people are making a fuss.

@screwtape @glitzersachen @mark
Keyword arguments are great!

I've done so many zillions of lines of C for systems programming that it's hard for me to see it as undesirable in that capacity, even if there is in fact a better alternative.

What one is accustomed to typically feels natural and right, just from the habits and experience, not from careful judgements.

Anyways...how easy is it to compile Common Lisp into something nicely efficient, so that it's not unnatural to use it as a systems programming language?

@screwtape
If you read Winograd's SHRDLU book, it all makes sense, but of course it only captures a fraction of the programming, which was a tour de force.

Someone resurrected it once, but not in a form that I personally was able to use. Not sure about these days.

@screwtape
Etymology doesn't necessarily prove anything, but it *is* pretty weird that "CAR" was the mnemonic for "Contents of A Register" and "CDR" for "Contents of D Register" -- literal machine registers, not originally an abstraction at all.

BTW

> CDR coding was only really used on the Lisp Machine

That's 100% false.

@amszmidt
@ksaj

@screwtape @riley
As a historical note:

> There isn't a lot of cost (well, one cons to nil)

Back in the days when RAM was measured in kilobytes / kilowords, some implementations did in fact have space-optimized representations for short lists represented as small arrays.

See cdr-coding
https://en.wikipedia.org/wiki/CDR_coding

That might still be in some implementations today, since its savings might be significant in large structures or in aiding cache locality.
 
The first paper may well have been L. Peter Deutsch: A LISP Machine with Very Compact Programs. IJCAI 1973, Pages 697 - 703

This is covered in 7.13 in the classic "Anatomy of Lisp", John Allen (1937-2022), 1978 (long out of print, and the author once replied to my query saying he didn't think it was worthwhile updating it for more modern times).

Has a lot on implemention, but tends to talk about abstractions in terms of M-Expressions, which is no longer in style.

ACM has it online:
https://dl.acm.org/doi/pdf/10.5555/542865

Glowing review of "Anatomy" on goodreads: https://www.goodreads.com/book/show/1537412.Anatomy_of_LISP

"John Allen (1937-2022) and Anatomy of LISP" by Paul McJones
https://mcjones.org/dustydecks/archives/2024/04/11/1249/

@northernlights

Sorry, I just meant @ screwtape. You go ahead and be you.

@screwtape @kentpitman @SDF @nosrednayduj @sacha @hairylarry @pkw @rat @pizzapal

@northernlights @screwtape @kentpitman @SDF @nosrednayduj @sacha @hairylarry @pkw @rat @pizzapal
But, as usual, *everyone* should avoid mentioning which editor is their favorite. We don't want bloodshed! It's hard to clean up.

@prahou
Appearing to be pathetically ignorant is my superpower!

Somehow.

@screwtape @mdhughes @nosrednayduj @hairylarry @pkw @sacha @shizamura @rat @SDF @kentpitman