i keep thinking about how programs that laypeople can practically edit (instead of theoretically, which is the only promise "foss" makes) would work.
surely it'd have to be ran directly from source (interpreted or jit'd or maybe a really fast compiler on first run) with zero build steps,
architected in a way where it's relatively intuitive where changes would be made,
with as much declarative as possible (so someone who just wants to tweak the values don't have to understand the internals of how they're applied), maybe in bespoke dsl-ish subsets of the language,
and presumably written in a language that
a) makes the transition from declarative to imperative very fluent (any language you can build a dsl on. kotlin and ruby are good examples) and
b) is human readable without being knee deep in obscure programming language theory (as the laypeople who should be able to edit these programs have better things to be experts on than lambda calculus) and
c) typed strictly enough that ide autocomplete can guide people through the options available to them
some way to apply "plugins" would likely be a good idea, so people can bundle up and share their customizations with each other. this system would need to be way more flexible than Just introducing new logic at Predetermined Points (previous art: game modding. the mixin tooling used in minecraft is a particularly good example)
and all this would have to be as hardware efficient as possible so the underlying application isnt a resource hog. so this leaves us with. uh. no pre-existing tooling capable of this? at all?
maybe carefully written kotlin?
