"Plan to build two systems and throw one away- you will anyway" (Brooks)
Prototyping is a technique of risk reduction. Prototyping is one means for addressing uncertainty. Experiment shows that the prototyping approach shows that this approach took 40% less time and resulted in 45% less code. From the prototype, developer can generate a system more quickly by using existing program fragments.
Prototyping consists of requirements and analysis gathering, quick design, prototype building, client evaluation, prototype refining and product engineering. This cycle continues until the required system is developed. The concept of prototyping is particularly for maintenance. In simple words, a prototype is created before the final product is built so that any adjustment or addition features and requirements can be implemented before the final system is built. Ideally, prototyping is done to test the principles, to ensure the system works, and to obtain design feedback which enables design to be altered and corrected before the money is spent.
Relationship of Components
The prototyping lifecycle. Chart extracted from the Internet. (Prototyping)
Software developer and client identify the overall objectives, requirements and specification for the prototype.
A "Quick Design" of the prototype allow client to evaluate what and how the real prototype works.
After iterations of evaluation from the client, a prototype is build.
At this phase, client evaluates the prototype. The prototype is "tuned" to satisfy the requirement of the client.
Refinements of requirements are made to the prototype so that client are satisfy and comfortable with the new system.
Finally, the prototype is built. The design of the prototype helps to skeleton the outline of the real system.
Relationships between Evolutionary and Throw-away Prototyping
There are two kinds of prototyping, which have different objectives and two different types of implementation:
The objective of evolutionary prototyping is to deliver a working system to end- users. The prototype is designed to form the basis for development of the final system. The objective is to build an implementation that is well understood by the client/end user. The final system is developed under constant evolutions of the prototype so that new features can be added and requirements can be refined as proposed by the client/end-user.
The objective of throw-away is to validate or to derive the system requirement.
Throw-away prototyping starts with poorly understood requirements. The prototype is designed in this way so that vague specification and requirement outlines can be ascertained. This is intended to clarify requirements and provide additional information for managers to reduce risk. Throw-away prototyping is intended to determine the system specification so that the final system follows the requirements set by the end-user.
Strength and Weakness of Prototype Model
Appropriate and Inappropriate Domains of Application in Prototype Model
Related Tools and Methodologies
There are a number of methods which can be used for system prototyping. In fact, there are three generic classes to do rapid prototyping.
Formal Specification and Prototyping Environments
Developing a prototype from a formal specification language combines unambiguous specification with a prototype. There are no additional costs in the prototyping development after the specification has been written.
One of the practical difficulties is that the prototype development may not be particularly rapid. This is because the formal specification requires detailed system analysis and time to have a detailed modeling after the prototype evaluation.
Fourth Generation Techniques (4GL)
Using 4GLs for developing data processing is very cost effective especially in small systems. Fourth Generation Techniques-based development can be used for evolutionary prototyping or in conjunction with a method based analysis to generate the prototype.
Reusable Software Components
Prototypes can be developed in a short time if there are a library of reusable components and mechanism to compile these components into the system.
An example of this approach of prototyping can be found in
The success of the Smalltalk and Lisp is due to their reusable component libraries in their language facility.