Software Life Cycle Models
Software lifecycle models define the series of steps through which the product / project progresses. The models specify the various phases of the process and the order in which they are carried out.
The models provide guidance for project management ( eg. Major tasks to be tackled, milestones , progress etc.)
Different Software Life Cycle Models
- Consists of a set of phases that a project progresses through in a sequential order.
- Each phase must be completed before the project can progress to the next phase.
- At the end of each phase is some form of gateway, usually a formal review where that decision is made.
- There is no overlap between phases.
- Straight forward, simple to understand and use.
- Deliverables are frozen at the end of each phase and serve as the baseline for the following phases.
- The Userdoes not see the software until the end of the project (big bang software development).
- Changes are not supposed to happen or are limited or are tightly controlled.
- Similar to waterfall except it emphasizes the importance of considering the testing activities up front instead of later in the life cycle.
- Each test phase is considered in its matching development phase:
- Requirements == System/Functional Testing
- High-Level Design == Integration Testing
- Detailed Design == Unit Testing
- Used to develop a quick implementation of the software prior to or during the software requirements phase.
- The customer uses the prototype and provides feedback to the software developers as to its strengths and weaknesses.
- This feedback is used to refine or change the prototype to meet the real needs of the customer.
- Can either be evolutionary or throw away.
- Minimal time investment in prototypes.
- The system is then designed, constructed, and implemented using waterfall model
- Rapid prototyping has been enabled by the availability of modern programming tools
- Allows a project to construct the software in incremental stages where each stage adds additional functionality.
- Each stage consists of design, code and unit test, integration test and delivery.
- Allows you to put functional software into the hands of the customer much earlier than either the waterfall or v-shaped model.
- You can plan the stages in such a way that you determine what functionality you do first. i.e., you may choose to deliver the most important functionality to the customer first.
- Provides tangible measures of progress.
- Requires careful planning at both the project management level and the technical level.
- Developed by Barry Boehm.
- A risk-oriented software life cycle.
- Each spiral addresses major risks that have been identified.
- After all the risks have been addressed, the spiral model terminates as a waterfall software life cycle.
- Very much an iterative approach.
- You start small, explore the risks, develop a plan to deal with the risks, and then commit to an approach for the next iteration.
- Each iteration involves six steps:
- Determine objectives, alternatives, and constraints.
- Identify and resolve risks.
- Evaluate alternatives.
- Develop deliverables and verify that they are correct.
- Plan the next iteration.
- Commit to an approach for the next iteration.
- Mainly used for large projects
- Rapid Prototyping for external projects
- Incremental for in-house projects / products