Awesome video from Laurie Wired. Talks about introspection in retro computer systems. IMO everything she describes here is still alive in modern computers - it's just hidden behind lots of layers of abstraction. The only piece of software that really accesses it at the moment are debuggers. Unfortunately debuggers are mostly made for programmers (actually a narrow subset of programmers)... Or maybe there is Cheat Engine - but it's still kind of "for programmers" in a sense... Another thing Laurie mentions are crashes. Did you know that any program can just disable crashes? Just hook SIGSEGV & whenever OS signals that an error happened, respond with "everything looks fine to me". Your program becomes practically immortal (probably corrupted though).

I just watched that! I love how she presents, she doesn't shy away from technical details, but it feels so lay-person friendly

it popped up in my feed and sounded interesting, but couldn't handle her over the top delivery in the first few minutes... Does it get better, or is that just her style?

Pretty irrelevant but I can see my office window in the background of the video.

@abeyer the delivery is getting sillier and sillier with every video but this is mostly a consequence of YouTube demographics and incentives that it puts on professional YouTubers. Don't blame the player, blame the game. And BTW I honestly adore this style of delivery because it's a great filter for programming gatekeepers that care about appearances more than the content. Laurie is an absolute beast & a top-tier hacker but you'll only see that if you can get past the input filter or watch her earlier videos (there is less fan service in the older ones).

over the top delivery? we have wildly different expectations (and likely: desires) for how much theatricality there should be in a video like this <3

I certainly don't begrudge a creator putting out free content for doing what they want and/or what pays the bills according to the youtube algorithm of the moment... but yeah, this is definitely more theatricality than I care for, when it starts to grate on my nerves and distract from the actual content. Clearly appeals to many, but not my cup of tea

for me the form is most of the content.

Aside: I'm off on a tangent thinking about programming simplicity. This video, to me, seems to be an example of virulent anti-simplicity, cramming more stuff into programming languages. Exponentially making them more accidentally complicated. Questions that arise from my perspective: • what is/are the purpose/purposes of programming? • then, what is the purpose of introspection - who benefits from it?

a huge benefit of programming for me is that through programming, i come to understand other things better.

Re introspection: I rarely care about it in my own software, but when it comes to others' software / external libraries I often wish it was available & standardized. I think introspection in programming mostly benefits the concept collaboration (rather a specific person)

Hence, I (continue to) conclude that "introspection" is a tool for programmers for use during program development. Non-programmers don't need it. [I still wonder what "programming" is].

That's a fun question... I remember one definition that goes like: programming is an approach to wider problem of "program synthesis", where the expected behavior of a computer program is provided as a formal specification. I think it kind of works but it also sounds like it was written by someone working on program synthesis 😛 I think this question (what is programming) may be easier to tackle if it's split into smaller aspects: 1. power to decide what is being computed: the logic / formulas / behavior of the program; 2. control over when things are computed: parallelism, scheduling, error recovery; 3. control over where things are computed: memory management, data storage, algorithms, software "architecture". I think that going through a list like that and pondering "is this essential to programming" might help in defining it. There are specialized tools that deal with each of those aspects and more general tools that deal with multiple of them. Maybe programming is just one of those aspects? Maybe two or three? Maybe programming is just the ability to make these tools do stuff? Personally - I find the definition of programming very interesting but not as interesting as the "powers" that it gives. I wouldn't care about programming at all if I had the power to do all these things without it.

I absolutely do not understand complaints about the production and performance of this video, but it’s a matter of taste so 🤷‍♂️ That said, weird Smalltalk erasure. It had the same “reach into the guts” abilities as the Lisp Machine with a sometimes more transparent interface to said guts.

I agree about the avoidance of Smalltalk. In fact, I wonder if tools like Forth and self-modifying languages with REPLs should be considered to be on the same path?

Most normal people, though, don't want to be bothered with a plethora of options and flexibility and malleability and things that change behaviour overnight.

I'm not so sure there... I think some of that may be in response to flexibility done poorly (the unfortunately common case), and they decide they'd rather have nothing rather than that. While it's true most users want a tool to solve a problem, those problems aren't static and unchanging, and the user also doesn't want to start over and learn a new tool tomorrow because they have a slightly different requirement than today.

Can anyone give me a realistic example of a bug/crash in an OS component that I could feasibly solve via introspection rather than rebooting? I assume they must exist, since enough people claim to have done it. Similar for CL's condition/restart thing. But I have a hard time imagining you actually unwedge a computation that has had (potentially) an arbitrary number of its assumptions invalidated, short of rebooting it.

... in response to flexibility done poorly ...

This sounds good in theory. What evidence is this based upon? What examples of good, malleable UX are there (I can only think of VisiCalc and, maybe, cartridge based gaming systems)? Admittedly, my opinion is based only on anecdotal evidence and observations of friends, family and myself in non-programming usage (for example, when I write an article I don't want to meta-customize my editor, I just want to write). I dumped Windows, Linux, Android and moved to the Apple ecosystem due to UX issues and the lack of desire to learn and twiddle 1,000s of essentially-random parameters (Apple ain't great, but, it's the best choice amongst those evils).

@guitarvydas As you note, VisiCalc/Excel are one family of such things. See also HyperCard, sophisticated uses of the Shortcuts app in iOS, Automator on MacOS, all sorts of end user hacks using AppleScript, &c. I will also point out that there’s a difference between “can modify” and “must modify”. @Andrew F For one example, I have fixed device driver problems in running systems under a number of OSes without needing to reboot. The shared property of such systems is a microkernel-ish architecture so there’s enough isolation to make that sort of thing practical. I’ve also fixed bugs in windowing apps on old Lisp Machines while they were running (“while they were running” was the obvious and correct way to work on any program on those machines).

I'd be tempted to argue that the lack of inbuilt easily-accessible reflection is a big driver towards creating a harder distinction between programmer and non-programmer. It can be a lot of knowledge and effort to get a build environment up and running, and the new version you build doesn't have the state that you're wanting to reason about, but you might be able to see things like "oh! it's trying to load from myfile.txt not myfile.json" easily.

further aside: I tend to agree with @psf's mastodon thread... > This brings me back to my original point that end-user programmability is not a true form of malleability, but a kludge indicating the program’s features were not well chosen. I do wish, though, that the word "macro" were qualified better. I see there being at least several kinds/degrees of macros: 1. keyboard / action recorder 2. C-style

#define

parameterized & glorified search and replace 3. Lisp-style macros that are actually a kind of code that writes code. This, also, includes languages that provide

eval()

and even shell scripts that can produce and run other shell scripts (and, of course, T2T). [IMO: banning

eval()

from program development languages was the wrong move, maybe it should only be banned from released production code] (

eval()

could be called

compile()

)