These Lab Notes document my research in progress. My research area is in the future of personal computing.
Notes on time
Gestural view construction
Free and easy organizations and associations
The Messy Desktop
Live items & Contextual notifications
Swappable reference views
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
Composing application interfaces
The Lab Notes
We use our computers to work, learn, think, create, and collaborate. As we do, we navigate around all kinds of different things — notes, web pages, events, to-do lists, emails, and so on.
Typically, when using a present-day operating system, we do that “navigating” by flipping between a number of windows, sometimes rearranging and resizing them.
One reason why we navigate this way is because many of our things are contained within their own apps (i.e. emails in an email client, notes in a note app). But as we saw in the last two Lab Notes, our concept for the future operating system breaks items out of these rigid containers (LN 002), allowing you to bring them anywhere you want among system and application views (LN 003).
Extending that fluidity, today we’ll look at one way to navigate around your different items.
In my concept for the operating system of the future, you can open any item on its own. It could be any individual item: an email, a note, an event, or a day from your planner; and it can be from any level of hierarchy within your system: a whole todo list or just one specific todo.
With just that item open, you’re now in an environment that allows you to focus on your task at hand, and you can bring in other items as you need them.
These items can be brought in using any of these three methods:
As you open new items, they line up horizontally, forming a browsing path (the general concept here is a “browsing context,” but in this particular horizontal execution you’ll see below, I’ve taken to using the friendlier “browsing path”).
Consider: Say you’re writing out a todo list for today’s work. You might start a new note to record some thoughts on a specific topic you’d like to refer to later. Further, you might pull up an article on Wikipedia to reference some information in your note.
This interaction allows you to easily move through your unfolding thought process, and develop your work while exploring related resources.
In this view, you can resize the width of any item, and you can reorder the items if you need to pull two things closer together. You can open new items between or beside any other items. You can pin any item to the side so that stays in place when you scroll around the other items as you work.
Your browsing path typically forms one cohesive context in which you’re doing some specific body of work. Conceptually, you might liken this to tabs in the web browsers of today, but encompassing all kinds of items (rather than just web pages).
But, unlike the tabs stacked into a modern-day web browser’s window, they don’t all disappear if you close it out.
When you leave a browsing path to open some other application or system view (or another browsing path), it isn’t gone. Later, you can open your “recent paths,” a view that contains all of the paths you’ve gone down, sorted by recency. You can grab a specific item from any of the paths, or you can simply return to a path in its entirety, and it’ll open back up just as it was.
Consider an extension on the above demo: Say something else has come up, and you leave the path to tend to other work. Later, when you want to continue this work, you open your recent paths, and return to this one, which is opened just as it was when you left it last.
Finding, opening, and arranging things to do some body of work is itself an amount of work. In today’s operating systems, this work is transient and volatile — a closed window is gone. But with recent paths, this work of gathering materials needed for some specific task is always remembered by the system and ready for reuse.
It’s a transformative new way to consider navigation on your system as a user, allowing for more graceful context-switching, greater focus on the present task, and no more worry that you might lose something that you’ve opened.
This help from the system is welcome: how many times have you lost a tab that you wished you had saved, or recorded long lists of links to try to keep that from happening?
Finally, just for fun: say you’ve typed an item in your note that you realize you’d rather have over in your day’s todo list instead. Thanks to universal data portability, you can just move it over.
Dragging and dropping between different items you’ve opened in a browsing path allows you to move, copy, or reference.
This is where we are starting to see the flexibility of universal data portability.
There are plenty more interesting things we can do with browsing paths, which we will explore in future Lab Notes. Be sure to subscribe if you’d like to receive the next lab note via email.