An Explanation To Causes Of Defects In Software And Its Life Cycle

Welcome to the world of technologies created and nurtured by us only. With Smartphone by your side, iPod on your right, laptop on your left, and many other things including USB-gadgets, headphones, medical gadgets, etc. located in some corner or the other of your room, we are experiencing technology in every way possible.

And let me clear that technology is not all about gadgets, but it is also about creating desired software to make your gadgets work the way you want. Without the development of required software, it is impossible to proceed ahead with that technology!

So, now we are quite clear about the Software and its Quality. As stated above that the Software which we use is developed by us (Developers), hence it cannot be regarded as an automated process. No one is perfect, so there are possibilities of having issues from the developer’s end. The possibility of Defects introduced can just happen because of the following reasons:

  1. Miscommunication or no communication,
  2. Software complexity,
  3. Programming errors,
  4. Changing requirements,
  5. Time pressures,
  6. Poorly documented code,
  7. Software development tools,
  8. Obsolete automation scripts.

So, for the above reasons, we need to verify the Quality of developed applications. And, before verifying it, we have to understand about the ‘Software Testing‘.

Software Testing – Introduction

The process of executing programs or applications with the intent of finding the bugs is commonly known as Software Testing. We can also define it as an activity to check or compare whether the actual result matches the expected result or not or to ensure that the Software System is Defect Free.

It also helps to identify errors, gaps, or missing requirements contrary to the actual requirements.

For more details about Software Testing, you can refer to SOFTWARE TESTING: A BRIEF GUIDE.

Necessity Of Software Testing

Now, it’s time to understand the necessity of Software Testing. As we all make mistakes, some of those mistakes are unimportant, but some of them are expensive or dangerous. So for this, we need to check everything and anything we produce because there is a risk of making mistakes at any point in time.

Since we assume that our work may have some mistakes, it is our duty to recheck things before taking the final call. Some of the mistakes come from bad assumptions and blind spots, so we could make the same mistakes on rechecking. Hence, we may not notice the flaws in what we have done.

Software Testing is very important nowadays because software bugs could be expensive or may even prove dangerous. Software bugs or issues can potentially cause monetary and human loss, history is full of such examples.

  • In the year 2015 fighter plane F-35 fell victim to a software bug, making it unable to detect targets correctly.
  • Taking 264 innocent lives, “China Airlines Airbus A300” crashed due to a software bug on April 26, 1994.
  • In April ’99, a software bug caused the failure of a $1.2 billion military satellite launch, the most expensive accident in history

Due to the above-mentioned scenarios, the need for Software Testing increases, and now each & every software, before introducing in a real World or to End Users, is first being tested by Quality Analyst, who prepared their Test cases on the behalf of  Requirements and they verify it by executing the Software.


defect is a bug or an error created in the application. A programmer, while designing and building the software, can make mistakes or errors. These errors mean that there are flaws in the software. These are called defects.

Where The Defects Arise?

Where The Defects Arise - Cost to fix a bug at different stages

Defects and failures basically arise from:

  • Errors in the specification, design, and implementation of the software and system,
  • Errors in use of the system,
  • Environmental conditions,
  • Intentional damage,
  • Potential consequences of earlier errors.

When The Defects Arise?

The defects arise in Software or an Application due to the following reasons:

  • The person using the software application or product may not have enough knowledge of the product.
  • It might be that the software is used in the incorrect way which leads to the defects.
  • The developers may have coded it incorrectly, and there can be defects present in the design.
  • Incorrect setup of the testing environments.

Now, when the defects arise in the Software, it might be due to any reason, but being a developer, they have to fix it. So, the cost of fixing that bug might be more if that defects found at the end. Now if the error is made and the consequent defect is detected in the requirements phase then it is relatively cheap to fix it and if the system has been implemented then it will be much more expensive to fix that bug.

Bug Life Cycle In Software Testing

The defect life cycle defines as the cycle in which a defect goes through during its lifetime. The defect life cycle is related to the bug found during the testing phase.

Bug Life Cycle In Software Testing

The bug life cycle includes the following steps:

  1. Assigned: After the tester posted the bug, the lead of the tester approves that the bug is genuine and he assigns the bug to the corresponding developer and the developer team. It’s state given as assigned.
  2. New: When a defect is logged and posted for the first time. Its state is given as new.
  3. Open: At this stage, the developer has started analyzing the logged bug and is working to fix it.
  4. Fixed: When a developer makes the necessary changes in the code and verifies the changes, then the developer can make bug status as ‘Fixed’, and the bug is passed to the testing team for testing that module.
  5. Pending retest: After fixing the defect by the developer, then they give that particular code for retesting to the Testing team. So due to this, the testing is pending on the tester’s end.
  6. Retest: At this stage, the tester does the retesting of the code which has been changed due to the fixing of bugs.
  7. Verified: When the bug is not present in the software, he approves that the bug is fixed and changes the status to “verified”.
  8. Reopen: After fixing the bug by the Developer, if the bug still exists, then the tester changes the status to “reopened”.
  9. Closed: If according to the tester that the bug no longer exists in the software, they change the status of the bug to “Closed”. This means that the bug is fixed, tested, and approved.
  10. Duplicate: When a bug is repeated twice or the two bugs mention the same concept of the bug, then one bug status is changed to “duplicate”.
  11. Rejected: In case the developer feels that the bug is not genuine, he rejects the bug. Then the state of the bug is changed to “rejected”.
  12. Deferred: When the bug is expected to be fixed in the next releases, it’s known as Deferred State.
  13. Not a bug: The statement given “Not a bug” if there is no change in the functionality of the application.

Concluding Here

Software testing is critical as nothing is bug-free. By proper testing and proper documentation, we can reduce the Bug percentage. After all, as said by Steve Maguire, “Don’t fix bugs later; fix them now”!
Follow me!

1 thought on “An Explanation To Causes Of Defects In Software And Its Life Cycle”

  1. Nice post. I am following your post for some time now. I have to say you provide detailed knowledge in all your posts. I would love to hear similar post about data recovery niche. I am working in this niche. You can check my work here


Leave a Comment