💫 Excited to share what I worked on this summer with @inkandswitch! We built Cambria, a tool that enables more flexible data compatibility in software.
Here's why I'm personally invested in this research... »
I believe deeply in being able to customize our software tools. But something has been bugging me: if we edit our tools, how does that square with collaboration?
Like, how far can I tweak my writing environment while keeping it working nicely with yours? »
The usual answer is: we all agree to use the same software, or the same file format. But this really limits how far we can tweak.
What if we could fudge around the edges more? Changing the data format while keeping things mostly working together... »
This is exactly the kind of workflow that Cambria supports. It's still early days, but I think we got some glimpses of how it might feel to live in this alternate reality...
The neat thing is, these kinds of problems _also_ appear all over the place today! So hopefully this kind of tool can provide near-term value, while nudging us towards a future of more flexible software.
A theory about why tools like Airtable and Notion are so compelling: they provide a much-needed synthesis between the design philosophies of UNIX and Apple.
Short thread:
UNIX is still the best working example of "tools not apps": small sharp tools that the user can flexibly compose to meet their needs.
Once you've written a few bash pipelines, it's hard to be satisfied with disconnected, siloed "apps"
The problem is, while the roots are solid, the terminal as UI is extremely hostile to users, esp beginners. No discoverability, cryptic flags, lots of cruft and chaos.
There's a saying that writing software is more like tending a garden than constructing a building -- things constantly change.
But the more I learn about how buildings evolve, I think this process is actually a perfect analogy for designing software!
Thread:
The gardening analogy originated in The Pragmatic Programmer (afaik).
The claim: buildings are designed once and stable forever. But in a garden, things grow organically, you need to constantly prune and weed and tend. Aka, refactoring.
I found this framing helpful as an early programmer, but ultimately a bit hollow. Software adapts in response to changing human needs. It doesn't just naturally grow like a plant. The fundamental motivations seem different.
Using @airtable to help cities organize volunteer grocery deliveries. A city asked for help batching delivery routes.
Built v1 of the feature in an hour (!), using a JS "Scripting Block" macro + @graphhopper geo API
2/ No-code + Turing-complete escape hatch is an old idea, and maybe not the most elegant, but can be so effective:
* Airtable provides great UX out of the box
* Ceiling on functionality can be pretty high if (big if) you can write macros
3/ Another example: a city was manually updating several related fields when assigning a volunteer to a delivery, and wanted to update all with one click.
The ability to screenshare a single window is the digital version of inviting someone into your living room but not your bedroom
Sharing the whole screen is awkward because it violates Christopher Alexander's Intimacy Gradient pattern
Spaces in a building need a clear sequence of privateness, and the desktop UI doesn't provide this at all
It's telling that inviting someone into a whole-screen screenshare (or, god forbid, letting them use your computer) feels more intimate than video chatting them from your physical bedroom -- we live in digital spaces now