with also (in a way that I haven’t been able to entirely compose together) CHERI https://www.cl.cam.ac.uk/research/security/ctsrd/cheri/ , and @cwebber ’s work on Mark-Miller-like capabilities.
Sorry, that sounds conspiratorial and I didn’t mean it to. What I mean is that a successful tool or service builds on the browser, or Android/POSIX say, or inside Twitter or Facebook’s ecosystem. Those environments are rich and complex and provide coherent and comprehensible abstractions for doing almost everything that their creators and sponsors want to do (and would like you to do) in the world
In earlier years, we were lobbying and picking and working on the abstraction towers we hoped would lead to a better world, but now it feels like those directions have been buried by the buildings built above them: you can think of this as co-option, but another way may be a narrowing of options after a period of abstractions that tended to general innovation - a post-Cambrian winnowing? Sorry for all the metaphors I’m still trying to name and frame this
I don't know the name for this act, but adversarial interop will do for now. You wire yourself up to the existing abstraction framework, and pull it in a new direction. But you only do that to the degree that the abstraction fails to be able to stop you, and to the degree that you can comprehend what the abstraction presents
Virtual Machines are a good present-day example of this approach: it shows the possibilities, and the challenges. Essentially, VMs enguls almost all of the software stack of entire operating systems. Something like Qubes run them within its (fairly thin) hypervisory world, where it can wrap them in its own model.
VMs have to do a little bit of adversarial interop -- they don't just wrap around the code, they push past its boundaries a little too. They dig a bit deeper into the old abstraction. They'll emulate the machine, but they'll also work out details about individual applications, and bring that to the surface.
We avoid doing this a great deal, because, frankly, it's /really difficult/ and /extremely fragile/. Abstractions have interfaces, and those interfaces are stable.
Everything else is what the abstraction is *meant to be hiding*.
But we are at a moment where *have* to dig deeper -- and perhaps all this computational power can assist us.
We have an abstraction in which *what we want* -- data, patterns, power, is buried deep deep below us -- and we are trying to build tottering, tall, highly experimental alternatives of our own.
I can run an existing app on my new computing environment, because I can -- given our current powers -- emulate it precisely. But how can my new computing environment *understand* what the app is doing, saying, processing?
It needs to be able to dig deeper: Rather than a bunch of syscalls, we need to be able to recognise certain computations -- turn the emulator's understanding of file and network operations into an understanding of photograph collections, contact updating, calendar sync
if i'm getting this right,
sounds kinda like you're talking about taking the concept of an "API" for a program or library and applying it to all computing?
where one goal is to "syndicate" data inside old systems that won't cooperate through various kinds of "bridge" tools that expose more free and flexible "APIs" to new systems
while reading this one of my main thoughts is,
"wow, sounds a bit like a very abstracted complaint that proprietary social media sites won't use a standard protocol like activitypub and it's hard to bridge them to it because the owners want control to be the only ones scraping the data"
i used to use wordpress but after a while i got So tired of mysql and its unmaintainability that i was like "i'm going to make a new post-authoring interface that puts a minimal amount of complexity between the text i write & it reaching the web"
so using tiddlywiki i "refactored" my wordpress blog into a simple static page generator making the same html, but now only "on" for just seconds to generate each page, unlike always-on php/mysql - & every letter of the html controlled /easily/
sandstorm is basically a virtualisation program where web apps are packaged like "desktop applications" that can then "author" simple containers as "files" ("grains").
so - the container users use & can easily backup/restore only contains user data (easily openable as a zip), while application binaries/libraries live in an application package also installed on the same server by users (!). users can also obtain source for any app package and upload a modified version instead
basically...... this thread has me imagining some kind of "better version of sandstorm" where the isolation of app data packages and individual user data bundles Perfectly serves the purpose of keeping apps simple and easy to modify + user data easy to read/backup
funnily enough my most used "sandstorm app" is just a containment box for tiddlywiki - a self-editing templating program that extends itself with any html data or code inside, & is effectively the most editable "sandstorm app"
For people who care about, support, or build Free, Libre, and Open Source Software (FLOSS).