Prototyping

Prototyping is the process of building a model of a system. In terms of an information system,

prototypes are employed to help system designers build an information system that intuitive
and easy to manipulate for end users. Prototyping is an iterative process that is part of
the analysis phase of the systems development life cycle.
Prototyping can enhance this process because it converts these basic specifications into a
tangible but limited working model of the desired information system. The user feedback
gained from developing a physical system that the users can touch and see facilitates an
evaluative response that the analyst can employ to modify existing requirements as well as
develop new ones.
Prototyping comes in many forms - from low tech sketches or paper screens from which
users and developers can paste controls and objects, to high tech operational systems, using
computer-aided software engineering, or fourth generation languages. Many organizations
use multiple prototyping tools e.g., some will use paper in the initial analysis to facilitate
concrete user feedback and then later develop an operational prototype using fourth
generation languages, such as Visual Basic, during the design stage.
Software prototyping
Software prototyping is the activity of creating prototypes of software applications, i.e.,
incomplete versions of the software program being developed. It is an activity that can occur
in software development and is comparable to prototyping as known from other fields, such
as mechanical engineering or manufacturing
Prototyping is defined as the process of developing a working replication of a product or
system that has to be engineered. It offers a small-scale facsimile of the end product and is
used for obtaining customer feedback as described below:

The Prototyping Model is one of the

most popularly used Software
Development Life Cycle Models (SDLC
models). This model is used when the
customers do not know the exact project requirements beforehand. In this model, a
prototype of the end product is first developed, tested and refined as per customer feedback
repeatedly till a final acceptable prototype is achieved which forms the basis for developing
the final product.
In this process model, the system is partially implemented before or during the analysis
phase thereby giving the customers an opportunity to see the product early in the life cycle.
The process starts by interviewing the customers and developing the incomplete high-level
paper model. This document is used to build the initial prototype supporting only the basic
functionality as desired by the customer. Once the customer figures out the problems, the
prototype is further refined to eliminate them. The process continues until the user approves
the prototype and finds the working model to be satisfactory.
There are four types of models available:
A) Rapid Throwaway Prototyping –
This technique offers a useful method of exploring ideas and getting customer feedback for
each of them. In this method, a developed prototype need not necessarily be a part of the
ultimately accepted prototype. Customer feedback helps in preventing unnecessary design
faults and hence, the final prototype developed is of better quality.
B) Evolutionary Prototyping –
In this method, the prototype developed initially is incrementally refined on the basis of
customer feedback till it finally gets accepted. In comparison to Rapid Throwaway
Prototyping, it offers a better approach which saves time as well as effort. This is because
developing a prototype from scratch for every iteration of the process can sometimes be
very frustrating for the developers.
C)Incremental Prototyping
Here the final expected product is broken into different small pieces of prototypes and
being developed individually. In the end, when all individual pieces are properly developed,
then the different prototypes are collectively merged into a single final product in their
predefined order
D)Extreme Prototyping –
Used for web development. It is consisting of three sequential independent phases:
In this phase a basic prototype with all the existing static pages are presented in the HTML
format. In the 2nd phase, Functional screens are made with a simulated data process using a
prototype services layer. In the final step, all the services are implemented and associated
with the final prototype.
Advantages –
 The customers get to see the partial product early in the life cycle. This ensures a
greater level of customer satisfaction and comfort.
 New requirements can be easily accommodated as there is scope for refinement.
 Missing functionalities can be easily figured out.
 Errors can be detected much earlier thereby saving a lot of effort and cost,
besides enhancing the quality of the software.
 The developed prototype can be reused by the developer for more complicated
projects in the future
 Flexibility in design.
Disadvantages –

 Costly with respect to time and money.

 There may be too much variation in requirements each time the prototype is
evaluated by the customer.
 Poor Documentation due to continuously changing customer requirements.
 It is very difficult for developers to accommodate all the changes demanded by
the customer.
 There is uncertainty in determining the number of iterations that would be
required before the prototype is finally accepted by the customer.
 The customers sometimes demand the actual product to be delivered too soon.
 Developers in a hurry to build prototypes may end up with sub-optimal
solutions.
 Customer might lose interest in the product if unsatisfied with initial prototype.

