The format I described in the last post is provisional. The title here is only half a joke; I fully expect the details to change. But the shape of it, a tiny set of composable commands, is doing real work, and it is worth saying why so little is enough.
Structured programming settled this a long time ago. Any computation at all can be built from a handful of constructs: a command that does one unit of work, a sequence of them, a selection that chooses between them, and a loop that repeats one. Add two conveniences - the function, to name a sequence you use in more than one place, and the structure, to group several values into one - and you have essentially every language in use today. Program is just another arrangement of those same pieces; the novelty is in the reactive and reversible behaviour layered over them, not in inventing new primitives.
Keeping the primitive set this small is not minimalism for its own sake. It is what pays for nearly every goal the language has:
- Polyglot output.
A small, regular format is one a target plug-in can walk and print mechanically, so new languages are cheap to add.
- Diagrams.
A handful of node types is something you can draw, lay out and edit visually without losing any of the language's power.
- Snapshots.
If both the code and a running program are simple data, a snapshot is just that data, captured, moved, resumed.
- Understandability.
Few enough moving parts that you could, if you wanted, learn the whole thing and build it yourself.
So while the exact tags and spellings are not final, the discipline behind them is the point: find the smallest format that can still express everything, and let the hard-won properties fall out of that simplicity rather than bolting them on afterwards.