Prototyping model

Prototyping is based on the idea of

developing an initial implementation for
user feedback.
And then redefining this prototype through
many versions until a satisfactory system
emerges.
 Creating software using the prototype model also
has its benefits.

One of the key advantages a prototype modeled

software has is the time frame of development. Instead
of concentrating on documentation, more effort is placed
in creating the actual software. This way, the actual
software could be released in advance.
The work on prototype models could also be spread to
others since there are practically no stages of work in
this model. Everyone has to work on the same thing and
at the same time, reducing man hours in creating a
software.
The work will even be faster and efficient if developers
will collaborate more regarding the status of a specific
function and develop the necessary adjustments in time
for the integration.
 Start

Requirements Quick Building

gathering and
refinement design prototype

Engineer Refining Customer

product prototype evaluation

Stop
 Where prototype model is
considered as best approach
Often, a customer defines a set of general
objectives for software but does not identify
detailed input, processing, or output
requirements.
In other cases, the developer may be unsure of
the efficiency of an algorithm, the adaptability of
an operating system, or the form that
human/machine interaction should take.
In these and many other situations, a prototyping
paradigm may offer the best approach.
prototyping can also be problematic
for the following reasons:
1. The customer sees what appears to be a working
version of the software, unaware that the prototype is
held together with chewing gum and baling wire,
unaware that in the rush to get it working no one has
considered overall software quality or long-term
maintainability.
When informed that the product must be rebuilt so that
high levels of quality can be maintained, the customer
cries foul and demands that "a few fixes" be applied to
make the prototype a working product. Too often,
software development management
relents.
2. The developer often makes implementation
compromises in order to get a prototype working quickly.
An inappropriate operating system or programming
language may be used simply because it is available and
known.
an inefficient algorithm may be implemented simply to
demonstrate capability. After a time, the developer may
become familiar with these choices and forget
all the reasons why they were inappropriate. The less-
than-ideal choice has now become an integral part of the
system.
 Key to prototype model
The key is to define the rules of the game
at the beginning; that is, the customer and
developer must both agree that the
prototype is built to serve as a mechanism
for defining requirements.
 Types of Software Prototypes
Throwaway prototype: process of creating
a rapid model (demonstration or
marketing)
Evolutionary prototype: build a system
then refine
Incremental: final product built as separate
prototypes
 Serial development is costly

The Longer You Wait for

Feedback, the more costs
are sunk.

Cost of
Change

Time
 Applications
Feasibility (must use)
Human Interface testing
Increases user involvement
Reduce time and cost
 Prototyping Model Characteristics
Developer and customer determine
objectives and draft requirements
Prototype quickly produced and evaluated
by customer
Prototype then refined, and re-evaluated
Process iterated, before final product
development
Advantages: Customer participation and
better requirements
 Problems of Prototyping Model
Problem 1: Customer may see prototype
as working model and expects fast results
Problem 2: Developer compromised when
producing prototype quickly, e.g. different
operating system or programming
language
 Prototypes
Plan to build a prototype
Document feedback from customer for the
prototype.
Manage the feedback into the software
product
 Prototyping with Reuse
Application level development
Entire application systems are integrated with the
prototype so that their functionality can be shared
For example, if text preparation is required, a
standard word processor can be used
Component level development
Components are mutually independent
Individual components are integrated within a
standard framework to implement the system
Framework can be a scripting language or an
integration platform.
 Prototyping Benefits
Misunderstandings between software users and
developers are exposed
Missing services may be detected and confusing
services may be identified
A working system is available early in the
process
The prototype may serve as a basis for deriving
a system specification
The system can support user training and
system testing
 Prototyping Approaches

Evolutionary Delivered
prototyping system

Prospectus
Throw-away Executable Prototype +
Prototyping System Specification
 Prototyping Objectives
The objective of evolutionary prototyping is to
deliver a working system to end-users
The development starts with those
requirements which are best understood.
The objective of throw-away prototyping is to
validate or derive the system requirements
The prototyping process starts with those
requirements which are poorly understood
 Evolutionary Prototyping
Must be used for systems where the
requirements specification cannot be
developed in advance
Based on techniques which allow rapid
system iterations
Verification is impossible as there is no
specification
Validation means demonstrating the
adequacy of the system
Evolutionary Prototyping Flow
Develop abstract Build prototype Use prototype
specification system system

Deliver YES System

system adequate?
 Evolutionary Prototyping
Advantages
Accelerated delivery of the system
Rapid delivery and deployment are
sometimes more important than functionality
or long-term software maintainability
User engagement with the system
Not only is the system more likely to meet
user requirements, they are more likely to
commit to the use of the system
 Evolutionary Prototyping
Technologies
Specification, design and implementation
are inter-twined
The system is developed as a series of
increments that are delivered to the
customer
Techniques for rapid system development
are used such as CASE tools and 4GLs
User interfaces are usually developed
using a GUI development toolkit
 Evolutionary Prototyping
Challenges
Management problems
Existing management processes assume a
waterfall model of development
Specialist skills are required which may not be
available in all development teams
Maintenance problems
Continual change tends to corrupt system
structure so long-term maintenance is
expensive
Contractual problems
 Prototypes as Specifications
Some parts of the requirements may be
impossible to prototype
E.g., safety-critical functions
An implementation has no legal standing
as a contract
Non-functional requirements cannot be
adequately tested in a system prototype
 Throw-away Prototypes
Used to reduce requirements risk
The prototype is developed from an initial
specification, delivered for experiment then
discarded
The throw-away prototype must NOT be
considered as a final system
Some system characteristics may have been left out
There is no specification for long-term maintenance
The system will be poorly structured and difficult to
maintain
 Throw-away Prototyping
Outline Develop Evaluate Specify
requirements prototype prototype system

Reusable
components

Delivered
Develop Validate software
software system system
Choice of Prototyping Language
What is the application domain of the
problem?
What user interaction is required?
What support environment comes with the
language?
Different parts of the system may be
programmed in different languages
Example languages
Java, Smalltalk, Lisp, Prolog, Perl, Tcl/TK
 Key points
A prototype can be used to give end-users a
concrete impression of the systems capabilities
Prototyping is becoming increasingly used
where rapid development is essential
Throw-away prototyping is used to understand
the system requirements
In evolutionary prototyping, the system is
developed by evolving an initial version to the
final version
 User interface prototyping
It is impossible to pre-specify the look and feel of
a user interface in an effective way
UI development consumes an increasing part of
overall system development costs
User interface generators may be used to draw
the interface and simulate its functionality with
components associated with interface entities
Web interfaces may be prototyped using a web
site editor
queries