You haven't programmed Smalltalk until you get your image into an unrecoverable state! Now that we're living in the 21st and the After Times (times after Git in this case), there really ought to be a better way to manage images. I mean there's the whole pit of CRDTs. Surely a new image based programming language should emerge out of it.

An interesting one is https://www.unisonweb.org/Its codebase is logically an append-only datastructure (but I suppose there is some form garbage collection). And although they call it a codebase, it stores some data as well (everything that has a global name associated with it). It's not quite an image, in particular because it doesn't store the run-time state. You can't "save a session" and take it up again. But it has none of the order-related issues because everything is immutable, except for the names.

@Nuno Leiria +1 to what @William Taysom and Konrad Hinsen said. I'll add that https://en.wikipedia.org/wiki/The_Art_of_the_Metaobject_Protocol is a good place to read more about advanced object systems that have things like updating of instances when class prototypes are changed, as Konrad described.

Thanks Jack Rusher, I'll have a look. I've also since found this paper which gets into the practice of using lisp interactively http://www.softwarepreservation.org/projects/interactive_c/bib/Sandewall-1978.pdf

Wht re you tlking bout? My McBook is mzing!

I guess that it is the nature of technology to both help and "suck". From the start people must have this in mind, especially when designing/building things. As engineer, we often are more focusing on bringing more and more "help", which brings it loads of friction too if we don't take care.

Maybe, it would be better if designers/engineers are focusing on lowering friction before adding any helping feature.

I plead guilty on this...

I'll add this longer form discussion of how poorly most sectors are served that Paul Ford dropped yesterday: https://www.wired.com/story/power-paradox-bad-software/

i guess my take on this is that the xerox parc vision was for computers to be curiosity enablers: things that gave us the ability to tinker together little models and tools on a lark, that (because they were stored on a hard drive) could be returned to and watered and grown until the curiosities become mature studies that could be shared and act as the starting point for the curiosities of others or stand alone as parts of your intellectual experience that you returned to regularly for fruit.

instead what we got was computers as curiosity disablers. weird bureaucracy contraptions that have let people like aetna and uber and facebook design increasingly arcane, complicated, and secret rules for their customers, employees, and users (respectively) to follow, in order for them to deliver further incentives so obscure that they might as well be random (perhaps this is intentional as it makes the a/b test “more scientific”) across a population of people being basically factory farmed for their output based on the barest and least qualitatively sophisticated metrics imaginable.

if you happen to live inside one of these systems (the hallmark of this is a weird circumstance that you’ve been forced or tricked into: do you want medical treatment? do you want to make a bunch of money with flexible hours? do you want to know what your friends are thinking about?) your experience is specifically determined by an inability to change or have control over any aspect of the experience. that would be detrimental—every one of these companies’ business models depends on its ability to change behavior (don’t go to this doctor; give up on your claim; be at this corner in three minutes; buy this—I mean, here’s someone you should be friends with who happens to be skinnier than you and post about this great supplement).

If you can change your experience, you can use the tool in a different way, and it’s harder to get you to comply with the needs of the company. Instead, apps like this reward behaving as expected, but more importantly punish deviation—you don’t get a reward, you lose track of where you were, you get returned to the start of the process and lose your place etc. punishing deviation punishes curiosity. </rant>

Jack Rusher that warrants a top-level post. ;)

Higher-order functions are imo the best example of a critical-yet-general language feature for concisely expressing domain-specific abstractions. “No raw loops” is another way of saying ” have a proper higher-order API for your collections”.