Many times following situations are occurred.
– Customers define a set of general objectives for software, but not detailed input, processing or output requirements.
– The developer may be unsure of the efficiency of an algorithm, the adaptability of an operation system, or the form that human-machine interaction should take.
In such cases prototyping approach can be used.
Prototyping is an approach that enables the developer to create a model of the software that must be built.
The prototyping model may be in any one of these forms.
1) Paper prototype (PC based model)
It enables the user to understand how interaction will occur (Slide Show or diagram).
2) Working prototype
It implements some subset of the function required for the desired software.
3) An existing program
It performs all the existing function required but we can improve it for the new development.
The prototyping paradigm begins with requirements gathering. Developer and customer meet and define the overall objectives for the software, identify whatever requirements are known, and outline areas where further definition is mandatory.
A quick design then occurs. It focuses on a representation of those aspects of the software that will be visible to the customer/user. (e.g I/P approaches and O/P formats)
The quick design leads to the construction of prototype. The prototype is evaluated by the customer/user and is used to refine requirements for the software to be developed.
Interaction occurs as the prototype is tuned to satisfy the needs of the customer, at the same time enabling the developer to better understand what needs to be done.
Ideally, the prototype serves as a mechanism for identifying software requirements. If a working prototype is built, the developer attempts to make user of existing program fragments or applies tools. (e.g. report generation, window managers, etc…) that enable working program to be generated quickly.
- The customer sees what appears to be a working version of the software, unaware that in the rush to get it working we haven’t considered overall software quality or long-term maintainability.
- The developer often makes implementation compromises in order to get a prototype working quickly.