Writing Java on paper

Read like a computer

Goal You can run a short Java program by hand, one line at a time, and write down every value it uses.

When you write code on paper, nothing tells you that a line is wrong. Your only check is to run the program yourself, half in your head and half on the page. This is called a dry run: you act as the computer, with a pen, one line at a time.

A computer has no idea what your program is for. It does exactly what each line says, in order, and it remembers only what is stored in variables. A variable is a named place that holds a value. While you trace, do the same. Do what the line says, not what you meant it to say.

The tool is a trace table. A trace table has one column for each variable and one row for each line that runs. Build it in four steps.

1. Number the lines of the program in the margin, starting at 1.
2. Draw the table. The first column is Line. Then one column for each variable. The last column is Note, where you write what happened, for example "test is true", or what the program printed.
3. Run the program. Execution starts at the first line inside main. Each time a line runs, add a row. Write the line number, then the value of every variable after that line has finished. Copy unchanged values down from the row above, so that every row can be read on its own.
4. Use two marks for a variable with no value. A dash (–) means the variable has not been declared yet. A question mark (?) means it is declared but nothing has been stored in it. Java refuses to compile a program that reads a question-mark variable, so on paper, reading one is a mistake you must catch yourself.

For now, write a String in its column as its text in double quotes, such as "data". The next lesson draws what really happens behind it.

A loop line runs many times, so it gets many rows. For a for loop, add one row each time the computer reaches the test. Write the values after the update part (such as i++), and write the result of the test in Note. The last row of a loop is the visit where the test is false. The body does not run after it. A variable declared inside the for line, such as i, stops existing when the loop ends, so write a dash for it afterwards.

An if line gets one row. If its test is false, the next row is the first line after the closing brace of the if.

If the program calls a method, draw a second small table for that call, with columns for its parameters and its own variables. Number the calls (f#1, f#2). When the method returns, write the returned value in the Note column of the line that made the call.

public class Main {
    public static void main(String[] args) {
        int count = 0;
        String word = "data";
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(i) == 'a') {
                count++;
            }
        }
        System.out.println(count);
    }
}

2

double half = 7 / 2;

double half = 7 / 2.0;

String word = "data";
for (int i = 0; i <= word.length(); i++) {
    System.out.println(word.charAt(i));
}

String word = "data";
for (int i = 0; i < word.length(); i++) {
    System.out.println(word.charAt(i));
}

System.out.println('a' + 1);

System.out.println((char) ('a' + 1));

System.out.println("sum: " + 1 + 2);

System.out.println("sum: " + (1 + 2));

Draw memory

Goal You can draw the stack and the heap for a Java program at any line, with one fixed convention, and say which objects have become unreachable.

Java programs work with objects, and several variables can lead to the same object. You cannot see that in the code. You have to draw it. Use the same picture every time.

Java keeps values in two places. Draw two columns, each with a heading: Stack and Heap.

The stack holds one frame for each method that is running right now. A frame is a box that holds that call's parameters and local variables. Draw main's frame first, at the top of the Stack column. Each call adds a new frame below it. When a method returns, cross its frame out. Everything inside it is gone.

The heap holds every object and every array. They are made with new. You never free them: Java does that for you.

Now the rules for drawing things.

1. A variable of a primitive type (int, double, boolean, char) is a box with its value inside, such as int n and 5.
2. A variable of any other type holds a reference. A reference is an arrow to an object, or the value null. Draw an arrow, and also write the target's label inside the box, so you can still read it when arrows cross.
3. Give every object a label: H1, H2, H3, in the order new is run. Write the label and the class on top, such as H1 (Box). Draw the fields of the object as boxes inside it, with their names. Draw an array as H2 (int[3]) with cells [0], [1], [2]. The cells of a new array start at 0 (numbers), false, or null (references). They are never ?.
4. An array of objects is an array of references. new Box[2] makes one array whose two cells hold null. It does not make any Box. Each Box needs its own new.
5. A String is an object. Draw it in the heap with its text, such as H3 (String) "hi". Two literals with the same text are the same object. new String("hi") makes a different one.
6. null is a reference that points at nothing. Draw a slash through the box and write null. Calling a method through null stops the program with a NullPointerException.

