Rethinking Computer Interfaces

The first dot-com boom has come and gone and we now find ourselves
in the gritty interim period, where only innovation, cunning, and
realized profits will save us and bring us back to prosperity. Gone,
thankfully, are the lucrative days when anyone with a webpage could
call themselves an “ebusiness” and acheive an obscene level of
rapport with investors. A lot of new business models have been tried and
a handful succeeded, but most failed.

What I thought particularly sad about the situation is that there
have only been a handful of attempts to really think outside the
box in terms of the computing experience and a user interface.
Some of this is understood, since so much of that which was new was
being thought up on the web and it was natural to think of the user
experience in “HTML mode.” HTML being just designed for document
formatting (and not a user experience akin to a program), the set
of operations we could perform using web applications actually
has decreased. There’s only so much you can do in the way of novel
interfaces if they have to be in HTML and rendered in a web browser.
Some creative folks have figured out how to give us a bit more power
in these experiences, such as having popup calendars to fill in a
date, but support of even such basic interface interactions as “drag
and drop” or uploading a folder of information at a time are made
impossible with HTML. HTML centrism has really made narrow possibilities for user interfaces; the move to try and shift all local applications to web applications has reduced the potential richness of user experiences.

To its credit, Macromedia has done a lot to attempt to fight this
battle and enable genuinely new and interactive experiences on the web.
However, such experiences have been primarily focused on entertainment
and artistic applications. There aren’t very many practical
Shockwave or Flash applications out there. Part of this has to do
with the fact that although both enable rich interaction experiences,
neither is designed as a full API for programming fully functional
applications. They make it easy to display data, but not to obtain it
or to interact with resources present on the local computer.

Thankfully, there is at least one trend that may bring hope to new user
experiences: peer-to-peer (P2P) computing. With most P2P computing
models, a program has to sit on the desktop that gives you access
to information through a network of peers, as opposed to a web server.
Since each P2P network uses a different client access program (and
indeed some of these networks have multiple clients!), there are a
rich array of opportunities to create novel end-user experiences.
We can only hope that some companies will take advantage of this
opportunity to experiment with making novel interfaces.

Now what is it that I mean by “novel interfaces?” It’s not that I mean
novel in the sense of entertaining, but instead, novel in the sense that
an interface that is unique, innovative, and takes advantage of the
client platform.

Most user interface designs are static. They are taken from the
standpoint of the text publishing world – to have an interface that is nicely
laid out is a high compliment. This aesthetic, as mentioned above,
works well for web design, which is largely a collection of pages with a
certain static visual arrangement. (This site is no exception.) It is
what I will call a “paper aesthetic.”

But paper is not by any means a natural aesthetic. Whether you’re a
creationist or a scientist, humans weren’t built to stare at flat
sheets of paper (or, indeed, flat monitors) for days and days on end.
It just isn’t how we work. We were built to focus in on things that
need our attention, keeping aware of our peripheral surroundings for
changes, quietly noting subtle changes and becoming alerted
to objects moving quickly and visibly.

This concept of motion bringing attention has been used primarily in one place on the web: banner ads. Since in most cases they are the only thing moving on the page, our attention often drifts to them. Taking a look at news.com‘s new user interface as applied to
particular pages, we see that they have restructured their site such that the only motion on the page is dead center and occupies a good percentage of screen real estate. It sits in the middle of the text, forcing your eyes to come to it as the text wraps around it. You can’t help but look at it: it’s their new series of Flash ads. Naturally, these ads pay much better since the use is forced to view them.

But what if we took some of these base concepts, these notions of
what attracts our attention, what distracts us, and what informs us,
and created a new style of user interface more closely adopted to an
ideal aesthetic – an interface that makes more sense for humans?
What would such an interface look like?

First off, in the real world, when we are working on something, we
bring it up close to us: it occupies the majority of our field of
vision. We get up and close to the screw needing tightening; we
push up close to the blueprint to consider each line. The watchmaker
does not engage his task from arm’s length. Consequent to this, a
good user interface will cause the primary activity to occupy the
majority of a user’s field of view and will clear away irrelevant
data to let us focus on the task at hand. While some applications
support a “full screen” mode that allows for focus on only the
task and nothing else (IE, MS Word, Excel, Adobe Acrobat, etc.),
the user experience should allow for every application to be a
central focus. Apple made a good stab at this by allowing a user
to hide all interface elements not pertaining to the currently run
application, including the finder. Most Windows users I know of
(including myself) have a very crowded desktop – while in one
sense our own fault, it ends up leaving a permanent and distracting
cruft on which I must perform all my work. In addition, most menubars
and icon trays are always visible and can’t be set to auto-hide.
This makes it considerably more difficult for a user to just focus
on what they’ve got to do. So the user must be able to concentrate
on a single task without being disturbed.

