At long last, I present to you: the OLLOS essay.
It's got everything: how it works & how I used it, design and concept iterations, future work for it and the OS, and what I learned about personal interfaces.
Enjoy:
"The concepts in modern operating systems — apps, windows, desktops, notifications, and so on — have so permeated our understanding of personal computing that it’s hard to imagine anything else, let alone believe there could be anything better."
New essay, link in reply.
For the last year or so, I've been working on a longer-term project that experiments with building itemized environments.
People should have sovereignty over their hardware, software, and data; unlocking opportunity, agency, curiosity, and creativity.
Last year we were exploring how to "kill the app" at
@inkandswitch
. To start, I made this prototype...
It explores an environment in which separate programs might "donate" certain data to the underlying substrate, and react to relevant data from nearby programs.
Vids in replies
This is one of the reasons why data needs to be independent from interfaces: so that when we adopt new technologies, we don't spend years carrying along incongruent UIs from past paradigms to access the underlying data.
We should be able to whip up these kinds of interfaces we envision supporting our best.
Software is capable of infinite representations – but we’ve made its interfaces more rigid than physical ones!
This year, I worked with
@inkandswitch
on a project that asks impt questions about the future of the OS
The user environments of today’s operating systems are over-abstract and overwrought, as Don Norman pointed out 30 years ago.
But how would you reorganize personal computing?
What if every individual thing in your personal computing domain could be linked or backlinked in your overall digital graph?
Emails, calendar events, notes, tasks, dates, contacts, webpages, PDFs, podcast episodes, articles, design files; all of it.
Lots of new stuff to share today.
- redesigned my website earlier this year, this is v3
- new email: [firstname]@[lastname].com (!)
- new pfp (it's been a while...)
- new member portal & perks (see replies)
Lots of new stuff to share today.
- redesigned my website earlier this year, this is v3
- new email: [firstname]@[lastname].com (!)
- new pfp (it's been a while...)
- new member portal & perks (see replies)
I've been working on a new member's site for the "little lab".
It has all of the lab’s updates, experiments, essays, and other member perks.
It'll be up shortly. Some details...
For many, computers are the most expressive, creative, and curious instrument that enables their life's work.
But they look increasingly sterile, almost medical.
One dream of mine: build a computer company where buying a computer is more like buying a guitar.
I've always wanted "rss.css" — a simple CSS file that lets sites publish some of their look & feel for articles read in RSS readers.
Each site has their colors, typefaces, etc., which I miss when reading via RSS; they partially form the "voice" of the things each site publishes.
Last year we were exploring how to "kill the app" at
@inkandswitch
. To start, I made this prototype...
It explores an environment in which separate programs might "donate" certain data to the underlying substrate, and react to relevant data from nearby programs.
Vids in replies
This demo is a lot of fun to use.
There's something about the tangible nature of it that makes it really satisfying.
The goal for it was not that though: it was to make "constructing" and "using" an interface one-and-the-same, in a dynamic and fluid environment.
Teenage Engineering worked on this for Swedish House Mafia's Coachella set.
Stuff like this always makes me think: what would you love bespoke hardware IO for?
(more on their 'mother of all decks': )
It was during this prototype that I learned to start using prototypes as a means of communication / co-thinking
When tinkering with a new idea for the environment, I kept the old and new idea, toggle-able in the interface, so everyone could explore.
Last year we were exploring how to "kill the app" at
@inkandswitch
. To start, I made this prototype...
It explores an environment in which separate programs might "donate" certain data to the underlying substrate, and react to relevant data from nearby programs.
Vids in replies
Failing to respect the fragility of early ideas is high treason in the space of creativity and curiosity.
When we use descriptions of ideas, we simply have to give them the benefit of the doubt. If anyone in the room defaults to criticism at this stage, very little good happens.
Waiting for my genius bar appt. as a teen, I watched as someone was learning about their new Mac. Clipboard was where they got stuck.
"But *where* is it?"
"It's in your clipboard, now you can paste it"
"But where is the clipboard?"
Long convo I keep in mind when designing sw.
ChatGPT isn't loading for me right now, so I'll do this the old-fashioned way.
What else should be on this list?
Smalltalk-76,-80
Emacs
Plan 9, Acme
BeOS
OpenDoc
HyperCard
Newton's Soup
What would a hundred-year OS look like?
One that would allow its user base to continue evolving it with the times, without ever having to recompile the base software?
Is this something we already have, or are there aspects we would still need to explore / build?
If the destination is quality, the journey is quantity.
Thinking about this lots lately — need to do a better job of this in my work in 2021.
@codinghorror
wrote a nice article on this a while back —
Having a chronological and an associative view on the items in my graph is something I've wanted for years!
Finally living in an itemized environment that has both now — too early for meaningful reflection, but it is nice to finally dive in.
Spent some time looking for a habit tracker that would do a small list of things nicely, but found most too rigid & complicated.
With my daily and weekly habits, I need more flexibility – but I still want to track them.
So I built an iOS app that keeps it simple & enjoyable:
@nathanwpyle
Fourth grade, first round — I got "gum".
I was so excited about getting such an easy word that when I started to say "G", it came out:
Me: "JAY-YOU-EM"
Teacher: "Sit down"
Me: eternal shame.
In my latest experiment, I've built OLLOS – part digital chronofile, part spaced review of items.
I posted a member update today, exploring the "spaced review" concept within:
Last year I designed an OS to work entirely this way — OLLOS: One Long Log OS.
The primary method of seeing your items was in one, mostly chronological log.
It spoke to me in ways I’m still trying to digest; I have a homemade notes app that works this way to help figure it out.
Most of my demos work on top of one "item store" which has all of my things in it: emails, calendar events, to-dos, read later links, etc. etc.
I've built a series of providers which bring external data into the item store.
A few years ago it occurred to me: I could build...
Last year I designed an OS to work entirely this way — OLLOS: One Long Log OS.
The primary method of seeing your items was in one, mostly chronological log.
It spoke to me in ways I’m still trying to digest; I have a homemade notes app that works this way to help figure it out.
You think after 11 years of marriage you really know your spouse, and then last night I found out mine uses his notes app by keeping EVERYTHING - grocery lists, reminders, birthday present ideas - in ONE LONG NOTE
A few things that have come up repeatedly in conversations lately:
Screws, not glues.
If modern software went through an iFixIt teardown and review, it'd fail instantly. It's all glued together!
Last year was my first with a membership program that lets people support my independent work.
This year I'm refreshing the program with a new name and new member perks:
Details, plus numbers and more from the first year, are in my annual review + below
Wonderful advice.
It's also how I naturally build things — playful exploration led by intuition & curiosity, then if a project seems to really click, I begin to survey the space to see if it holds any novel contribution.
Sometimes it's just a new perspective on previously...
Your pie doesn't need to be original (unless you claim it so)
Imagine you bake a delicious peach pie over the weekend, and you offer a slice to your friend. They respond:
"Wait, how is this different from every other peach pie that's ever been baked? It seems really similar to
This is one of the new things going live in the new year on my site - if you want to grab the first slot before January begins, let me know & I’ll send you the stuff.
You can imagine how the pieces might work in other types of interfaces. We started with a spatial canvas that hosted computational elements. More on this in a lab note soon
The essay is out now; it’s a thorough read discussing what we did and why. Enjoy.
It’s exciting to see so many people “get”
@tana_inc
from the start.
They’re thinking about everything that follows from good core primitives; this leads to lots of “obvious in hindsight” things that personal computing has needed for some time.
Email, in some ways the original internet application, had so many of the right pieces from the start: local-first, standardized protocols, data portability.
And given the complexity of the protocols, building an email client is a wonderful intro to making good software.
Personal computing’s past looks a lot older than it actually is, because of how far it has come so quickly.
I think this leads people to believe personal computing is more mature than it is; that it is set in stone, or mostly sculpted already.
The widgets on my screen include weather and calendar.
The calendar widget knows where I'll be over the next 5 days. But the weather widget shows the 5-day forecast for where I happen to be right now.
Why can't I put the two together somehow?
For some reason, this is not a widely held understanding — how we structure education is a systemic example.
But it runs through even in research circles, in which individuals often undermine or undervalue efforts that rhyme with prior efforts. The aperture is too narrow.
This is absurdly delightful
Its results are far more interesting that what I get on google.
Searching for things related to ideas for the future of personal computing, google gives me a bunch of uninteresting news articles; Metaphor gives me wildly rich results!
Environments that are a "simple box where i can input everything", but then make that 'everything' useful / organized in clear, deterministic – yet meaningful – ways are often the basis of my experiments.
Cross-reference nav was similar in this vein:
i've been imagining a 'simple box where i can journal everything' for a while now, inspiring to see this elegantly realized in
@alexobenauer
's OLLOS demo, and way farther with types and spaced-repetition–'own your digital timeline' vibes 🙌🏽
Love how this works — showing your notes both in-context on the webpage, as well as in their own listing that you can refer to separately / review regularly
What are your favorite ongoing projects that you like to follow?
For example, some of mine: SerenityOS (
@awesomekling
), Playbit (
@rsms
), Hundred Rabbits (
@hundredrabbits
).
Date Me Docs are a really cool instance of people being fed up with apps and rigid interfaces not working for them, and turning to more freeform tools to build what might.
If your work has benefitted from mine, consider becoming a member — it has a very real impact on how much time I get to do my indie work.
Plus, I’ll be sending out demos of my next experiment to members soon. It’s called Earthling, and it explores inklings around authoring
Some months ago, Emil really helped me understand the things in this thread. Unlocked lots in my implementation.
Now, in the itemized OS, relationships are themselves items (I think
@Paul_Rony
gave me that suggestion?), and can hold user-defined attributes like any other item.
Since tools for thought people are talking a lot about custom data structures and schemas these days, let me share my thoughts on what our tools’ graph structures have to offer:
"Too much of our artificial world is oversimplified, overabstract, thereby taking away our most powerful capabilities."
This point is key: the abstractions we have in computing today are not just wrong, they're too abstract (too higher-level?), and they can't handle complexity.
Kicked off a series of summer projects this past weekend.
First project: I made an items system service. It runs an items server on your OS so that your various programs can interact with your overall items graph and - through the same protocol - sync with your other devices.
Leaving my demos a bit unpolished lately.
Recently learned that polish was often reading as finalization, prompting converging feedback, when diverging is still needed! (Thanks to
@alexwarth
for the help discerning / understanding this)
More on this in a member essay, out soon.
In the OS of the future, once the fundamentals are set, the other concepts follow.
In the itemized OS, if:
- everything in your system is an item
- items are created (e.g. note) or brought in by services (e.g. email from email service)
- services provide actions along with items
I've long enjoyed the idea of making a Finder replacement as a wedge into somewhat materially changing the computing environment on existing OSs. Looking forward to this:
Currently-playing media should be a “stack” on the OS. If I play some video on a website, pausing the music is usually fine, but it should be represented in a stack that lets me pop the current thing off, and return to the prior playing thing.
The widgets on my screen include weather and calendar.
The calendar widget knows where I'll be over the next 5 days. But the weather widget shows the 5-day forecast for where I happen to be right now.
Why can't I put the two together somehow?
One of the most glaring insights from living in my own OS’ user environments is simply that it takes too long to unearth insights!
Today's lab note starts to explore one experiment aimed at tightening up that feedback loop.
Ways OSs have allowed software to inject into system interfaces:
Menu bar, dock, spotlight, taskbar, system tray, widgets, notifications, app clips.
What are some other good ones?
Embark proposes one such way: separate the data, functions, and interfaces users need.
Then let users recombine these pieces for their own needs and context.
Embark puts these pieces into an outliner, which has familiar mechanics for grouping, hiding, etc.
So I've been building it to include some creature comforts, and to make it easy for folks to introduce 1) other providers, and 2) their own "app"-like interfaces which they can load up on demand.
It's a fair bit of work, so stay tuned!
Today's lab note was the hardest one to write yet.
It's complex in how it influences how we might think of an itemized operating system.
But it's an interesting, alternative way to think about our systems and how we interact our things. I hope it's understandable!
Up soon.
Hello, Operator! is the guide to WonderOS.
It's an exercise in exploring how computer literacy is attained, and how people might learn to evolve itemized, malleable systems.
What are some good examples of software interfaces that maintain the "history" / timeline of your use of it visually, as the primary interface you're working in?
(I have some examples but they're from others' private demos, so I'm looking for ones that can be shared publicly.)
In a few weeks, it will have been 10 years since we shipped the very first Mail Pilot to backers.
I'm also about to finish its v5, which almost feels like capping the adventure at the other end.
Would you be interested in a brief talk of the highlights & insights from it all?
I ended up going a different direction for this, but just for fun: here was the original idea for what will be at [list.] sometime after the main site goes up.
...an "itemized playground" — just the scaffold of providers + item store — for other developers to have, in which they can create their own ideal personal software.
It'd be an interesting experiment to see what's possible when people have access to an itemized environment.
People want to... [a list of things software should support]
People want to tinker
People want to explore
People want to take notes on things
People want to chat about things
People want to create
People want to remix
People want to personalize
Lots coming this week: a new lab note, and this weekend, a year in review, a redesign of the membership program, and a couple other little things.
Hop on the newsletter or RSS if you want these when they go live.
Finally, a huge thanks to all
@inkandswitch
colleagues for putting up w/ me this year. In particular to collaborators
@paulsonnentag
+
@geoffreylitt
; advisors
@pvh
+
@alexwarth
.
I’m glad to live in a world in which I&S exists. It’s been a privilege to support the work this year.
Watching others use their computers has long been a fascination of mine. There’s so much to glean from lots of little details.
One of the more shocking anecdotes from this fascination kicks off my latest lab note:
I love Augmenting Human Intellect (1962), but there's something really special about a short paper like Man-Computer Symbiosis (1960). I can print it out, mark it up, spend a few days with it, research references, get into the headspace of that thinking and that time.
Some projects more people should know about:
@tanagram_
from
@FeifanZ
and Formable from
@EmilBruckner
.
These projects have their creators asking interesting questions; watching along as they find answers is thrilling.
The latest from Feifan on Tanagram:
November update: I’m narrowing my focus for now to a tool that enables users to define a relational schema describing a codebase. There’s plenty to figure out around this topic, and I can always add more complex ideas later.
I also added a "text detector" widget which would donate found entities (dates, places, etc.) from freeform text. Then everything would react.
So you could drop in an email, for example:
Copy editing this one was funny; design issues with bi-temporality are hard to communicate precisely in plain english.
e.g. "The main item is shown at the time it is scheduled for, with a mention when it was created / scheduled"
When I need to do high-execution work, I tend to play music I know well. When I need to do high-exploration work, finding new ground, I tend to play music new to me (helps carve new paths of thought). Delightfully, when I'm in between, playing covers hits a nice balance!
The second edition of my Member Magazine comes out tomorrow. It has articles on: my personal stack of software I've built for myself, hardware projects that paint interesting directions for the future of personal computing hardware, my challenges as an indie, plus a few more.
While reading Feynman's lecture on "What is Science?" it became clear to me:
In school, I was mostly just taught the *results* of others' processes: definitions, memorizations.
Rarely taught the processes themselves, which could be used to further explore the world.
For ex.:
Working on my experimental itemized system within its own language. It feels akin to building a webpage, while designing the HTML and CSS langs, and building the browser & rendering engine, all at the same time.
Progress can feel quite slow!