Bugs in Programming

Classifying Bugs

This section classifies bugs into five broad categories, each illustrated via an analogy that should help clarify its nature. Knowing the names of our enemies is the first step toward defeating them, so in the paragraphs below we define and explain the terms token error, syntax error, syntax constraint error, execution error, and intent error. You might ask, “Why spend so much time talking about bugs when they should never occur?” The answer to this question is that programming requires an inhuman amount of precision, and although bugs should not occur in principle, they occur frequently in practice. Instead of expecting to write a completely correct program, we should expect to write a partially correct program. Then, we must become adept at quickly finding and fixing bugs by hand simulating our programs. Whenever we change a program, we should be able to prove that at least one bug has been removed, and that our program has become more correct. It is common for novice programmers to change programs randomly, and as a result make them less correct. Avoid this temptation: debug your programs by carefully analyzing them, making only proven corrections.

Token Errors

A token error occurs whenever our program contains a word or symbol that is not in Java's vocabulary. As an analogy, suppose that one day we are standing on a street in San Francisco, and are asked by a lost motorist, “How can I get to Portland, Oregon?” If we say, “Just keep gngoi for ihegt hundred semil,” we would have committed multiple token errors. The motorist is unable to follow our instructions, because he is unable to decipher some of the words from which the instructions are composed. Similarly, the Java compiler must recognize each token (identifier, symbol, literal, and comment) in our programs.

Syntax Errors

Even though the Java compiler may recognize every token in a program, the program still may contain a syntax error. This type of error occurs whenever we use incorrect grammar or punctuation (according to the syntax rules of the Java programming language). Going back to our lost motorist, we might reply, “For keep hundred miles going eight just.” Here, each word/token is individually recognizable as correct English, but we have combined them in a senseless and convoluted manner: the parts of speech are not in their correct positions for English grammar.

Syntax Constraint Errors

These errors occur when the Java compiler cannot determine the meaning of a program. Sometimes a sentence might seem syntactically correct but, meaningless; for example, “Colorless green ideas sleep furiously.” Suppose that we told the motorist, “Keep going for eight hundred just miles.” Technically, this sentence is syntactically correct: we can use the word “just” an adjective meaning righteous —as in the sentence, “He is a just man.” But while the phrase “just man” is meaningful, the phrase “just miles” is meaningless. So once again, the motorist would not be able to understand fully what we told him. If a program contains any token, syntactic, or syntax constraint errors, the Java compiler will discover them. In all three cases, the Java compiler has no idea of what we meant to say, so it will not try to correct the error; it will simply report the problem (as best as it can) in the Errors & Warnings window and be unable to finish compiling the program. All these errors are called compile-time errors, because the Java compiler detects them while compiling our programs. We can link and run only programs that contain no compile-time errors. Errors that occur when the program is running (or executing) are called run-time errors. Since the compiler points out compile-time errors, they are much easier to fix.

Execution Errors

Execution errors occur when the Java runtime system is executing a program and discovers that it can't legally carry out one of our instructions (for example, dividing by 0). If it recognizes such a case, it terminates execution of the program (again, supplying some information about the error). Returning to our motorist trying to get from San Francisco to Portland, we might tell him to, “Just keep going for eight hundred miles”. But, if he happens to be facing west at the time, and interprets our instructions literally, he could travel only a few miles before reaching the Pacific Ocean. At this point he would stop (we hope) and realize that he could not complete our instructions as given. This illustrates an execution error. Execution errors are often called run-time errors, because the Java runtime system can detect them only when it tries to execute or run a program.

Intent Errors

The final error class is the most insidious, because neither the Java compiler or runtime system can detect this type of error when it occurs. An intent error occurs whenever Java successfully completes execution of a program, but the program doesn't compute the correct answer. Coming back to our motorist who is trying to reach Portland from San Francisco; we could again tell him, “Just keep going for eight hundred miles.” But if this time he happened to be facing south, he could successfully carry out our instructions to completion, but he would end up in Tijuana, Mexico not Portland, Oregon. Remember that Java understands neither our programs or what we indended to do with them. It knows only how to compile, link and execute the instructions that we give it. There is no way for Java to know what we intend the program to do, or detect that our program did not accomplish what we intended it to do. Frequently, intent errors occur early in our programs and then later lead to execution errors. In such cases, the error becomes manifest at a location that is different than the source of the error. Thus, we must carefully hand simulate our programs, either from the beginning, or backward from the execution error or end of the program, to locate the incorrect instructions.

Footnotes

On the origin of Bugs: the OED

In fact, the Oxford English Dictionary cites a 1889 newspaper quotation that said, "Mr. Edison, I was informed, had been up the two previous nights discovering 'a bug' in his phonograph."