Understanding SDLC - Software Development Life Cycle

One of the essential knowledge areas for a professional software tester is understanding and mastering the SDLC (Software Development Life Cycle), as software testing is an integral and closely related part of it.

The Software Development Life Cycle (SDLC) is a process followed for a software project within a software organization. It includes a detailed plan describing how to develop, maintain, change, or upgrade specific software.

The process is an extremely important factor in ensuring the success of software manufacturers, as it enables all project members, both within and outside the company, to synchronize their work according to the company's common approach, or at least at the project level.

In practice, companies building and developing software may adjust, combine, or separate stages according to the practical needs of the company. However, to create a software product, it will typically involve the following stages:

1. Requirement Phase In this phase, the requirement analysis department will meet with and discuss with the customer, as well as clarify the functions and requirements that the customer wishes to build into their software. This is a crucial phase that influences the construction and development of software in the future. Therefore, the requirement analysis team is usually composed of experienced individuals who can clarify and understand the customer's problem requirements, as well as collect relevant project information to serve the analysis in the next stage.
   

2. Specification Phase After recording the customer's requirements, the analysis department will clarify these requirements and operationalize them into a document called the Software Requirement Specification (SRS). This document is vital for the software development process as it includes all the product requirements designed and developed throughout the project lifecycle. Related departments such as programming and testing will work based on the detailed function descriptions in the document, aiming to answer the question "What will the software do?"

3. Design Phase In this phase, based on the specification document, the design department will design a general interface, and the programming department will design detailed interfaces for each function of the software. This means realizing the functions in the specification document into prototype functional software interfaces. Then, using this software framework to discuss and agree with the customer on the interface, layout. Once the customer agrees to the software design according to that prototype, it will move on to the next phase; otherwise, feedback will be noted and adjustments made until the customer agrees with the software prototype.

4. Programming Phase In this stage, the SDLC begins actual development, and the product is built. The programming phase is about realizing the functions of the software after the customer has approved the software prototype. Here, developers will code to implement the function, modules as required, and then hand them over to testers to test the functions according to the test cases built based on the specification document.

5. Testing Phase In this phase, testers will receive the delivered functions from developers. Then, they will test these functions according to the test cases developed. During the testing process based on the test cases, if errors occur, testers will report bugs for developers to fix those function errors.

The process of function testing, rechecking, bug reporting, and reporting will be repeated until the programmed functions are correctly implemented according to the specification document or customer requirements.

After completing the functions and meeting the testing requirements, the software will be deployed for testing in the customer's environment. If there are any requests for modifications, the software development team will make additions, fix bugs to enable software acceptance testing.

1. Deployment and Maintenance Phase Once the product has been tested and ready for deployment, it will be officially released to the appropriate market. Sometimes, product deployment may occur in stages according to the organization's business strategy. During the customer's software usage process, the software development company will have to support and handle any errors that arise during usage. Here, there are two concepts to note:

• Software repair: Fixing errors that occur during the customer's software usage.

• Software update: Maintenance completion and maintenance adaptation: Modifying the software according to the customer's requirements, Maintenance adaptation: Modifying the software to adapt to a new environment.

SDLC (Software Development Life Cycle) Models

There are many software development life cycle models identified and designed to follow in the software development process. These models are called software development process models. Each process model follows steps for its type to ensure success in the software development process. Here are the most important and popular SDLC models:

1. Waterfall Model

This model consists of sequential processing stages as follows:

• Requirements and Specifications Analysis: This stage determines the functional and non-functional requirements that the software system needs. It requires active participation from the customer and ends with a document called the "Software Requirement Specification" or SRS. The requirements specification document is the basis for subsequent activities until the end of the project.

• System Analysis and Design: This stage determines how the software system will meet the requirements specified in the SRS document.

• Coding and Unit Testing: This stage implements what is outlined in the "System Analysis and Design" stage.

• Testing: Includes integration testing for component groups and system-level testing. A final testing step typically performed is acceptance testing, with customer participation to determine if the software system meets their requirements.

• Deployment and Maintenance: This stage involves installation, configuration, and training for customers. This stage also addresses software bugs (if any) and develops new changes requested by the customer (such as modifications, additions, or deletions of system functions/features).
  

2. V-Model

In the Waterfall model, testing is performed in a separate phase. With the V-Model, the entire process is divided into two corresponding sets of development and testing stages. Each development stage is combined with a corresponding testing stage.

The main principle of the V-model is that testing activities must be conducted in parallel (as much as possible) from the beginning of the cycle alongside development activities. For example, planning for system-wide testing activities can be carried out in parallel with system analysis and design activities.

3. Spiral Model

In the spiral model, the software development process is carried out like a spiral coil. Each spiral loop represents an activity in the software development process.

• It is based on the idea of minimizing risk by analyzing risk factors at each iteration and using prototype methods. The development process is divided into multiple iterative steps, each starting with planning, risk analysis, then creating a prototype, completing and developing the system, reviewing, and continuing. It includes four main activities:

• Planning: Setting goals, solutions, and constraints.

• Risk Analysis: Analyzing options, identifying and mitigating risks.

• Development and Verification: Developing the "next level" product. Building one or more representations of the application.

• Planning for the next iteration: reviewing all results of previous sub-stages and planning for the next iteration.

With each spiral loop (starting from the center), versions are gradually completed. At a spiral loop, risk analysis must come to a decision to "continue or stop." If the risk is too high, the project may be suspended or requirements changed appropriately. This model is suitable for developing large-scale systems.

2. Agile Model: Scrum Process

A Sprint is a small cycle to develop a product. In the Sprint, the project team will focus on developing specific functions and completing them at the end of each sprint. Each Sprint has a fixed time, usually 1 or 2 weeks and usually no more than 4 weeks.

Before the entire team performs the sprints, the production team meets with the Product Owner to plan each Sprint (called Sprint Planning). The result of the planning session (in the Scrum manner) is the Sprint Backlog containing the tasks to be done throughout a Sprint.

Throughout the development process, the team will need to update the Sprint Backlog and hold daily meetings (Daily Scrum) to share progress and address any challenges in the collaboration process. The team is empowered to self-manage and organize their work to complete tasks within the Sprint.

The Sprint Review Meeting at the end of the Sprint will allow the customer to see what the team has been able to deliver, what needs to be done, or what needs to be changed or improved. After evaluating the Sprint, the Scrum Master and the team hold a Sprint Retrospective to seek improvements before the next Sprint begins, which helps the team continuously learn and grow through each Sprint.

Sprints will be repeated until all items in the Product Backlog are completed, or until the Product Owner decides to stop the project based on actual circumstances. Due to the constantly evolving process, Scrum teams typically have very high labor productivity. These are two major benefits that Scrum brings to an organization.

Scrum defines rules for four key events (meetings) to create an environment and conventions for the operation and collaboration of project members. These ceremonies take place before the Sprint starts (Sprint Planning), during the Sprint (Daily Scrum), and after the Sprint ends (Sprint Review and Sprint Retrospective).

In Scrum, the development team is divided into three roles with clear responsibilities to ensure optimization of the specific tasks. These roles include the Product Owner, Scrum Master, and Development Team.