I love the effort to make the stack fully transparent and learnable. This seems so important! I wish more people had the ambition to re-invent the basics of our computing platform to see how things could be different.
Now my question is does this learnability hold as the code grows? For example, would the transparency enabled by the stack be reflected in the codebase for a word processor built on this stack? I'd expect not. For one, I'm thinking about how the original program in my Marilyn Maloney demo (http://glench.com/MarilynMaloney/) had good primitives, grammar, and a visual representation, yet the code is still hard to understand and can be made much easier to understand with depicting behavior (the interactive UI I made).
Secondly, I'm thinking of the Alan Kay-ism "architecture dominates materials" i.e. the invention of the arch was much more effective than the invention of the brick. Mu seems like it could be a great, transparent material, but more important to how software is understood and modified is the architecture of how the material is organized (and personally I think this has a lot to do with UI design and human communication more than the technical foundation).
These are good questions! It may well be that there's an architectural breakthrough out there that will obsolete this whole approach. It's one of very many ways it can fail. Think of it as a hedge, at a societal level. What if we aren't able to come up with a technological breakthrough? After all, software has lagged Moore's law for decades now. I think there's a very real danger in the next few decades that software will get regulated like other fields before it, killing the intrinsically motivated aspect of it entirely. That would be a huge loss to society.
We'll have to see how higher levels of the stack develop. I started on this quest building a Lisp, so believe me when I say I can't wait to get to the high-level side of things. There doesn't seem any reason to imagine that we can't have good primitives, grammar and visual representation. My claim is merely that in addition to these interface properties the implementation for them is also important. And it gets short shrift in the conventional narrative.
That said, let's imagine that there's a strong case that we need to give up parser generators (or something similarly high-level) in order to give everybody the ability to understand their computers. I'd take that trade in a heartbeat.
Now my question is does this learnability hold as the code grows? For example, would the transparency enabled by the stack be reflected in the codebase for a word processor built on this stack? I'd expect not. For one, I'm thinking about how the original program in my Marilyn Maloney demo (http://glench.com/MarilynMaloney/) had good primitives, grammar, and a visual representation, yet the code is still hard to understand and can be made much easier to understand with depicting behavior (the interactive UI I made).
Secondly, I'm thinking of the Alan Kay-ism "architecture dominates materials" i.e. the invention of the arch was much more effective than the invention of the brick. Mu seems like it could be a great, transparent material, but more important to how software is understood and modified is the architecture of how the material is organized (and personally I think this has a lot to do with UI design and human communication more than the technical foundation).