Lesson 1.1 · Unit 1 · CED topic 1.1

Algorithms, programs, and compilers

An algorithm is a step-by-step process for finishing a task or solving a problem. You already follow algorithms all day: a recipe, the directions to a friend's house, the steps for long division. A program is an algorithm written in a language a computer will accept, and this course teaches that language: Java.

Two ideas make an algorithm precise. First, the steps are sequenced: they happen one at a time, in a defined order, and swapping two steps can change the result. Second, each step is exact enough that nobody has to guess what it means. "Add a little tip" is not a step a computer can follow; "multiply the bill by 0.15" is.

Describing an algorithm before you code it

You can describe an algorithm in written language or in a diagram, and the exam expects both. A diagram often shows the order at a glance; the same steps in plain sentences are easier to turn into code line by line.

Here is the same algorithm in written form.

1. Read the amount of the bill.
2. Compute the tip as the bill times 0.15.
3. Compute the total as the bill plus the tip.
4. Display the total.

Try swapping steps 2 and 3. The total would be computed before the tip exists, so the algorithm no longer does what you meant. That is what sequencing means: an order is part of the definition of the algorithm.

From source code to a running program

Java code can be written in any text editor, but programmers use an integrated development environment (IDE) because it bundles the tools you need to write, compile, and run code in one place. The path a Java program takes is always the same.

1. You write source code in a file ending in .java.
2. The compiler (javac) checks that code against the rules of the language. If it finds a mistake it reports it and stops; nothing can run until every error it can detect is fixed.
3. If the code is acceptable, the compiler produces bytecode in a .class file.
4. The Java Virtual Machine (the JVM, started with java) runs the bytecode.

Every program on the exam sits inside a class, and execution begins at the first statement of main:

public class Main {
    public static void main(String[] args) {
        // statements run in order, top to bottom
    }
}

The file is named after its class (Main.java). Statements end in semicolons and blocks are wrapped in braces. On the exam, snippets usually show only the statements; you can assume the class and main around them.

Four ways code goes wrong

The compiler can catch some mistakes and cannot catch others. The difference is the most tested idea in this lesson.

The rows are not equal in how loudly they announce themselves. A syntax error shouts at compile time. An exception shouts at run time. A logic error says nothing at all, which is why testing matters: the only way to find it is to compare what the program did with what it should have done.

public class Main {
    public static void main(String[] args) {
        double celsius = 21.5;
        double fahrenheit = celsius * 9.0 / 5.0 + 32.0;
        System.out.println(celsius + " C is " + fahrenheit + " F");
    }
}

21.5 C is 70.7 F

public class Main {
    public static void main(String[] args) {
        double celsius = 21.5
        System.out.println(celsius);
    }
}

Main.java:3: error: ';' expected
        double celsius = 21.5
                             ^
1 error

int total = 120;
int count = 0;
System.out.println("Average: " + total / count);

Exception in thread "main" java.lang.ArithmeticException: / by zero

int a = 4;
int b = 10;
System.out.println("Average: " + (a + b / 2));

Average: 9