Programs, source code, and compilers

A program is a set of steps a computer follows to get a job done. Your alarm app is a program. Its steps are roughly: wait until 7:00, then play a sound.

The chip inside a computer that follows the steps is called the processor. It is very fast and very literal. It only understands steps written as numbers, one tiny step at a time, like "add these two numbers" or "move this number over there". Steps written in that number form are called machine code. A phone's chip and a laptop's chip don't even speak the same number language.

People don't write numbers like that. They write words and symbols a person can read, using a coding language like Rust. That readable text is called source code. You type it into an ordinary text file. A Rust source file's name ends in .rs, the way a photo's name might end in .jpg.

So there's a language gap: you write readable text, and the chip reads only numbers. A compiler closes the gap. It is a translator program. It reads your whole text file, checks that you followed Rust's rules, and then writes a brand-new file of machine code. That new file is called an executable, because it's the file your computer can execute, which means run. Programmers also call it a binary. On Windows its name ends in .exe. On a Mac or on Linux, the name normally stops with no dot and letters after it.

Here's the part that surprises people. The text file and the executable are two different files. Think of a recipe card and the cake baked from it. Crossing out "sugar" on the card doesn't change the cake already on the table. You have to bake again. In the same way, if you change your source code, you have to run the compiler again to get a new executable.

A program is a list of instructions a computer carries out, in order, to do a job. The part of the computer that carries them out is the processor. A processor understands only one kind of instruction: machine code, small operations such as "add these two numbers" or "copy these bytes", each stored as a pattern of numbers. Different processor families (the chips in most laptops, the chips in most phones) use different machine code.

Nobody writes machine code by hand anymore. People write source code: the text of a program in a programming language such as Rust, typed into an ordinary text file. Rust source files end in .rs. Source code is written for people to read and change, so the processor can't use it directly. It has to be translated first.

A compiler is the program that does that translation. It reads the whole source file and checks that it follows the language's rules. Then it writes out an executable (also called a binary): a new file of machine code, plus a little bookkeeping the operating system needs to start it. On Windows an executable's name ends in .exe; on macOS and Linux it usually has no ending at all. The source file and the executable are separate files. Changing one does not change the other, so after you edit the source you must compile again to get a new executable.

Think about getting a speech across a language barrier. One way is to have the whole speech translated in advance, printed, and handed out. The other is to bring a person who stands beside the speaker and turns each sentence into the listeners' language out loud, as it's spoken.

Coding languages come in the same two styles. A compiled language works like the printed copy. Rust is one. The compiler translates your entire program first. Later, as a separate step, you run the result. Because that work is finished, you can give the executable to a friend. It runs on their computer, as long as it has the same kind of chip and the same system, such as Windows. They don't need the compiler. They never see your source code either.

An interpreted language works like the person at the speaker's side. A helper program, called an interpreter, reads your source code and carries it out bit by bit while it runs. Nothing is prepared in advance. So the helper must be installed on each computer where the program is used. And if there's a mistake near the end of the file, nobody finds out until the program reaches that spot. Python, as most people run it, works this way.

The real world is messier than two neat boxes. Many interpreters prepare a little ahead of time, behind the scenes. What matters for this course is when your program gets checked. With Rust, every line is checked before the program exists at all.

There are two broad ways to get from source code to a running program. A compiled language, such as Rust, translates the whole program ahead of time. Compiling is one step and running is a separate, later step, and the executable runs on its own: the person running it needs no compiler and no copy of the source. An interpreted language hands the source code to a helper program called an interpreter, which reads it and carries it out piece by piece while it runs. Nothing is translated ahead of time, so every computer that runs the program needs the interpreter installed, and a mistake late in the file may go unnoticed until that line is reached. Real systems blur the line (many interpreters do some translation internally), but the difference that matters here is when the checking happens: for Rust, all of it happens before the program exists.

Before the compiler writes anything, it reads your whole program and checks it against Rust's rules. Think of a building inspector who checks the plans before any construction starts. If one rule is broken, the compiler stops and prints an error: a message saying which file, which line, and what it expected to see. And it makes no executable. So there's nothing to run, not even the lines above the mistake. That's what people mean when they say "the compiler refused to build it."

Look at the program just below this explanation. Its error message is real, copied from the compiler when this page was built. Line 2 is missing the ; at its end. Without it, the compiler has no way to know where one instruction stops and the next one begins. Its message says three things. First, the complaint: it expected a ; but found the word println. Second, the place: src/main.rs:2:35 means the file src/main.rs, line 2, character 35 along. (Rust projects keep their main file under that name, which you'll see in Chapter 1.) Third, the line itself, with a ^ pointing at the spot and a hint: add ; here.

A refusal feels like a setback, but it's the compiler doing you a favor. Fixing a mistake now takes you a minute. Found later, by someone using your program, the same mistake means a crash, lost work, or worse. Rust's compiler is famously strict. Later chapters show it catching whole families of serious bugs before the program ever runs, bugs other languages only find by crashing.

Before it writes an executable, the compiler checks the whole program against the language's rules. If any rule is broken, it prints an error, which names the file, the line and column, and what it expected, and it writes no executable at all. "The compiler refuses to build it" means this: there is no program to run, not even the lines before the mistake. In the program below the pair of explanations, line 2 lacks its closing ;, so the compiler can't tell where the first instruction ends. Its message reads top to bottom: the complaint, then the location (src/main.rs:2:35 is file, line 2, column 35), then the offending line with a ^ under the exact spot and a suggested fix. The refusal is a feature. A mistake the compiler catches costs a minute at your desk; the same mistake found while the program is running costs a crash in front of whoever is using it. Rust's compiler is unusually strict, and later chapters show it rejecting whole kinds of bugs, such as using memory after it has been handed back, that other languages only discover at run time.