Prototyping
A typical prototype simulates or animates some but not all features
of the intended system.
- A prototype is like a more sophisticated scenario.
It allows end-users to gain a somewhat realistic experience
with the system to be.
- Early and rough prototypes can be built very quickly.
This makes them particularly suitable for trying out gross ideas
early on and postpone details until later.
- Playing with prototypes is very motivating and stimulating for end-users.
There are three categories of prototypes:
- vertical prototypes
A vertical prototype implements a small part of the user-interface and
the underlying application in-depth.
This is useful to test common design ideas by implementing only a few
instances.
include complete functionality for only a few selected features
- horizontal prototypes
A horizontal prototype provides an overview of the entire user-interface,
but little or no underlying functionality.
Some modern GUI-builders let you "draw" the entire user-interface in a very
short time, and provide a dummy implementation in which user-actions
have no effect.
provide an overview of the entire user-interface with little or no
underlying functionality.
- scenarios
A scenario shows a particular instance of the use of the system.
Although it gives the impression of offering complete functionality,
only one action is permitted at any given time.
This is almost like a video of the system which pauzes until the user
gives the next instruction.
provide a script of a particular use of the system.
Different types of prototypes involve different prototyping methods:
- throw-away
A throw-away prototype is built rapidly to get some user feedback.
It needs to be very inexpensive.
Horizontal prototypes can be easily built this way using GUI builders
or even using HTML and a WWW browser.
a rapid prototype is built to get some user feedback and is then thrown away.
- incremental
This approach is especially useful for building systems that consist
of separate components or modules that can be individually built and tested.
Each of these modules is a vertical prototype.
for products built out of components that can be individually tested.
- evolutionary
In this approach one may start with a horizontal prototype which is
altered in each iteration (of the design cycle). Bits of functionality
may be added each time, and bits may be modified each time as well.
The prototype eventually becomes the final product.
a prototype is extended and modified many times until it becomes the final
product.
For each method there are different appropriate tools:
- painting/drawing packages
Each storyboard scene is drawn on a computer, which makes them easier to
modify than with paper storyboards. The drawn interface is a very thin
horizontal prototype.
Each user action results in the presentation of a new screen, which does
not provide an adequate look and feel of the final product.
painted screen-shots provide a very thin horizontal prototype.
- scripted simulations and slide shows
Using tools like Hypercard or Macromedia Director, a complete storyboard can be
implemented.
Specific user-input leads to specific transitions between scenes.
Animations can also be created using these tools.
The result may look like a vertical prototype (but isn't).
tools like Hypercard and Macromedia Director let you create scenarios and
simulate vertical prototypes.
- GUI builders
For many computing platforms there are GUI builders that let you draw a
user-interface and that generate a horizontal prototype.
XVT for X-Windows, Delphi for Borland-Pascal and MS-Windows and
Symantec Visual Café for Java are well-known examples.
The interfaces built with these tools can form the basis for the user-interface
for the final product.
GUI builders work best for object-oriented user-interfaces, which are
common nowadays.
Widgets behave as they would (a button changes when pressed, sliders move, etc.).
Vertical functionality can be added selectively by programming.
An alternative to using a GUI builder is to use HTML with frames, tables
and forms to create a mockup which does not yet completely resemble the
final user-interface.
GUI builders let you create a complete horizontal prototype with fully
functional widgets.
A complementary technique is the The Wizard of Oz method:
A human simulates the vertical functionality and provides the feedback
for all user actions.
This method is especially useful for prototypes of expert systems.
IBM tried it with a prototype of a speech-recognition system.
This method is difficult to implement and requires a very methodical
human expert whose behaviour should be based on an algorithm.