What = does. a = b copies what is in b's box into a's box. For a primitive, that is the number. For a reference, that is the arrow. After Box c = a; both c and a lead to the same object, and the object is not copied. == between references asks whether the two arrows end at the same object. It does not look inside. To compare the text of two Strings, use equals.

What a method call does. It copies each argument into a new parameter box in the new frame. Java always copies. For a reference, the copy is an arrow. So the method can change the object through the arrow, but it cannot make the caller's variable point somewhere else.

What becomes unreachable. An object is reachable if you can get to it by following arrows from a variable in a frame that still exists. An object that no arrow leads to is unreachable. The garbage collector, the part of Java that reclaims memory, may remove it at some moment. On paper, cross the object out at the moment it becomes unreachable: when the last arrow to it is changed, or when the frame that held the last arrow is crossed out.

public class Main {
    static class Box {
        int value;

        Box(int value) {
            this.value = value;
        }
    }

    static void bump(Box b, int n) {
        b.value = b.value + n;
        n = 0;
        b = null;
        // A: draw the memory here, inside bump
    }

    public static void main(String[] args) {
        int n = 5;
        Box a = new Box(1);
        Box c = a;
        Box[] row = new Box[2];
        row[0] = new Box(7);
        bump(a, n);
        System.out.println(c.value + " " + n + " " + row[0].value + " " + row[1]);
        a = new Box(40);
        c = null;
        // B: draw the memory here
        System.out.println(a.value);
    }
}

6 5 7 null
40

String a = new String("hi");
String b = new String("hi");
boolean same = (a == b);

String a = new String("hi");
String b = new String("hi");
boolean same = a.equals(b);

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 9;

int[] a = {1, 2, 3};
int[] b = a.clone();
b[0] = 9;

Box[] row = new Box[2];
row[0].value = 3;

Box[] row = new Box[2];
row[0] = new Box(0);
row[0].value = 3;

static void reset(Box b) {
    b = new Box(0);
}

static void reset(Box b) {
    b.value = 0;
}

Syntax to memorise

Goal You can write the eleven Java skeletons below from memory, shortest first, with every bracket and semicolon in place.

Some code cannot be worked out on the spot. You must know its shape without looking. The eleven shapes in this lesson are the ones Java needs again and again. They are short enough to learn by heart. Learn them in this order, shortest first, and add the next one only when the last is solid.

1. A class. 2. main. 3. A constructor. 4. for-each. 5. length, length() and size(). 6. String methods. 7. ArrayList. 8. HashMap. 9. try and catch. 10. Generics. 11. interface and extends.

How to memorise: cover the page and write the shape on paper. Compare it with the page, character by character. Tick it only when it is right with no peeking. Do it again tomorrow. A shape that you write correctly three days in a row is learned.

The program below contains all eleven shapes, each marked with a comment such as (4). Read it once. Then cover it and write each shape on its own, in a few lines of your own paper.

Three spellings of "how many". An array has a field, so there are no brackets: nums.length. A String has a method, so there are brackets: word.length(). An ArrayList or a HashMap has a method called size(): names.size(). A way to remember: only the plain array has no brackets.

String methods. Positions start at 0, and a String never changes: every method gives you a new value. length() is the number of characters. charAt(i) is one char. substring(from, to) takes the characters from position from up to, but not including, position to. indexOf("x") is the position of the first x, or -1 when there is none. equals(other) compares the text. toUpperCase() gives a new String in capitals. contains("x") says whether x occurs.

ArrayList: ArrayList<String> names = new ArrayList<>(); with add(x), get(i), set(i, x), remove(i), size(), contains(x). HashMap: HashMap<String, Integer> ages = new HashMap<>(); with put(key, value), get(key), containsKey(key), remove(key), size(). The types inside the angle brackets must be classes: Integer, not int. Both need an import line at the top.

import java.util.ArrayList;
import java.util.HashMap;

/* (11) interface and extends */
interface Shape {
    double area();
}

class Rect implements Shape {
    private double width;
    private double height;

