oconnor0

Basically, can you write the lowest layer of Mu on top of an existing OS and attempt to encode the appropriate assumptions and reasoning into that layer rather than starting from bare metal?

Attempting to reinvent all of modern software is probably a losing proposition. Can you embed reasoning in from Mu from its lowest layer?

Changing abstractions only works when I have control over the abstraction and its users. When someone else provides the abstraction or when I am responsible for providing that abstraction for others, I am not able nor empowered to change it.

Your thoughts about having a language that enables the encoding of why along with what and how is fascinating. Do you feel like you've captured that with Mu? Or gotten closer?

Abstractions and naming are really hard. I have spent hours stuck on a problem because I couldn't name some transformation or operation. This is one of the reasons I've been reticent to "believe" in concatenative languages. They can read beautifully - if all the words are small and properly named. As soon as it turns into bi dup dup swap my eyes glaze over.

And abstractions have a tendency to leak and to miss important details - requiring ugly hacks or poking at the innards to do what is needed.

I am also very intrigued by both total languages and dependently-typed languages. But one of my big peeves about languages is when they have dramatically different syntaxes for different things. C++ being my favorite example. Recursion is relatively easy to write, but attempting to do the same recursion at compile-time in the template system is awful. C++ template syntax is so foreign that I find myself incapable of thinking in it beyond the simplest of expression.

Yeah, I've looked at concatenative languages because of that, but I haven't been convinced they scale up nicely in abstractions.

I'm a professional compiler developer and so find myself annoyed with existing languages.

What projects or languages exist that build a language up from "first principles"? Lisp and Scheme are the obvious two since they both allow constructing new abstractions on top of the existing ones. I'm interested in something more statically typed.

I have this idea about a language where each layer of abstraction is built on top of the previous one and is done in such a way that the language is built from the "ground up". I love functional languages but find them so disconnected from the actual hardware we run on.

I don't know exactly what I'm asking for… :D