As part of the Alice project
we have conducted formal and informal observations of hundreds of users.
From these observations we have learned many lessons about how to make
3D graphics more accessible to novices. On this page we summarize
some of the most important lessons we learned.
Download: PDF
Commands Are Always Animated
All commands in Alice animate
over 1 second by default. This allows users to determine the effects
of their commands by watching those effects unfold over time. Systems
that make commands happen instantaneously force the user to reconstruct
the effects of commands by comparing what may be two widely different world
states.
Controlled Exposure to
Power
We can use function overloading
and optional keyword parameters in a programming language to mask API complexity
until the user is motivated to learn it. Users start by learning
the simple versions of commands, and as they themselves become more sophisticated
they learn the more complex variations of commands.
Ex. bunny.move(forward)
bunny.move(forward, distance=2)
bunny.move(forward, distance=2, duration=4)
bunny.move(forward, distance=2, duration=4, asSeenBy=helicopter)
bunny.move(forward, distance=2, duration=4, asSeenBy=helicopter,
style=abruptly)
Ubiquitous Undo
Users need to feel like they
can explore safely. In system terms, they should always be able to return
to a safe state. To support this we allow users to undo any command
an Alice, and we provide an infinite undo stack so that any number of commands
can be undone. Like all other commands in Alice, undo actions are
also animated over 1 second.
Death of XYZ
Users do not think in terms
of the X, Y, and Z axes. Instead, they think about directions like
forward, left, right, up, and down. To support this we refer to the
Left, Up, and Forward directions as the canonical axes, and every object
possesses forward and up directions. While not objects possess instrinsic
forward and up directions (like a ball), we note that no object possesses
an intrinsic X direction.
Objects are Coordinate
Systems
In addition to moving objects
in their own instrinsic coordinate system (e.g. moving the bunny forward),
users also think about moving objects relative to other objects in the
world. To support this we allow an object to be used as a frame of
reference using the AsSeenBy keyword. For example, bunny.move(forward,
1, AsSeenBy=helicopter) will move the bunny 1 meter in the helicopter's
forward direction.
Beyond Translate, Rotate,
Scale
Many authoring tools for
building interactive 3D worlds only provide the translate, rotate, and
scale primitives and leave the user to construct more complex behaviors.
In addition to these primitives, we provide a more advanced set of behaviors
for users to draw upon. This set includes behaviors like PointAt,
AlignWith, Nudge, Place, StandUp, and Pan. Users can also compose
simple behaviors to form more complex behaviors using DoInOrder and DoTogether.
Resize
Most 3D graphics systems
provide a scale primitive that scales an object's space in addition to
its geometry. This means that, if the user scales an object by 2,
subsequent commands to the object to move forward 1 meter will actually
move the object forward 2 meters relative to other objects. We address
this by having the Alice resize behavior only affect an object's geometry.
As a result, a meter in Alice is always a meter, regardless of whether
or not the user has resized an object.
Vocabulary Matters
The choice of names for behaviors
is critically important in a system for novices. Among the more notable
examples in the names we use are:
Move, not Translate:
Translation, to novices, is the process by which English is translated
to French.
Resize, not Scale: A scale
is an object used to weigh other objects, not a verb.
Color names, not RGB triples:
The RGB triple (0, 1, 0) has no meaning to a novice, while everyone understands
that green is a color.
Rotation Rate
When we first designed Alice
we used degrees instead of radians to specify how far to turn because radians
were hard and degrees were easy. However, while designing turning
at a rate we discovered that users preferred to talk about the number of
rotations per second, rather than the number of degrees per second.
We went back and redesigned turning so that users specify how far to turn
in terms of rotations (e.g. 1/2 turn, 1/4 turn).
Importance of 0 and 1
When faced with a new Alice
command that required a parameter, we saw many users try a 1 just to see
what would occur. Partly due to this we adopted a convention that
all bounded scalar parameters to Alice calls would range between 0 and
1. Magic ranges like 0..255 and 0..327667 do not hold much appeal
to novices.
Typing is Hard
Most of our users are non-typists
and appreciated any help we could give them that would keep them from having
the use the keyboard. We are addressing this issue in the latest
version of the Alice authoring tool.
Alice: Lessons Learned
from Building a 3D System for Novices. Matthew Conway, Steve Audia, Tommy
Burnette, Dennis Cosgrove, Kevin Christiansen, Rob Deline, Jim Durbin,
Rich Gossweiler, Shuichi Koga, Chris Long, Beth Mallory, Steve Miale, Kristen
Monkaitis, James Patten, Jeff Pierce, Joe Shochet, David Staack,
Brian Stearns, Richard Stoakley, Chris Sturgill, John Viega, Jeff White,
George Williams, and Randy Pausch. ACM CHI 2000, pages 486-493
|
|
