Eidola Notation Gallery

	Notations and Visualizations
	User Interface Philosophy
	User Interfaces of Note
	Existing Visualizations of Programs
	Possible Eidola Notations

Discussion

Eidola home

This model is a big hit in the business world. It is simple and lends itself to the sort of institutionalized accountability that keeps projects managable. And it represents a great improvement over the ad hoc method of interface design programmers usually follow, in which interfaces happen as a spontaneous by-product of coding, without ever being designed at all.

The problem with the use case model is that it tends to lead to debilitating featuritis, and successive versions, instead of converging to an optimally effective program, diverge and grow without bound until the growth of the software outstrips the growth of the company that must maintain it.

Of course, this is only an approximation method -- some areas in the domain may be poorly covered (at the fringe of an existing feature) or not covered at all, and there is always room for improvement, for new features which catch bare spots in the domain of functionality. However, we can drive the software arbitrarily close to completely covering the domain of functionality simply by driving the number of use cases to be dense in the domain of functionality, and thus driving the number of features and the size of the software to infinity. The result will generally look something like Microsoft Word, a rare example of use-case-driven software in which the company actually has the resources to drive the size of the software to infinity.

Aside from the obvious problems of escalating resource use and development costs, the results of this approach taken too far do not even achieve what they intend. The idea that many features can cover a domain of functionality fails to take into account the fact that humans have a limited ability and willingness to learn a complex skill; thus, even if a word processor has hidden deep in its bowels a "wizard" for printing addresses on label sheets, half the users attempting to print labels will go at the problem without the wizard's help, using the basic tools they are already familiar with -- margin adjustments, tabs, carefully placed carriage returns, and a few dozen test printouts. Wouldn't you?

For sufficiently complex problems, a good interface works like a natural language: it is robust and expressive, and seeks not to directly address every possible scenario specifically (as a phrasebook does), but rather to provide a set of tools which fit together coherently and are adaptable to wide variety of uses (as a whole language does). The use case model says (loosely speaking):

An interface should address as many expected uses of the software as possible. (Therefore, more features are good.)

I propose the alternative:

An interface should provide maximal functionality with a minimal feature set. (Therefore, more features are bad; generality and robustness are good.)

This is a bit oversimplified -- in particular, it disregards the possibility of scalable interface complexity, an idea which is particularly important to Eidola's multi-notation world, but which I will not address here. As oversimplified mottos go, however, I believe this is a good one.

P(b) is the state of the motor after pushing button b down R(b) is the state of the motor after releasing button b
P(On)	=	on
R(On)	=	on
P(Off/Pulse)	=	on
R(Off/Pulse)	=	off

Cuisinart could have put on the front panel a series of buttons labeled "On/Off," "Intermittent Fast," "Intermittent Slow," "Off," and perhaps a timer and a set of speeds, "Puree," "Whip," "Mince," "Eviscerate"...and so on. Yet they have used the two-button interface at least since my childhood, and with good effect -- their food processors are so widely used and respected that, like Kleenex and Xerox, their brand name is in danger of becoming the vernacular term for their product's entire category. This interface's strength is its simplicity. People can learn to use it with only a few seconds of experimentation, and not only can do most everything they need to with it, but can easily see how. The extra features they might have added to the front panel have proved unnecessary in years of use. The Cuisinart's front panel is quite close to the Platonic ideal of a front panel for a food processor.

Great interfaces are not always small; they just choose features judiciously. Adobe Photoshop has a gigantic and very intricate interface; we can forgive it, however, because the functionality-to-feature ratio is very high, and the rewards of navigating its interface are tremendous. One testament to its quality is its long-time dominance in the world of publishing, which it has maintained for about 1.7 eons of software industry time. Another is the way it became an instant standard for serious web page designers -- a status which it achieved long before it was being designed for the web.

A first-time user of Photoshop will usually spend hours messing with its wonderful collection of filters (splashy visual effects and instant gratification); those who know it well, however, love it for things like selections and layers, very general features whose incredible power is difficult to quickly appreciate. A selection is a subset of an image which serves as a mask for other drawing operations (painting, filling, moving). It is a fuzzy subset (so a particular pixel of an image could be only 42% selected), and is as arbitrarily editable as any other grayscale image. A layer is like an image on a clear plastic sheet. A user can build up a whole image from a stack of independent layers, edit them individually, and modify the composition process that flattens them into a single image.

These building blocks of Photoshop's interface are not feature-specific, and do not arise from any single particular use case. They are general and robust, and wondefully powerful. A user approaching Photoshop with a particular task in mind need not know which page of a thousand-page "interface phrasebook" the appropriate feature is on; Photoshop's interface features have the power and generality of mathematical abstraction behind them, and combine to cover its domain of functionality in much the same way that a natural language builds concepts from isolated words. The strength of this interface goes far beyond mere ease of use. Learning to use Photoshop well is hard work, but it is work well spent.