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

 In Quality Assurance
1
186 Views

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 are 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 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, in that 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 of time.

Since we assume that our work may have some mistakes, hence it is our duty to recheck things before taking the final call. Some of the mistakes come from bad assumptions and blind spots, so it might make 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 costliest accident in history

Due to the above-mentioned scenarios, the need of Software Testing increases and now each & every software, before introducing in a real World or to End Users, it 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

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

Where The Defects Arise?

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 Application, due to the following reasons:

  • The person using the software application or product may not have enough knowledge of the product.
  • May be the software is used in the incorrect way which leads to the defects.
  • The developers may have coded 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

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

Bug life cycle includes 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 state, the developer has started analyzing the logged bug and working to fix it.
  4. Fixed: When a developer makes necessary changes in the code and verifies the changes, then the developer can make bug status as ‘Fixed’ and the bug is passed to 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 testers 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 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, he/she changes 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 next releases, its know 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 very necessary as nothing is bug-free and by proper testing and proper documentation, we can reduce the Bug percentage. Afterall as said by Steve Maguire, “Don’t fix bugs later; fix them now”!
Recommended Posts

Start typing and press Enter to search