Today I was in couple good threads on programming/metaprogramming and on the design of universal undo. I feel blessed by the awesome folks who argue about computers with me on mastodon.

The first thread is longer and has more drift, but it’s worth digging through, because it’s mostly a meditation on what kind of language we might want (what kind of facilities and attributes we might want) for small computing (i.e., for exploration, prototyping, and a composition-friendly general computing environment).

My take on it is that we want:
1) homogeneity — all mechanisms should be in the same language and be equally easy to edit (rather than having distinct domains like compiled c programs vs shell scripts, or having separate privilege levels like kernel vs user space); because this is a small-computing environment, neither security nor performance should take priority over flexibility
2) support for an agglutanative / syntax-lite style — the need to produce boilerplate & declarations, explicit types, and any constraints that require conceptually similar things to be visually very different all get in the way of iteration, while the likes of lisp, forth, rebol, bourne-style shells, APL, and io all present a style more well-suited to long-term iteration on a persistent interactive REPL-like environment
3) both function-like, message-like, and pipe-like code composition — different kinds of data flows and different kind of modularization have different patterns of behavior that are convenient for them
4) backtracking and pattern matching as a built-in facility — constraint programming is rare as a feature in imperative-style languages, but a declarative style is a very powerful tool for rapid iteration, because it means that not-yet-implemented code can literally run so long as the requirements for that code are well-defined

In the second thread, the idea of system- or vm-level backtracking exposed as both a mechanism for capabilities-based security and fast constraint solving in user code is explored. My take is:
1) if we combine copy-on-write with the parallelism supported by the underlying host system, we can get fast and easy constraint solving for the whole system
2) this is completely compatible with global forking undo on the vm level
3) it can be conveniently implemented in terms of a journal and a vm image

Written by

Resident hypertext crank. Author of Big and Small Computing: Trajectories for the Future of Software.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store