These Lab Notes document my research in progress. My research area is in the future of personal computing.
Experimenting with the item as the core primitive
Designing systems for computer literacy and evolvability
Personal Computing Network & Devices
Mutations & Item change logs
Services & Item Drives
Today & Daily summary
Cross-reference Navigation in Obsidian
Cross-references & References cloud
The Graph OS
Why is our thinking on computers so restrained?
References box & Topics
General purpose personal computing software
User-created application and system views
User-created item views
Browsing contexts & recent paths
Universal reference containers
Universal data portability
Building apps in minutes, not months
The Lab Notes
What if you could build an entire, production-ready app not in weeks or months — but in minutes?
In order to build the many experiments for my research on the future of personal computing, and the subsequent demos for these Lab Notes, I needed a way to build much faster than was presently possible (the work simply won’t work if it takes weeks or months to scale up each experiment; the learning has to be faster than that).
Here’s what I’ve been building:
It’s a framework that allows me to build entire production-ready apps in minutes. Watch the video for an early demo.
Engineering and architecting, coding, refactoring and simplifying, testing, bug-fixing — it takes a lot of time.
Normally, if you want to build a reasonably sophisticated app, you could spend months to years on development. You would have to build authentication, ensuring users can log in and out, and a way to transmit and store their data securely. You would have to build the entire interface, maybe with the help of a framework, and you’d build a state management system, as well as a way to syncronize the user’s data from the server into the system, and a way to bind the data in the system to the interface components for users to see. For most apps, it is a months-log slog to version 0.1 (which will have to be rebuilt anyway once critical insights are uncovered).
This new framework I’ve been working on explores getting rid of nearly all of those steps: once you know what you want your app to do and how you want it to look, the actual coding takes minutes.
The framework explores a new way of writing apps through composition in place of data piping.
It is made up of interface components built in React that you use very much like you’d use HTML to construct a website.
But the real magic is when you give a component an
itemId attribute: the framework automatically handles syncing its value to the server, and reloading it later, wherever that
You don’t have to worry about piping data around your app, syncing, binding state to interface components, etc. You just construct your app.
You can combine the fundamental building blocks provided by the framework to create increasingly sophisticated interfaces. And as you combine the pieces, the framework automatically handles everything else — you just give out the
itemIds and you’re set.
The hope is to create a pit of success by making it possible to write entire apps in the same way you’d write a simple webpage in HTML, using an expressive set of fundamentals to build complete applications.
That’s not to say you can’t go beyond composition — it does expose the hooks for you to do custom things with the framework if you’d like to, while still handling all of the rote complexity.
I’ll dive more into it in the coming weeks, because it exposes some pretty interesting possibilities and consequences.