A Kardashev scale for interfaces
In 1964, Soviet astronomer Nikolai Kardashev proposed that we measure an alien civilization's level of technological advancement by the amount of energy it can harness. The Kardashev scale:
Type 0: (You are here)
Type 1: Can harness all of the energy available on its planet.
Type 2: Can harness energy at the scale of its solar system. Think Dyson Spheres.
Type 3: Can harness energy at the scale of its entire host galaxy. (???)
It’s a kind of sci-fi corollary to Lotka’s Maximum Power Principle:
During self-organization, system designs develop and prevail that maximize power intake, energy transformation, and those uses that reinforce production and efficiency.
From Nick Arner, in reply to Collapse the distinction between user and programmer:
Coming from the music world where I played around with MaxMSP and Quartz Composer was probably what lead me to an interest in things like composable software, etc… if I could connect all these things to make music, why can't I do the same thing with code?
That said, it always feels like the barrier to these things working properly is the fact that they can create the tangled wires problem… I'm not sure if this is an interface design problem, or if it's an intractable issue due to the nature of composability as something that can create very deep and complex nesting.
The tangled wires problem.
On the one hand, what a mess! On the other hand, you couldn’t achieve this level of expressiveness using a point-and-click GUI interface. That’s why node-based programming often shows up in creative tools. Point-and-click interfaces just don’t have the expressiveness to compose a song, or program a video game.
What if the tangled wires problem is a good problem to have? An expressive system pushing up against the boundaries of its expressiveness.
Matt Webb’s post on interfaces and notation reminded me of Max Kreminski’s notes on controls as language, and Christopher Alexander’s thoughts on systems generating systems.
Interfaces, language, expressiveness, evolvability. Let’s join a few threads I’ve been pulling on over several posts.
Interfaces are a kind of language.
Languages are made up of alphabets.
Different alphabets have different levels of expressiveness.
The mechanism of composition determines a lot about the expressiveness of an alphabet.
Sufficiently expressive alphabets are capable of open-ended evolution.
Taken together, we could look at the alphabet of an interface, and think about its expressive potential. We might even begin to group interfaces by expressiveness, and rank them.
A Kardashev Scale for interfaces. Instead of measuring energy, we measure the expressive potential of the interface.
Type 1 / Discrete: You can select discrete verbs and apply them to nouns. Clicking a button. Saving a file. There is no mechanism of composition. Examples:
GUIs
Hardware control panels
In a discrete interface, you combine actions across time, by manually pointing and clicking. In some discrete interfaces, verbs can only apply to specific nouns. The more expressive discrete interfaces have general-purpose verbs that can act on many nouns.
Type 2 / Composable: Composable interfaces might include composable nouns, composable verbs, or both. Discrete interfaces only let you combine actions across time, by manually pointing and clicking. Composable interfaces let you combine actions across space, using notation.
Composable nouns are data that have the same shape, so you can combine them together.
Lego
Excel and SQL tables
Composable verbs are actions you can string together into pipelines that can be run over and over with different nouns.
Unix pipes
Spreadsheet formulas
Nodes-and-wires programming
Modular synthesizers
Type 3 / Recursively composable: Composed verbs and nouns can themselves be used as verbs and nouns in other compositions.
Functions
Shell scripts
Systems that include scripting languages, like Hypercard or the web.
Recursive composition takes the logic of composition to its most extreme endpoint. You can bundle up complex combinations of verbs or nouns so that they can be treated as a single unit. This starts to get you toward something like general-purpose computing.
Recursion is the root of computation since it trades description for time.
Alan Perlis
You can freely trade between time (actions you take) and space (notation) to get the job done. You might even code yourself out of the loop completely.
The original Kardashev scale only goes to 3, because Kardashev figured that harnessing the energy of an entire universe would be impossible. That’s not going to stop me, however.
Type 4 / Self-authoring. The system itself is defined through the nested composition of a small number of primitives, giving you complete access to the very alphabet that was used to construct the system.
Lisp
SmallTalk
DNA
Physics
When an interface is self-authoring, those using the interface can rewrite it completely to meet their needs. A self-authoring interface collapses the distinction between user and programmer.
So, this scale is as handwavey as the Kardashev Scale. A Kardashev Type 0 civilization might mean anything from stone tools to nuclear reactors. Likewise, each type in our scale brackets a massive design space.
Within each type there are good and bad designs, simple and complex designs, expressive and inexpressive designs. Still, I think this scale might describe something like orders of magnitude in expressiveness?
Discrete (1x)
Composable (10x)
Recursively composable (100x)
Self-authoring (1000x)
There’s also, I think, a relationship between expressiveness and complexity, but the relationship is not linear or obvious. It’s not 1:1 more expressiveness means more complexity. Consider the Xerox Alto. It was much simpler to use than other systems of the time, but was also self-authoring. The expressiveness revealed itself in layers. I suspect complexity has more to do with pushing up against the limits of your interface language.
Perhaps this could be seen as pace layering in an interface? A personal computer might span everything from GUIs (discrete), to command lines (composable), to scripting languages (recursively composable), to bytecode (self-authoring). And what if every tool worked this way?