For a majority subset of software, called “information software,” I argue that interactivity is actually a curse for users and a crutch for designers, and users’ goals can be better satisfied through other means.
Information software design can be seen as the design of context-sensitive information graphics.
Most software is information software. People spend more time learning than creating.
Information software design is graphic design. People learn by looking. Looks are all that matters.
Context-sensitive information graphics. Software trumps print by showing only what’s relevant.
Inferring context from the environment. The outside world can suggest what’s relevant.
Inferring context from history. Memories of the past can suggest what’s relevant.
Interactivity considered harmful. The user can suggest what’s relevant, but only as a last resort.
Graphic design is the art of conveying a message on a 2D surface. This is a broad field, because people have such a variety of messages to convey — identity, social status, emotion, persuasion, and so on. Most relevant to software is a branch that Edward Tufte calls information design — the use of pictures to express knowledge of interest to the reader. Some products of conventional information graphic design include bus schedules, telephone books, newspapers, maps, and shopping catalogs. A good graphic designer understands how to arrange information on the page so the reader can ask and answer questions, make comparisons, and draw conclusions.
A good industrial designer understands the capabilities and limitations of the human body in manipulating physical objects, and of the human mind in comprehending mechanical models.
Just as importantly, she designs an understandable mapping from physical features to functions — pressing a button snaps a picture, pulling a lever advances the film, opening a door reveals the film, opening another door reveals the battery.
At the present, software can’t do much for physical needs — if your avatar eats a sandwich, you remain hungry. But people are increasingly shifting their intellectual activities to the virtual world of the computer. This suggest 3 general reasons why a person will turn to software: to learn, to create, to communicate.
I propose that software can be classified according to which of these needs it serves. I will call these categories information software, manipulation software, and communicative software.
Visions give people a direction and inspire people to act, and a group of inspired people is the most powerful force in the world. If you’re a young person setting off to realize a vision, or an old person setting off to fund one, I really want it to be something worthwhile. Something that genuinely improves how we interact.
Programming is a way of thinking, not a rote skill. Learning about “for” loops is not learning to program, any more than learning about pencils is learning to draw.
People understand what they can see. If a programmer cannot see what a program is doing, she can’t understand it.
Thus, the goals of a programming system should be:
- to support and encourage powerful ways of thinking
- to enable programmers to see and understand the execution of their programs
A live-coding Processing environment addresses neither of these goals. Javascript and Processing are poorly-designed languages that support weak ways of thinking, and ignore decades of learning about learning. And live coding, as a standalone feature, misses the point.
“To understand a program, you must become both the machine and the program.” This view is a mistake, and it is this widespread and virulent mistake that keeps programming a difficult and obscure art. A person is not a machine, and should not be forced to think like one.
Alarmingly, the latest platforms forgo both of these virtues. CSS, a language for specifying visual appearance on the web, is a particularly egregious example. It is so complex that it has never been implemented correctly; yet, successive versions specify even more complexity. At the same time, it is so underpowered that many elementary graphic designs are impossible or prohibitively difficult, and context-sensitivity (or anything computational) must be addressed externally. Most CSS lore is dedicated to describing the tangles of brittle hacks needed to circumvent incompatibilities or approximate a desired appearance.
One cause of the CSS mess is the eschewing of elegant, flexible abstractions for “1000 special cases,” a detrimental approach which precludes simplicity and generality in any domain. However, the larger and more germane fault is the language’s attempt to serve as both tool and platform, thereby succeeding as neither.
For universal reliability, the ideal platform must be optimized for ease of implementation. For artistic expressiveness and exploration, a tool must be optimized for the designer’s manipulation. Thus, the tool and platform cannot be the same — we must expect a layer of translation between what the designer works with and what the platform interprets.
I suggest that the root of the software crisis is an identity crisis — an unclear understanding of what the medium actually is, and what it’s for. Perhaps the spark of life is misdirected magic.
Some products of conventional information graphic design include bus schedules, telephone books, newspapers, maps, and shopping catalog. A good graphic designer understands how to arrange information on the page so that reader can ask and answer questions, make comparisons, and draw conclusions.
Industrial design is the art of arranging and shaping a physical product so it can be manipulated by a person. This too is a broad field, because people work with such a variety of objects. A good industrial designer understands the capabilities and limitations of the human body in manipulating physical objects, and of the human mind in comprehend mechanical models.
But people are increasingly shifting their intellectual activities to the virtual world of the computer. This suggests 3 general reasons why a person will turn to software: to learn, to create, to communicate.
Information software serves the human urge to learn. A person uses information software to construct and manipulate a model that is internal to the mind — a mental representation of information. Good information software encourages the user to ask and answer questions, make comparisons, and draw conclusions.
Manipulation software serves the human urge to create. A person uses manipulation software to construct and manipulate a model external to herself. Manipulation software can be considered a virtual tool — like a paintbrush or typewriter or bandsaw, it is used as an interface between creator and artifact.
Communication software serves the human urge to communicate. A person uses communication software to construct and manipulate an internal model that is shared with others — an understanding synchronized across multiple minds.
The primary design challenge, just as with any industrial design, is to provide affordances that make these mechanical operations available, understandable, and comfortable. However, in a physical space, each operation would use a specialized tool. Designing a “mega-tool” that cleanly incorporates all operations (and flattens them into two dimensions, and uses only the gestures “click” and “drag”) is a significant challenge indeed.
Although manipulation is the focus, good manipulation software must provide superb visualization as well. This establishes the feedback loop that is critical for all creative activity — the manipulator must see the effects of her manipulation. Thus, manipulation software design is also a significant graphic design challenge.
Because of these intertwined design challenges, the design of excellent manipulation software in unbelievably difficult, and mustn’t be underestimated. Fortunately, for an enormous class of software, manipulation is not only largely unnecessary, but best avoided.
I tried to keep track of what one moderately technical person [myself] actually did during the hours he regarded as devoted to work. About 85% of my “thinking” time was spent getting into a position to think, to make a decision, to learn something I needed to know. Much more time went into finding or obtaining information than into digesting it. Throughout the period I examined, in short, my “thinking” time was devoted mainly to activities that were essentially clerical or mechanical: searching, calculating, plotting, transforming, determining the logical or dynamic consequences of a set of assumptions or hypotheses, preparing the way for a decision or an insight.
Most of the time, a person sits down at her personal computer not to create, but to read, observe, study, explore, make cognitive connections, and ultimately come to an understanding. This person is not seeking to make her mark upon the world, but to rearrange her own neurons. The computer becomes a medium for asking questions, making comparisons, and drawing conclusions — that is, for learning.
People using this software do not care about these artificial objects; they care about seeing information and understanding choices — manipulating a model in their heads.
I want to see how all of this information interrelates, make connections, and ultimately make a decision about what to do when. Entering a dentist appointment is just a tedious minor detail, and would even be unnecessary if the software could figure it out from my dentist’s confirmation email. My goal in using calendar software to ask and answer questions about what to do when, compare my options, and come to a decision.
Ignore the structure of current designs, and ask only, “Why is a person using this?” Abstracted, the answer almost always is, “To learn.”
I’m asking for software to display a complex set of data in a way that I can understand it and reason about it. This is a well-established problem; it’s the raison d’etre of information design.
A well-designed information graphic can almost compel the viewer to ask and answer questions, make comparisons, and draw conclusions. It does so by exploiting the capabilities of the human eye: instantaneous and effortless movement, high bandwidth and capacity for parallel processing, intrinsic pattern recognition and correlation, a macro/micro duality that can skim a whole page or focus on the tiniest detail. Meanwhile, a graphic sidesteps human shortcoming: the one-dimensional, uncontrollable auditory system, the relatively sluggish motor system, the mind’s limited capacity to comprehend hidden mechanisms. A graphic presents no mechanism to comprehend or manipulate — it plugs directly into the mind’s spatial reasoning centers.
Compared to the excellent ink-and-paper designs, most current software communicates deplorably. This is a problem of surface, but not a superficial problem. The main cause, I believe, is that many software designers feel they are designing a machine. Their foremost concern is behavior — what the software does. They start by asking: What functions must the software perform? What commands must it accept? What parameter can be adjusted? These designers start by specifying functionality, but the essence of information software is the presentation. ***
Unfortunately, these questions are completely unaddressed by the information provided. To see relevant information, the user must click on each listing individually. That is, she must navigate by hand instead of by eye, and must use her memory to compare information across time instead of space.
Is a book good? A rating and reviews indicate popular opinion. Because all of this information is on a single page, it can be compared by eye, with no need for memory.
The standard 5-star rating system is information-weak — it gives only an average. It can be enhanced with whiskers underneath that indicate the distribution of ratings.
The user wants to see books related to a topic in her head. But ideas in the head are nebulous things, and may not translate perfectly to a concrete search term. For this reason, a mini-list of related books is provided for each book. This is similar to a “related words” section in a thesaurus listing — it allows the user to correct a near miss, or veer off in a tangential but intriguing direction.
A reader consulting an encyclopedia must not only find the right entry on the page and the right page in the book, but even the right book on the shelf.
All software lives within an environment, rich with evidence of context. Using software that doesn’t look outside itself is like conversing with a blind person — constantly describing what is plainly visible.
On the other hand, the power of the environment is multiplied when it is correlated with the past — that is, when the software makes use of history.
A human doesn’t just use her senses to recognize her situation; she also uses memories of past situations.
Learning predictors attempt a deeper understanding of the user. They construct a model to explain past contexts, and use the inferred relationships to predict the current context.
Most software wake up each day with a fresh case of amnesia.
Crawford defines interaction as a 3-phase reciprocal process, isomorphic to a conversation: an interactant listens to her partner, thinks about what was said, and speaks a response. Her partner does the same.
For manipulation software, interaction is perfectly suitable: the user views a visual representation of the model, considers what to manipulate next, and performs a manipulation. The software, in turn, inputs the user’s manipulation request, updates the model, and displays the update representation. With good feedback and effective means of “speaking” to the software, this process can cycle smoothly and rapidly. It mimics the experience of working with a physical tool.
Information software, by contrast, mimics the experience of reading, not working. It is used to achieving an understanding — constructing a model within the mind. Any manipulation happens mentally. The only reason to complete the full interaction cycle and speak is to explicitly provide some context that the software can’t otherwise infer — that is, to indicate a relevant subset of information. For information software, all interaction is essentially navigation around a data space.
In fact, it is the author’s opinion that poorly designed navigation presents the number-one problem in the design of any software application or system.
A low-interaction, non-mechanical information graphic relieves both user and designer from struggling with mental models.
Navigation implies state. Software that can be navigated is software in which the user can get lost.
Unless it is enjoyable or educational in and of itself, interaction is an essentially negative aspect of information software.
A second reason why modern software is dominated by mechanical metaphors is that, for the people who create software, the computer is a machine. The programmers lives in manipulation mode; she drives her computer as if it were a car. Thus, she inadvertently produces software that must be operated like a machine, even if it is used as a newspaper or book. Worse, the people who design platform and GUI toolkits are even more prone to this perspective, since they work at a lower level. The application designer is then almost forced into a mechanical model by the design environment.
Although there clearly is more to the widget than this, most of the “user experience” is represented by the picture above. That is, this software is normally “used” by simply looking at it, with no interaction whatsoever.
Ironically, the BART widget appears so fresh because its underlying ideas are so old. The time bar graph was invented about 250 years ago. The map and the written sentence are both about 5K years old. They are beautiful, venerable forms of visual communication. The bugs have been worked out. They are universally, intuitively understood.
The pulldown menu, the checkbox, and the bureaucracy-inspired text entry form were invented 25 years ago, desperation devices to counter inadequate technology. They were created for a world that no longer exists.
25 years from now, no one will be clicking on dropdown menus, but everyone will still be pointing at maps and correcting each other’s sentences. It’s fundamental. Good information software reflects how humans, not computers, deal with information.
Between the businessman’s specifications and the engineer’s implementation, there was no design. Within a few decades, a new profession arose to fill the gap — industrial design.
Good design makes people happy, but feature count makes people pay.
In all artistic fields, from painting to writing to music to architecture, students study the works of the masters. (In fact, artists who claim to be “self-taught” usually mean that they learned purely from examples.) Much has been written about the failure of software engineering schools to provide examples of great works, expecting students to somehow derive style from first principles. Since software design isn’t yet recognized as an artistic field in the first place, its situation is even worse — the very concept of a gallery of software designs will seem absurd to most people. But a corpus is crucial for the development of any artistic field. Outstanding designs must be recognized, collected, and explicated.
POSIX, Java, and newer web standards (DOM, CSS) are some attempts at universal platforms that have proven too complex to implement uniformly. In each case, the power of the platform is effectively constricted to some simple, reliable subset, and enormous time is wasted designing around incompatibilities. By contrast, JPEG, MP3, and modern CPU instruction sets are universally dependable, because much of the complexity is placed at the encoding tool, not the decoding platform.
For a platform to be reliable, it must either have a single implementation, or to be so utterly simple that it can be implemented uniformly. If we assume a practical need for open, freely implementable standards, the only option is simplicity.
One cause of the CSS mess is the eschewing of elegant, flexible abstractions for “1000 special cases.”
Before 1786, authors invariably presented quantitative data as tables of numbers. William Playfair single-handedly invented the line graph, the bar graph, and the pie chart, and thereby the entire field of statistical graphics.
Alternatively, a designer can draw a series of mockups, snapshots of how the graphic should look for various data set, and present these to an engineer along with a verbal description for what the mean. This results in ridiculously large feedback loops — seeing the effect of change might take a day instead of a second. This is no environment for creative exploration.
Early music composers typically work in silence, with pen and paper, and did not actually hear their compositions until they were presented to musicians. Composers who couldn’t handle this abstraction were belittled.
To understand a system, we must explore it. The 3 features above — time, structure, data — define the territory. We explore this territory by controlling parameters, abstracting over them, and stepping down from these abstractions.