Today I was in couple good threads on programming/metaprogramming and on the
design of universal…
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…
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:
- 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
- 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
- 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
- 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:
- 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
- this is completely compatible with global forking undo on the vm level
- it can be conveniently implemented in terms of a journal and a vm image
By John Ohno on September 21,
2018.
[Canonical link](https://medium.com/@enkiv2/today-i-was-in-couple-good-
threads-on-programming-metaprogramming-and-on-the-design-of-
universal-781982ba69d)
Exported from Medium on September 18, 2020.