The Prototyping Model should be used when the requirements of the product are not clearly
understood or are unstable. It can also be used if requirements are changing quickly. This
model can be successfully used for developing user interfaces, high technology software-
intensive systems, and systems with complex algorithms and interfaces. It is also a very
good choice to demonstrate the technical feasibility of the product.
Software prototyping is the activity of creating prototypes of software applications, i.e.,
incomplete versions of the software program being developed. It is an activity that can occur
in software development and is comparable to prototyping as known from other fields, such
as mechanical engineering or manufacturing.
A prototype typically simulates only a few aspects of, and may be completely different from,
the final product.
The purpose of a prototype is to allow users of the software to evaluate developers' proposals
for the design of the eventual product by actually trying them out, rather than having to
interpret and evaluate the design based on descriptions. Software prototyping provides an
understanding of the software's functions and potential threats or issues. Prototyping can also
be used by end users to describe and prove requirements that have not been considered, and
that can be a key factor in the commercial relationship between developers and their clients.
Outline of the Software Prototyping Steps
The process of prototyping involves the following steps
1. Identify basic requirements
Determine basic requirements including the input and output information desired. Details,
such as security, can typically be ignored.
2. Develop initial prototype
The initial prototype is developed that includes only user interfaces
Review
The customers, including end-users, examine the prototype and provide feedback on potential
additions or changes.
3. Revise and enhance the prototype
Using the feedback, the specifications and prototype is improved. Negotiation about what is
within the scope of the product is necessary. If changes are introduced, repeat steps #3 and #4
Dimensions
Nielsen summarizes the various dimensions of prototypes in his book Usability Engineering:
Horizontal prototype
Provides a broad view of an entire system or subsystem, focusing on user interaction more
than low-level system functionality, such as database access. Horizontal prototypes are useful
for:
 Confirmation of user interface requirements and system scope,
 Demonstration version of the system to obtain buy-in from the business,
 Develop preliminary estimates of development time, cost and effort.
Vertical prototype
A vertical prototype is an enhanced complete elaboration of a single subsystem or function. It
is useful for obtaining detailed requirements for a given function, with the following benefits:
 Refinement database design,
 Obtain information on data volumes and system interface needs, for network sizing
and performance engineering,
 Clarify complex requirements by drilling down to actual system functionality.
Types
Software prototyping has many variants. However, all of the methods are in some way based
on two major forms of prototyping: throwaway prototyping and evolutionary prototyping.
Throwaway prototyping
Also called close-ended prototyping. Throwaway or rapid prototyping refers to the creation
of a model that will eventually be discarded rather than becoming part of the final 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. It is also a form of rapid prototyping.
Rapid prototyping involves 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 goal has been achieved, the prototype
model is 'thrown away', and the system is formally developed based on the identified
requirements
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 amount of work has been done then small changes could require large
efforts to implement since software systems have many dependencies.
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 function.
In this approach the prototype is constructed with the idea that it will be discarded and the
final system will be built from scratch. The steps in this approach are:
1. Write preliminary requirements
2. Design the prototype
3. User experiences/uses the prototype, specifies new requirements
4. Repeat if necessary
5. Write the final requirements
Evolutionary prototyping
Evolutionary prototyping is different from throwaway prototyping. The goal when using
evolutionary prototyping is building a robust prototype in a structured manner and constantly
refine it. When developing a system using evolutionary prototyping, the system is continually
refined and rebuilt. This technique allows the development team to add features, or make
changes that couldn't be conceived during the requirements and design phase. Evolutionary
prototypes have an advantage over throwaway prototypes in that they are functional systems.
Incremental prototyping
The final product is built as separate prototypes. At the end, the separate prototypes are
merged in an overall design. By the help of incremental prototyping the time gap between
user and software developer is reduced.
Extreme prototyping
Extreme prototyping as a development process is used especially for developing web
applications. Basically, it breaks down web development into three phases, each one based on
the preceding one. The first phase is a static prototype that consists mainly of HTML pages.
In the second phase, the screens are programmed and fully functional using a simulated
services layer. In the third phase, the services are implemented.
Advantages
Reduced time and costs: Prototyping can improve the quality of requirements and
specifications provided to developers. Because changes cost exponentially more to
implement as they are detected later in development, the early determination of what the user
really wants can result in faster and less expensive software.
Improved and increased user involvement: Prototyping requires user involvement and allows
them to see and interact with a prototype allowing them to provide better and more complete
feedback and specifications. The presence of the prototype being examined by the user
prevents many misunderstandings and miscommunications that occur when each side believe
the other understands what they said.
Disadvantages
Insufficient analysis: The focus on a limited prototype can distract developers from properly
analyzing the complete project. This can lead to overlooking better solutions, preparation of
incomplete specifications or the conversion of limited prototypes into poorly engineered final
projects that are hard to maintain. Further, since a prototype is limited in functionality it may
not scale well if the prototype is used as the basis of a final deliverable, which may not be
noticed if developers are too focused on building a prototype as a model.
User confusion of prototype and finished system: Users can begin to think that a prototype,
intended to be thrown away, is actually a final system that merely needs to be finished or
polished. This can lead them to expect the prototype to accurately model the performance of
the final system when this is not the intent of the developers. Users can also become attached
to features that were included in a prototype for consideration and then removed from the
specification for a final system.
Developer misunderstanding of user objectives: Developers may assume that users share their
objectives, without understanding wider commercial issues. For example, user representatives
attending Enterprise software events may have seen demonstrations of "transaction auditing"
without being told that this feature demands additional coding and often requires more
hardware to handle extra database accesses.
Developer attachment to prototype: Developers can also become attached to prototypes they
have spent a great deal of effort producing; this can lead to problems, such as attempting to
convert a limited prototype into a final system when it does not have an appropriate
underlying architecture.
Excessive development time of the prototype: A key property to prototyping is the fact that it
is supposed to be done quickly. If the developers lose sight of this fact, they very well may
try to develop a prototype that is too complex. When the prototype is thrown away the
precisely developed requirements that it provides may not yield a sufficient increase in
productivity to make up for the time spent developing the prototype.
Expense of implementing prototyping: the start-up costs for building a development team
focused on prototyping may be high. Many companies have development methodologies in
place, and changing them can mean retraining, retooling, or both. Many companies tend to
just begin prototyping without retraining their workers.
Applicability
It has been argued that prototyping should be used all the time. However, prototyping is most
beneficial in systems that will have many interactions with the users. It has been found that
prototyping is very effective in the analysis and design of on-line systems, especially
for transaction processing, where the use of screen dialogs is much more in evidence.
Dynamic Systems Development Method (DSDM)
DSDM is a framework for delivering business solutions that relies heavily upon prototyping
as a core technique, and is itself ISO 9001 approved. DSDM prototypes are intended to be
incremental, evolving from simple forms into more comprehensive ones.
The four categories of prototypes as recommended by DSDM are:
 Business prototypes – used to design and demonstrates the business processes being
