Contact Us:
CheapDeveloper » Webmaster » Articles » What is a bug: let's talk about programming errors

What is a bug: let's talk about programming errors

04 December 2021, Saturday By Priyanka Boruah

Errors in programs are commonplace. Applications hang, crash, stop running. In the simplest case, the user solves the problem by reinstalling the software or cleaning the "garbage". Developers also need to clearly understand what a bug is, how to fix it and how to get timely feedback from users.

What is a bug

What is a bug?

The term "bug" (translated as "bug") for programmers means a situation when a certain code gives an incorrect result. The reasons for the occurrence are different: errors in the source code, the program interface, or incorrect operation of the compiler. They are detected at the debugging stage or already at the beta testing stage, the release of the product to the market.

Error options:

  1. An error message appears, the program continues to run.
  2. The application freezes or crashes without any warning.
  3. One of the events occurs and a report is simultaneously sent to the developer.

The hardest part is working with computer games, which often use the term "crash". It indicates a critical problem when starting or using the program. When people talk about bugs, they often mean graphics glitches, for example, if a player "falls into textures".

Bug classification

Users' points of view are often not the same as those of programmers. So, for the users, there was just a failure, "the application has stopped working." The coder, on the other hand, has a headache to determine the source of the problem. After all, an error in the program, probably, manifests itself only on a specific hardware or when combined with other software (often with antivirus software).

Bugs are divided into categories depending on their criticality:

  1. minor errors,
  2. serious mistakes,
  3. showstopper.

Bug classification

The latter indicate a critical software or hardware problem due to which the software loses its functionality by almost 100%. For example, it is not possible to log in through the username-password or the "Next" button has stopped working. Therefore, such errors are given priority.

There is also a division of errors by frequency of occurrence. The easiest way is to fix the constant ones that occur under the same circumstances, regardless of the platform, the hardware of the computer or some user actions. The complexity increases with periodic failures, when the cause may well be buggy RAM or drive errors.

There is an option when the problem occurs only on a specific client's machine. Here you either have to order an individual "error correction", or change the computer. Because no one will edit software for a mass user because of "one". Only if there is a certain critical mass of identical cases.

Types of errors

It is also important for the programmer to divide into different types of application errors based on the typical conditions of their operation. For example, arising from an increase in the load on the processor, in the interface, in the module for processing incoming data. There are bugs of boundary conditions, failure of identifiers, banal incompatibility with the processor architecture (more often in mobile devices).

Coders classify errors by complexity:

  1. Bohr Bug is a "stable" bug that is easily detected even during the debugging phase or during beta testing, when it is not yet a question of releasing a stable version.
  2. Heisenbug - periodically appearing, sometimes disappearing for a long time bugs with changing properties, including dependence on the software environment, "hardware".
  3. Mandelbug - a bug with entropic behavior, with almost unpredictable results.
  4. Schroedinbug - critical bugs, often leading to the appearance of the possibility of hacking, although outwardly they do not manifest themselves in any way.

The latter category of errors is one of the main reasons for regularly updating Windows operating systems. It seems that the user is satisfied with everything, and the developer releases new patch packages over and over again. The most famous bug that has ruined the nerves of many coders is the "2000 error" (Y2K Error). It was successfully forgotten about, but the lessons were learned.

Programmers distinguish between those errors that prevent compiling the program, and the warnings. The second category is only a warning about the "jambs" found in the code, but they do not interfere with either the software assembly or subsequent operation. For example, we are talking about the absence of a dot or a semicolon in the syntax, when the compiler is able to solve the problem itself.

Coders classify errors


Most serious error. Such bugs lead to a change in the functioning of the program, contrary to the terms of reference. No one knows what this will lead to - they may write “wrong data” on the disk, incorrectly change important documents or provide access to commercial information without authorization. You can fix them only if you know the original logic.


Syntax errors exist at the level of a specific programming language: C, Java, Python, Perl, etc. That on one platform the maximum works with warnings, for another it will be a serious problem. Such bugs are easy to fix at the compilation stage, because the tool will not allow you to "go beyond" the incorrect section of code.


The situation occurs when code written in a high-level language is converted to "simple", machine-readable. This can be caused by a serious syntax error or by a malfunction in the compiler itself. Such bugs are eliminated at the stage of development and debugging of programs, because it will not work to release them even for beta testing.

Runtime Environments

So-called Run-Time errors. They appear in compiled programs at startup. For example, due to a lack of resources on the machine, as a result of an emergency (breakdown of memory, media, input-output devices). This happens if the developer did not take into account the real working conditions; will have to return to the stage of working out the logic.


One of the varieties of logical errors. Occurs when the program calculates a lot of variables during its operation, but at some stage the unexpected happens. For example, division by zero, or the application gets an "infinite" result. It will be possible to change the situation only at the level of the code, the algorithm embedded in it.


Mostly buffer overflow errors fall into this category. The programmer did not consider the need to clear memory before placing new data. Or the interface is designed without taking into account the typical screen resolutions, and its elements are constantly "moving out", the logic of button operation is violated, etc. You can fix it only by rewriting part of the code.


It is about interacting with a hardware or software environment. In the case of an application for a cloud resource, the programmer could make a mistake when using the web protocols. With the constant appearance of an error, it remains only to rewrite the section of the code responsible for the appearance of the bug, otherwise the program will remain inoperable.

What is an exception

The introduction of exceptions into the program can reduce the risks of unforeseen errors. These are events that trigger “wrong” behavior. This mechanism allows you to systematize the handling of bugs, regardless of the type of application, platform and other conditions. And develop a unified response system, for example, from the operating system.

There are software and hardware exceptions. The first ones are generated by the program itself and the OS under which it is launched. Hardware refers to those created by the processor. For example, division by 0, buffer overflow, access to unallocated memory. With exceptions, coders cover the most serious, critical bugs.

How to avoid mistakes?

There are two effective ways to avoid problems during the development phase. The first is debugging with special programs. They display the results of execution in numbers, which objectively show the coder whether the next piece of code has been processed correctly or whether you need to look for a creeped in error.

The second way is to attract special people, testers. They will help you understand the performance of the interface in different situations, on different platforms. This happens as close as possible to real conditions. Therefore, any serious product must go through this stage.


Bugs are an accompanying factor in any development. The user does not see most of them, because they are eliminated at the stage of alpha testing. Beta versions already contain minor bugs, for example, those related to specific "narrow" operating conditions. Rare problems can be solved by crash reports - reports sent to the manufacturer by the program itself.


Read also:

AWS re:Invent 2021 Keynotes - AI/ML
03 December 2021, Friday
AWS re:Invent 2021 Keynotes - AI/ML
What is a dashboard
25 November 2021, Thursday
What is a dashboard
What is Jira Software and How To Work With It
24 November 2021, Wednesday
What is Jira Software and How To Work With It
AWS re:Invent 2021: Keynotes
02 December 2021, Thursday
AWS re:Invent 2021: Keynotes
Add a comment
Comments (0)