Although the powerful insect lobby convinced Disney to portray bugs as cute creatures (see image above), any good programmer knows their mischief and cruelty.
In today’s article, we’ll take a look at the worst foes you might end up facing on the cyber battlefield! Let’s analyze the 5 main types of software defects categorized according to their nature, which are:
- Performance bugs
- Functional bugs
- Usability bugs
- Security bugs
- Compatibility bugs
Later on, we’ll also spend a few words regarding bugs’ severity and priority levels.
1. Performance bugs
Software performance is an essential element in determining its usability and greatly influences users’ perception of the product.
It is mainly related to the stability, speed, or response time of software resources. Any defect that undermines these features falls into the performance bug category.
This type of programming defect causes significant performance degradation and leads to a frustrating user experience, not to mention user abandonment and the potential loss of millions of dollars.
Is the response delay ten times longer than described in the requirements? We are probably facing a performance bug. A really BAD performance bug, I’d say.
Performance bugs hide well
Dealing with performance bugs can be especially tricky. In fact, according to research, fixing performance bugs is generally more difficult than fixing non-performance bugs, even though the two types of fixes are equally prone to errors.
While most non-performance bugs can be detected through observing the negative effects of bugs, a large percentage of performance bugs must be spotted through code reasoning.
Basically, performance bugs usually don’t generate incorrect results or crashes in the program under test. Therefore, they cannot be detected simply by checking the software output.
“According to research, fixing performance bugs is generally more difficult than fixing non-performance bugs, even though the two types of fixes are equally prone to errors.”
Can we fix this issue?
Developers need better tools and greater mastery to spot performance bugs and test patches.
Specifically, the performance bug detection process can be improved with efficient profiling techniques and test oracles, which are mechanisms to decide if the software performance under a certain workload is acceptable.
Unfortunately, the lack of adequate test oracles for this specific task is a well-known problem that will need to be addressed in the future.
2. Functional bugs
Functional bugs affect the functionality of a piece of software.
YOU DON’T SAY?
We are talking about errors that make the software behavior not compliant with the declared functional requirements. This type of defect can be spotted pretty easily through functional tests.
An example of a functional bug could be the non-reaction or the total crush of the program to user input, such as pressing a button.
Another case may concern the search engine of an e-commerce site that does not recognize the product ID but only the name, contrary to what is stated in the specifications.
Is it really a bug?
While functional bugs are generally easier to fix than performance bugs, as explained in the previous paragraph, that doesn’t mean testers always have an easy time.
Especially in the case of an external team, the testers are not 100% aware of the software functionality or its implementation and operation in different scenarios.
Because of that, it may not be so straightforward to determine whether some feature is designed a certain way or if it is actually broken.
For example, if a specific accounting software functionality works in a different way than other similar software, this could be a developers’ precise choice.
How to manage functional bugs
Consider the following situation: testers have noticed that a form field is not validated and think they have found a functional bug. At this point, they should look for any clues that the developers intended to validate the field.
Good evidence of their suspicions would be that the field is validated in some cases but not in others.
To sum up, testing the software under a multitude of different conditions and combining the suspicious feature with other features to spot potential differences can help us clear our minds.
A pair of special cases
Two other peculiar cases that could create doubts on how to deal with the problem are edge case bugs and forced bugs. Edge case bugs only occur when a feature is used in a “weird” way.
Let’s say that you repeatedly opened and closed a menu as fast as you press the buttons for a Tekken combo. Meanwhile, you minimized the app and finally threw your computer out the window. This could trigger an edge case bug (and prove that you need some valium).
Even forced bugs only occur under very specific conditions, such as clicking multiple items simultaneously on your smartphone screen.
These types of defects will occur with extreme rarity and will therefore be treated as low priority or irrelevant bugs.
3. Usability bugs
When an application is more enigmatic and weird than a Jigsaw puzzle, the main reason could be a usability bug. Usability bugs, in fact, undermine the user experience making software over-complicated to use.
We may be dealing with an interface that is difficult to navigate or with a new account registration that is excessively long and frustrating.
Be careful not to confuse functional and usability bugs. For example, if you enter a password that exceeds 10 characters in a text box whose limit is programmed to be 10 characters, this is a functional defect.
But… what if you do the same and the app refuses your password (as expected) without sending a validation message such as “enter a password between 1 and 10 characters”? This could be confusing and therefore falls into the category of usability bugs.