by zackmorris | 2026-02-06 16:36:11+00:00
That's a fair question. For me, it's about removing the steep learning curves and gatekeeping from computer science and tech. Because the realities of being a developer have all but consumed my career with busywork.

For example, when I first learned about the borrow checker in Rust, it didn't make sense to me, because I had mostly already transitioned to data-driven development (just use immutable objects with copy-on-write and accept using twice the memory which is cheap anyway). I had the same feeling when I saw the syntactic sugar in Ruby, because it's solving problems which I specifically left behind when I abandoned C++. So I feel that those languages resonate with someone currently working with C-style code, but not, say, Lisp or SQL. We should be asking more of our compilers, not changing ourselves to suit them.

Which comes down to the academic vs pragmatic debate. Simple vs easy. Except that we've made the simple complex and the easy hard.

So I hold a lot of criticism for functional languages too. They all seem to demand that developers transpile the solution in their minds to stuff like prefix notation. Their syntax usually doesn't even look like equations. Always a heavy emphasis on pedantry, none on ergonomics. So that by the time solutions are written, we can't read them anyway.

I believe that most of these problems would go away if we went back to first principles and wrote a developer-oriented language, but one that's formal with no magic.

For example, I would like to write a language that includes something like gofmt that can transpile a file or code block to prefix/infix/postfix notation, then evolve the parser to the point that it can understand all of them. Which I know sounds crazy, but that would let us step up to a level of abstraction where we aren't so much concerned with syntax anymore. Our solutions would be shaped to the problems, a bit like the DSL you mentioned. And someone else could always reshape the code to what they're used to for their own learning.

You're right that FCIS is currently more of a pattern than a syntax. So the language would need to codify it. Normally imperative code would have to run in unsafe blocks, but I'd like to ban those, because they inevitably contaminate everything, leaving us with cruft. One way to do that might be to disallow mutability everywhere. Const is what allows imperative code to be transpiled to functional code and vice versa.

Except then we run into the problem of side effects and managing state, which leads us to monads, which leads us to promises/futures/closures and the async/await pattern (today's goto) which brings us full circle to where we started (nondeterminism), so we want to avoid those too. So we'd need to codify execution boundaries. Rather than monads, we'd treat all code as functional sync/blocking, and imagine the imperative shell as outside the flow of execution, at the point where the environment changes state (like a human editing a cell in a spreadsheet). Maybe the imperative shell should use a regular grammar (type 3 in Chomsky's hierarchy) to manage state transitions like Redux but not be Turing-complete (so more like a state machine than flow control).

Except that state machines are hard to reason about above a few dozen states, especially with nested state machines. Thankfully state machines can be transpiled to coroutines and vice versa. So we can imagine the imperative shell sort of like a shader with const-only variables. An analogy might be using coroutines in Unity for sprite behavior, rather than polluting the main loop with switch() commands based on their state. I've been down both roads, and coroutines are so much easier to reason about that I'll never go back to state machines.

I should add that I realized only recently that monads can be thought of as enumerating every execution path in the logic, so sacrificing them might be premature. For example, if we have a monad that's a boolean or undefined, and we've written a boolean logic function, then it becomes trinary logic with the monad. Which is related to stuff like Prolog, Verilog/VHDL, SPICE and SAT solvers, because we can treat the intermediate code like a tree because Lisp can be transpiled to a tree and vice versa. Then we can put the tree in a solver with the categories/types of the monads and formally define the solution space for a range of inputs. Sort of like fuzzing, but without the uncertainty. So the language should formalize monads too, not for I/O, but for solving and synthesis, so that we can treat code like logic circuits (spreadsheets).

Anyway, this is the low-hanging fruit. I haven't gotten into stuff like atomic operators (banning locks and mutexes), content-addressable memories for parallelizing execution without caching, reprogrammable hardware for stuff like loop optimization, etc. All of this represents the "real work" that private industry refuses to do, because it has no incentive to help the competition enter the walled gardens which it profits from. Fixing this stuff is up to academia (which is being constantly undermined), or people who have won the internet lottery (which presents a chicken and egg problem because they can't win without the thing that gets them to the thing).

Note that even though designing this language would be ambitious, the end result would feel familiar, even ubiquitous. I'm imagining something that looks like JavaScript/PHP but with value-only argument passing via const variables to higher-order methods (or automatic conversion from side-effect-free flow control statements), with the parallel code handling symantecs of Octave/MATLAB, and some other frivolties thrown in like pattern matching, destructuring, really all of the bells and whistles that we've come to expect. It would auto-optimize to the fullest extent possible for a high-multicore machine (1000+ cores, optionally distributed on a network or the internet), so run millions of times faster (potentially infinitely faster) than most anything today that we're used to. Yes we'd still hit Amdahl's law, but not resource limits most of the time. And where some people might see a utopian dream, I see something pedestrian, even boring to design. A series of simple steps that are all obvious, but only from the perspective of having wasted a lifetime fighting the existing tools.

Sorry this got so long. Believe it or not, I tried to keep it as short as possible.