in the past I’ve posted about how my ideal language would be made out of the bare minimum of simple parts, and then built out from there as a tree structure of abstractions

the root node would unfortunately have to be defined in natural languages which are messy and imprecise, but all of the root’s child nodes would be defined in terms of the language features in the root node - as well as having natural language descriptions to help people understand what they’re reading and why it’s designed that way

and for every node in the graph, its features would be defined only in terms of the features contained in its child nodes (with natural language to help explain things more of course). also, each child node would reuse as many concepts as possible from its parent nodes, to minimize the number of special cases that a user of the language would have to learn

there are a few reasons why I want a language like this:

• just simple aesthetics. it’s beautiful to me to take the bare minimum of parts and build outward from that, and I love that if some node somewhere in the tree isn’t beautiful for someone, then they can make their own node instead
• more importantly, beginners can learn in discrete “steps” and gain a basic understanding very very quickly. after they’ve learned the root node they can feel accomplished that they’re able to do everything the language is capable of already, and all there is left to learn are bonus convenience features
• as they learn more and more distant nodes, they’re able to incrementally increase their ability to express complex thoughts using the language - effectively allowing them to learn chunking in the new language
• every single feature of the language, not including the root node, is defined with complete precision because it’s written in code rather than natural language
• in theory, a language designed like this would require users to learn the minimum number of discrete concepts in order to use the language - which would also create a “there’s only one way to do it” effect where users can often correctly guess how to use a new language feature just by applying existing language features in the way that makes the most sense

I feel like a lot of languages over-rely on people “just knowing” what different behaviors are and do, and they also take for granted that users of those languages are willing to memorize arbitrarily many special cases that could have been simplified by reusing existing concepts. just compare Lua’s import system with any other scripting language’s import system for a great example. Lua’s import system only has two special-case rules (how it finds the file, and the fact that that file gets executed like a function) and otherwise works entirely using pre-existing language features. can any other language say the same? if so I want to know about it

meanwhile Python is a mess of “okay so… this directory is treated like a module, right? is that in the search path? wait this is from . import foo so it looks in the current directory… but what’s ‘the current directory’ in this case? wait no it’s not the current directory it’s the current module, isn’t it? but how does Python define a ‘module’ again?” I’ve used Python since I was 14 and I still couldn’t tell you the behavior of a lot of imports without running it just to make sure. and my experience is that every programming language besides Lua is like this. so I’m forced to experiment with each import system by trial-and-error instead of just understanding it right away in terms of stuff I already know

and I think that’s a microcosm of a bigger problem, which is that languages take for granted that their users are willing to learn arbitrarily many special cases, extra syntax rules, new keywords, etc. a lot of languages are really fucking big and every new feature is a self-contained “thing” that has to be learned in complete isolation from anything else in the language - without any familiar reference point to understand it from (looking at you, Rust)

but imagine, instead, if I had a clear progression of nodes to traverse, and traversing those nodes required me to learn as few discrete concepts as possible - but rather let me recycle my old knowledge to learn each new system. wouldn’t that be so much better - not just for learning, but for understanding and applying that knowledge?

anyway, I’ve been hopeful that there’s some Lisp language out there that could do this for me. since they can be built up from literally like 9 discrete concepts, and from there it’s possible to build an arbitrarily complex language, with special syntax and built-in DSLs and everyting - which I find incredibly beautiful

unfortunately the Lisps that I’ve found so far (other than Fennel) have felt… not good. and they definitely don’t follow this philosophy. so I’m still looking for my ideal language, or at least something a bit closer to it than Lua is, in case it’s out there somewhere (currently I’m hopeful about Scheme and warily curious about Haskell)

in the meantime, though, I’m happy to have Lua and Fennel because they get pretty damn close. especially Fennel

here’s an example of what I mean. let’s say that my ideal language is a Lisp (because that seems likely). The root node would have natural language explanations of how to use (cond) and (defmacro) and other language features like that. it would also define what the word “evaluate” means and what a “form” is and etc. but then a child of the root node would contain stuff like:

(if) is defined as:

(defmacro if (condition if-form else-form)
  `(cond ,condition ,if-form
         true ,else-form))

in other words, (if) evaluates to the if-form as long as condition is truthy. otherwise it evaluates to the else-form. either way, only one form is evaluated. here are some examples:

(examples are so fucking important - although I won’t give any here because I’m lazy :P. massive bonus points if the examples are so exhaustive that they’re used as unit-tests for the language)