Software Development Life Cycle and its Phases

What is SDLC?

Software Development Life Cycle (SDLC) is the series of stages that software must undergo from its conceptualization (inception) to running smoothly. It consists of all the stages that are required to ensure that a useful and robust software product is developed, and involves processes that are cost-effective and trackable.
‍

Phases of SDLC

The SDLC consists of logically ordered phases as follows:

1. Feasibility Study:

This stage is very important. Once a business proposal has been accepted, it is important to define the scope of the project. Cost versus benefits analysis, effective resource utilization, workability, and matching of customer requirements need to be done to ascertain the Return on Investment (ROI). The findings of this study are submitted to the top management, which helps them decide whether to go ahead with the project. The project initiation, planning (scheduling, budgeting) occur during this phase. It is often useful to list down the top-level business requirements during this phase as a reference guide for the later phases, as well as to get better data for the actual feasibility of the project.

2. Requirements Gathering and Analysis:

This is where the details of the top-level business requirements are described. In addition to user-specified fundamental requirements, derived and implicit requirements also need to be identified. This stage is important to clarify the expectations of the customer to the development team. This entails detailed discussions with system architects, project leads, and end-users/clients. The requirements need to be documented in such a format that the design team can pick it up smoothly. Often use-case analysis is done to depict the scenario-based mapping of requirements to the corresponding behavior of the system.

3. Design:

System architects, lead developers, and technical heads map the requirement specifications into detailed design. Often there are two stages of this phase – HLD (High-Level Design) and LLD (Low-Level Design). Techniques such as DFDs (Data Flow Diagrams), data dictionaries, flowcharts, decision trees, alternative design strategy analyses are often used. The required hardware and development software platform, programming language, staffing, and skill requirements for project development are identified. Inputs, outputs, databases, data structures, interfaces, documentation, and software control process are specified. Risk analysis is also done to an extent in this phase.

4. Coding and Unit Testing (CUT):

This stage involves the actual construction of working bits of software as per the design by the developers, using the software and hardware platforms in the coding language specified by the system designers. The code developed by the team is also unit tested to ensure that any local errors are detected and removed. The coded programs control the movement of data as defined in the design.

At times, the developer may have to work in close coordination with the design or even the requirement team and there may be rework required at all the stages in case the results of UT suggest a deviation from the expectations. Code should be modular in nature and should generally be future expandable to avoid major rework in a subsequent upgrade. Test cases should be written independent of the coding, following a guided test plan for maximum efficiency. Bugs caught in the UT stage are more cost-effective to fix than those found in later stages.

5. Integration and System Testing:

The modules delivered from the CUT stage are brought together and their interfaces tested, along with the behavior of the integrated software. Various levels of testing can be done at this stage. Interface testing could check the flow of information across the interfaces between the modules. Pair-Wise-Integration (PWI) involves validating the cohesive behavior of two interacting modules.

System integration entails bringing all the modules together in the test environment and testing the entire system. Good test plans and various expert skills are needed to conduct different levels of testing. The input to test plans is usually the requirement specification and design deliverables, to keep it independent of the coding perspective. Errors found are documented and sent back to developers, designers, or requirement teams to fix, depending upon where the origin of the error may be found. Updated software is re-tested and test reports prepared.

6. Implementation (Deployment/Migration):

Once the system is found free of errors, it is ready to be migrated to the customer site. This may require customer acceptance testing before actual deployment can begin. User documentation is a crucial deliverable for this phase. Training the users and IT personnel may be a part of this stage. The software may be rolled out in a systematic way, adding sites incrementally. The process of changeover from the old system to a new one that is operating smoothly marks the end of this stage.

7. Maintenance and Updating:

Once a system is deployed, it needs to be maintained well. This shall ensure smooth working in the real-time environment. Any errors found during the functioning of the software must be fixed. Any future enhancement and additional features need to be developed during this phase. It is of paramount importance that any changes made to a running system do not impact the performance of the system. Software maintenance is essential as long it is running till it faces replacement or obsoleteness and eventually retires.

8. Closure:

Once the software has been developed, it is good to have a formal closure, mostly after the major functionality of the project has been implemented. At this stage, it is important to have brainstormed to note down the lessons learned from the project, which could serve as valuable input in future projects. Unfortunately, this stage is often skipped as it is not mandatory and organizations often fail to learn from past mistakes. As a result, the foresight to avoid follies that could have saved cost and time is lost.
‍

SDLC Models

Two models of SDLC are popular – Waterfall and Agile:

1. The Waterfall model is highly formal and structured, requiring each phase to be executed thoroughly before proceeding to the next stage. Large software projects work well with this approach as many stakeholders are involved to make a complex system.
2. The agile system is more flexible, allowing stages to overlap, and is quite iterative in nature. Very small pieces of functionality are usually developed using the Agile method, where continuous improvement is the prime focus.
   ‍

In conclusion, SDLC is a key factor to ensure quality software is developed in a controlled environment that meets the expectations of the customer.