The Compilation Process: From Source Code to Executable

After completing this topic, you will be able to:

• Explain the difference between compilers and interpreters.
• Understand the steps involved in converting source code into machine code.
• Know how Python, JavaScript, and C are executed.

Computers Cannot Read Source Code

The code we write is text for humans.

print("Hello, World!")

What the CPU understands is machine code — instructions in 0s and 1s.

10110000 01001000  (mov al, 'H')
11001101 00100001  (int 21h)

We need to convert source code into machine code. The programs that perform this conversion are called compilers and interpreters.

Compiler vs. Interpreter

Think of it this way: a compiler is like translating a book (translating the whole thing first and then publishing it), and an interpreter is like simultaneous interpretation (translating as you speak).

Compilation Steps: The Case of C

The process of a C code file becoming an executable:

Source Code (.c)
    ↓ Preprocessing
Preprocessed Code
    ↓ Compilation
Assembly Code (.s)
    ↓ Assembly
Object File (.o)
    ↓ Linking
Executable File (a.out / .exe)

1. Preprocessing

#include <stdio.h>
#define MAX 100

int main() {
    printf("Max is %d\n", MAX);
}

The #include directive is replaced with the actual header file content, and #define is replaced with its value. This step involves text substitution.

2. Compilation

The preprocessed code is analyzed and converted into assembly code. Syntax errors are detected here.

mov    edi, OFFSET FLAT:.LC0
mov    esi, 100
call   printf

3. Assembly

Assembly code is converted into machine code (binary instructions). The result is an object file (.o).

4. Linking

Multiple object files and libraries are combined into a single executable file. The actual implementation of printf is in the C standard library, so the linker connects it.

# GCC performs all these steps in one go
gcc hello.c -o hello
./hello

How Python is Executed

Python is a hybrid of compilation and interpretation.

Source Code (.py)
    ↓ Python Compiler
Bytecode (.pyc)
    ↓ Python Virtual Machine (PVM)
Execution Result

# Checking the bytecode
import dis

def add(a, b):
    return a + b

dis.dis(add)
#   LOAD_FAST    0 (a)
#   LOAD_FAST    1 (b)
#   BINARY_ADD
#   RETURN_VALUE

Bytecode is not machine code. The Python Virtual Machine (PVM), which is an interpreter, executes the bytecode line by line. This is slower than the CPU directly executing the code (as in C), but it can run on any operating system.

You may have seen .pyc files appear in the __pycache__/ folder. These are the bytecode caches. If the source code hasn't changed, the cache is used without recompilation.

How JavaScript is Executed

JavaScript engines (V8, SpiderMonkey) use JIT (Just-In-Time) compilation.

Source Code (.js)
    ↓ Parsing
AST (Abstract Syntax Tree)
    ↓ Interpreter
Bytecode Execution (slow)
    ↓ JIT Compiler (detects frequently executed code)
Converted to Machine Code (fast)

Initially, it starts executing with an interpreter for quick startup, and when it detects that "this function has been called 1,000 times?", it compiles that part into machine code. Since it compiles during execution, it is called "Just-In-Time".

Java: The Quintessential Hybrid of Compilation and Interpretation

Java is similar to Python, but more complex.

Source Code (.java)
    ↓ javac (compilation)
Bytecode (.class)
    ↓ JVM (Java Virtual Machine)
    ├── Interpreter (initially)
    └── JIT Compiler (for frequently executed code)
    ↓
Machine Code Execution

// Hello.java
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

javac Hello.java   # Creates bytecode (.class)
java Hello         # JVM executes the bytecode

"Write once, run anywhere" — Java bytecode can run anywhere that has a JVM. A .class file compiled on Windows will also work on a Linux JVM.

Static Typing vs. Dynamic Typing

Type systems are closely related to compilation.

// C: Static typing - Types are checked at compile time
int x = 42;
x = "hello";  // Compile error!

# Python: Dynamic typing - Types are checked at runtime
x = 42
x = "hello"  # OK - Type changes during execution

Practical Implications

Why is Python slower than C?
→ C: The CPU directly executes machine code.
→ Python: The virtual machine interprets and executes bytecode line by line.

Why use TypeScript?
→ Adds static typing to JavaScript → Catches errors before execution.
→ TypeScript → (tsc compilation) → JavaScript → (V8 execution)

Why do Docker images differ for each OS?
→ Compiled binaries are dependent on the CPU architecture (x86, ARM).
→ A macOS binary will not run on Linux.

Key Summary

Build Tools and Transpilers

In modern development, in addition to "pure" compilation/interpretation, there are various other conversion tools.

TypeScript → (tsc) → JavaScript → (V8) → Execution
JSX/React  → (Babel) → JavaScript → (V8) → Execution
Sass/SCSS  → (sass) → CSS → Browser Rendering

A transpiler converts code into a code at the same level. If a compiler converts high-level to low-level, a transpiler converts high-level to high-level. TypeScript to JavaScript and ES6 to ES5 are examples.

"Python is an interpreted language" is only half true — it compiles to bytecode and then interprets it. "JavaScript is an interpreted language" is also only half true — V8 uses JIT compilation. Modern languages mix compilation and interpretation to achieve both development convenience and execution performance.