What are the views on bugs within the software company?

Is fixing bugs just a distraction from the real work? Is code written by a professional always error-free? If you answered “yes”, you’re not alone in your opinion. It is very common in software development for bugs to be viewed negatively and for their existence to be frowned upon.

In this blog post, however, we’re taking a bold peek into the world of bugs. Despite their negative reputation, bugs are a perfectly normal part of everyday life at software companies. So we asked Hurja’s coders directly about their thoughts on bugs: what is a bug, when does it cause a problem, and can bugs even be useful?

What is a bug?
The good, the bad and the ugly bugs
How are bugs found?
Tackling bugs through interaction and collaboration
A competent software company doesn’t panic when faced with bugs
- Shall we get started?

What is a bug?

In short, a bug is an error in the code that prevents the software from working correctly. A very simple example is when a user expects the program to return a value between zero and one, but the application surprises them by returning “seven”. In this kind of error situation, the computer is indeed working according to the instructions, but because of the bug, it returns an unexpected result.

In the table below, we have compiled some more detailed and technical examples of different types of bugs and their effects. There are all sorts of bugs!

Bug type	An example of a developer’s work	The user’s perspective
A bug in the SDK (Software Development Kit): the administration features used by the developer are not working correctly.	This makes development work more difficult, as you are not always able to make your own bug fixes to the SDK’s source code.	Not visible to the end user.
Graphical bug: The visualizations are not working properly.	In the 3D application, the code randomly selects between two elements, which is visible as a “clash” between the shapes or as a distorted shape.	The user interface elements are a bit of a mess, but everything else works.
Logical error: The program’s operational logic has been conceived incorrectly.	There is a loop in the code which, due to the conditional statement, enters an infinite loop and prevents the function from continuing.	A particular feature isn’t working at all.
Compatibility issue: The software does not work on certain hardware or devices.	The bug only occurs in Android or iOS version x.x.	The software does not work properly on certain devices.
Semantic error: The syntax is correct, but some other part of the code is preventing the function from working.	The code uses a variable that does not have the value required for the calculation.	A particular feature isn’t working properly.
Type error: The data type of the variable has been selected incorrectly or inappropriately.	The value assigned to the variable does not match its declared data type, so the method cannot process the variable.	A particular feature isn’t working at all.
User interface bug: the user interface functions are not working as expected.	Can be identified using other bug types: logic error, graphical bug, responsiveness issue, etc.	Some of the functionality is confusing: for example, pressing a button causes the wrong thing to happen, or the view doesn’t display correctly.

The good, the bad and the ugly bugs

A bug that has slipped into production and compromises software quality is always harmful and undesirable. It can lead to a negative user experience, hinder the use of the software’s functionalities and, in the worst case, even create a serious vulnerability that threatens information security.

It is, however, normal for minor errors to occur, particularly during the rollout of a new digital service. Such less serious bugs might include, for example, errors affecting styling or layout, or clunky user interface displays on different devices.

For example, there were already over 24,000 different Android devices last year (source: Quartz). It is probably impossible to take full account of the details of every combination of device and operating system. Although devices comply with certain standards, there are always differences, some major and some minor. Such variations can affect, for example, graphical elements such as 3D rendering.

However, there is one exception to the rule. A bug in production may be well received by users if the error is not too serious and offers some entertainment value. For example, players of digital games may get excited about a bug in a familiar game if it enables an unusual, inspiring and perhaps slightly odd gaming experience.

The line between a software bug and a feature can sometimes be blurred.

How are bugs found?

Bugs can be seen as part of an ongoing development process. That is why identifying sources of errors and problem areas in the code is part of the day-to-day work of Hurja’s application developers. When bug issues are addressed without delay, the adverse effects do not have time to escalate. This also means that corrective measures are implemented more quickly, saving working time that can be spent on coding effective solutions.

Many bugs are the result of human error, time pressure, conflicting machine instructions, or the challenges that sometimes arise when taking every specific situation into account and bringing everything together. The importance of testing in a software project and in ensuring software quality should therefore never be underestimated.

However, the scope and methods of testing are always agreed separately with the client. The more thorough and systematic the testing is, the greater the proportion of the project’s total workload it will account for. For example, a lighter testing approach may often suffice for non-critical systems, whereas systematic testing is appropriate for critical systems.

Appropriately comprehensive testing protocols and systems help developers identify a wide variety of bugs and effectively prevent errors from reaching production. Our application developers have access to a range of tools suitable for both automated and manual testing. For example, applications that provide error reports and consoles integrated into the development environment offer real-time error monitoring.

In larger projects, on the other hand, it may be appropriate to adopt a test-driven approach to the entire software project. Test-driven development is a working method associated with agile methodologies, in which code is written and iterated until it works, guided by tests. Separate test cases are created for each bug that is found and fixed, and if the same bug reoccurs, it is caught before release.

Testing is also important during the maintenance phase. For example, if the implementation utilises code written by several different suppliers, a bug may arise within a separate component or module. A bug visible in the final product may therefore be a reflection of updates and changes whose scope of impact was impossible to predict during the development phase.

Tackling bugs through interaction and collaboration

In addition to technical tools, bugs can be identified through good communication and collaboration within the team. Code reviews, explaining the logic behind one’s own code to colleagues and asking other developers for advice are essential ways of finding and preventing bugs, as many potential issues are resolved before they even become bugs. Even unwanted but fixed bugs can be instructive when they arise and help to achieve an even better end product. We can, and must, learn from our mistakes.

Although code deployed to production should not cause users any headaches, sometimes a bug is unfortunately only spotted thanks to an observant end-user. The software user should never be blamed for a bug. The ability to provide feedback on the software and the proper handling of that feedback are also important factors in minimising the adverse effects of bugs.

“I searched for the source of the incorrect data displayed in the application on my own, but despite my efforts, I wasn’t able to locate the bug. However, as I was describing how the application works to a colleague, I suddenly realized what was wrong with my code. I had been looking for the logic error in completely the wrong place.”

Jukka Software Developer

A competent software company doesn’t panic when faced with bugs

You come across bugs everywhere, in software programs both large and small, on websites and in other digital services. Bugs come in all shapes and sizes, and their location, as well as the nature and extent of the problems they cause, vary.

It is not worth trying to eliminate all bugs at once. It is more a question of how and when to respond to errors, and how to fix problematic code as part of normal software development. Thorough bug checks should always be an integral part of development and maintenance, so that critical bugs in particular can be eliminated before the software is released for end users to enjoy.

The topic of bugs is vast, so a single blog post is merely a scratch on the surface of a huge subject. But whatever the nature or location of a bug, in a professional software company, bugs do not cause panic. Errors are identified and prevented as part of day-to-day operations. This ensures that potential bugs are detected and their adverse effects nipped in the bud.