Alexander Obenauer

@alexanderobenauer.com

1337 Followers 110 Following

I explore the interfaces with which we think & the future of personal computing. I also make books. alexanderobenauer.com

With this new book we are trying with equal enthusiasm & sincerity to curate a collection of essays that not only put forward sharp ideological positions (which are undeniably important to synthesize and articulate) but then also to extrapolate forward from those positions past the merely abstract to offer concrete prescriptions for building actual new things to move the world out of its present surly quagmire. Our field is notably bad at the former (though naturally with scattered exceptions); doing the first and then the second in a continuous gesture is a feat in any field. But to some extent doing that very thing right -- pulling off that feat and plenty of it -- now has a kind of lest-we-slip-into-a-metaphoric-but-maybe-also-literal-dark-ages feel to it, so here we go.
Augment is a forthcoming collection of essays on the future of personal computing: specifically, on the kind we as a species need in order to move beyond our stuck present, and on the ideas that will help us get there. This book is meant to serve as guidance and inspiration as we build a next generation of hardware, software, and systems. We hope you’ll share this page with those you think might write great essays for Augment, and even consider writing one yourself. Submissions are due by July 31. The technology field is today in a precarious state. A tsunamic tide of commercial thinking has managed the wholesale capture of practitioners, institutions, and dialogue. This capture has drained all imagination from our surround, and so actual invention has slid likewise near to zero. Along the way, the systems meant first to extend human reach have instead become dull and clanking manacles. Yet the same quality that makes technology easy to hijack — that massless, abstract ductility — leaves it as easy to re-form. The opportunity is still with us, undimmed, to build anew the beautiful thing, the powerful thing, the luminous thing, the human thing. This then is the invitation: to trawl a net through waters that, far enough down, remain idea-rich and that, with care, might still teem.
Picture from the red line over the Charles at sunset
LAYERING UP THE ITEMIZED USER ENVIRONMENT December 3 In this lab report, we consider one way to look at the architecture for the itemized user environment: a layering that has been happening since the dawn of time. Some harbor an inclination toward a “grand design” in the construction of a new operating system’s user environment; a sort of “turtles all the way down” architecture that features one substance, or one core primitive, which defines the mechanics of an entire computing system deep under the hood and up into userland. I’m more inclined toward the “layers” which we’ve been stacking up since we first made the jump from hard-coded circuits to programmable, general ones (and on which we have built many new layers — machine code, assembly, low- and high-level programming languages, and so on). Each layer adheres to the contract of the one below, and offers a new way to think about things to the layers which will be built above. This is how we’ve bootstrapped into all of modern computing starting from simple logic gates, in a slow, evolutionary construction. This isn’t just the way modern computing came to be; it’s the way our physical world came to be, too! This “layering” is how our world has evolved into the one we know. But it comes with some important consequences.
One other interesting feature of Wonderful is how it handles certain kinds of dot calls. If a function has an unlabeled first parameter, that function can be used in a dot call on matching types: ```Swift func square(_ num: Int) -> Int { return num * num; } let a = 10; var b: Int; b = square(a); // standard function call b = a.square(); // same result as standard call ``` This matches on any expression of the right type, so you can even use it with literals or more complex expressions: ```Swift func square(_ num: Int) -> Int { return num * num; } var a = 10.square(); var b = (5 * 2).square(); ``` This lets us add member functions to types in the current scope with little formality. And by flipping calls around this way, we can chain the use of functions together which read from left to right: ```Swift func square(_ num: Int) -> Int { return num * num } func double(_ num: Int) -> Int { return num * 2 } func abs(_ num: Int) -> Int { return num < 0 ? -num : num } print((-3).abs().double().square()) // abs(-3)=3, double(3)=6, square(6)=36 ```
DESIGNING A LANGUAGE FOR THE ITEMIZED ENVIRONMENT September 17 In this lab report, we look at Wonderful, the language purpose-built for handling items and interfaces in the itemized operator environment. I’m in the midst of building a new user environment with the kinds of ideas that I’ve been exploring for personal computing’s future. Over the course of several lab reports, we’re looking at how this user environment works, inside and out. In the last lab report, we explored the Item Store, a database of chronological facts that serves as our persistent storage layer in the itemized environment. Now, we’re going to take a look at the programming language purpose-built for handling items and interfaces in this environment. It has several features that help interfaces connect to the item store, and for users to iterate on their interfaces and programs from within their normal operating spaces, interacting with code items with the same benefits they gain from the rest of their things existing in an itemized environment. First, we’ll look at the basics of the language, then dive into some ways it serves the particulars of an itemized environment. Finally, we will look at how it is internally architected to allow the itemization of its own code — so that it can be further developed in-environment, with the benefits of an itemized IDE interface.
Building an Item Store for the itemized environment *In this lab report, we look at the _Item Store_, a database of chronological facts that serves as the itemized environment's persistent storage.* This year, I've been hard at work building a user environment that reifies personal computing of the kind I've explored for the last several years — something I can fully live in. Over the next several lab reports, we're going to take a deep dive into this environment and its implementation, as well as a bit of the project's philosophy. This first report is on the environment's storage mechanism. The next one will cover the environment's programming language. After that, we'll move toward the environment's interface. First, we will look at the kinds of ideas the Item Store was built to support. Then we will look at how the Item Store works, highlighting some key implementation details.
It’s funny to have such a strong association of times with places. Lots of specific times in our lives were spent in distinct places, so my recall of memories often starts at this association. It’s also interesting to note that time slowed down when we were on the road. Particularly for the longer-than-a-year trips, when the year was packed with so many different places, each week or month holds distinct memories that don’t blur together. The gradual acceleration of life’s time was put on hold.
I've found no driving force quite like curiosity. A rich problem can capture the mind far beyond its necessary duties; not even hunger can hold a candle to the flame, when properly lit. **Find the gaps**. My curiosity pulls me forward when there’s something I’m not sure of, something I don’t know yet; an unanswered question. This is what makes new projects more interesting; it’s all one big gap! Lots to explore. To keep going on existing projects: find the gaps. They are certainly there; they just aren’t as obvious. Look for the gaps, point at them, and describe them. Once they bug you, you're off to the races. **Look for good problems**. Good problems have a way of taking care of themselves, in the minds of the curious. Get to know everything you can about the problem, how people have tried to solve it before, etc. Any amount of time spent finding rich problems is also well worth it, thus justifying many of our conversations, odd explorations, and excursions into other fields (though we need no justification to do these things). Ruminating on good problems, in the background and on the foreground, is one of life's great joys, and one of the greatest sources of human progress. **Good ideas come last.** Often, the *best* ideas hide behind the *obvious* ones. It can be helpful to write all the ideas, then wrestle with the boredom that follows, waiting on more ideas to come. One of the last ideas to arrive is often the most important. You'll know which ideas are the best: they'll generate more thought than the others, taking up more space on the page than you expected.
You can do things for their own sake without having to provide justification. But if you really need one, it's this: *things lead to other things.* Doing things opens up doors, ideas, pathways, and opportunities that couldn't have been imagined or designed without having first done those things. By definition, doing things you enjoy leads to more things you'll enjoy. It's another way of saying "the dots connect looking backwards", one of the three messages in Steve Jobs' (wonderful) commencement address at Stanford, but it keeps the frame in the present. Simply following one's curiosity — even when it seems unproductive to do so — is wildly underestimated as an activity that moves the human race forward. Feynman's spinning plates led to his Nobel prize. It's easy to lose motivation when it isn't clear how some work will contribute. But quite often, the biggest contribution something makes is the next thing it leads us into. We can't predict these paths in advance, but we can notice how much it has happened in the past, and trust that it will continue. This is one worth repeating early and often. Things lead to other things. It's a powerful reminder in the face of creative doubts. "What if this is nothing?" Doesn't matter, it will lead to something.
Screenshot of alexanderobenauer.com
Convert menus to palettes: You can "tear off' both the Tools menu and the Patterns menu so that you can have constant access to them as you work. Just drag through them, past the bottom or off to one side; then leave them where you want them. When they get in your way, move them by dragging their top bars. Click their dose boxes to make them go away.
Bootstrapping Computing - 16 available.
Reimplementing the Canon Cat document interface
Inside page of Bootstrapping Computing.
Cover of Bootstrapping Computing
Screenshot of lab note #40 titled "The venerable hyperlink"
Today we live in an information-based technological word. The problem is that this is an invisible technology. Knowledge and information are invisible. They have no natural form. It is up to the conveyer of the information and knowledge to provide shape, sub-stance, and organization. The irony is that too much of our artificial world is oversimplified, overabstract, thereby taking away our most powerful capabilities.
Adding to the corpus of ideas, some observations on process My exploration into the operator environment for an OS of the future has been guided by need and intuition, but how I’ve reacted to those forces has evolved over time. If you’ll allow some naval-gazing, I’ll share some observations and reflections on process. My present aim is to add to the corpus of ideas. Fundamentally, I believe the ideas we’re working with today aren’t very good. There’s a very high bar; we can only work on so many things. So I have this heavy bias towards divergence in my work. Diverge and diverge again.
Screenshot of a workout item and weather report item which have selected data points opened to further detail.
Part of this story I left out: When I said to open Finder, they actually opened Spotlight first, guessing that might be what I was referring to as "Finder" — that was interesting!