In interactive systems design prototypes are critical in the early
stages of design unlike other fields of engineering design where
design decisions can initially be carried out analytically without
relying on a prototype. In systems design, prototyping is used
to create interactive systems design where the completeness and
success of the user interface can utterly depend on the testing of a working
model. The prototype gives the designer a functional working model
of their design so they can work with the design and identify
some of its possible pros and cons before it is actually produced.
The prototype also allows the user to be involved in testing design
ideas. User involvement can however,
have some drawbacks such as: users may lack the ability to imagine
the implications of decisions made by the design team and/or users
may be unable to comment on the technical content of the design.
Speaking expansively, there are two kinds of prototyping: paper-based
and computer based. Examples of paper-based prototyping are sketches,
story boards and scripts. Paper based methods are inexpensive,
and they can provide very valuable insights, but they lack the
capability of demonstrating functionality. Computer-based prototyping
actually provides a system with limited functionality so that
users can interact with it. In the engineering arena, prototypes
are expected to be quick and inexpensive to produce as well as
thrown way after they have served their purpose. Here the prototype
is used to concentrate on a specific area of an interactive system
and ignore others. These prototypes are made to duplicate a final
part in size, reliability, and robustness. Hopefully the design
team will find faults in the product before production takes place.
An example of an area that prototyping has proved critical in
the recent past is process control fault diagnosis. At the task
level, prototyping the steps needed to identify and correct an
error is crucial. Waiting until the system is in place before
performing such testing could be fatal so good prototyping is
essential.
In software prototyping however, it is a dynamic simulation where users can try out functions of the system by interacting with the it in 'real time' where functionality is usually the only attribute simulated. A software prototype is a system that actually works, can serve many different purposes, is built quickly and cheaply, and it allows for iterative designs.
There are two basic approaches to design, formative and summative.
The formative approach is where the prototype is built, based
on the current stage of the design, then tested on users, and
the results are fed into the next stage of development to enhance
the usefulness of the design. The summative approach takes a different
route, where one single exercise is performed at the end of the
iterative design enhancing process. At this stage it is usually too costly to make changes. The summative approach is obviously
less time consuming and more cost effective initially but in the
long run it is definitely more beneficial for a software design
team to go with the formative approach. If the system is tested
as a whole once in the end it is hard to pin point various different
problems that may exist within the design. Thus it is important
to test the system in sections as it is developed as well as in
the end.
There are four different methods to formative evaluation which are:
In the first method, learning from designing and building prototypes, working prototypes of the user interface are built initially so that designer can discover problems early on. This method usually lasts the entire duration of the design process all the way till the implementation of the final product. The second, running informal user tests on the initial prototype, usually consists of testing the first working prototype on the designers themselves as well as others people who are willing to try it out. This method is very effective in exposing unexpected design flaws. The duration of each iteration of the prototype usually takes anywhere from a few days to a few weeks. The third method, conducting a series of field tests, is based on progressive enhancements of the same prototype. Rather than build a new prototype each time, the initial one is just readjusted until it is 'perfect'. This design is implemented initially in the field and critiqued extensively by the various members of the user population. This whole process takes month's or even years, but the individual periods of evaluation take about three weeks. The final method, testing a component of the design under controlled conditions, is normally done in a controlled usability lab and can provide more accurate results than the other methods because every attribute of the experiment is monitored intensely . This process usually takes several weeks, sometimes months.
When a design team chooses between the above methods the time
factor is definitely a consideration. A lot of questions can be
answered using methods 1 and 2 in a short period of time. The
real question arises when it is necessary to put 3 and 4 into
effect. These methods are definitely more consuming and expensive.
The third is used in the case where the system will
be used for a critical application. A critical application is
a system that is used for an application where the end user will
depend on it for essential services such as health and safety.
This method is also used extensively when the system will be used
in collaborative activities. The fourth method is used when a
crucial decision needs to be made over a central component of
the interface such as the use of icons. This method is also useful
for systems that need to comply with standards. Only a controlled
atmosphere can provide statistically valid results that may be
needed to support the system if ever under investigation by a
specialized bureau or law agency.
Despite whichever method above is chosen, the success of such an experiment is only as good as the planning, execution and analysis of it. This depends on the designers having a clear perception of what they hope to find out from these experiments. There are six stages of evaluation that a recommended for designers to follow which are:
Prototyping can resolve uncertainty about how well a design fits the user's needs. It helps designers to make decisions by obtaining information from users about the necessary functionality of the system, user help needs, a suitable sequence of operations, and the look of the interface. It is important that the proposed system have the necessary functionality for the tasks that users may want to perform anywhere from gathering information to task analysis. Information on the sequence of operations can tell the designers what users need to interact successfully with the system. Exchanges can be fixed and supportive, but potentially constraining, or free and flexible, but potentially chaotic. It is the job of the design staff to may a sufficient compromise between them. The resulting system may have poor usability if designers make the wrong choice, even if it has adequate functionality. Work patterns should not be disrupted due constraints on operation sequences. Prototypes have revealed that some ways of operating systems can create inappropriate tasks for users. For instance users, at an unsuitable moment, may have to search for off-line information. In this instance prototyping can provide information that enables designers to provide a more appropriate sequence of operation. Prototyping can also aid in determining how effective help and other possible kinds of user support are for proposed users. Representation information can reveal symbols and displays which users can readily understand, recognize without confusion, remember on a regular basis as well as those they find difficult. Suitable representations such as icon design, display layout, message content and command or menu item names are all necessary to the success of an interface. The adequacy of many representation designs have to be tested with users.
Various kinds of prototyping have been developed to obtain different
kinds of information such as requirements animation, rapid, incremental,
and evolutionary prototyping.
Requirements animation, in most cases used to demonstrate functionally,
is construed in the software prototype that can be assessed by
users. Tools used to produce a representational aspects are built
with animation packages and screen painters. Data manipulation
languages and other high level languages are also used to demonstrate
key functional aspects while menu builders and active image tools
are used to promote operational aspects.
Rapid prototyping is a form of collecting information on requirements
and on the adequacy of possible designs. The prototype is thrown
away in the end although it is an important resource during the
products development. Tools used for representational requirements
in Rapid Prototyping are screen painters, animation, form systems,
report generators, menu systems, hypermedia and other high level
languages.
Incremental prototyping enables large systems to be installed
in phases to avoid delays between specification and delivery.
After the customer and supplier agree on certain core features,
the installation of a skeleton system occurs as soon as possible.
Important requirements can be checked out in the field enabling
changes to core features while extra, less important, features
can be added later. Reusable software and highly modular languages
are often the most useful tools to piece sections together.
Evolutionary prototyping, considered to be the most involved form of prototyping, is a compromise between production and prototyping. The prototype is constructed initially, then evaluated as it evolves continually into the final system. Many designers believe that more acceptable systems would result if evolutionary prototyping were interconnected with periods of requirements animation or rapid prototyping. Here the tools are the actual facilities resources where the final system will be implemented.
There are many different types of prototypes such as full, horizontal
and vertical prototypes, high fidelity and low fidelity prototypes,
chauffeured prototypes and Wizard of Oz prototypes.
A full prototype is equip with complete functionality although
it is often limited by lower performance. A horizontal prototype
contains all the high level functionality of a system but minor
details of the system are often neglected. A vertical prototype,
probably the most respected, contains all of the high level and
lower level functions of a specific part of a system. The latter
is the most comprehensive in that it concentrates on one area
intensively, providing the designer with an explicit knowledge
of the particular section of their product.
High Fidelity prototypes can be thought of as prototyping through
a medium such as video, where the prototype resembles the final
system as close as possible. Commercial organizations often use
high fidelity video prototypes because they make their product
appear complete and aesthetically pleasing. Low fidelity prototypes
tend to be cheaper and faster to develop. Lower fidelity prototypes
are produced with materials that are further away from the final
version. For instance, a version of a software interface with
cut down functionality rather then a fully working high fidelity
prototype.
Chauffeured prototyping is a user involved design process. The user watches someone, usually a member of the design team, navigate through the interface system. This method is a way to test an interface to see if it meets the user's needs without the user actually having to perform the lower level actions of the system. It can be useful in determining, for example, the sequence of actions needed to perform a task. Another form of prototyping that involves a third party is called Wizard of Oz prototyping. Here the user is unaware that the developer is sitting at another screen answering the queries and responding to the user. This kind of prototyping is especially useful in the early development stages because the design team is able to get a feel for the user's expectations. Being so involved with the users provides an extra understanding of the users and their needs.
A two-phase view of iterative design can be achieved by the use
of different kinds of prototypes in different stages of software
design. Prototypes in the first phase of design are made to gather
different forms of information as well as radically different
alternatives. This prototyping phase will end at some undetermined
point providing a proposal for an initial design. Iterations are
then made of the design based on test results received by running
the system. By now any radical changes are unlikely due to production
standards that now rule the system as well the expense factor
of any major changes. This second phase can be regarded as a fine-tuning
stage with a slow cycle time.
Prototyping is very useful at different stages of design such
as product conceptualization at the task level and determining
aspects of screen design. Prototyping can be used to gain a better
understanding of the kind of product required in the early stages
of system development where several different sketch designs can
be presented to users and to members of the development team for
critique.
Once a good version of an idea exists, people tend to get easily carried away by thinking that this must be the only or the best solution to the problem. At this stage it may be more beneficial to consider using some paper-based prototyping such as story boarding or sketching avoiding prematurely closing the design space. However, on the other side of that argument prototyping should be done with a product that is as close to the intended system as possible. The whole purpose of producing a prototype is to give a presentation picture of what the final system will look like. Pictorial representation may not describe all the features one may need to see on a screen, such as animation. An alternative to both of the above is a computer-based prototype, that may simply involve a sequence of screens controlled from the keyboard, or programmed as a predetermined sequence. It is important in software design that the designer concentrates mainly on icons, menus and screen layout. Particularly they need to focus on the suitability of icons and screen layouts, the of color, visual and audio effects, and the sensible grouping of commands. The perfection of all these attributes can be crucial to the success of an interface therefore a 'real time' computer simulation can be critical.
MacroMind Director (MMD) is a Macintosh-based multimedia package
for combining text, graphics, animation, music and other sound,
and video. The package has been used extensively in the film,
engineering, education and business industries. This package is
a effective tool for producing impressive simulations, visualizations,
presentations and for prototyping interfaces. The results are
portrayed on a Macintosh screen or output to a video channel.
There are also similar versions of this package for Windows and
Unix platforms.
One of MMD's most attractive features is that it can be used by
graphic designers with no programming expertise. No programming
is needed to create an interface, although producing complex animations
does require programming skill. The designer can draw example
screens and cause a video clip, music, animation, another screen,
or other screen movement to occur when the mouse is clicked on
a certain portion of that screen. Screen elements can be used
repeatedly throughout the interaction. The three aspects to producing
an application in MMD are animating graphics, creating interactive
elements and assembling the final movie. HyperTalk, a script language
can be used to define the programs functionality as well as attaching
it to a graphic or text object thus giving a 'button' effect.
External functions which must be written in a third generation
language such as C can be attached to MMD scripts.
QuickTime, which can be used with MMD, facilitates dynamic data such animation, video clips and sound to be incorporated in a document as well as allowing copying, pasting, recording, playing and cutting of dynamic media. QuickTime is used in educational software, where special effects such as physics experiments or chemical reactions are better simulated at the click of an icon, than with simple hypertext documents for computer aided instruction. It is also useful in business presentations where it may be appropriate to animate such things as sales figures creeping up (or down) in real time or presenting data in slide shows. Data recorded by monitoring equipment often done in the science and engineering fields can be replayed through QuickTime so researchers to study events of interest such tornadoes.
Prototyping can help to establish the suitability of the interface at the task level once the requirements for a system have been determined and its functionality is defined. Hopefully this ensures that the user can perform the tasks necessary for the job as well as guarantee that a task sequence can be completed successfully. Generating realistic scenarios is important for all forms of prototyping, but particularly so in case of a Human Computer Interface. It is not enough for the user to play with the prototype. Tasks need to be performed relating to that of the system's intended use. System tests and acceptance tests which are generated through standard software engineering practices could be used in these scenarios. Providing and testing early versions of the user documentation can be useful in the design process in that it may unearth usability problems as well as give researchers innovative ideas to make their product better. Prototyping is becoming an irreplaceable asset in all industries and should not be overlooked. It can be crucial to finding critical faults in a system.