In this topic, we described about the below sections -
Why Prototyping Model?
When followed the waterfall model, the final product may not satisfies the client or client has an another expectation on the output or the product may not developed properly due to the communication gap. Because the client reviews the development only after the testing completion in waterfall model. This becomes the failure of the waterfall model and also increases the cost if the product is not developed as expected. To avoid these, there is a requirement of new SDLC model. To overcome these issues, prototyping model was introduced.
What is Prototyping Model?
Prototyping Model is also known as Evolutionary approach. The main objective of prototype model is developing software applications based on the prototypes. The prototype is used to showcase the functional behaviour of the developing product. However, the prototype wont hold the exact logic of the original software product.
The basic idea of prototype model is that the prototype gets reviewed and approved by the client before proceeding to a design or coding phase can proceed. The temporary prototype is developed to showcase to cilent based on the customer new requirements. Once the prototype is ready, it presents to the client to get his approval to move to further phases. Using this prototype, client can get the "real behaviour" of the developing product. Client provides his valuble feedback once he reviews the prototype. This feedback helps the developers and designers work on the prototype to incorporate feedback comments. Once the design modified, again sends for client review. This process will continue until no review comments from client or gets a client signoff to proceed with design and development.
This model helps to develop a product as per user or client expecations and avoids the communication gap between them.
- Quick Design - Development team develops the initial prototype of the system with the new basic requirements. These features are used in quick design and it may not work exactly in the same manner as the final software product. However, the overall look and feel would be same as the original product that is going to develop.
- Building prototypes - The prototype is being built from the quick design which is the output from the previous step. The buliding prototype gives the look and feel similar as the final product.
- Customer evaluation - Once the prototype built, it sends for the customer or client for the review. Client checks for the working functionolity and gives feedback to the development team. If any improvement suggestions in the customer feedback, then they moves to the customer feedback step. If no review comments and prototype is as per the expectation, client provides signoff to the prototype and development team moves to the design phase in SDLC.
- Customer Feedback - If any review comments or any improvement suggestions in customer evaluation, customer sends it through this step. Development team has to take them and move to quick design phase again.
There are different types of SDLC prototype models used in various companies for system development. The detailed information about the types of prototype model are specified below -
- Rapid Throwaway Prototype
- Evolutionary Prototype
- Incremental Prototype
- Extreme Prototype
Rapid Prototyping –
The rapid prototyping also known as throwback prototyping or close ended prototyping. Rapid prototyping uses very less efforts with minimum requirement analysis to build a prototype. Once the actual requirements are understood by the team, the prototype is ignored, and the actual development starts with much clear understanding of user requirements.
Evolutionary Prototyping –
Evolutionary prototyping also called as breadboard prototyping. This approach is working, continuous prototype that is modified after the client feedback from each iteration. It helps to save time as well as effort because the each prototype doesn't start from scratch.
It is helpful when the requirement is not stable or not understood clearly at the initial stage.
Incremental Prototyping –
In incremental prototyping, divides the final product concept into small pieces. It develops functional prototypes for the divided sub-products. After building all these functional prototypes, combine all these prototypes to build a full functional system called final product.
Extreme Prototyping –
This type of prototyping model is mainly used for web applications. It is classified into three phases-
- As a first step, basic prototype with static pages gets created and it consists of HTML pages.
- Next step, data processing is simulated using a services layer.
- In the last phase, services are implemented.
- Easy to detect errors in the initial stage.
- Lowers the risk.
- Easy to identify the missing functionality.
- Helps in effective team communication.
- Flexibility in designing.
- Encourages innovation.
- Prototypes can be modified or removed.
- Easily understandable as it is a straightforward model.
- Almost no chances of rejections.
- Help the users to understand the functionality earlier.
- Quicker feedback from client helps for better solutions.
- Missing functionality can be identified easily.
- Proper risk analysis.
- Less chances of developed software rejection.
- Developed prototype can be reused by developer or tester.
- Slow and time-consuming process.
- No parallel deliverables.
- Unpreditability of no of iterations.
- If the initial demonstrated prototype is not impressive, the client may loose interest in the final product.
- Documentation is poor.
- Customer may suggest too many variations each and every time he/she evaluates the prototype.
- Large amount of change requests are accepted.
- Sometimes challenging for the developers to do all the changes suggested by the customers.
- Customer may not be interested to get involved in the iteration cycles which are too longer.
- Cost of design and developing prototype becoming waste if the prototype is rejected or doesn't met client expectations.
- Developing the prototypes quickly would result in building an inefficient prototype.