Software prototyping has many variants. However, all the methods are in some
way based on two major types of prototyping: Throwaway Prototyping and
Throwaway or Rapid Prototyping refers to the creation of a model that will
eventually be discarded rather than becoming part of the finally delivered
software. After preliminary requirements gathering is accomplished, a simple
working model of the system is constructed to visually show the users what their
requirements may look like when they are implemented into a finished system.
Rapid Prototyping involved creating a working model of various parts of
the system at a very early stage, after a relatively short investigation.
The method used in building it is usually quite informal, the most important
factor being the speed with which the model is provided. The model then
becomes the starting point from which users can re-examine their
expectations and clarify their requirements. When this has been achieved,
the prototype model is 'thrown away', and the system is formally developed
based on the identified requirements.
The most obvious reason for using Throwaway Prototyping is that it can be
done quickly. If the users can get quick feedback on their requirements, they
may be able to refine them early in the development of the software. Making
changes early in the development lifecycle is extremely cost effective since
there is nothing at that point to redo. If a project is changed after a
considerable work has been done then small changes could require large efforts
to implement since software systems have many dependencies. Speed is crucial in
implementing a throwaway prototype, since with a limited budget of time and
money little can be expended on a prototype that will be discarded.
Another strength of Throwaway Prototyping is its ability to construct
interfaces that the users can test. The user interface is what the user sees as
the system, and by seeing it in front of them, it is much easier to grasp how
the system will work.
…it is asserted that revolutionary rapid prototyping is a more effective
manner in which to deal with user requirements-related issues, and therefore
a greater enhancement to software productivity overall. Requirements can be
identified, simulated, and tested far more quickly and cheaply when issues
of evolvability, maintainability, and software structure are ignored. This,
in turn, leads to the accurate specification of requirements, and the
subsequent construction of a valid and usable system from the user's
perspective via conventional software development models.
Prototypes can be classified according to the fidelity with which they
resemble the actual product in terms of appearance, interaction and timing. One
method of creating a low fidelity Throwaway Prototype is Paper Prototyping. The
prototype is implemented using paper and pencil, and thus mimics the function of
the actual product, but does not look at all like it. Another method to easily
build high fidelity Throwaway Prototypes is to use a GUI Builder and create a
click dummy, a prototype that looks like the goal system, but does not
provide any functionality.
Not exactly the same as Throwaway Prototyping, but certainly in the same
family, is the usage of storyboards, animatics or drawings. These are
non-functional implementations but show how the system will look.