In this article, we will talk about the concept of software, its models, and software development methodologies. Understanding the different development organization options will help you manage your resources and projects better. Software, like a living being, has its life cycle. The software life cycle is the stages that a software product goes through from the emergence of an idea to its implementation in code, performance in business, and further support. Life cycle models largely determine software development methodologies.
Table of Contents
Software Life Cycle Models
Software development includes the following best-known life cycle models:
- Cascade model (aka “waterfall” – waterfall)
- Iterative model
- Incremental model
- Spiral model
Let’s take a closer look at them and find out what they have in common and what is different.
Waterfall (Cascade Model)
The essence of this model is stages that depend on each other. The continuation of the stages begins only when the previous one ends, and a progressive movement is embodied.
Although limited, the parallelism of stages in the cascade model is possible for completely independent works. At the same time, the integration of parallel parts still occurs at some subsequent stage, and not within the framework of one.
Teams of different stages do not communicate with each other, each team is responsible for its location.
The disadvantages of this model are obtaining a result after passing all stages and the difficulty of detecting errors. Going back is difficult. It is not clear what to return: if a failure occurred at some stage, its consequences are visible only at the end.
In reality, the cascade model cannot be called simple, in practice, it is difficult to manage. The introduction of significant changes by the customer during the waterfall development process or the triggering of serious risks not foreseen by the project are destructive for the entire process – the model has to be rebuilt, and the schedules rescheduled.
Iterative, Spiral, and Incremental Models
- The iterative model involves dividing the project into parts (stages, iterations) and passing the stages of the life cycle on each of them. Each stage is complete in itself, the totality of stages forms the final result.
Let’s explain the division into stages using a household example. Suppose we need a table in the living room.
- In the first stage, we will make a tabletop, and legs and fasten them so the table stands.
- On the second, we will strengthen and paint it.
- And on the third, we will cover it with a tablecloth and buy chairs for it.
- What is a spiral model?
All stages of the life cycle in the spiral model are turns, at each of which design, coding, design, testing, etc. take place. This process reflects the essence of the name: going up, one turn (cycle) of the spiral is passed to achieve the final result. Moreover, the same set of processes doesn’t need to be repeated from turn to turn. But the results of each turn lead to the main goal.
- Now let’s talk about the incremental model.
The principle underlying the incremental model implies the expansion of capabilities, completion of modules, and functions of the program. The literal translation of the word increment is “increase by one.” This “increment by one” is also used to indicate product versions.
If the cascade model essentially has two product states: “nothing” and “finished product”, then with the advent of iterative models, product versioning began to be used. Each iteration is marked with a number: 1,2,3, and accordingly, the product after each iteration has a version with the corresponding number: v.1, v.2, v.3. Numbers after the word version indicate large-scale changes to the core of the product.
And when one of the versions is in use, the next one, due to the shortcomings of the previous one, is only being planned or is already being developed, and the improvement to the customer and the user wants to be delivered right now, then minor versions appear. Some changes do not affect the core of the development itself and are subversions 1.1, 1.2, and 1.3 or releases 1.1.1, 1.1.2, etc. Collectively, these incremental releases lead to a full-fledged version 2.0.
Conclusion
Despite many studies, the opinion about the effectiveness of methods, principles, and methodologies is often based on personal experience, emotional response, and competencies of the manager who applied them. And not always the model you like from the description will be the best for the implementation of your project. Therefore, the more methodologies and approaches you know, the higher your ability to manage projects by combining best practices.
