The overall objective of software design is to make sure that the stakeholders apprehend the design and verify that the project teams understand their needs and expectations clearly. A software development life cycle focuses on producing the high quality software product to meet the stakeholders’ expectations.
A life cycle is a chain of multiple steps that lead to the completion of a project. Over the years, various software development life cycles have been used and practiced in the industry. Software development life cycles are used every day in IT departments around the world.
Software Development Life Cycle (SDLC) Methodologies
There are various Software Development Life Cycle methodologies that are used in the IT industry today. The most updated and the latest methodology is the ‘Agile’ methodology or process that is used in almost all IT organizations to develop new software/system.
To completely define Agile, it is an iterative and progressive development process that allows the project requirements to be updated based on the clients’ feedback on a frequent basis. Agile process or methodology allows organizations to develop new software/system in small fragments known as SPRINTS.
In this methodology, a backlog is created and maintained throughout the project execution once the requirements are documented and approved by the clients. Based on the priorities, requirements are pulled in from the backlog for each SPRINT and implemented. A SPRINT is mostly of 2 weeks and it can be of 4 weeks in some cases. When the SPRINT gets over, implemented requirements are presented to the clients and their feedback is recorded. Based on the clients’ feedback, the new requirements or the updates are added in the next SPRINTS based on the priorities.
Phases of Agile Process
There are various methodologies that follow agile process to execute projects, which include:
- Extreme Programming
- Lean Software Development
- Feature Driven Development (FDD)
- Dynamic System Development Method (DSDM)
Each agile methodology has its own approach of project execution to develop agile projects. All above agile methodologies will be explained in detail in the coming articles. We will also take a look at several other Software Development Life Cycle (SDLC) models or methodologies below:
Cyclical System Development Life Cycle Model
The Cyclical System Development Life Cycle is a cyclical model or methodology in which the phases repeat after each cycle completes. Since this methodology is cyclical in nature, changes can be made to the design in the next cycles. This is the very basic software life cycle which involves the following broad stages:
- Preliminary/Feasibility Study
In ‘Preliminary/Feasibility Study’ a feasibility study is performed and it is investigated whether the stated purpose satisfies the customer’s objectives or not. During this study, the technical, environmental and social constraints are explored and verified if they satisfy the purpose. This step leads to the go ahead for the project.
- Detailed System Study
The detailed system study involves the requirement elicitation and analysis phase. Once the detailed system study is performed, it leads to a detailed understanding of the existing system, its drawbacks, business logic, people, roles and the transactions involved.
- Requirement Specification
Post feasibility and system study, a detailed Software Requirement Specification (SRS) is created for the project.
- Preliminary/Feasibility Study
- Logical System Design
In logical system design, a conceptual design of a new software/system is created which overcomes the limitations of the existing system.
- Physical Design
Physical design of the new software/system gives the physical form to conceptual design and visualizes the new software/system in the following context:
- Real Life Organizational Structure
- Actual Processes
- Departments Involved
- Equipments Used
- Logical System Design
In ‘Coding’ phase of Implementation, coding is done for the necessary software programs as per the program specification. Program specification mentions the following parameters:
- The Program Purpose
- Input Used
- Expected Outputs
- The Logic
- Checks to be Performed
In ‘Testing’ phase of implementation, the software/system is tested against a set of test cases. The individual units and modules are put together and tested to test the software/system functionality.
- User Acceptance Testing
In User Acceptance Testing (UAT) phase, the new software/system is tested under real-life conditions that include:
During the Review phase of implementation, it is validated whether the new software/system has yielded the stated purpose or not.
Waterfall Model (Classical Life Cycle)
Waterfall model is the oldest model of Software Development Life Cycle (SDLC). In this model of SDLC, the development of a software or an application moves step by step in a linear manner. As this moves through the steps one after the other, it looks like a waterfall thus known as the Waterfall model. This model consists of the following stages of development of software or a system:
- Planning: In ‘Planning’ stage the problem is defined and the objectives of new software/system are set.
- Analysis: ‘Analysis’ stage plays an important role in Software Development Life Cycle (SDLC). In this stage of SDLC, a detailed system study is done and the requirement analysis is performed by the analysts based on the inputs received from the stakeholders and Subject Matter Experts (SMEs) in the organization.
- Design Stage: In ‘Design’ stage, the data and processes are defined. Based on the Software Requirement Specification various design approaches are proposed and design documents are prepared. Post review from the stakeholders, the best suitable design document is selected based on the stakeholders’ reviews.
- Coding: During ‘Coding’ stage of implementation, the development starts and coding guidelines of the organization are followed.
- Testing: During ‘Testing’ stage of implementation, a test plan is prepared based on the SRS. Multiple test cases are created by the testers and bugs in the software/system are reported while performing the testing. Once the bugs and issues are fixed and the software/system is finally ready as per the quality standards defined in the SRS, the software is accepted.
- Review: In ‘Review’ stage, it is validated that the software/system has been developed and the results are as per the defined purpose and the analysis performed.
In this model of SDLC, there is no overlapping between each step and there is no way of going back to the previous step once it is completed. For example, once the Analysis is completed and it moves to the Design stage, there is no possibility of coming back to the Analysis stage.
- The biggest advantage of the Waterfall model is its consistency as it moves through the various stages sequentially.
- The simplicity of this model offers a lucid approach to handle and manage the project execution.
- The milestones are well defined and structured to understand well.
- When the quality is of utmost concern, this model is very beneficial to use.
- Long run project becomes irrelevant before implementation.
- All the requirements must be completely specified before the implementation starts.
- The customer does not get the opportunity to review the software/system in the middle to propose any change of requirements.
- For larger software projects, it is not possible to study and understand the entire requirements and implement it in one go.
The Prototype model follows a completely different approach in Software Development Life Cycle. A Prototype refers to a Mock-up of the end product that is developed based on the basic requirement of the project. This model involves different stages of life cycle and the stages involved are iterative in nature.
When the user is unable to define and specify the requirements in some of projects, prototyping is used to define the user needs. In the Prototype model, based on the initial project requirements, a prototype is created and reviewed. Post review, various feedback are received that lead to the next iteration. Based on the subsequent feedback, multiple iterations occur that leads to the final product.
Thus, the Prototype model consists of two major stages that include:
- Prototype Development
- Verified Software Development
First, the prototype is developed in multiple iterations of development, review and feedback. Once the prototype is approved, the actual software is developed.
- The ‘Prototype’ model reduces risk in complex projects.
- In this model, it is easier to adjust the prototype based on the user feedback and move it to the completed software.
- In few of the cases, the prototype developed cannot be adjusted and used only as a guideline for the actual software/system to be developed again.
The V-Shaped model of Software Development Life Cycle is an add-on to the classical Waterfall model.
In V-Shaped model of SDLC, the Testing phase is separately defined and matched with each of the stages which are defined before testing phase in the following manner:
- Matching of Requirements and Functional Testing
In this matching of the model, system test cases are created to perform functional testing. During the functional testing of the system/software, the Quality Assurance team validates the requirements. They make sure that requirements stated in the document are fully functional work as per the business rules specified.
- Matching of High Level Design and Integration Testing
In this matching of the model, integration test plan is created by the Quality Assurance team. The team combines individual units together and performs the integration testing of the units grouped together. While testing the integrated units, the team validates the high level design with the results based on the test cases. In Integration testing, multiple individual units or components are grouped together and tested so as to verify it with the high level design.
- Matching of Low Level Design and Unit Testing
In this matching of the model, Unit test plan is created by the Quality Assurance team and the team tests the individual units of the system/software based on the test cases. The team then validates the low level design with the results. In Unit testing, each and every smallest unit or component is tested so as to verify it with the detailed design of the system/software.
- In ‘V-Shaped’ model, the testing activities are planned well before the coding starts, thus reduces the risk of project failure.
- This model is very useful for the small size projects.
- This model provides no flexibility for any changes in the requirements in the middle of the project execution.
- As and when the requirements are changed, the testing specification need to be updated along with the requirements specification.
In the Spiral model of Software Development Life Cycle, a proper risk analysis is carried out and the software to be developed is envisioned in the first phase of prototyping. Once the initial prototype is visualized, the development moves to the next cycle that is similar to the stages of Waterfall model. Another cycle of development has its own risk analysis process.
Thus, the Spiral model of SDLC integrates the benefits of both the Prototype and Waterfall models. It consists of the following four stages:
- Planning: In ‘Planning’ phase the requirements are defined.
- Risk Analysis: The ‘Risk Analysis’ phase identifies the management and technical risk such as feasibility, schedule and cost overruns.
- Engineering: The ‘Engineering’ phase starts with the conceptual design and the physical, logical and architectural design is developed during the base spiral. When the final design is developed in successive spirals, it is sent for the customer feedback. Once the design is approved, the development starts followed by the testing and the actual software/system is sent to the customer for the feedback after each spiral.
- Customer Evaluation: During the ‘Customer Evaluation’ phase, the customer assesses and provides his feedback at the end of each spiral.
- This methodology is beneficial to use when the developers do not have clear understanding of the requirements and the solution to be developed.
- The functionality of the solution developed in each spiral can be revisited.
In this model of Software Development Life Cycle, the software is developed in successive iterations. In each of the successive iterations, some functionality is developed and the next iteration adds some more functionality to already developed functionality.
For example, if we are developing a basic software application then in the first iteration only the Menu Tabs are developed. In subsequent iterations, options under the Tabs and their details are added to complete the software application.
- The biggest advantage of this methodology is that the whole system/software is visualized as a blue print and the details are added to it with the time.
- This helps the user to visualize the entire system and add details to it.
In this model of Software Development Life Cycle, the software is developed in small increments. Each of the increments has the following stages like a Waterfall model, which include:
- Planning and Analysis
- Review and Maintenance
All the above stages of Incremental methodology are performed in the same manner as in the Waterfall model. Each increment moves through the above stages and once an increment is completed, the software moves to another increment.
- This methodology enables developers to prioritize most important features from the business point of view.
- This methodology makes it easier for the developers to visualize smaller increments thereby reducing the risk.
- This methodology needs lesser resources.
The selection of the Software Development Life Cycle (SDLC) model to be used completely depends on multiple factors that include:
- Project Type
- Organizational Culture where the project takes place
Any of the Iterative methods has various benefits over a classical Waterfall method, which includes:
- The running software/system is available much earlier that makes it easier to get immediate feedback from the user of the software/system.
- The large schedule and budget overruns are avoided.
- Smaller teams are required for smaller units of work thus reducing the project overhead.
- The software/system features that are developed in short iterations and deployed immediately offer quick ROI.