BOOK THIS SPACE FOR AD
ARTICLE ADThe defect life cycle, also known as the bug life cycle, explains the steps a software bug or issue goes through from start to finish. This process helps teams during software development and maintenance to find bugs, document them, prioritize, fix, and keep track of them.
I would like to provide you with information about the defect life cycle. Let’s start with other related definitions.
Defect ⚠️
A “defect” is when software doesn’t do what it should, or acts in unexpected ways. This might be because of errors made while designing the software, during its creation, or even in the instructions on how to use it. Simply put, it’s when something in the software is wrong or missing, making it not work right. A defect stays unnoticed until someone spots and fixes it. Here, the important point is that it arises from the not covering the acceptance criteria of the requirements.
Bug 🐞
A “bug” refers to a particular mistake in the software’s code that stops it from working correctly. It’s tied to the way the software was written. Bugs can make the software act up, skip steps, or do things users don’t want it to. Developers have various ways and tools to find and fix these bugs.
Failure ❌
“Failure” happens when software completely misses on doing something it was supposed to. It means some deeper issue, like a bug or defect, is stopping the system from doing a task it’s meant to, according to users or the design. “Failure” is the term used when such problems are noticed while the software is being used.
Error 🔴
An “error” is a wrong move made by someone making the software. This could be using a bad method, coding mistakes, or not getting what the software should do. The term “error” points to these kinds of mistakes that happen during software creation, which can then lead to bugs.
In summary:
⚠️ Defect: When software doesn’t meet what’s needed or expected by users.
🐞 Bug: A mistake in coding that prevents expected results.
❌ Failure: When software can’t do what it’s supposed to.
🔴 Error: Wrong choices or mistakes by people making the software.
Each environment’s bug lifecycle consists of different steps.
1- In the grooming session, before starting the coding, you need to check if the requirements and acceptance criteria match each other when creating test cases. If a mistake is found at this stage, it can be corrected with a brief meeting, and early detection saves time.
2- In the QA/UAT environment, the steps of the bug lifecycle found during the sprint’s tickets are as follows:
✔️Finding: Someone discovers a bug and reports it for the first time.
✔️Documenting: The bug is recorded with details like where it was found, how to replicate it, the difference between what was expected and what actually happened, and how serious it is.
✔️Checking: The bug is checked to make sure it’s real and to decide how urgent and important it is to fix.
✔️Assigning to Fix: Once the bug is confirmed, it’s given to a developer or team to resolve.
✔️Fixing: The developer works on the bug, changes the code, and then marks the bug as fixed, explaining what was done to correct it.
✔️Testing the Fix: The team tests to make sure the bug is truly fixed and that nothing else was broken in the process.
✔️Closing: After the fix is verified, the bug is closed. If it can’t be fixed right away, it might be postponed or noted for later.
3- When bugs are fixed and the code freeze starts during the sprint, regression testing for the release begins in UAT environment. The bug lifecycle in this process is as follows:
✔️New: Bug is discovered in the software for the first time during the regression testing.
✔️Assigned: After reproducing the bug, the development lead is informed. A decision is made to fix it based on its priority. If it is of very low level, it is moved to the next sprint. If it is of medium or high level, it is assigned to the responsible developer.
✔️Open: The bug is acknowledged and actively being looked into or worked on by the assigned person or team.
✔️Fixed: The developer has made changes to the code that are believed to solve the bug.
✔️Retested: After the fix, the bug is tested again to make sure the problem has been resolved. A sanity test is performed there.
✔️Close: Once the bug is confirmed to be fixed and no longer affects the software, it is officially marked as closed.
4-The bug lifecycle in the production is as follows:
✔️Discovery: Someone using the software or a tool that checks for problems spots a bug in the live setting where people are already using the software.
✔️Reporting: This bug gets reported using a system for tracking bugs or through customer support.
✔️Reproduce: The bug is then looked at for the first time to see how bad it is, how much it affects things, and how quickly it needs to be fixed.
✔️Assignment: After figuring out the bug’s details, it is given to a dev lead or a team that knows how to fix that part of the software.
✔️Fixing: The developer looks into why the bug happened, comes up with a solution, and makes the needed changes to the software.
✔️Testing: Before the fix is put into the real software that everyone uses, it’s tested a lot in a separate setting to make sure it really fixes the bug and doesn’t cause new problems.
✔️Deployment: Once it’s clear the fix works and is safe, it’s added to the real, live software during a planned update.
✔️Verification: After the update, testers or the person who first reported the bug check to make sure the bug is truly fixed in the live software.
➖Find the Bug: People using the app and automated error checks showed there was a problem with logging into a mobile banking app.
➖Reproduce: The QA team tried logging in different ways and found out the problem happened with certain usernames and password lengths.
➖Assigned: They gave the problem to a coder who knows a lot about keeping mobile apps safe and how they check who you are when you log in.
➖Open: The problem was detailed and added to the app’s system for keeping track of bugs.
➖Fixed: The coder found the issue was because of a mistake in how the app checks if you’re allowed in. They made a fix to correctly deal with all the different ways people might enter their information.
➖Retested: They checked the app again, especially the part where you log in, to make sure the fix worked and didn’t mess up anything else.
➖Close: With the login functionality confirmed to be working correctly across all scenarios, the bug status was updated to closed.