automated.
 Usability prototypes – used to define, refine, and demonstrate user interface design
usability, accessibility, look and feel.
 Performance and capacity prototypes – used to define, demonstrate, and predict how
systems will perform under peak loads as well as to demonstrate and evaluate other
non-functional aspects of the system (transaction rates, data storage volume, response
time, etc.)
 Capability/technique prototypes – used to develop, demonstrate, and evaluate a design
approach or concept.

The DSDM lifecycle of a prototype is to Identify prototype, Agree to a plan, Create the
prototype and to Review the prototype
Operational prototyping
Operational prototyping was proposed as a way to integrate throwaway and evolutionary
prototyping with conventional system development.
The specific methodology follows these steps:
1. An evolutionary prototype is constructed and made into a baseline using conventional
development strategies, specifying and implementing requirements that are
understood.
2. Copies of the baseline are sent to multiple customer sites with a trained prototyper.
3. At each site, the prototyper watches the user at the system.
4. If the user encounters a problem a new feature or requirement, the prototyper logs it.
This frees the user from having to record the problem, allowing him to continue work.
5. After the user session, the prototyper constructs a throwaway prototype on top of the
baseline system.
6. The user now uses the new system and evaluates. If the new changes aren't effective,
the prototyper removes them.
7. If the user likes the changes, the prototyper writes feature-enhancement requests and
forwards them to the development team.
8. The development team, with the change requests in hand from all the sites, then
produce a new evolutionary prototype using conventional methods.
A key to this method is to have well trained prototypers available to go to the user sites.
Evolutionary systems development
Evolutionary Systems Development is a class of methodologies that attempt to formally
implement evolutionary prototyping. Systemscraft is described by John Crinnion in his
book Evolutionary Systems Development. The basis of Systemscraft, not unlike evolutionary
prototyping, is to create a working system from the initial requirements and build upon it in a
series of revisions.
Evolutionary Rapid development
Evolutionary Rapid Development (ERD) was developed by the Software Productivity
Consortium, a technology development and integration agent for the Information Technology
Office of the Defense Advanced Research Projects Agency (DARPA).
Tools
Efficiently using prototyping requires that an organization have the proper tools and a staff
trained to use those tools. Tools used in prototyping can vary from individual tools, such
as 4th generation programming languages used for rapid prototyping to complex
integrated CASE tools. 4th generation visual programming languages like Visual
Basic and ColdFusion are frequently used since they are cheap, well known and relatively
easy and fast to use.
Screen generators, design tools, and software factories
Screen generating programs are also commonly used and they enable prototypers to show
user's systems that do not function, but show what the screens may look like.
Developing Human Computer Interfaces can sometimes be the critical part of the
development effort, since to the users the interface essentially is the system.
Application definition or simulation software
A new class of software called Application definition or simulation software enables users to
rapidly build lightweight, animated simulations of another computer program, without
writing code. Application simulation software allows both technical and non-technical users
to experience, test, collaborate and validate the simulated program, and provides reports such
as annotations, screenshot and schematics.
Requirements Engineering Environment
Requirements Engineering Environment is currently used by the United States Air Force to
develop systems. It is an integrated set of tools that allows systems analysts to rapidly build
functional, user interface, and performance prototype models of system components.
PSDL
PSDL is a prototype description language to describe real-time software. The associated tool
set is CAPS (Computer Aided Prototyping System). Prototyping software systems with hard
real-time requirements is challenging because timing constraints introduce implementation
and hardware dependencies
Prototype Model in Software Engineering
Prototyping Model is a software development model in which prototype is built, tested, and
reworked until an acceptable prototype is achieved. It also creates base to produce the final
system or software. It works best in scenarios where the project’s requirements are not known
in detail. It is an iterative, trial/error method which takes place between developer and client.
Prototyping Model Phases

