In this article, we will be moving forward with the software development models and thereafter, we will be looking into the software testing life cycle(STLC).
Before learning about software development models, let’s understand what is software development life cycle (SDLC).
What is Software Development Life Cycle(SDLC)
The development process adopted in every project is according to its aims and goals. There are different life cycle models designed to fulfill each requirement.
The development model chosen for a particular product has a big impact on the testing process. The life cycle below describes the software development life cycle (SDLC).
We need to understand what happens in each phase of the development life cycle and why these phases are important.
There are six phases in the software development life cycle (SDLC)
- Requirements Gathering: Requirements gathering is the most important phase for any of the software development life cycles. Top-level management like project managers, stakeholders, & directors collect the requirements and have a meeting on what needs to be done. They analyze the requirement and validate it. Finally, a requirement-specific document has been made, and then it goes to the developers and testers. Developers and testers do the requirement analysis and move onto the next phase.
- Design: This phase comes after the requirement analysis phase where a system design has been made which justifies the requirement. System design is an important phase as it makes the implementation a lot easier.
- Development/Implementation: Actual coding gets started in this phase to meet the design specifications and the requirement specification. The design which has been made in the earlier phase gets implemented in this phase.
- Testing: After the development, the software goes under test, and testing is done to verify whether the software under test is meeting the requirement specification or not. The main focus of this phase is to ensure quality and finding defects.
- Deployment: Once testing is done, the product is ready for deployment. In this phase, the product is deployed after ensuring that it meets the requirement specifications. The software undergoes deployment at the client’s side and beta testing is performed to ensure the software is meeting the user’s requirement.
- Maintenance: Once the customer starts using the software, the issues fixed, support given and the needs to be solved come under the maintenance phase. The software deployed is taken care of according to the needs after deployment.
There are various software development models designed based on their sequence of phases. The most common type of the development models we are going to discuss here. These models are:
- Waterfall Model
- V Model
- Prototype Model
- Spiral Model
- Agile Model
Now, that we know about the popular models, let’s look into it one by one.
This model is in a linear sequential manner. This development model involves executing each phase and then going into the next phase.
- Suitable for small and mid-size products with fixed requirements.
- Easy to determine the critical points in each phase.
- Best when there are enough resources.
- Testing happens at the end of the project, so the defects tracked are close to the implementation.
- Not suitable for the projects having frequent changes in requirements.
- Resources have to sit idle and wait for the phases to complete. For example, if the project is in the development phase, then testers have to sit idle and wait for the development phase to complete.
- Backtracking is not possible as requirements are constant.
As the name suggests, the testing and development life cycle run parallel, the one side of V is verification (development) and the other side is validation (verification). Hence this is also called the Verification and Validation model as well.
This model is an extension of the waterfall model, the only difference is that the process steps are bent upwards after the coding phase, to form a typical V shape.
- Designed for small and medium-sized projects.
- Better than waterfall model as it allows to test the software side by side.
- V-model provides guidance that testing needs to begin as early as possible.
- It has four Test levels- component, integration, system, and acceptance testing.
- Defect tracking is easy.
- Lack of flexibility.
- Changing requirements at the later phase could cost high.
- High business and development risk.
It is a smart and practical approach of SDLC, where a prototype is being made and implemented prior to the final product.
The prototype may not have the exact logic of the targeted product, but it matches the product's functionality and visualization.
- Recommended to projects with uncertain requirements.
- Easy to track bugs.
- Prototyping makes it easier to visualize the final product.
- Quick implementation and completion.
- Fewer investments.
- Dependency on the prototype is risky.
- Additional time is spent in testing the prototype as well.
- If one prototype goes wrong, so another has to be built, takes time, delays project.
- Consumes more time and money for building prototypes.
As the name suggests, it is a method where the model is designed and built incrementally until the product is finished. This model combines the philosophy of the waterfall model and the iterative model. In this development model, development and maintenance go side by side. Each iteration passes through requirements, design, coding, and testing phases.
- Feedback from one phase provides information for next phase
- Very useful when more staffing is unavailable.
- Divides project into smaller parts and finishes off project early.
- Communication and coordination is required in every step for changes made.
- Informal requests for improvement of each phase may lead to confusion.
Initially, the first version of the product has been developed according to the product specifications and if the requirement comes, then the newer versions will be deployed with the new set of iterations. Every release of an iterative model finishes in exact period of time, called iteration, hence the name iterative model.
- More flexible than the waterfall model.
- Testing and debugging are easy.
- Resolves risks before implementation.
- Rework takes place from one iteration to the next iteration
- Parallel activities may lead to misconceptions and miscommunications.
Rapid application development (RAD) model is an adaptive software development model which adapts features of both prototyping and iterative models. It focuses more on implementation and less on documentation.
- Encourages user feedback.
- Reduced development time.
- Integration from early stages leads to lesser issues.
- Higher customer satisfaction.
- Suitable for projects with short deadlines.
- Less focus on documentation, hence unstructured.
- High dependency on modeling skills.
The Spiral development model is iterative and contains the phases of the waterfall model.
This model supports risk handling and the project is delivered in loops. Each loop of the spiral is called a phase of the software development model.
- Testing several times gives a bug-free product.
- Issues and risks are more likely to be recognized in the early stages.
- The flexibility allows you to make changes till the last implementations.
- The model is a bit costlier.
- Consumes more time to test repeated tasks all over again.
- It may not be sufficient for smaller projects.
To overcome the disadvantages of the waterfall model in terms changing of the requirements, the agile model came into the picture. The agile model operates in rapid and small cycles. This results in more frequent incremental releases with each release building on previous functionality. Thorough testing is done to ensure the quality of the product.
- Encourages change and minimizes the risk.
- Require less time to deliver specific features.
- Customer’s and stakeholder’s involvement at each stage benefits to fulfill their needs.
- Not suitable for large-sized projects.
- Challenges in estimating the cost due to changes.
- New requirement implementation can be tricky.
This is about the types of software development models we have learned till now. Moving onto the next topic, Let’s learn about the testing life cycle (software testing life cycle).
In the world of software, the testing process is formally called the software development life cycle (STLC)
What is Software Testing Life Cycle(STLC)
Testing is an important part of any production process. Before the product is used by the customer, testing is done to find the defects and deliver a quality product.
Software testing life cycle is the whole process of how testing is performed, and what are the phases involved. Software testing life cycle involves several phases which are required in the entire testing process.
The testing life cycle consists of six phases as follows:
- Requirement analysis
- Test planning
- Test case development
- Test environment setup
- Test Execution
- Test cycle closure.
These phases are very important in the testing process and each phase has its own role to play. Starting from requirement analysis, moving onto test planning, test case preparation, and test execution, every step has a motive to serve.
Let’s look at each phase one by one and understand why testing life cycle is important.
- Requirements Analysis: This phase is the same as the requirements phase in the software development life cycle. The requirement documents are reviewed and then made sure that the deliverable product meets the requirement. The testing is not only done to find the bugs but also ensures the quality of the software as well.
- A requirement is a document specifying the functional and non-functional requirements.
- In this phase the requirement specifications are reviewed and then the planning has been made in the planning phase. Here, reviewing and analyzing the requirement specification document is important because any misinterpretation can lead to a defect which can cost in later stages.
- Planning: After the requirement analysis is done, we will proceed to the test planning phase. It is an important stage as the test plan is made in this phase.
- Test Plan is a document describing the approach, resources, and scheduling of the testing activities.
- Risks and costs of the testing process are estimated in this phase. Every little detail is planned in this phase that how testing is going to be done, what resources are required, and where and when we need to perform the testing processes.
- Test Case Development: After the test planning is done, the test cases are developed. Test cases are nothing but scenarios specifying the functional and non-functional specifications of the product.
- A test case is a set of conditions for evaluating a particular feature of a software product to determine its compliance with the business requirements.
- A test scenario is generally a one-line statement describing a feature of the application to be tested.
- Test Environment Setup: After the test cases are developed, now it’s time to set up the environment feasible for testing. It is an important step to ensure that the environment in which the software being tested matches the environment where the product will deploy.
- A test environment is a set of hardware and software that are required for an application to function.
- A key step of this phase is smoke tests, which verifies that the environment is ready. The smoke test mainly tests the main functionalities of a product.
Once it is confirmed that the environment is set up, we will move onto the next phase to carry out test execution.
- Test Execution: After the test environment is set up and the smoke tests were run to validate the environment, this phase is about executing the test cases developed in the test case development phase.
- Test cases are executed to ensure that the requirement is met.
- There are two ways of execution: manual and automated execution of test cases. Either a test case passes or fails after the execution is done. Pass or fail is the status for a test case, a test case passes if it meets the requirements and fails vice-versa.
- Test Cycle Closure: When the test execution is done, the report is generated for the closure of the life cycle.
A test closure report is a document that evaluates the entire process and all the phases of software testing.
The report analyzes the basis of objectives, time, cost, coverage, and the number of defects identified. When an STLC process comes to an end, the closure reports are prepared and a conclusion is given for the entire process.
Now, that we know about the software development life cycle and the software testing life cycle, let’s look what is the difference between these two.
These are not very different from each other but there’s a slight difference.
Difference between SDLC vs. STLC
The software development life cycle is the process of the overall software development process beginning from requirements gathering to the deployment and the maintenance of the product.
Testing is a phase of the development life cycle and the processes involved in the testing comes under the software testing life cycle.
So far, we learned about the software development life cycle and the software testing life cycle. Now, let’s summarize everything we learned in this section:
- Software development life cycle
- Types of software development models
- Software testing life cycle
- SDLC vs. STLC