types of computer bugs

 

Arithmetic bugs

• Division by zero
• Arithmetic overflow or underflow
• Loss of arithmetic precision due to rounding or numerically unstable algorithms

Logic bugs

• Infinite loops and infinite recursion
• Off by one error, counting one too many or too few when looping

Syntax bugs

• Use of the wrong operator, such as performing assignment instead of equality test. For example, in some languages x=5 will set the value of x to 5 while x==5 will check whether x is currently 5 or some other number. In simple cases often warned by the compiler; in many languages, deliberately guarded against by language syntax

Resource bugs

• Null pointer dereference
• Using an uninitialized variable
• Using an otherwise valid instruction on the wrong data type (see packed decimal/binary coded decimal)
• Access violations
• Resource leaks, where a finite system resource such as memory or file handles are exhausted by repeated allocation without release.
• Buffer overflow, in which a program tries to store data past the end of allocated storage. This may or may not lead to an access violation or storage violation. These bugs can form a security vulnerability.
• Excessive recursion which though logically valid causes stack overflow

Multi-threading programming bugs

• Deadlock, where task A can't continue until task B finished, but at the same time, task B can't continue until task A finishes.
• Race condition, where the computer does not perform tasks in the order the programmer intended.
• Concurrency errors in critical sections, mutual exclusions and other features of concurrent processing. Time-of-check-to-time-of-use (TOCTOU) is a form of unprotected critical section.

Interfacing bugs

• Incorrect API usage
• Incorrect protocol implementation
• Incorrect hardware handling

Performance bugs

• Too high computational complexity of algorithm
• Random disk or memory access

Teamworking bugs

• Unpropagated updates; e.g. programmer changes "myAdd" but forgets to change "mySubtract", which uses the same algorithm. These errors are mitigated by the Don't Repeat Yourself philosophy.
• Comments out of date or incorrect: many programmers assume the comments accurately describe the code
• Differences between documentation and the actual product