    /* (3) constructor */
    Rect(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return width * height;
    }
}

class Square extends Rect {
    Square(double side) {
        super(side, side);
    }
}

/* (10) generics */
class Box<T> {
    private T item;

    Box(T item) {
        this.item = item;
    }

    T get() {
        return item;
    }
}

/* (1) a class */
public class Main {
    static <T extends Comparable<T>> T larger(T a, T b) {
        if (a.compareTo(b) >= 0) {
            return a;
        }
        return b;
    }

    /* (2) main */
    public static void main(String[] args) {
        /* (7) ArrayList */
        ArrayList<String> names = new ArrayList<>();
        names.add("Leon");
        names.add("Mia");
        names.add("Emma");

        /* (8) HashMap */
        HashMap<String, Integer> ages = new HashMap<>();
        ages.put("Leon", 20);
        ages.put("Mia", 22);

        /* (4) for-each */
        for (String name : names) {
            if (ages.containsKey(name)) {
                System.out.println(name + " is " + ages.get(name));
            } else {
                System.out.println(name + " has no age");
            }
        }

        /* (5) length, length() and size() */
        int[] nums = new int[3];
        String word = "banana";
        System.out.println(nums.length + " " + word.length() + " " + names.size());

        /* (6) String methods */
        System.out.println(word.substring(1, 3) + " " + word.indexOf("n") + " " + word.charAt(0) + " " + word.toUpperCase() + " " + word.equals("banana"));

        Shape s = new Square(3);
        System.out.println(s.area());
        System.out.println(larger("pear", "apple"));
        Box<Integer> box = new Box<>(7);
        System.out.println(box.get());

        /* (9) try and catch */
        try {
            int x = Integer.parseInt("12a");
            System.out.println(x);
        } catch (NumberFormatException e) {
            System.out.println("not a number");
        }
    }
}

Leon is 20
Mia is 22
Emma has no age
3 6 3
an 2 b BANANA true
9.0
pear
7
not a number

int a = nums.length();
int b = word.length;
int c = names.length();

int a = nums.length;
int b = word.length();
int c = names.size();

String word = "banana";
String part = word.substring(1, 3);

String word = "banana";
String part = word.substring(1, 4);

for (String name in names) {
    System.out.println(name);
}

for (String name : names) {
    System.out.println(name);
}

class Rect {
    private double width;

    public void Rect(double width) {
        this.width = width;
    }
}

class Rect {
    private double width;

    public Rect(double width) {
        this.width = width;
    }
}

Common handwriting mistakes

Goal You can read your own Java answer a second time, as the compiler would, and catch the slips that would otherwise cost marks.

On a computer, the compiler stops you at the first error and tells you the line. On paper, nobody stops you, and every one of these slips costs marks even though it has nothing to do with whether you understand the problem. So you must be your own compiler.

When your answer is finished, read it a second time. This time do not ask whether the logic is right. Ask only whether the form is right. Use this list, and tick each item with your pen.

