Exception handling facts for kids

In computing and computer programming, exception handling is how a computer program deals with unexpected or unusual situations that happen while it's running. Think of it like a "plan B" for your program. When something goes wrong, or something unusual happens, the program stops its normal work and jumps to a special part of the code designed to fix or manage that problem. This special part is called an exception handler.

These unusual situations, called exceptions, can come from different parts of a computer system. Some are from the computer's CPU (like interrupts), some from the operating system (like signals), and others are defined by the programming language itself. Even though they come from different places, they all need a way to be handled so the program doesn't crash. Sometimes, these problems can be fixed so well that the program can just continue where it left off!

What Are Exceptions?

Every part of a computer program, like a procedure or a function, expects certain things to be true before it starts its job. This is called a precondition. If these expected conditions aren't met, the procedure can raise an exception. This means it signals that something unexpected happened. Then, the exception handling system steps in to deal with it.

For example, if a program tries to divide a number by zero, that's usually an exception because division by zero isn't allowed. Another common exception is when a program tries to open a file that doesn't exist. Or, if a program runs out of memory, that's also an exception. Programmers decide what counts as an "exception" and how to handle it.

Exception handling helps programs tell the difference between a normal result and an error. In older programming languages like C, programs often had to return special numbers to show if an error happened. Exception handling makes it much clearer when something goes wrong. The word "exception" is used instead of "error" because it doesn't always mean something is completely wrong. It just means something unusual happened that needs special attention.

Sometimes, an "exception" might even happen quite often. For instance, if you have a program that looks up words in a dictionary, it might throw an exception if a word isn't found. This "word not found" situation could happen very frequently, but it's still handled as an exception because it's not the usual "word found" outcome.

A Brief History of Exceptions

The very first way computers handled unexpected events was in the UNIVAC I computer back in 1951. If a math problem resulted in a number too big to store (called an "arithmetic overflow"), the computer had a special way to deal with it.

Software exception handling, which is what we mostly use today, started to develop in the 1960s and 1970s. By the 1980s, many popular programming languages began to include built-in ways to handle exceptions. This made programs much more reliable and easier to manage when things went wrong.

How Hardware Handles Exceptions

When we talk about hardware, an exception is very similar to an interrupt. Imagine the computer's processor is busy doing its work. If an exception happens (like a problem with the memory or a special signal from a device), the processor stops what it's doing. It then looks up a special set of instructions, called an interrupt handler, that tells it how to deal with that specific problem. After handling the problem, it might go back to what it was doing before.

Floating-Point Exceptions

The IEEE 754 standard is a set of rules for how computers handle numbers with decimal points. This standard also defines how to handle "exceptions" that can happen during math operations. For example, if you try to divide by zero with floating-point numbers, the standard says the result should be "infinity" by default. It also sets special "flags" that programmers can check later to see if an exception occurred.

This default way of handling exceptions (like returning "infinity" instead of crashing) is very important. For example, a famous space mission in 1996, the Cluster spacecraft launch, failed partly because its software crashed when a math error occurred. If it had used the IEEE 754 default exception handling, which avoids crashing, that problem might have been prevented.

Exceptions in Programming Languages

Vue.component('parent', {
    template: '<div><slot></slot></div>',
    errorCaptured: (err, vm, info) => alert('An error occurred');
})
Vue.component('child', {
    template: '<div>{{ cause_error() }}</div>'
})

<parent>
    <child></child>
</parent>