Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

How to Become the Sherlock Holmes of Bug Searching: Concentration on the Details

DZone's Guide to

How to Become the Sherlock Holmes of Bug Searching: Concentration on the Details

Concentrate on the details in order to become the Sherlock Holmes of bug searching.

· Performance Zone ·
Free Resource

SignalFx is the only real-time cloud monitoring platform for infrastructure, microservices, and applications. The platform collects metrics and traces across every component in your cloud environment, replacing traditional point tools with a single integrated solution that works across the stack.

If you want to find something, you need to know what exactly you’re looking for. Like detectives, testing experts do a so-called investigation when they are looking for bugs. Each type of bug has its peculiarities. A software tester has to know all of them to recognize the “criminal.” Let’s learn the different types of bugs that often prove to be more challenging to pinpoint.

Functional Bug

We can find this bug while examining all system’s functions and making sure they do what they have to. If the function does something odd, which is not on the requirements list, it is a bug. Let’s see it on the example: there’s a button in the app and it has to open window A, but instead, it opens B or doesn’t open anything at all. It is a functional bug.

This type of bugs is harder to find in case there are no functional requirements. In this case, previous experience with a similar type of software comes in very handy. You can also perform the exploratory testing.

User Interface Bug

UI bugs are easy to find when you have all mockups of the software screens. All you have to do is compare the position, shape, color, and other peculiarities of visual elements with the mockup.

You can also be handed a designs guidelines together with the mockups or instead of them. The guidelines usually describe the styles and additional elements in their different states. For example, how the color of the link changes when it’s in the initial state, in hover, and after the click.

If there’s no documentation at all — don’t worry, you can find most of the UI bugs just by examining the software. Pay attention to the broken layout, overlapping blocks or elements, text that’s coming out of the block, and all the elements that are off the place or missing. You will notice that often UI bugs show up while searching for functional bugs.

Localization Bug

You search for localization bugs only if the software supports several languages and/or is adapted for use in different time zones.

The first thing to check is whether different languages work equally well. The text has to be translated on all elements of the system. Detailed documentation comes in handy, but even if you don’t have it, you can detect bugs anyway. You have to examine all elements after you’ve changed the default language and if you notice some of them haven’t been translated — it is a bug. On this stage, you can also notice UI bugs because words and phrases are of different length in different languages. Thus, the text can stick out of the block or completely break it.

Depending on the type of software, sometimes there’s a need to check whether the time is displayed correctly. Pay attention to the date and time format because it can be different for different countries. Take note of the time indicator, it has to correspond to the country’s timezone. If there’s a currency change option as well, you also need to check if it works fine.

Usability Bug

If software is uncomfortable to use, chances are nobody will like it and it will never get popular, so usability bugs need special attention.

When users can’t find some function for a long time, e.g. registration button, it is definitely a usability bug. Poorly chosen colors are also considered a bug. For example, when you can’t see the text clearly because of the background brightness and your eyes get fatigued from the continuous use of this application. Another widespread issue is buttons with unclear functions: no hints popping-up, no clear icon or button name.

The following bugs are not clearly described in the Internet or books but it doesn’t mean they don’t exist.

Integration Bug

Integration between software components can be implemented not only in complex systems but also in a well-designed website.

If the information is not properly transferred from one component to the other, it is a bug. There can be several examples of such an issue.

Firstly, let’s take a website with a page A with information B, which has to be transferred to the page C. If the information B differs from the one on page C, it is a bug.

Secondly, let’s take a big ERP system where there are lots of integrations between components. Let’s say we create a contract and choose a profile that corresponds to the data in this contract. If there’s a personal profile in the system but it’s not automatically dragged into the contract, it is a bug.

System Update Bug

System updates are an integral part of modern software. They usually contain new functions and important bug fixes, but there also can be bugs in the update process itself. They are quite hard to find but the most common ones usually result in the user losing all the settings or being logged out of the account.

Audio Bug

Not all applications have sounds, but the ones that send notifications or have a sound like one of the main functions have to be thoroughly checked.

The first thing to do is to check whether there’s sound at all. If there is, you need to make sure the quality of this sound is good, without possible interruptions or distortion. Don’t forget to check the volume and whether it corresponds to the required when set on default or turned up or down.

Textures and 3D Objects Bugs

This is a wide-spread bug in MMORPG type of games and other 3D games. Sometimes, it’s hard to find them because they can be visually undistinguished. In order to detect such issues, you have to understand the difference between the texture bug and a 3D object bug.

Let’s take a look at the 3D bugs. For example, your character suddenly disappears after doing some certain action or going to a certain place. It can happen due to the inconsistencies and poor alias of the objects exactly in this state/location. This type of bug can be missed because of the overlaying textures. The other example is when you’re stuck in some place and objects are blocking your way out of there.

Texture is just a picture which is put on the object. If the character can’t go further because of some invisible obstacle, it means it has no texture. Sometimes there’s a texture but it’s not compatible with the object.

Content Bug

Content of the website is usually checked by an editing or copywriting team since they know what exactly has to be written there. However, some content bugs are too obvious to be ignored. It can be a mistake in the title or a company name. Missing pictures and incorrect linking are also considered content bugs.

Finally, let’s take a look at a couple of not-so-obvious software bugs.

Heisenbug

This bug is named after Heisenberg, the uncertainty principle in quantum mechanics. It refers to such type of bugs as the error, which appears when the software is run through the IDE, but when it’s run through the debugger, there’s no error.

Bohrbug

This bug is named after the Bohr atomic model. Unlike Heisenbug, Bohrbug appears under the same conditions each time, but it’s nearly impossible to trace back the whole set of events to find the core of the issue.

Mandelbug

It is named after Benoit Mandelbrot, who’s made huge contributions into the study of fractals. Mandelbug is an error thats cause is so complicated and vague that it seems illogical and unexplainable (exactly “seems”). It can happen because of a slow system reaction. For example, an error has already occurred but you’ll know about that later, which makes it harder to trace the cause of the problem.

Schrödinbug

The bug is named after famous “Schrödinger’s cat” experiment. Imagine there’s a program, and it works just fine. Once you decide to look at the code of this program and you realize it never should have worked in the first place, it stops working until you fix the problem. It seems an impossible thing to happen but in real life, such bugs are quite widespread.

SignalFx is built on a massively scalable streaming architecture that applies advanced predictive analytics for real-time problem detection. With its NoSample™ distributed tracing capabilities, SignalFx reliably monitors all transactions across microservices, accurately identifying all anomalies. And through data-science-powered directed troubleshooting SignalFx guides the operator to find the root cause of issues in seconds.

Topics:
bug ,software bugs ,bug searching ,performance ,how to find bugs

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}