Notices by screwlisp (screwtape@mastodon.sdf.org)

Terry's point is that rather than being a "dead end" as people would blithely tell him, SHRDLU is actually /exactly/ the kind of computer program that is meaningful to write.
Its behaviour is both deliberate and mindbogglingly complex (barely fitting in Winograd's head). His argument is that each computer program should be as intricate and expansive a contribution to the world as possible at the periphery of the author's ability.

Not get-rich-quick-scheme style learning and crunching.

Argh, I reread Breaking The Complexity Barrier (Again) 1973 and Winograd's still completely right.
It would be nice if:
- we could just run "learning" on a bunch of data, and it would figure everything out without us telling it
- we could just run "crunching" on a bunch of symbols, and it would figure everything out without etc.
but neither of those have an antecedent for being a way things work.

It makes me think I actually have to do the work of using Sandewall's Leonardo System =_=

I can't say I'm happy about it but this implies that currently freecad and linux are humanity's premier contributions to the universe.

Edit:
I guess we can be happy that emacs is also up there. Compilers and languages generally maybe. I think McCLIM should be regarded as an important ongoing success. It's just that rather than McCLIM and emacs being exceptional, anyone belonging to the computer-fanciers-association should be part of contributing something like Sandewall's Leonardo System.

LLMs are in the first class of failures. Transformers - using a feedforward network with attention on terabytes and terabytes of scraped data - is an attempt to get something without contributing a boundary-pushing program (having been allowed by world governments to steal data without recompense, they got it for free).

I actually do consider LLMs to be spooky, even beyond making public vast quantities of private historical emails.

But this is a legal innovation, not a human-authored one.

@dougmerritt

@amszmidt @larsbrinkhoff
You two don't happen to be aware of an intact source for historical SHRDLU? The 90s clisp port, "SHRDLU after suffering a stroke" sounds kind of unappealing.

@dougmerritt Understand Natural Language '72, right?

@ksaj My first guess is that you're doing something annoying like this ->
CL-USER> (defun bar (&aux (y 1))
(+ y (locally (declare (special y)) y)))
BAR
CL-USER> (defparameter y -1)
Y
CL-USER> (bar)
0
CL-USER> (defun bar (&aux (y 1))
(+ y (locally (declare (special y)) y)))
WARNING: redefining COMMON-LISP-USER::BAR in DEFUN
BAR
CL-USER> (bar)
2
I can never get special variables straight.
I'll think tomorrow
@khleedril @amszmidt

@ksaj
in the spirit of obliquely addressing your cleverness, I wrote this version of the same point:

<ignore the fact that the code in this toot worked in some contexts>
@khleedril @amszmidt

@ksaj
It hadn't occurred to me that we could separate local and special references to one variable by declarations about different cases of that variable (which will be upcased for the purposes of finding the value later)
@khleedril @amszmidt

@ksaj
Eh, I didn't get it, but I'm on my way to sleep. This just looks normal to me:
(defun fact (n)
(prog
((x n) (result 1))
start
(when (< x 1) (return result))
(setq result (* result x) x (1- x))
(go start)))
I thought you would be doing -modern for something like my redacted snippet, but I don't think so.
@khleedril @amszmidt

@slgr
Oh side note, the author coins the words [complete] programming system for emacs, but to my knowledge this phrase was common in the lisp community basically always (often refering to lisp+emacs+etc)
@ramin_hal9001

@slgr
I read these, and I mean, the author mostly has CLIM jealousy. "Why is no-one intuitively thread-safe with enhanced message (let's say command) passing", CLIM, why does no-one generate GUIs intuitively (CLIM). Then the author lists a bunch of examples of how nothing like CLIM existed in the past, all of which were younger than CLIM.

I mean, it took me a long time and other people a lot of effort to get me to realise #McCLIM exists myself and its antecedents a long time.
@ramin_hal9001

@amszmidt
I want to read the original name ?MACS as questionmarks, but this is probably how rumors get started
@ramin_hal9001 @masso @AmenZwa @sacha

@amszmidt
ah yeah, thanks for the summarised statement of events.
@ramin_hal9001 @masso @AmenZwa @sacha

@amszmidt
https://www.gnu.org/software/emacs/manual/html_mono/efaq.html#Origin-of-the-term-Emacs
(GNU says emacs was a project started by steele and completed by rms)
@ramin_hal9001 @masso @AmenZwa @sacha

@ramin_hal9001 @sacha
3/3 and needing to read more
I wonder if GNU can be understood to have survived primarily as a vehicle for running emacs. GIMP is kind of the odd counterexample, though in hindsight, GIMP in 1997 was a libre copy of the then-more-central proprietary CLIM implementations but GIMP used tinyscheme instead of clim-lisp/common-lisp as its command language (button programming language, whatever gimp calls it) as its point of difference.

@ramin_hal9001 @sacha

oh I should actually say something. Thank-you for your thinking you two!

Viz unix and emacs, do you remember that Japanese emacs lisp blogger 15 years ago writing that emacs was a key value source for the unix ecosystem because of the secret sword [if memory serves] of writing external programs whose primary interface are an emacs mode with the example of flycheck, which became popular outside of emacs @masso do you remember what I'm talking about or am I totally lost?

@ramin_hal9001 @sacha @masso

a few weeks ago I did highlight that in Pike's infamous Software Research Is Irrelevant talk that the emacs-centric lisp machines prior to the 90s were not unix(-compatible) and were a casualty of unix in the same way Pike's plan9 was a casualty of unix.

But then, Pike was complaining that in 2000, basically every programmer used emacs on unix and in 1990, basically every programmer also used emacs on unix so maybe there is a special link between emacs and unix.

So I'm not the expert but for one example there are multiple memory bands, and when you patch your system, you copy/create the new patched system in a different band, then switch the active band to that one. @amszmidt @symbolics @weekend_editor @remilia @notptr

@amszmidt I might have garbled it, but he was talking about structured programming. So when the data structure being operated on is a cons cell, use car and cdr, and when the data structure being operated on is a list, use list functions like first and last (for example, but also consider something like subseq). I'm open to not necessarily agreeing with Allen's book (for undergraduates).
@simon_brooke