But what does it mean to be disturbed? One example of a bad
behavior in this example is Eudora’s default action when fetching
mail – if you’ve set it to go grab your email every five minutes
and put it in the background, when you do have mail, it whips you
out of whatever you’re in the middle of, takes you to Eudora, and
proudly displays a dialog box proclaiming that you have new mail.
This is obviously non-ideal behavior, but it’s also not a very
dramatic example simply because so many applications exhibit similar
characteristics. The classic thing that frustrates me is that if I’m
in the middle of wading through programs on the Start bar and some
program calls itself to attention, the computer drops the submenu
navigation (i.e., the Start bar menu goes away). The computer’s
designers are clearly making the statement “that which my program
has to say is more important than your navigation or input.” In
this modality, the computer can be considered an ouiji-based
entertainment center. You merely consent to the computer’s
understanding of how you should spend your time – it’s not designed
to take your interaction seriously.

A computer’s crisp, jerkily static imagery is poorly suited to
human interactions – we’re used to a world of “soft changes” and
things that move slowly, with a more or less smooth derivative,
instead of dialog boxes that jump out of nowhere and exclaim sounds
at us. We should come up with better interaction mechanisms for
keeping a user up to date with the status of a system without
disturbing them from a task. That is to say, an interface should
be designed such that with a cursory look, the status of the
system can be determined and changes actively reported, but not in
such a way as to be distracted. One way to do this would be through
color fades. For example, you could imagine a mail interface where
mail was sorted into various inboxes. Instead of having a list of
numbers of the quantity of unread messages in each inbox, coloring
each inbox in accordance with the importance of the unreplied
or unread messages in an inbox would allow for smooth color fades
when new messages came in. It would be subtle enough not to
distract you from a task, but by glancing over at the colors, you
could tell what you probably should look at next.

A database-backed file and email system is also called for. Instead
of putting a file into a specified category (i.e., folder), files
simply exist and can be filed under multiple categories (a job lead
from your friend Kevin about a Linux company could simultaneously
be filed under “job leads”, “Kevin”, and “Linux” without having three
copies). Data could also be retrieved via a variety of mechanisms
(looking for how recently it was composed, key words in its title,
its size, its type, etc.). As an added bonus, if implemented as a
“journalling” filesystem and coupled with a bit of data synchronization
sofftware, you could guarantee against losing documents and even
automatically have an infinite-level “undo” mechanism built in on the
filesystem layer, allowing you to version any files on your hard drive.
Modern hard drives are sufficiently large (80Gb hard drives now cost $300)
that there is no longer any feasible reason why textual, pictoral, and
even sound data should ever be deleted. Old copies should be automatically
kept around, but quietly so (e.g., they wouldn’t turn up in a general search or
clutter your views of which files existed, but you could still bring them
up explicitly).

The skills of television producers in drawing people’s attention to
information, actors, and scenes are particularly ingenius;
us programmers should learn from them and exploit the tricks they
have discovered. In the same way that many computer interfaces accidentally draw attention to the wrong things in the wrong ways (as mentioned above), we should
consider how we could purposefully bring the user’s attention to
certain things to guide and assist their focus. Apple had this in
mind when designing how alerts work in OS/X – they pull, transparently,
out of the top of a window. The motion lets the user know to look
there without surprising them, and the transparent but attached nature
of the alert lets the user know that the alert is tied to that particular
application.

The main reason why these interface elements have not previously been
incorporated into common programs is inertia: with the current set of APIs, it’s much easier to piece together a program with usual menus, square windows, and a generally consistent feel relative to other applications (this is a good thing) than something really
groundbreaking. (Sonique, with its next-gen UI, has taken years to cobble together.)

Secondly, however, it’s only pretty recently that one
could assume that an end user’s computer would be fast enough to handle
smooth transforms, 3D effects, and fades in a complex environment. But
with even the cheapest of computers shipping with high-speed 3D accelerators these
days, that assumption is being shown to be false. But we haven’t really taken the
time to question the basic parameters by which we decided upon the current
mode of interfacing with a computer whose design really originated in the late 70’s
and early 80’s at Xerox PARC – and that actually originated from Stanford work
done in the mid-70’s! Clearly, (hopefully?) there is a larger set of possibilities
for human-computer interaction enabled by faster and more advanced technologies.
Now we only need to harness it and conceive of the next wave of interfaces, in
turn to be swept away in another 10-20 years when hardware will permit another
rethinking of interaction.

Author: dweekly

I like to start things. :)