Incremental Model

In recent times, one of the most commonly used software development life cycle models is the Incremental model. In Software development, the various models are developed depending on the objectives that are to be met. The developed model will specify the way that the software is developed for each iteration stage, it will also specify the process that is to be carried out for these stages to be actualized. When choosing a model, there are some factors to consider. These factors are the nature of the organization, the impact on the testing methodologies, and the objectives that are to be met. Other popular models used by organizations include RAD, Spiral model, Waterfall model amongst others; but for the sake of this tutorial, we will be looking at the Incremental model.

What Is Incremental Model?

In the Incremental model, the processes involved in software development are divided into multiple individual modules in the Software development life cycle (SDLC). This model can be otherwise called a Successive version model. Once the modules are divided, the process of incremental development will begin in stages. These stages will cover all the analysis, implementation, designing, testing/verification, and even maintenance. The incremental model can be related to the Waterfall model in the sense that it combines the elements of the waterfall model but iteratively. The waterfall model is applied repeatedly in each increment. The incremental model also applies linear sequences in a required pattern. 

Each of the iterations in the Incremental model passes through four different phases. They are the requirements phase, design phase, coding phase, and testing phase. When a new system is released, it improves the function of the previous release. This is done until all the design functionality has been actualized.

Phases of Incremental Model

There are 4 phases involves in the Incremental model and they are enumerated below:

1. Requirement Analysis: This is the first phase of the incremental model. In this phase, the experts on product analysis identify the product requirements, which include both functional requirements and non-functional requirements; and they also make sure the requirements are compatible. This is a crucial phase when developing software using Incremental models.
2. Design and Development: This is the second phase of the incremental model. In this phase, the development method and system functionality designs must have been successful. The design is then proposed on how to archive and implement this requirement. When the software develops new practicality, the incremental model then uses the development phase and style.
3. Coding: This is the third phase. In this phase, coding is done according to the purpose of the requirements. The coding standards must be followed without any unnecessary hard codes and defaults. This phase also enables the implementation of the designs which is done practically. By completing this phase, the quality of the working product can be upgraded and enhanced. 
4.  Testing: This is the final phase of the incremental phase. In this phase, the performance of each of the existing functions, as well as other additional functionality, are checked. Also, various methods are used to test the various behaviors of each task.

Types of Incremental Model

There are two types of incremental models in Software development life cycle models. They are:

1. Parallel Development Model: In this type of incremental model, different sub-systems are developed simultaneously. If sufficient resources are available, this model helps in decreasing the calendar time (also known as Time to Market TTM) that is needed for the development process.

2. Staged Delivery Model: In this type of Incremental model, the construction is done one at a time for only one part of the project.

Life Cycle Activities Involved in Incremental Model

In the incremental model, the software requirements are first broken down into different modules that can be constructed incrementally and delivered. There are no long-term plans at any time during this process as the plan is just for the next increment. This makes it easier to modify the version depending on the customer’s needs. 

Firstly, the development team develops the core features of the system. After successfully developing the core features, they are then refined by adding new functionalities in successive versions which will increase the level of capabilities. The incremental versions are developed with an iterative waterfall model. As the process continues and each successive version is constructed and delivered, the feedback of the customer is then taken which is added in the next version. This means that each version of the software possesses more features than the previous ones. 

After the requirements have been gathered and specified, they are then divided into different versions beginning with version-1. After each successful increment, the next version is constructed and then at the customer site. When the process ends, the last version (version n) is now deployed at the customer client.

Characteristics of Incremental Model

1. At any point in time, there are no long-term plans involved. This means that the plan is done for only the existing increment and complete focus is on the requirement worked on at the moment.
2. Priority is given to each of the requirements/stages and the requirement of the highest priority is first tackled.
3. The software that is to be developed will be divided into different stages. This leads to many mini sub-projects present in the software.
4. The phases used in developing each increments version follow the analysis, design, code, and test phase. The iterative waterfall model is also frequently used to develop the incremental version, even though other models can be used as well.
5. The partial systems that are to be developed are combined to produce the complete objective of the software.
6. After handling a requirement of the increment, it is then frozen so that focus can shift to the next requirement or increment.

Example of Incremental Model

A practical example of an incremental model is a piece of drawing shown below. In this case, the drawer starts with a section of the drawing, and then, he/she keeps adding to the drawing piece by piece until it is complete. We can thus say that the drawer works incrementally. The drawer started from the first iteration and once the module was completed, the second iteration started which was the other module. Once that was completed, it was then integrated into the first module. This was done until the whole product was integrated and ready.

Merits of Incremental Model

Some of the advantages of the incremental model include:

1. The cost of initial delivery is reduced.
2. Since the project is divided into several incremental stages, 100% requirements will be achieved as well as 100% objectives of the software met.
3. Feedback can be provided by the customer at each stage of the model. This will prevent sudden changes in the requirement and also value work efforts.
4. Since each incremental phase is tested, there will be numerous testing for the software which will, in turn, lead to fewer defects and better results.
5. The incremental model tends to be cheaper on the side of the consumer when compared to other software development models.
6. It is easy to identify errors when using this model.
7. The model is flexible. The cost is low even when there is a change in the scope of the requirement.
8. The software is quickly generated during its life cycle.
9. Risk management is easy because the risky parts are identified and properly handled during iteration.
10. A new feature is added to the product after a new release.

Demerits of Incremental Model

1. The total cost of the complete system is high.
2. The model requires an efficient design to ensure the inclusion of the required functionality as well as providing for changes later in the project.
3. The interfaces used for software development must be well-defined, as some of the interfaces are developed long before others begin development.
4. The model requires proper planning of iterations.
5. The model also requires the early definition of a fully functional and complete system to allow the definition of increments.

When to Use the Iterative Model

The iterative model can be applied when the following is present;

1. When there is a need to have the basic functionality delivered as quickly as possible.
2. When the domain of the project is new to the team.
3. When the requirements needed for the project are prioritized.
4. When a project possesses a new technology.
5. When most of the requirements needed are known before the start of the project, but they are expected to change as the project progresses.
6. When a project has a lengthy development schedule.
7. When high-risk goals and features are involved.
8. When the software development team is not fully trained.

Importance of Incremental Model

The major importance of using the incremental model is that it splits the software development into sub-modules and each of the sub-modules is obtained by following the software development life cycle (SDLC) process. This process includes the analysis, design, code, and test process. Also, following this model makes sure that no objective expected by the end of the software is missing no matter how minor the objective might be. By this, this model achieves the 100% objective of the model. By testing rigorously after each stage, it is certain that the end software is detect-free and that each stage is compatible with both the future and previously developed stages.

Conclusion

Many models can develop software and meet the required objective, but we have seen that incremental models meet the requirements with 100% objectives of the software expected.