In this article we will talk about 4 of the more commonly used or referred to Software Development Models. Of course, there are plenty more but I have decided to limit this post to the following four: Waterfall, Evolutionary Prototyping, Spiral, and Agile.
The waterfall design model is where it all started, it was the first process model to be introduced. And as you can see below it places great emphasis on documentation,
The waterfall model is typically split into 5 stages; where roughly 20–40% of the time is invested into the first two stages; 30–40% of the time for coding, the third stage; and the remaining time is used for the final 2 stages.
Waterfall Design Model Stages
- Requirements: Requirements documents & use cases.
- Design: Software architecture & mapping the stakeholders.
- Implementation: Coding.
- Verification: Install, test, and debug.
- Maintenance: Check errors and optimize.
- Simple and easy to understand and use.
- Phases do not overlap.
- Each stage has its own deliverables and review process. Making it very clear as to whether the current stage has been completed or not.
- Reduce future costs by catching bugs/problems earlier on in the process.
- A high amount of risk due to the difficulty of going back to fix something.
- Poor model for long or ongoing projects.
- Requirements must be very clear and fixed.
- No software is produced until later in the process.
Due to the limited usability, especially in today’s day and age, the waterfall model is regarded more for academic purposes, to demonstrate that software has different stages.
There are many different types of the prototyping model, the one we will discuss here is the evolutionary model. The main difference is that in this model the previous system and requirements as a whole are refined and rebuilt until the desired outcome is reached. This enables us to build a very robust system. Compared to other prototyping models wherein each cycle the previous system is scratched and you start from the beginning.
Evolutionary Prototyping Stages
- The client is heavily involved in the development process.
- Errors can be caught earlier on.
- Feedback and confusion between the client and developers can be identified quickly; Reducing risk.
- Wasted time is also reduced due to the client being able to adjust requirements and functionality accordingly.
- May lead to functionality overload, where client continues to add new features beyond original plans.
- Due to the rapid change and growth of the system, documentation may be difficult.
- Can also create more confusion. Where the developers are unsure of the client’s objectives or end goals.
Evolutionary Prototyping is commonly used where the final product requires a lot of interaction with the end users. User interfaces and web interfaces for online systems typically require a high amount of interaction with the end users.
In the spiral model, a software project repeatedly passes through four phases: Planning, Risk Analysis, Engineering, and Evaluation. Barry Boehm refers to the spiral model as a ‘Sequence of waterfall increments.’ The spiral model is a risk-driven process model, where greater emphasis is placed on the Risk Analysis phase.
Spiral Model Phases
- Planning – Requirements are gathered during the planning phase.
- Risk Analysis – A prototype is produced at the end of this phase and is closely analyzed to identify risk and alternative solutions. If any are found they are then implemented.
- Engineering – Coding, and testing are done in this phase.
- Evaluation – The client evaluates the output of the project and depending on the satisfaction the project is either marked as complete or continues to the next spiral.
- Considering this model places great emphasis on Risk Analysis, the risk is greatly reduced.
- The client can adjust requirements throughout the cycles.
- Accommodates major changes.
- Software is produced early-er on compared to other models.
- Model depends on the Risk Analysis phase, it can make or break the project.
- Depending on the number of cycles, it can be a costly model to use.
- Is not intended for smaller projects.
The agile method is one of the more recently introduced methods. It is a collection of best practices, values, and principles. Agile is another type of an incremental model, where software is released in small increments and is thoroughly tested to ensure software quality is maintained.
- Similar to evolutionary prototyping, the client is heavily involved in the development process.
- Working software is produced frequently.
- Individuals and interactions over processes and tools.
- Customer collaboration over contract negotiation.
- Responding to change over following a plan.
- Not suitable for large teams, especially where team members are unable to share and collaborate.
- The model is not very efficient when the deliverables are large.
- Again, similar to evolutionary prototyping, the model may lead to functionality overload, where client continues to add new features beyond original plans.