Understanding Types of Software Bugs

Types of bugs

There are many different ways we can classify bugs. Here, we will look at some common types, see what they are, and see what they can look like.

Arithmetic bugs

Arithmetic bugs, as the name suggests, have to do with arithmetic operations. There are a few things we should look out for, as outlined below.

Division by zero

One thing to look out for is division by zero. This is not only related to computers—we can also never perform a division operation where the divisor is zero. In mathematics, dividing by zero has no meaning, because if we do 6 / 2, we will get 3. If we multiply 3 and 2, we’ll get 6 back. But if we take 6 / 0, there is no number we can multiply by zero to get back to 6.

This might seem simple enough, but sometimes, it happens anyway, especially when we’re working with variables. Let’s assume that we have two variables that get their value somewhere in our application, like this:

Later on in the program, we perform some calculations, maybe with some other variables, and it might look like this:

 y = y – current_temperature

If the current_temperature variable now has the same value as y, which is 14 in our case, we’ll store the result, 0, back in y. If we then did something like this, our application would crash:

result = x / y

The reason for this is that we are dividing by zero. It might not be obvious that y is 0, so the problem isn’t easy to spot.

Note: Every compiler throws an error for dividing by 0. The error message differs depending on the type of compiler.

Arithmetic overflow and underflow

Previously, we talked about integer types and how they can have a fixed size. What that means is that some ...