Software Development Life Cycle (SDLC) and Software Test Life Cycle (STLC) in Agile/Scrum Development Approach.

Software development is difficult and risky as it can result in cost overruns, schedule slippages, low product quality, and project cancellation for non-viability. The maintenance of tighter development models such as the widespread Waterfall is threatened by innovative and more flexible models. Agile/Scrum Development is an iterative and incremental approach to software development which provides a good insight into the project management since it focuses on the customers and facilitates the coordination and optimization of project resources.

Agile/Scrum development enables faster deliveries as overall planning is short, performing complete cycles of planning, development, and testing with new features. Agile principles encourage practitioners to jointly create an ideal flow for continuous updates, with the ability to adapt to market changes. It is not only a development methodology, but also an operational culture that makes the work environment faster and more effective. As the customer has the possibility to see the result earlier in the first iteration, it is possible that planning changes are less impacting than they occur in the Waterfall development. In addition, the feedback given in each iteration serves as valuable input to the team for the next iterations. Another advantage that stands out is the communication among developers and managers is greatly improved.

The Agile Manifesto

From the Manifesto for Agile Software Development in 2001, software development methods became known by the term Agile. This manifesto marked the beginning of agile practices and became the basis for all existing practices, techniques, and frameworks.

In general, the Agile Manifesto proposes:

  • Individuals and interactions rather than processes and tools;
  • Running software rather than comprehensive documentation;
  • Client collaboration rather than contract negotiation;
  • Quick responses rather than following a plan.

Since then, several emerging solutions have implemented the concepts of Agile Manifesto. Scrum is not in itself a development methodology, but it is a framework in which product owners work with stakeholders to divide and prioritize the product backlog into the sprint backlogs with well-defined user stories in order to deliver products with high quality and on a tight schedule.

Among the various aspects that differentiate the Agile Development from Waterfall development, we can highlight the software development life cycle (SDLC). Waterfall planning is on a release basis whereas Agile/Scrum backlogs are planned at the sprint levels which roll up to the release level for deployment to production.  

SDLC and Agile/Scrum Development Approach

The SDLC includes the project phases, processes and norms that will facilitate the predictability and, mainly, measure the productivity of the development team.

Each SDLC phase has a set of specified and complementary activities to address the requirements allotted to that phase in the implementation of a software project.

These phases are:

  • Project start-up phase
  • Project planning phase
  • Project execution phase
  • Project closure phase

The Agile Development Life Cycle is similar to the others:

  • Define what the client wants and start the project
  • Plan the project and estimate the level of effort
  • Execute the plan and build the solution
  • Monitor results and deliver products to the customer
  • Faster cycles, run multiple times
  • Planning improves agility. Agility gives efficiency to planning.

Regardless of the development methodology, one of the most recurrent problems in software development is the high incidence of defects. Defective software causes:

  • Slow development: when a bug or problem is reported, the developer spends a lot of time debugging the code to find out where the defect is and then to fix it. In addition, the developer who wrote the functionality is not always responsible for correcting their defects.
  • Side effects: often, correcting a defect introduces other side effects. This is due to several factors, such as: lack of developer experience, lack of architecture in the software, lack of organization in the company's work processes, very tight deadlines, among others.
  • High costs: defects in software found in production have a correction cost higher than the defects found during the development cycle.

In the previous section of this article, it was mentioned that the test activities are part of the software development life cycle, but there is a specific life cycle for testing, the STLC, that defines a series of tasks regarding software testing activities to guarantee the software quality. Those activities can vary for each software development methodology, but in the agile development approach, the testing activities are part of the development process; the tester role is assigned among the agile development team, and the testing tasks must be planned during the iteration planning.

The testers provide an additional line of defense to detect defects early. In addition, the testers perform tests that are typically skipped by users and developers, such as performance, usability, security, and so on. It is important to highlight the importance of the tester in agile teams in helping the developers to do the root case analysis of problems, simulating scenarios to recreate the bugs, in order to promote improvement and continuous learning.

There are some tasks regarding the STLC that can be planned and executed by the tester in agile development iterations:

  • Planning: it is very important to make a good and efficient software test planning, including the test cases for each backlog item that will be developed and the test environment setup. Both test cases development and test environment setup are subsets of the test planning phase.
    • Preparation: before starting the tests, it is needed to have the environment ready for tests execution.
    • Specification: create step-by-step test cases that are easy for execution by any team members.
  • Execution: execute test cases.
  • Issue recording/retesting: record and retest issues that are detected during the test case execution.
  • Reporting: report the final results upon the test completion.

It is important to note that those activities listed above are independent of the development methodology being used, whether it is agile or not, and are always inside any SDLC.

In the Agile/Scrum perspective, testing is a parallel task and intrinsic to all the development stages, it is the task closely linked to the act of programming. Through the practice called Test-Driven Development (TDD), the developer writes the test scripts before writing the code that implements the functionality.

The TDD has become one of the most popular practices among Agile/Scrum developers as its goal is to help developers write code that works. n. In addition, many developers also claim that the TDD guides them in designing system classes.

In this philosophy, the developer is induced to first think about the rules and constraints of the functionality to then map those rules and constraints on unit tests. Then the developer writes the code of the functionality to meet the expected behavior that is determined by the tests.

 The TDD practice adds many benefits to the development process. The product quality is assured. The execution of automated tests gives more security to the developer at any time during the development life cycle.

In addition to the unit tests written by the developers, it is important to include other types of tests inside the development life cycle.

  • Integration Tests ensure that one or more combined components (or units) will work.
  • Regression Tests are required when changes are made to a system as they verify that existing functionalities are not adversely impacted by the changes.
  • Performance Tests check if the response time is the desired time for the application to be used.
  • Release-Level Tests include all iteration/sprint backlogs to be released to production since each sprint backlog is just a potentially shippable product.