programmers do a curious shuffle between meta levels.

at first there was only the machine itself, and to do anything you had to work directly on the object level. literally rewiring the physical machine to let current flow through the right set of semiconductors to get the computation you wanted.

then we went up a meta level, and could now describe what rewiring we wanted done, and the machine would do it while computing the answer. machine code is actually not the most fundamental level!

then we took that and wrote machine code that writes machine code based on notation that could generalize across machines.

and now here's the bit that makes it a shuffle instead of a walk in one direction... we could take that same notation and make it map to a different lower meta level. this program could be made to translate to different machine code for a different machine entirely than where it was originally!

and so it's possible to build both up and down from wherever you are in the stack!

you can keep doing the meta shuffle and replacing things until you've got a system where no or at least very few person hands have ever touched the stack as it exists below a certain point

and this entire process has kind of happened ad-hoc over time, with no grand plan that encompasses the entire stack. leaky abstractions and things that don't quite fit but were good enough happen everywhere, and the choices down the stack affect what every layer above it can do and how they have to interface with the layers below...

so that's why computers are so bad sometimes. nobody really knows everything they're doing on every layer when they work on their chosen layer because it's practically impossible to, and they sure as hell don't talk to each other!

and afaict every attempt to take control of the entire stack and remake it under one fully coherent plan has stalled or otherwise failed.

that's why the story of the lisp machine gets me, because afaik they actually did it! and it still didn't take off!!