Microprogramming: A New Way to Program

As other's have said, this is just a bunch of small functions.

Write some Haskell, every function is just another another function with parameters. If you look at the definition of a function, you will find the function is defined as a single call to another function with some parameters. Most functions are 1 line, which is actually quite hard to wrap your head around at times.

Or learn some APL where every "microprogram" is a single letter.

I also recommend the extremely out of print book Threaded Interpretive Languages to understand how an OS can be built up out of a simple building block words one step at a time.

I glue them together with "function calls".

It's quite amazing.

I don't see anything on the scale of GIMP, FreeCAD, or even SyncThing (Probably one of the most famously simplicity focused tools I use regularly) doing this stuff, although it may be useful for "Language people" who frequently deal with ideas outside the "Standard vocabulary" of most languages.

It seems to be fairly elegant and perhaps nice for people who like to develop interactively in small, hand-testable pieces, but.... I don't understand why I wouldn't just use Python+Jinja2 or Svelte or Vue, unless this has better linting somehow(Since that's my biggest complaint about web tech, the way so much isn't lintable).

From what I've seen I get the impression he's almost as much of a philosopher as a coder, and there's probably aspects to this whole thing that don't make sense the less mathematical-minded.

The good thing is that you do not require a new language.

If you want to be helpful to this effort, please check out how we give feedback on BuilderNews (https://news.pub/).

I would love to see Looms of people attemptig to use some of the products here (and there are many! all free, no signup, all public domain), so that we can prioritize what we need to fix and document better to allow more people to benefit from this technology.

Mahalo!

If it’s not satire, I really do not want to read any code the author wrote before “inventing” microprogramming.

I also hate when established terms are reassigned to something completely different.

“No, this code takes no env variables or outside configs. All configs are hardcoded to only run on my machine. I’ve decided to call it… machine code.”

Basically each line is a type of markup?

- Why do programs get their own processes, but not functions?[0]

- Why can't I load and use any function from any package in my program at any time? Or run it from my shell? Genera had this.

- Why are functions organized into files?[1] you can have multiple functions in a file, which implies that they are somehow related. This creates structure, which is often unnecessary or downright confusing. The structure can only be hierarchical (files of functions or directories with files of functions). If I change the definition of a function somewhere (e.g. a REPL), it's textual representation will grow out of sync with the actual implementation. Smalltalk didn't have this.

- Why do we only ship collections of functions (programs)?[2]

- Why should all the functions in my program be written in the same language? And why is doing otherwise a pain in the ass everywhere except for Lisps?

This, to me, sounds like a lot of invisible coupling. We don't question it because it's always been this way, but I strongly believe (without having much data to prove it), that this prevents interoperability, and makes programs more bloated by increasing redundancy. I like to think that rather than reinventing "functions and function calls" or "the UNIX command line" the author described what OOP was supposed to be when it was just being rolled out in the 70s at Xerox PARC.

The project in OP addresses none of these, except maybe the bit about languages, but it did bring up an interesting point. For me, anyway.

[0] This one's easy, the process overhead on UNIX systems is a few kilobytes so you can't have everything be a process. In e.g. Erlang you can spawn a bajillion processes at will, so it's not that big of a deal. Still, AFAIK Erlang makes a process per actor rather than function.

[1] During development, I mean. You'd obviously need to put them into text files at some point. Making a Github repo and dumping a new Smalltalk image into it every day is not the way to develop software. Unless... \s

[2] scrapscript.org has an interesting take on this, where every expression (a "scrap") is content-addressable and can be replaced with it hash. They then store these expressions in "scrapyards" over IPFS. You could pull the same expression from different timeframes with built-in syntax. I think it's quite interesting.