SHARE THIS POST

For a tester, the failure to report a bug/defect isn’t a good. Yet, it may not be the tester who’s entirely to blame since several other factors can lead to defects leaking into production. Here are the top ten reasons.

1. Communication problems: Miscommunication or lack of communication during various stages of the software development process (right from requirement gathering to its interpretation/documentation or translation stage) can make defects go unnoticed and/or unreported.
2. Human errors: Humans are prone to errors and quite naturally, expecting the products they develop to be flawless and without errors/defects would be foolish. That explains why bugs/defects may creep up in software. But despite the possibility of human-induced errors, humans still continue to develop a better product than any other non-human agent. So, unless we find one that can do the job better than humans, we need to rely on human intelligence and thus risk the chance of errors.
3. Impractical development timeframe: Insufficient or limited resources, unrealistic release schedules, and project deadlines – software developers often have to face some or all of them. As a result, they probably have to make certain compromises (such as not investing adequate time for designing, not testing their code giving it to the testing team etc), which can increase the chances of bugs/errors. Design/feature changes at a much later stage of the SDLC too can boost the chances of errors.
4. Faulty design logic: As software applications are getting increasingly complicated, some level of brainstorming as well as R&D is needed to arrive at a reliable solution. Yet, the strong desire to get the job completed at the earliest, lack of patience, faulty application of technology (products, components, techniques etc), improper understanding of the technical viability before designing the architecture, the need/temptation to take the fastest and easiest route to implement a solution etc – all can make errors/bugs to creep in.
5. Bad coding: This involves bad coding practices such as unhandled errors, missing exceptions, and faulty validations of inputs together with the use of bad tools (such as like faulty compilers, debuggers, validators etc. that some programmers are using) – all of which can invite errors in the code, which may be too tricky to debug. At times, it could just be the case of bad coding that causes errors to slip into the code.
6. Absence of version control: In case you continue to face lots of regression bugs that keep occurring at regular intervals, you should check the version control system (if there’s any). With concurrent version systems, you can keep track of all changes in a set of code base. If there’s a complete lack of a version control system, you are likely to encounter lots of regression errors. However, errors may still occur in the final builds despite having a version control system in case the programmers fail to ensure that the most current version of every module is linked when they create a new version to be tested.
7. Third-party tools containing bugs: Third-party tools such as debuggers, HTML editors, shared DLLs, add-ons/plug-ins to save time (map navigation API, shopping cart plug-in etc) are often needed during software development but may have bugs in them that pass onto your software.
8. Lack of skilled testing: In several companies, poor testing is often the norm, which may include scarcity of skilled testers, shortcomings in the testing process that’s followed, testing being taken lightly, and the process getting conducted without giving it much importance etc. All of these can cause bugs/errors to creep into the software.
9. Excessive dependability on automation testing: Since automation testing lacks human intuition and experience, being excessively dependent on it may make a manual tester miss a bug/defect. It’s important to remember that for successful automation testing, you need experienced testers along with good management.
10. Last-minute changes: Just before a product release, changes made to the infrastructure, requirement, tools, platform etc can be dangerous. Actions such as testing the compatibility of your software across a variety of browsers and operating systems, database migration etc are complex things and if done in a hurry (due to a last-minute change), they may introduce bugs/ errors in the software/application.

You may add some more bugs/errors to this list that you’ve come across while testing a software.