Software bug facts for kids

Kids Encyclopedia Facts

A software bug is like a tiny mistake or flaw in the instructions that tell a computer program what to do. Imagine a recipe with a wrong ingredient or a step missing – the food might not turn out right! In the same way, a bug can make a computer program act strangely, crash, or not work at all. When a program has many bugs, people might call it buggy.

Bugs can cause small problems, like a misspelled word on a screen, or big problems, like a program crashing often. In 2002, a study in the US found that software bugs cost the economy about $59 billion each year! Since the 1950s, some computer systems have been made to find or even fix these errors on their own.

To report a MediaWiki error on Wikipedia, see Wikipedia:Bug reports.

What Are Software Bugs?

A software bug is a problem in the code that makes a computer program not work as it should. These problems can be small, like a typo, or very serious, causing the program to stop working completely.

How Bugs Get Their Name

The word "bug" for a problem in a machine actually goes way back! In the early days of computers, a real moth got stuck in a relay of a computer, causing it to malfunction. This event helped popularize the term "bug" for technical glitches.

Real-Life Examples of Bugs

Software bugs can sometimes lead to very serious situations. Here are a few examples:

In the 1980s, bugs in a radiation therapy machine called Therac-25 caused harm to patients.
In 1996, a very expensive European Space Agency rocket, the Ariane 5, exploded less than a minute after launch. This happened because of a bug in its guidance computer program.
An RAF Chinook helicopter crashed in 1994, killing 29 people. It was first thought to be pilot error, but later investigations suggested a software bug in the engine-control computer might have been the cause.
In the early 21st century, buggy software caused a major problem for the British Post Office scandal.

Stopping Bugs Before They Start

Preventing bugs is a big goal for people who create software. The earlier a bug is found and fixed, the easier and cheaper it is.

How Programming Languages Help

Newer programming languages are often designed to avoid common mistakes found in older languages. For example, lessons learned from languages like BASIC and C helped create newer ones like C# and Rust.

Some languages check for errors before the program even runs. This is like a spell-check for code. If you try to put text where a number should be, the program won't even start until you fix it. This helps catch mistakes early.

Smart Coding Techniques

Programmers use special ways of writing code to prevent simple errors. For example, using style guidelines and defensive programming can help avoid typos that are easy to miss.

Imagine you have a set of instructions. Sometimes, you can skip certain brackets if there's only one instruction. But adding those brackets, even if not strictly needed, can prevent a bug where the computer misunderstands what you want it to do.

Planning and Testing

Writing a clear plan for how a program should work can help prevent bugs. This plan is called a program specification.

One of the main goals of software testing is to find bugs. The more a program is tested, the more reliable it becomes.

Agile Methods

Some software teams use "agile" methods, which means they release small updates often. This way, users can give feedback quickly, and any bugs are found and fixed faster.

With test-driven development (TDD), programmers write tests for their code even before they write the code itself. The code isn't finished until all these tests pass.

Looking Inside the Code

Tools can be added to software to watch how it runs. This helps find problems like slow spots or confirm that everything is working correctly. Sometimes, just seeing where the program spends most of its time can help programmers make it better.

Open Source Software

Open source software means anyone can look at its code. Some people believe that popular open-source software has fewer bugs because "given enough eyeballs, all bugs are shallow." This means if many people look at the code, they are more likely to find problems. However, others argue that it's still possible to hide bugs in complex code, even if many people are looking.

Finding and Fixing Bugs

The process of finding and fixing bugs is called debugging. Maurice Wilkes, an early computer pioneer, realized in the 1940s that a lot of his time would be spent finding errors in his own programs!

Using Debuggers

A special program called a debugger can help programmers find faulty code. It lets them look at how the program works step-by-step and see the values of different parts of the code.

Sometimes, instead of a debugger, programmers add special messages to their code that print information as the program runs. This helps them trace what the program is doing.

The Challenge of Debugging

Finding a bug can sometimes feel like solving a mystery. A bug in one part of a program might cause problems in a completely different part, making it tricky to figure out the real cause.

Often, the hardest part of debugging is finding the bug itself. Once you know what's wrong, fixing it can be quite easy. Sometimes, a bug isn't just a small mistake but shows a bigger problem in how the program was designed. In these cases, a whole section of the program might need to be rewritten.

