What a program is

A computer does exactly what it is told, and nothing else. A program is the telling: a list of instructions precise enough that a machine with no common sense can follow it. This lesson explains what that list looks like, how it reaches the processor, and how to read one the way a computer does.

Instructions, in order

A program is a sequence of instructions. The computer runs them one at a time, from the top, unless an instruction says to jump somewhere else. Each instruction does something small: store a number, add two numbers, compare two values, print a character.

Here is a five-line program in pseudocode, which is plain, informal notation that is not tied to any language:

set total to 0
set count to 3
while count is greater than 0:
    add count to total
    subtract 1 from count
show total

Most of the line count comes from the loop. A loop repeats its indented lines until the condition stops being true. You will meet loops properly in the lessons on control flow; for now, read them as “do this again while the condition holds”.

Tracing by hand

The most useful skill in this lesson is to be the computer. A trace is a table that records every variable after every step.

The program adds 3 + 2 + 1. Here it is in four real languages. Every one of them prints 6.

total = 0
count = 3
while count > 0:
    total = total + count
    count = count - 1
print(total)

let total = 0;
let count = 3;
while (count > 0) {
  total = total + count;
  count = count - 1;
}
console.log(total);

public class TraceProgram {
    public static void main(String[] args) {
        int total = 0;
        int count = 3;
        while (count > 0) {
            total = total + count;
            count = count - 1;
        }
        System.out.println(total);
    }
}

#include <stdio.h>

int main(void) {
    int total = 0;
    int count = 3;
    while (count > 0) {
        total = total + count;
        count = count - 1;
    }
    printf("%d\n", total);
    return 0;
}

The ideas are identical. What differs is punctuation, and how much ceremony the language wants before the first useful line. Java and C need a main function, and C also needs an #include; Python and JavaScript need neither.

Source code and machine code

What you type is source code: text in a programming language, written for people to read. A processor cannot run text. It runs machine code, a stream of numbers where each pattern means one tiny operation, and different processor families (x86-64, ARM) use different patterns.

So something has to translate. There are two main strategies.

In practice the line is blurry. Python compiles your source to a compact intermediate form called bytecode and then interprets that. Java compiles to bytecode, and a virtual machine then runs it, translating hot sections to machine code on the fly. JavaScript engines do something similar. When a language course says “compiled” or “interpreted”, read it as “mostly”.

The runtime

Whatever the strategy, a program rarely runs alone. The runtime is the supporting machinery present while it runs: memory management, the standard library, error reporting, the virtual machine if there is one. When you hear “the Python runtime” or “the JVM”, this is what is meant.

The REPL

Many interpreted languages offer a REPL: Read, Evaluate, Print, Loop. You type one expression, the interpreter evaluates it, prints the result, and waits for the next. It is the fastest way to test a small idea.

>>> 2 + 3 * 4
14
>>> total = 10
>>> total * 2
20

Most popular languages have one, started with a single command:

C has no standard REPL because C code must be compiled before it can run. The expression 2 + 3 * 4 typed into python3, node or jshell gives 14 in each.

A REPL is for experiments. Anything you want to keep, repeat or share belongs in a file, which is what the next lesson is about.

Common pitfalls

• Reading code as a description instead of a procedure. Code is not a summary of what you want. It is the exact steps, in exact order. If you cannot say what a line does to the variables, trace it.
• Assuming the computer understands intent. If a program adds the wrong numbers, it adds the wrong numbers faithfully.
• Thinking compiled means fast and interpreted means slow. Speed depends on the language, the implementation and the task. Do not decide on that alone.
• Tracing from the end of your memory instead of the table. Write the table. Skipping it is how people mis-predict loops by one.

set result to 1
set n to 4
while n is greater than 1:
    multiply result by n
    subtract 1 from n
show result

set total to 0
set n to 2
while n is at most 8:
    add n to total
    add 2 to n
show total

total = 0
n = 2
while n <= 8:
    total = total + n
    n = n + 2
print(total)

let total = 0;
let n = 2;
while (n <= 8) {
  total = total + n;
  n = n + 2;
}
console.log(total);

public class EvenTotal {
    public static void main(String[] args) {
        int total = 0;
        int n = 2;
        while (n <= 8) {
            total = total + n;
            n = n + 2;
        }
        System.out.println(total);
    }
}

#include <stdio.h>

int main(void) {
    int total = 0;
    int n = 2;
    while (n <= 8) {
        total = total + n;
        n = n + 2;
    }
    printf("%d\n", total);
    return 0;
}

Summary

• A program is an ordered list of precise instructions, and you can predict it by tracing the variables step by step.
• Source code is text for people; machine code is what the processor runs. Compilers translate ahead of time, interpreters translate while running, and many languages mix both.
• The runtime is the machinery present while your program runs.

Next: Editors, terminals and running code, where you will run your first program yourself.