Prototype Model in Software Engineering

What is Prototype Model in Software Engineering?

The Prototyping Model is one of the most often used SDLC Models. It is applied when customers do not know the exact project requirements ahead of time. In this paradigm, a prototype of the eventual product is created, tested, and refined based on consumer feedback until a final acceptable prototype is reached, which serves as the foundation for building the final product. The process begins with client interviews and the creation of a high-level document. This document is used to create the initial prototype, which will only offer the minimal capabilities requested by the customer. The system is partly developed before or during the analysis phase, allowing clients to experience the product early in its life cycle. Once the customer has identified the issues, the prototype is improved to eliminate them. The process is repeated until the user approves the prototype and is satisfied with the working model.

Steps of Prototype Model

The following steps are involved in the working of the Prototype model:

• Requirement Gathering and Analysis
• Quick Decision-Making
• Building a Prototype
• User Evaluation
• Prototype Refinement
• Building the Final Product and Maintenance

Requirement Gathering and Analysis

It is the first step in building the prototype model. The users are interviewed to collect and define the requirements for the software product, and various analysis techniques are applied to this information.

Quick Decision-Making

In this step, a preliminary design of the prototype is made. This is not the complete design of the product; it just gives the user a brief idea of the system.

Building a Prototype

In this step, a prototype is made using the information from the previous step. It is a small working model of the software product being built.

User Evaluation

The prototype built in the previous step is presented to the users. They evaluate the model for strengths and weaknesses and give their suggestions and comments to the developers.

Prototype Refinement

The developers use the feedback collected from the users in the previous step to refine the prototype. This step is repeated again and again until the user is satisfied with the prototype.

Building the Final Product and Maintenance

The final product is built based on the approved prototype from the previous step. The product is then deployed in the user environment and undergoes routine maintenance.

Types of Prototype Models in Software Engineering

There are four types of Prototype Models available:

1. Rapid Throwaway Prototyping
2. Evolutionary Prototyping
3. Incremental Prototyping
4. Extreme Prototyping

Rapid Throwaway Prototyping

This method uses very little effort and minimum requirement gathering to build a quick prototype to demonstrate an initial image of how the requirements will look visually. The customer's feedback influences the changes, and the prototype is built again until the requirements are baselined. This approach will discard a developed prototype and it will not be included in the final accepted prototype. This technique effectively brainstorms ideas and receives immediate feedback on consumer requirements.

Evolutionary Prototyping

The prototype is improved incrementally depending on customer feedback until it is eventually accepted. It allows us to save both time and effort. This is because creating a prototype from scratch for each process interaction might sometimes be extremely unpleasant.

This concept is useful for a project that involves the usage of unknown new technology. It is also employed in complex projects where each functionality must be tested only once. It is useful when the demand is not constant or is not clearly known at the outset.

The Evolutionary Prototype method is similar to the Iterative Paradigm in that the phases outlined for the waterfall model occur in a circular pattern here. However, this model differs from the iterative model because it does not mandate creating a functional product after each cycle. In evolutionary development, requirements are implemented by type rather than priority.

Incremental Prototyping

The final product is split into small prototypes and produced separately in incremental prototyping. The several prototypes are eventually combined into a single product. This strategy helps shorten the feedback time between the user and the application development team. In addition, the time interval between the project's inception and delivery is reduced because all system parts are prototyped and tested in parallel.

Extreme Prototyping

The web development industry makes extensive use of extreme prototyping. This paradigm is divided into three stages:

1. First, an HTML prototype with all of the existing pages is displayed.
2. A prototype services layer is then used to mimic data processing.
3. Finally, the services are implemented and integrated into the final prototype.

This method is known as Extreme Prototyping because of the second phase of the process, in which a completely functional UI is created with minimal care for the actual services.

Applications of Prototype Model in Software Engineering

• In many cases, the client has just a broad understanding of what is required of the software product. In this case, if there is a lack of precise information on the system's input, processing needs, and output requirements, the prototype approach may be used.
• It can also be used if the requirements are frequently altered.
• It is also a good choice to demonstrate the product's technical feasibility.

Advantages of Prototype Model

• The customer gets to see partial products early in the lifecycle, hence ensuring customer satisfaction.
• The developed prototype can be reused for bigger projects in the future.
• There is scope to accommodate new requirements.
• Errors and missing functionalities can be identified much early in the lifecycle because the users are actively involved.
• User feedback is accommodated quickly.
• The model is very straightforward and does not require skilled experts to implement.

Disadvantages of Prototype Model

• Prototyping is a slow and time taking process.
• Documentation is poor as the requirements change frequently.
• When the customer evaluates the prototype, there may be much too many variances in software needs.
• There is a risk of inadequate requirement analysis owing to too much dependency on the prototype.

Example for Understanding

Let us understand evolutionary prototyping with the example of a simple database application. In this application, one cycle may implement the graphical user interface (GUI), another file manipulation, another query, and yet another update. Before a workable product is available, all four cycles must be completed. The graphical user interface (GUI) lets users engage with the system; file manipulation allows data to be saved and retrieved; inquiries allow users to exit the system, and updates allow users to put data into the system.