The Software Prototyping refers to building software application
prototypes which displays the functionality of the product under development,
but may not actually hold the exact logic of the original software.
Software prototyping is becoming very popular as a software
development model, as it enables to understand customer requirements at an
early stage of development. It helps get valuable feedback from the customer
and helps software designers and developers understand about what exactly is
expected from the product under development.
Prototype is a working model of software with some limited
functionality. The prototype does not always hold the exact logic used in the
actual software application and is an extra effort to be considered under
effort estimation.
Prototyping is used to allow the users evaluate developer
proposals and try them out before implementation. It also helps understand the
requirements which are user specific and may not have been considered by the
developer during product design.
Following is a stepwise approach explained to design a software
prototype.
This step involves understanding the very basics product
requirements especially in terms of user interface. The more intricate details
of the internal design and external aspects like performance and security can
be ignored at this stage.
The initial Prototype is developed in this stage, where the very
basic requirements are showcased and user interfaces are provided. These
features may not exactly work in the same manner internally in the actual
software developed. While, the workarounds are used to
give the same look and feel to the customer in the prototype developed.
The prototype developed is then presented to the customer and the
other important stakeholders in the project. The feedback is collected in an
organized manner and used for further enhancements in the product under
development.
The feedback and the review comments are discussed during this
stage and some negotiations happen with the customer based on factors like –
time and budget constraints and technical feasibility of the actual
implementation. The changes accepted are again incorporated in the new
Prototype developed and the cycle repeats until the customer expectations are
met.
Prototypes can have horizontal or vertical dimensions. A
Horizontal prototype displays the user interface for the product and gives a
broader view of the entire system, without concentrating on internal functions.
A Vertical prototype on the other side is a detailed elaboration of a specific
function or a sub system in the product.
The purpose of both horizontal and vertical prototype is
different. Horizontal prototypes are used to get more information on the user
interface level and the business requirements. It can even be presented in the
sales demos to get business in the market. Vertical prototypes are technical in
nature and are used to get details of the exact functioning of the sub systems.
For example, database requirements, interaction and data processing loads in a
given sub system.
There are different types of software prototypes used in the
industry. Following are the major software prototyping types used widely −
Throwaway prototyping is also called as rapid or close ended
prototyping. This type of prototyping uses very little efforts with minimum
requirement analysis to build a prototype. Once the actual requirements are
understood, the prototype is discarded and the actual system is developed with
a much clear understanding of user requirements.
Evolutionary prototyping also called as breadboard prototyping is
based on building actual functional prototypes with minimal functionality in
the beginning. The prototype developed forms the heart of the future prototypes
on top of which the entire system is built. By using evolutionary prototyping,
the well-understood requirements are included in the prototype and the
requirements are added as and when they are understood.
Incremental prototyping refers to building multiple functional
prototypes of the various sub-systems and then integrating all the available
prototypes to form a complete system.
Extreme prototyping is used in the web development domain. It
consists of three sequential phases. First, a basic prototype with all the
existing pages is presented in the HTML format. Then the data processing is
simulated using a prototype services layer. Finally, the services are
implemented and integrated to the final prototype. This process is called
Extreme Prototyping used to draw attention to the second phase of the process,
where a fully functional UI is developed with very little regard to the actual
services.
Software Prototyping is most useful in development of systems
having high level of user interactions such as online systems. Systems which
need users to fill out forms or go through various screens before data is processed
can use prototyping very effectively to give the exact look and feel even
before the actual software is developed.
Software that involves too much of data processing and most of the
functionality is internal with very little user interface does not usually
benefit from prototyping. Prototype development could be an extra overhead in
such projects and may need lot of extra efforts.
Software prototyping is used in typical cases and the decision
should be taken very carefully so that the efforts spent in building the
prototype add considerable value to the final software developed. The model has
its own pros and cons discussed as follows.
The advantages of the Prototyping Model are as follows −
· Increased
user involvement in the product even before its implementation.
· Since
a working model of the system is displayed, the users get a better
understanding of the system being developed.
· Reduces
time and cost as the defects can be detected much earlier.
· Quicker
user feedback is available leading to better solutions.
· Missing
functionality can be identified easily.
· Confusing
or difficult functions can be identified.
The Disadvantages of the Prototyping Model are as follows −
· Risk
of insufficient requirement analysis owing to too much dependency on the
prototype.
· Users
may get confused in the prototypes and actual systems.
· Practically,
this methodology may increase the complexity of the system as scope of the
system may expand beyond original plans.
· Developers
may try to reuse the existing prototypes to build the actual system, even when
it is not technically feasible.
· The
effort invested in building prototypes may be too much if it is not monitored
properly.