To find a bug, the first step is usually to make it happen again reliably. If a programmer can't make the bug appear, they can't find its cause or fix it. Some bugs are very hard to reproduce. For example, a bug in the Therac-25 machine only happened when the operator entered information very, very quickly. It took days of practice to do this, so the bug wasn't found during testing. Bugs that disappear when you try to find them are sometimes called heisenbugs.

Managing Bugs

Bugs are managed by documenting them, putting them into categories, assigning them to people, and then fixing and releasing the corrected code.

Special tools are often used to keep track of bugs. These tools help teams manage their work and track feedback from users. A tracked problem might be called a "bug," "defect," "ticket," or "issue." For agile teams, it might be called a "story." These items are often sorted by how serious they are and how important it is to fix them.

Severity and Priority

Severity describes how big of an impact a bug has. This could mean data loss, financial problems, or just wasted effort. For example, a game crashing is different from a bank server crashing. Severity levels might include "crash," "no workaround" (meaning you can't do your task), or "visual defect" (like a misspelling).

Priority describes how important it is to fix a bug compared to other bugs. A bug that stops the product from being released is called a show stopper. Sometimes, a bug that isn't very serious but is easy to fix might get a higher priority than a moderately serious bug that takes a lot of effort.

Fixing and Releasing Updates

If a bug is very important, a special update called a patch might be released quickly to fix it. A software release that focuses mainly on fixing bugs is called a maintenance release.

Known Issues

Sometimes, software is released with known bugs that are not very important. This can happen if there's a deadline, if the bug is already fixed in a future update, or if fixing it would be too difficult or risky. Sometimes, what one person sees as a bug, another might see as an undocumented feature!

The Cost of Bugs

Bugs can be very costly, not just from the damage they cause but also from the effort needed to fix them. In 1978, studies showed that about 17% of the effort in software projects was spent fixing bugs. By 2020, this number was around 20%.

Some projects have achieved very low bug rates. For example, the software for the Space Shuttle had almost no defects, even though it was very complex!

Different Kinds of Bugs

Bugs can come in many forms:

Design Mistakes

A bug can happen if the plan for the software isn't clear or is incorrect. For example, if a program is supposed to alphabetize a list of words, but the design doesn't consider words with symbols, it might sort them incorrectly.

Math Problems

Numerical calculations can lead to unexpected results or crashes. This can happen if the program doesn't handle very large or very small numbers correctly, or if it tries to divide by zero.

Logic Errors

A control flow bug, also known as a logic error, means the code doesn't crash, but it doesn't do what it's supposed to. This could be an infinite loop (where the program keeps repeating something forever) or making a wrong comparison.

Communication Problems

Bugs can happen when different parts of a program or different programs try to communicate. This could be due to incorrect use of instructions (APIs) or problems with how different systems work together.

Resource Issues

These bugs happen when a program uses up all of a computer's resources, like memory or file handles, without releasing them. This can lead to crashes or slow performance. A common one is a Buffer overflow, where a program tries to store too much data in a small space.

Typos and Syntax Errors

A syntax error is like a grammar mistake in the code. For example, in some languages, `x=5` sets the value of x to 5, while `x==5` checks if x is already 5. Using the wrong one can cause a bug.

Teamwork Challenges

Sometimes, bugs happen because of miscommunication or mistakes within a programming team. For example, if one programmer changes a part of the code but forgets to update another part that uses the same logic.

Bugs and Politics

In 2016, a report called "Bugs in the System" suggested that US policymakers should make changes to help researchers find and fix software bugs. The report highlighted that laws about computer crime and copyright might make it harder for security researchers to do their important work of finding vulnerabilities.

Government researchers, companies, and cybersecurity experts are usually the ones who discover these software flaws. The report argued that laws like the Computer Fraud and Abuse Act could accidentally make it illegal for researchers to do their job of finding bugs.

Images for kids

Error resulting from a software bug displayed on two screens at La Croix de Berny station in France
Example bug history (GNU Classpath project data). A new bug is initially unconfirmed. Once reproducibility is confirmed, it is changed to confirmed. Once the issue is resolved, it is changed to fixed.