BHSawesome AP CSA

The first kind of bug we need to deal with are called syntax errors. These are the programming equivalent of typos in English and usually come from the same cause: misplaced or missing punctuation, misspelled words, and incorrect capitalization. However, unlike in English, where we can still understand text even if it contains a misplaced comma or two, when a program does not exactly follow the rules of Java, it can’t be run at all.

In Java running a program actually happens in two steps; first we compile it and that produces a set of files that Java can then run. Errors that are detected during compilation mean we don’t get the runnable files so we so we have to fix them before we can even run our program. These are also called compile-time errors because they are detected by the compiler.

The good news is the Java compiler will tell you if your Java code is not exactly right. Examples of syntax errors are a semicolon ; missing or if the code has a open curly brace { or open quote ", but no close curly brace } or close quote ".

The more code you write and the more syntax errors you create and then remove, the more you will learn which details you really need to pay attention to. To get some practice at creating syntactically correct code try the following two exercises.

public class Hello
{
---
   public static void main(String[] args)
   {
---
      System.out.println("Hi my friend!");
---
   }
}

public class Hello
{
---
public Class Hello
{ #paired
---
   public static void main(String[] args)
   {
---
   public static void main()
   { #paired
---
      System.out.println("Hi there!");
---
      System.out.println("Hi there!")
 #paired
---
   }
}

In this book when you press the Run button on coding exercises, the code is first complied and then run. But if the code has syntax errors or other compile-time errors, you will see error messages displayed below the code.

In the exercises below, you will click the run button to compile and run the code. Unfortunately you will find that the initial code in each exercise contains at least one syntax error that you need to fix.

It will be a lot easier to find the problems if you understand a few basics about how to read the error messages. They aren’t always easy to understand but knowing how they’re structured can help so let’s take a closer look.

An error message will look something like this:

FirstClass.java:5: error: unclosed string literal
       System.out.println("Hi there!);
                          ^
1 error

The first line starts with the name of the file that was being compiled. (When we run code in this book we don’t name the file but it will be named to match the name of the class.) Then there’s a colon (:) followed by a number. That number tells us the line number in the file where the compiler detected the error, in this case line 5.

Error messages aren’t always 100% accurate about where the error actually is; sometimes we actually need to change something a bit earlier in the program and sometimes a bit later. But the line the compiler is pointing us at is the best place to start looking.

After the line number and another colon, we will find the actual error message. These can be kind of cryptic but you should still read it. As you learn more Java vocabulary they will become more meaningful but they almost always contain some useful clues. For instance take this error message: “unclosed string literal”. You may not know what a string literal is (yet) but “unclosed” suggests something was opened and then not closed. Keep that thought in mind.

Now look at the next two lines. The very next line is just the line of code from your program. But below that is a very important line containing a single caret (^) positioned to point at exactly where in the line the Java compiler thinks the problem is. In this case it’s pointing at the quotation mark (") before “Hi”. So it’s complaining about something being unclosed and it’s pointing us at a quotation mark. Usually quotation marks come in pairs called the open quote and the close quote, right? And if you look at the line of code you’ll see that there’s no closing quotation mark. Could that be the problem? Try adding a quotation mark and see if that fixes it!

It is worth getting in the habit of really reading error messages. The people who wrote the Java compiler put in lot of work to try to make the error messages useful. If you read them, you’ll soon learn to recognize common mistakes and will get much quicker at finding your syntax errors.

Another thing that happens sometimes is after we fix one syntax error, we’ll get a new syntax error. This is because sometimes the compiler can’t even detect the second error until the first one is fixed.

Which is another reason it’s important to read error messages! It’s very tempting when we see that there’s an error to jump immediately to trying to fix it. Arg, an error! Get rid of it! But if we don’t slow down and read the message in a case like this, we might not notice that we’ve actually fixed the first error. And if we don’t notice that we fixed it, we might undo our change and unfix it!

So read the error messages—they’re there to help you. With that in mind, see if you can fix the errors in the exercises below

Practice finding and fixing syntax errors with the next three exercises.

Some errors cannot be detected by the compiler. These are called run-time errors. These errors occur when the program is running, after the code is compiled. They can be caused by a variety of things, such as dividing by zero or trying to read from a file that doesn’t exist or a logic error in the code.

An exception is a type of run-time error that occurs as a result of an unexpected error that was not detected by the compiler. It interrupts the normal flow of the program’s execution. Java will sometimes report an exception with a message that tells you what went wrong. For example, if you try to divide by zero, Java will throw (report) an ArithmeticException while running. Try this out in the code below.

Run-time errors can be difficult to find because they don’t always cause the program to crash. Sometimes they just cause the program to behave in unexpected ways because of an error in the logic. A logic error is a mistake in the algorithm or program that causes it to behave incorrectly or unexpectedly causing a run-time error. For example, a programmer might have made a math mistake so the wrong value is calculated. Logic errors can be detected by testing the program with specific data to see if it produces the expected outcome. We’ll see an example of this after learning about expressions in the next lessons.

Watch the following video to see that all coders get bugs. Debugging is a normal part of coding. It can be frustrating at times, but you will get better at it with practice! Sometimes another pair of eyes really helps, so ask a friend if you get stuck or try explaining your code line by line to someone or even a rubber duck. Rubber duck debugging is a lot of fun!

Working in pairs, debug the following code. Can you find all the bugs and get the code to run?