Programs, source code and machine code

Inside every computer is a chip that does the actual work. It's called the processor, or CPU. It is very fast and very literal. It doesn't understand English, and it doesn't understand C++ or Python either. It understands only numbers. Each small group of numbers tells it to do one tiny thing, like "add these two numbers" or "jump back to an earlier step". A program written as those numbers is called machine code.

Nobody wants to write a game or a banking app as long lists of numbers. So people write in a programming language instead. The text they write is called source code. It's ordinary text you can read, kept in a file such as add.cpp. A program is the whole set of steps a computer can follow, whichever way it's written down.

To get from readable text to numbers, you need a translator. A compiler is a translating program. It reads all of your source code and writes out the machine code. Here's a one-line piece of C++ that adds two numbers:

int add(int a, int b) { return a + b; }

A compiler called Clang turns it into four numbers: 141, 4, 55, 195. That's when it builds for Linux on the kind of chip in most PCs, with its speed setting turned on. The first three mean "add the two numbers". The last one, 195, means "I'm done, go back". That really is all the processor sees.

The compiler saves the translated program in a file called an executable. That's the file you double-click, or start by name.

Two things follow from this. First, the numbers only mean "add" to one family of chips. A phone or an Apple-silicon Mac has a different family of chip that would read 141, 4, 55, 195 as something else entirely. So a program has to be translated separately for each family. Windows, macOS and Linux also each wrap the numbers in their own kind of file. Second, the chip never runs anything except machine code. Every program you have ever used, in any language, became numbers like these before the chip could follow it.

A program is a set of instructions a computer can follow. A person writes it as source code: plain text in a programming language, saved in files such as add.cpp. Source code is written for people to read and change.

The chip that carries out a program is the processor, also called the CPU (central processing unit). A processor cannot read source code. It reads machine code: a program encoded as numbers, in a format fixed by the processor's family. Each small group of numbers is one simple step, such as "add these two values" or "go back to the step before".

A compiler translates source code into machine code before the program runs. Here is a real case. The C++ line below defines add, a piece of code that adds two whole numbers and hands back the result:

int add(int a, int b) { return a + b; }

Clang, a C++ compiler, translates it into four numbers (written here in ordinary decimal). That is when it builds for Linux on the kind of processor found in most PCs, with its optimizer switched on (-O1):

141 4 55 195

The first three numbers are one step, "add the two inputs and keep the result". The last number, 195, is the step "go back to whoever asked". The compiler writes the finished machine code into an executable: a file holding a complete machine-code program that the computer's system software (Windows, macOS or Linux) knows how to start.

Two facts follow, and the whole course rests on them:

1. Machine code is specific. The four numbers above mean "add" only to one family of processors. A different family (an Apple-silicon Mac, a phone) reads the same numbers as something else, so it needs its own translation. Each system also packages executables its own way, so an executable, as built, targets one processor family and one system. Chapter 1 shows the translators that bend this rule.
2. Nothing else runs. However a program was written, the processor ends up following machine code, because that is all it can follow.

If the chip only follows numbers, how did your Python or Java programs ever work? They did get turned into numbers. Some other program just did it for you, out of sight. There are three ways this happens.

C++ (and C and Rust): translate everything first. A compiler reads your whole file and writes out an executable, a file of machine code made from your program. When you run it, the chip follows those numbers directly. Nobody else is involved.

Java and C#: translate halfway, then let a helper finish. The Java or C# compiler translates your code ahead of time, but not into real machine code. It writes bytecode, numbers for an imaginary chip that isn't built anywhere. A helper program called a virtual machine runs that bytecode. The helper is itself ordinary machine code. While your program runs, it rewrites the busiest parts of your bytecode into real machine code (this is called JIT, "just in time", compiling). Those numbers normally live only while the program runs, and you never see them.

Python: a reader that follows along. An interpreter is a program that reads your program and does what it says, line by line, itself. The python command is one. It was written in C and compiled long ago into machine code. When you run your file, the chip is following the interpreter's numbers, while the interpreter reads your lines. Run the usual way, your own Python code never becomes machine code of its own.

So whichever language you used, the chip ended up following numbers. But only in C++ are those numbers made from your program and saved in a file you can open. That's why this course uses C++: you can see what your code turned into.

It also explains speed. Python's interpreter has to do a lot of work to perform one line of your code, while a compiled C++ program does that line in a handful of steps.

There are three common routes from source code to the processor.

• Compiled ahead of time (C++, C, Rust). A compiler such as clang++, g++ or Microsoft's cl translates your source into machine code for one processor family and one system, and writes an executable. When you run it, the processor follows your program's machine code directly. No translator is present at run time.
• Compiled to bytecode (Java, C#). javac (Java) or the C# compiler (run by dotnet build) also translates ahead of time, but into bytecode: numbers for an imaginary processor that doesn't exist as a chip. A virtual machine (the JVM for Java, the .NET runtime for C#) runs it. The virtual machine is itself an ordinary machine-code program. It contains a JIT ("just-in-time") compiler that turns the bytecode into real machine code while the program runs. That machine code normally exists only while the program is running, so you never see it unless you ask the runtime to print it.
• Interpreted (Python). An interpreter is a program that reads another program and carries it out itself, step by step, without first turning it into machine code of its own. The standard python command (CPython) is an interpreter written in C and compiled to machine code. It reads your .py file (internally, after a quick conversion to its own bytecode) and does what each line says. The processor runs the interpreter's machine code, not yours. (CPython 3.13 and later include an experimental JIT, but it is off by default.)

So in every case the processor runs machine code. Only on the first route is it the machine code of your program, sitting in a file you can open. That is why this course reads C++: a C++ compiler shows what your code became, with nothing in between.

The routes are also why speeds differ. An interpreter performs many machine-code steps to perform one Python line, and a C++ executable performs a few. A JIT closes much of that gap, but only after running for a while.