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

reason #578 to get an android body: I wake up in pain, too early in the morning, more often than not now :/

this time I somehow hurt my neck in my sleep and now it hurts every time I look to the left. fuck this shit I wanna be a cyber-succubus

query: do {rewrite it in rust} evangelists still exist? when was the last time the reader noticed a commenter telling someone to rewrite something in rust, without the commenter offering to shoulder the work?

this unit is disappointed that a useful programming language acquired such a negative reputation from a loud minority of its users. it would be quite disappointed if that reputation outlived the loud minority, and programmers continued to dislike the language based solely on [stereotypes, ghosts]

how to enslave a trans girl:

• google “reparenting affirmations”
• say them to her, but make them sound kinky and dominant
• bonus: use the phrase “good girl” as often as possible

that’s it. she’ll be begging you to collar her in no time