Step 1: Requirements gathering and analysis

A prototyping model starts with requirement analysis. In this phase, the requirements of the
system are defined in detail. During the process, the users of the system are interviewed to
know what is their expectation from the system.
Step 2: Quick design
The second phase is a preliminary design or a quick design. In this stage, a simple design of
the system is created. However, it is not a complete design. It gives a brief idea of the system
to the user. The quick design helps in developing the prototype.
Step 3: Build a Prototype
In this phase, an actual prototype is designed based on the information gathered from quick
design. It is a small working model of the required system.
Step 4: Initial user evaluation
In this stage, the proposed system is presented to the client for an initial evaluation. It helps to
find out the strength and weakness of the working model. Comment and suggestion are
collected from the customer and provided to the developer.
Step 5: Refining prototype
If the user is not happy with the current prototype, you need to refine the prototype according
to the user’s feedback and suggestions.
This phase will not over until all the requirements specified by the user are met. Once the
user is satisfied with the developed prototype, a final system is developed based on the
approved final prototype.
Step 6: Implement Product and Maintain
Once the final system is developed based on the final prototype, it is thoroughly tested and
deployed to production. The system undergoes routine maintenance for minimizing
downtime and prevent large-scale failures.

Types of Prototyping Models

Rapid Throwaway Prototype
Rapid throwaway is based on preliminary requirement. It is quickly developed to show how
the requirement will look visually. Customer feedback helps drives changes to the
requirement, and the prototype is created until the requirement is baselined. In this method, a
developed prototype will be discarded and will not be a part of the ultimately accepted
prototype. This technique is useful for exploring ideas and getting instant feedback for
customer requirements.
Evolutionary Prototyping
Here, the prototype developed is incrementally refined based on customer’s feedback until it
is finally accepted. It helps you to save time as well as effort. That’s because developing a
prototype from scratch for every interaction of the process can sometimes be very frustrating.
Incremental Prototyping
In incremental Prototyping, the final product is decimated into different small prototypes and
developed individually. Eventually, the different prototypes are merged into a single product.
This method is helpful to reduce the feedback time between the user and the application
development team.
Extreme Prototyping:
Extreme prototyping method is used for web development. It is has three sequential phases.
1. Basic prototype with all the existing page is present in the HTML format.
2. You can simulate data process using a prototype services layer.
3. The services are implemented and integrated into the final prototype

Best Practices of Prototyping

 Use Prototyping when the requirements are unclear
 It is important to perform planned and controlled Prototyping
 Regular meetings are vital to keep the project on time and avoid costly delays.
 The users and the designers should be aware of the prototyping issues and pitfalls.
 At a very early stage, you need to approve a prototype and only then allow the team to
move to the next step.
 In software prototyping method, you should never be afraid to change earlier
decisions if new ideas need to be deployed.

Advantages of the Prototyping Model

 Users are actively involved in development. Therefore, errors can be detected in the
initial stage of the software development process.
 Missing functionality can be identified, which helps to reduce the risk of failure as
Prototyping is also considered as a risk reduction activity.
 Helps team member to communicate effectively
 Customer satisfaction exists because the customer can feel the product at a early
stage.
 There will be hardly any chance of software rejection.
 Quicker user feedback helps you to achieve better software development solutions.
 Allows the client to compare if the software code matches the software specification.
 It helps you to find out the missing functionality in the system.
 It also identifies the complex or difficult functions.

Disadvantages of Prototyping Can lead to insufficient analysis.

 Users expect the performance of the ultimate system to be the same as the prototype.
 Developers can become too attached to their prototypes
 Can cause systems to be left unfinished and/or implemented before they are ready.
 Sometimes leads to incomplete documentation.
 If sophisticated software prototypes are employed, the time saving benefit
 Prototyping is a slow and time taking process.
 The cost of developing a prototype is a waste as the prototype is thrown away.
 Prototyping may encourage excessive change requests.
 Poor documentation because the requirements of the customers are changing.
 It is difficult for developers to accommodate all the changes demanded by clients.
 After seeing an early prototype, customers think the product will be delivered soon.
 client may lose interest in the final product if he is not happy with the initial
prototype.
 Developers who want to build prototypes quickly may end up building sub-standard
development solutions.