1. Every statement ends with a semicolon. There is none after a closing brace of a class, method, if or for.
2. Every ( [ { has its partner. Count the braces in pairs.
3. Every variable has a type before its name. String starts with a capital S.
4. Every class from java.util has an import line.
5. = stores a value. == asks a question about numbers and chars. For Strings, use equals.
6. Strings use double quotes. A single char uses single quotes.
7. A method that is not void returns a value on every path.
8. Putting a double into an int needs a cast.
9. Collections hold classes: Integer, not int.
10. A local variable has a value before you read it.
11. A method that implements an interface method is marked public.
12. The class name matches the file name, and main is written exactly.

Below are four pairs that cost the most marks. In each pair the first block is what people write, and the second block is the repair.

ArrayList<int> nums = new ArrayList<>();
nums.add(5);
int first = nums[0];

ArrayList<Integer> nums = new ArrayList<>();
nums.add(5);
int first = nums.get(0);

class Rect implements Shape {
    double area() {
        return 1.0;
    }
}

class Rect implements Shape {
    public double area() {
        return 1.0;
    }
}

double x = 7 / 2.0;
int half = x;
String s = 'hi';

double x = 7 / 2.0;
int half = (int) x;
String s = "hi";

static int sign(int x) {
    if (x > 0) {
        return 1;
    } else if (x < 0) {
        return -1;
    }
}

static int bump() {
    int n;
    n++;
    return n;
}

static int sign(int x) {
    if (x > 0) {
        return 1;
    } else if (x < 0) {
        return -1;
    }
    return 0;
}

static int bump() {
    int n = 0;
    n++;
    return n;
}

Mark yourself

Goal You can mark your own paper answer honestly against a rubric, find where the marks went, plan tomorrow's practice, and write under time.

On paper, a page of writing can look finished and still be wrong. Marking yourself fixes that. You compare your answer with a rubric. A rubric is a list of lines, each worth a number of marks, each describing something that you can see in the answer. Be strict. The mark that counts is the one a stranger would give.

How to read a rubric, line by line.

1. Read one line. Ask: what exactly would I see in a correct answer?
2. Find that thing in your answer and touch it with the tip of your pen. If you can point to it, tick the line and write its marks. If you cannot point to it, the line is worth zero.
3. Do not give half marks for "nearly". Give part of a line only if the rubric says how it splits.
4. Check every path. A line such as "handles the empty list" is zero if only the normal case works.
5. Add up the lines. Write the total as marks out of the maximum on the page.

How to find where the marks went. Put each lost mark into one of four boxes. Idea: I did not know how to solve it. Recall: I knew, but could not remember the syntax or the method name. Slip: a small mistake in something I did know, such as a missing semicolon or a wrong sign. Time: I ran out of time. Count each box. The biggest box tells you what to work on. Idea: reread the lesson. Recall: more cover-and-write practice. Slip: the compiler pass from the last lesson and a tiny test. Time: practise planning.

What to do the next day. First, rewrite the same answer on a blank page without looking. Second, do a different question of the same kind. Third, mark both again. Repeat after three days and after a week. When the biggest box changes, you are improving.

How to write under time.

1. Plan first. Use the first tenth of the time. Write the method header and three or four comment lines that name the steps. Do not skip this.
2. Leave a blank line between lines of code. You will need room to insert a line you forgot.
3. Name variables clearly: count, not c; longest, not l. Clear names stop you from mixing up two variables.
4. Test with a tiny input, by hand. When the code is written, run it on the smallest case: one element, an empty list, a word of length 1. Then run one case that sits exactly on a boundary. This takes a minute and finds most boundary errors.
5. Spend about one minute per mark. If you are stuck on a part, write a comment saying what you would do, move on, and come back.
6. Leave two minutes for the compiler pass.

On the Practice page, the questions of kind Write code have a Paper mode with a timer, a model answer and a rubric with tick boxes. Use it exactly like this lesson: write on paper, then mark.

import java.util.ArrayList;

public class Main {
    /* A student's answer. It has one bug. */
    static int countLong(ArrayList<String> words, int min) {
        int count = 0;
        for (String w : words) {
            if (w.length() > min) {
                count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        ArrayList<String> words = new ArrayList<>();
        words.add("a");
        words.add("bb");
        words.add("cc");
        words.add("ddd");
        System.out.println(countLong(words, 2) + " (expected 3)");
    }
}

1 (expected 3)

for (int i = 0; i <= words.size(); i++) {
    System.out.println(words.get(i));
}

for (int i = 0; i < words.size(); i++) {
    System.out.println(words.get(i));
}

static int total(ArrayList<Integer> xs) {
    for (int x : xs) {
        int sum = 0;
        sum = sum + x;
    }
    return sum;
}

static int total(ArrayList<Integer> xs) {
    int sum = 0;
    for (int x : xs) {
        sum = sum + x;
    }
    return sum;
}

static void total(ArrayList<Integer> xs) {
    int sum = 0;
    for (int x : xs) {
        sum = sum + x;
    }
    System.out.println(sum);
}

static int total(ArrayList<Integer> xs) {
    int sum = 0;
    for (int x : xs) {
        sum = sum + x;
    }
    return sum;
}