Software Engineering Life Cycle Models
In software engineering, a life cycle model is a framework that describes the activities that will be carried out during each phase of software development project. The discussion will focus on five software development models namely: the waterfall model, the spiral model, the v-shaped model, the iteration model, and the structured evolutionary prototyping model.
The Waterfall Model
This model is linearly sequential, resembling a series of cascades. It involves the following phases; establishing requirements, designing, implementation, testing, installation and maintenance. Each stage of this model produces a deliverable that is required by the next phase and the deliverable has to be completed before beginning the next phase. An assessment is carried out at the end of each phase in order to ascertain that the development is on the right track. The evaluation is helpful in deciding whether to continue or discard the software development project.
The waterfall method has several advantages. It is easy to understand and use. Furthermore, it is ease to manage due to the rigidity of the model. Despite these advantages, it has weaknesses as well. For one, the design is poor for complex and object oriented projects. The model does not produce working software until late during the life cycle. This late delivery implies that grave errors will be discovered late.
The V-Shaped Model
In this model, execution of processes is done in a sequential path just like the waterfall model. There is dependence among phases, in that; one stage needs to be completely done before beginning the next one. The model lays emphasis on extensive testing. Testing procedures are laid down before coding takes place. The main phases for this model are establishing system requirements, creating system test plan, high-level design, and system implementation. After system requirements have been established, the test plan in the second period is used to meet the functionality defines by the conditions in phase one. The third stage involves system architecture and design. Pieces of the software systems are tested for their ability to work together using integration test plan. All coding takes place in the implementation phase.
The V-Shaped design is simple and straightforward to apply. The model has higher chances of success because there is an early development of test plans. It works suitably for small projects in which the project's requirements are easy to understand.
This model is rigid and inflexible, and any adjustment to it is expensive and difficult. In addition, software development is done in the implementation phase. This means that no initial testing is performed. Any problems arising cannot be dealt with explicitly, since the model has no definitive way for handling problems.
The Incremental Model
This model involves developing a partial implementation of the complete system. It aims at developing and giving the customer a subset of the whole system which is useful and then slowly add increased functionality. Increments are done through repetitions. Each repetition undergoes the processes of requirements formulation, design, implementation and testing phases and a working version of the system is produced in the first iteration.
Incremental model leads to a fast development in the early stages of the software lifecycle. It is also flexible because it is cheap to change requirements and scope. Despite these merits, the model faces the following weaknesses. A problem may emerge that pertains to the structure of the system since not all requirements are gathered in advance for the entire software life cycle. In addition, every step of each iteration is less flexible and do not overlap one another.
The Spiral Model
The model resembles the incremental model, emphasizes more on risk analysis. It entails four phases, namely: planning, risk analysis, engineering, and evaluation. A software development project has to pass through these phases in loops known as spirals. There is a baseline spiral from which each subsequent spiral are built. The baseline loop starts in the planning phase whereby requirement gathering is done, and risk assessed. Risks are identified in the risk analysis phase, and solutions offered. At the end of this stage, a prototype is built. In the engineering phase, software is developed. At the end of the engineering phase software testing is carried out. The software is evaluated in the evaluation phase.
This model's main advantage is that it requires comprehensive risk analysis. Since software is created in the early stages, errors can be identified and corrected early. Due to these advantages, the design is suitable for large and mission-decisive projects. However, this model is costly to use. Extremely specified expertise is required for the risk analysis. Furthermore, the project's achievement highly depends on the risk analysis phase. The model does not work suitably for small projects.
The Structured Evolutionary Prototyping Model
In this model, a prototype is created at the requirements phase. End users evaluate the prototype and provide corrective responses then developers enhance the prototype through refining until the customers are satisfied, the point at which the prototype code is written to the standards of the final product. This model is powerful in that customers are able to keep track of requirements during gathering. Developers also are able to learn from customer hence leading to the development of more accurate system software. On the hand, the model has weaknesses; it faces scope creep whereby the process may continue forever due to continuous change of requirements and at the same time, overall maintainability can be overshadowed.
Current trends in terms of software life cycle modeling
The software world is ever changing. These changes necessitate keeping track of the current trends of technologies in terms of software system development. Capability has been expanded in three areas of mobile development, cloud computing services and support of agile development methodology. Emphasis has also been laid on release management through continuous delivery techniques.
References
Mohammed, N., Munassar, A., & Govardhan, A. (2010). A comparison between five models of software engineering. International Journal, of Computer Sciences, 7 (5).
Volker, M., Stahl, T., Beltin, J., Haase, A., & Helsen, S. (2013). Model-driven software development: Technology, Engineering and Management. New York: John Wiley & Sons.
