Compilers and Interpreters: How Code Actually Runs — Everything Developers Need to Know

Source Code → [Lexer] → Tokens → [Parser] → AST → [Semantic Analysis] → IR → [Optimization] → [Code Gen] → Execution

# Input: "let x = 42 + y;"
# Output tokens:
# [LET, "let"] [IDENT, "x"] [ASSIGN, "="] [NUMBER, "42"]
# [PLUS, "+"] [IDENT, "y"] [SEMICOLON, ";"]

import re
from enum import Enum, auto
from dataclasses import dataclass
from typing import List

class TokenType(Enum):
    NUMBER = auto()
    PLUS = auto()
    MINUS = auto()
    STAR = auto()
    SLASH = auto()
    LPAREN = auto()
    RPAREN = auto()
    IDENT = auto()
    ASSIGN = auto()
    LET = auto()
    EOF = auto()

@dataclass
class Token:
    type: TokenType
    value: str
    line: int
    col: int

KEYWORDS = {"let": TokenType.LET}

TOKEN_PATTERNS = [
    (r'\d+(\.\d+)?', TokenType.NUMBER),
    (r'[a-zA-Z_]\w*', TokenType.IDENT),
    (r'\+', TokenType.PLUS),
    (r'-', TokenType.MINUS),
    (r'\*', TokenType.STAR),
    (r'/', TokenType.SLASH),
    (r'\(', TokenType.LPAREN),
    (r'\)', TokenType.RPAREN),
    (r'=', TokenType.ASSIGN),
]

def tokenize(source: str) -> List[Token]:
    tokens = []
    pos = 0
    line = 1
    col = 1

    while pos < len(source):
        if source[pos] in ' \t':
            pos += 1
            col += 1
            continue
        if source[pos] == '\n':
            pos += 1
            line += 1
            col = 1
            continue

        matched = False
        for pattern, token_type in TOKEN_PATTERNS:
            regex = re.compile(pattern)
            match = regex.match(source, pos)
            if match:
                value = match.group()
                actual_type = KEYWORDS.get(value, token_type)
                tokens.append(Token(actual_type, value, line, col))
                pos = match.end()
                col += len(value)
                matched = True
                break

        if not matched:
            raise SyntaxError(
                f"Unexpected char '{source[pos]}' at {line}:{col}"
            )

    tokens.append(Token(TokenType.EOF, "", line, col))
    return tokens

# Test
source = "let x = 42 + y"
for tok in tokenize(source):
    print(f"{tok.type.name:8} | {tok.value}")

LET      | let
IDENT    | x
ASSIGN   | =
NUMBER   | 42
PLUS     | +
IDENT    | y
EOF      |

@dataclass
class NumberNode:
    value: float

@dataclass
class BinaryOpNode:
    left: any
    op: str
    right: any

@dataclass
class AssignNode:
    name: str
    value: any

class Parser:
    def __init__(self, tokens: List[Token]):
        self.tokens = tokens
        self.pos = 0

    def current(self) -> Token:
        return self.tokens[self.pos]

    def eat(self, token_type: TokenType) -> Token:
        token = self.current()
        if token.type != token_type:
            raise SyntaxError(
                f"Expected {token_type}, got {token.type}"
            )
        self.pos += 1
        return token

    def parse_expression(self):
        left = self.parse_term()
        while self.current().type in (TokenType.PLUS, TokenType.MINUS):
            op = self.eat(self.current().type).value
            right = self.parse_term()
            left = BinaryOpNode(left, op, right)
        return left

    def parse_term(self):
        left = self.parse_factor()
        while self.current().type in (TokenType.STAR, TokenType.SLASH):
            op = self.eat(self.current().type).value
            right = self.parse_factor()
            left = BinaryOpNode(left, op, right)
        return left

    def parse_factor(self):
        token = self.current()
        if token.type == TokenType.NUMBER:
            self.eat(TokenType.NUMBER)
            return NumberNode(float(token.value))
        elif token.type == TokenType.LPAREN:
            self.eat(TokenType.LPAREN)
            node = self.parse_expression()
            self.eat(TokenType.RPAREN)
            return node
        elif token.type == TokenType.IDENT:
            self.eat(TokenType.IDENT)
            return token.value
        raise SyntaxError(f"Unexpected token: {token}")

    AssignNode
    ├── name: "x"
    └── value: BinaryOpNode(+)
              ├── NumberNode(42)
              └── BinaryOpNode(*)
                        ├── "y"
                        └── NumberNode(2)

PRECEDENCE = {
    TokenType.PLUS: 10,
    TokenType.MINUS: 10,
    TokenType.STAR: 20,
    TokenType.SLASH: 20,
}

def pratt_parse(parser, min_bp=0):
    left = parser.parse_factor()

    while True:
        op = parser.current()
        bp = PRECEDENCE.get(op.type, 0)
        if bp <= min_bp:
            break
        parser.eat(op.type)
        right = pratt_parse(parser, bp)
        left = BinaryOpNode(left, op.value, right)

    return left

JavaScript Source
    ↓
  Parser → AST
    ↓
  Ignition (Bytecode Interpreter)
    ↓ (Collects profiling data)
  TurboFan (Optimizing JIT Compiler)
    ↓
  Optimized Machine Code
    ↓ (Deoptimization — if assumptions break)
  Fall back to Ignition

// Good pattern — same Hidden Class shared
function Point(x, y) {
  this.x = x;  // Hidden Class C0 → C1
  this.y = y;  // Hidden Class C1 → C2
}
const p1 = new Point(1, 2);  // Shape: C2
const p2 = new Point(3, 4);  // Shape: C2 (same!)

// Bad pattern — Hidden Class mismatch
const a = {};
a.x = 1;
a.y = 2;  // Shape: S1

const b = {};
b.y = 2;  // Different order!
b.x = 1;  // Shape: S2 (different Shape!)

function getX(obj) {
  return obj.x;  // Inline Cache created here
}

// Monomorphic (1 Shape) — fastest
getX(p1);  // Cached for Shape C2
getX(p2);  // Shape C2 — cache hit!

// Polymorphic (2-4 Shapes) — slightly slower
// Megamorphic (5+ Shapes) — slow, generic path

import dis

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# View bytecode
dis.dis(fibonacci)

  2           0 LOAD_FAST                0 (n)
              2 LOAD_CONST               1 (1)
              4 COMPARE_OP               1 (<=)
              6 POP_JUMP_IF_FALSE       12

  3           8 LOAD_FAST                0 (n)
             10 RETURN_VALUE

  4     >>   12 LOAD_GLOBAL              0 (fibonacci)
             14 LOAD_FAST                0 (n)
             16 LOAD_CONST               2 (1)
             18 BINARY_SUBTRACT
             20 CALL_FUNCTION            1
             ...

# GIL makes multithreading inefficient for CPU-bound tasks
import threading
import time

def cpu_bound(n):
    count = 0
    for i in range(n):
        count += i
    return count

# Single thread
start = time.time()
cpu_bound(50_000_000)
cpu_bound(50_000_000)
print(f"Single: {time.time() - start:.2f}s")

# Multi-thread (can be slower due to GIL)
start = time.time()
t1 = threading.Thread(target=cpu_bound, args=(50_000_000,))
t2 = threading.Thread(target=cpu_bound, args=(50_000_000,))
t1.start(); t2.start()
t1.join(); t2.join()
print(f"Multi:  {time.time() - start:.2f}s")

# Solution: use multiprocessing
from multiprocessing import Pool
start = time.time()
with Pool(2) as p:
    p.map(cpu_bound, [50_000_000, 50_000_000])
print(f"Multi-process: {time.time() - start:.2f}s")

CPython:  fibonacci(35) → ~4.5 seconds
PyPy:     fibonacci(35) → ~0.3 seconds (roughly 15x faster)

// Hello.java
public class Hello {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 1000; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

# Compile
javac Hello.java

# View bytecode
javap -c Hello.class

public static void main(java.lang.String[]);
  Code:
     0: iconst_0
     1: istore_1        // sum = 0
     2: iconst_0
     3: istore_2        // i = 0
     4: iload_2
     5: sipush  1000
     8: if_icmpge  21   // if i >= 1000 goto 21
    11: iload_1
    12: iload_2
    13: iadd
    14: istore_1        // sum += i
    15: iinc    2, 1    // i++
    18: goto    4
    21: ...             // println

Bytecode Execution (Interpreter)
    ↓ (Method invocation counter)
  C1 Compiler (Fast compilation, basic optimizations)
    ↓ (More executions)
  C2 Compiler (Slow compilation, aggressive optimizations)
    ↓
  Optimized Machine Code

# GraalVM Native Image — AOT compilation
native-image -jar myapp.jar -o myapp

# Result: native binary with ~20ms startup time
# JVM: ~2s startup → GraalVM Native: ~20ms startup

Frontend           Middle-end            Backend
(per language)     (shared)              (per target)
                                     ┌→ x86_64
Clang ─┐         ┌→ Opt. Passes ────┤→ ARM
       ├→ LLVM IR ┤                  └→ WASM
rustc ─┤         └→ Analysis Passes
       │
swiftc ┘

; Function: add(a, b) = a + b
define i32 @add(i32 %a, i32 %b) {
entry:
  %result = add i32 %a, %b
  ret i32 %result
}

; Function: factorial(n)
define i64 @factorial(i64 %n) {
entry:
  %cmp = icmp sle i64 %n, 1
  br i1 %cmp, label %base, label %recurse

base:
  ret i64 1

recurse:
  %n_minus_1 = sub i64 %n, 1
  %sub_result = call i64 @factorial(i64 %n_minus_1)
  %result = mul i64 %n, %sub_result
  ret i64 %result
}

# Apply LLVM optimization passes
opt -O2 input.ll -o optimized.ll

# Key optimization passes:
# -mem2reg     : Promote memory access to registers
# -inline      : Function inlining
# -gvn         : Global Value Numbering (remove redundant computation)
# -licm        : Loop Invariant Code Motion
# -loop-unroll : Loop unrolling
# -sccp        : Sparse Conditional Constant Propagation
# -dce         : Dead Code Elimination

// Before optimization
int x = 3 + 4;
int y = x * 2;

// After constant folding
int x = 7;
int y = 14;

1. Mark phase: Mark all reachable objects from roots
2. Sweep phase: Free memory of unmarked objects

Roots:
  - Global variables
  - Local variables on the stack
  - Registers

[A] → [B] → [C]
       ↓
      [D]

[E] → [F]  (Unreachable from roots → collected)

Young Generation (Minor GC — frequent, fast)
  ├── Eden Space (new object allocation)
  ├── Survivor 0
  └── Survivor 1

Old Generation (Major GC — infrequent, slow)
  └── Long-lived objects

GC process:
1. New objects → allocated in Eden
2. When Eden fills up → Minor GC
3. Survivors → moved to Survivor space
4. After N survivals → promoted to Old Generation
5. When Old Generation fills → Major GC

Traditional GC:  Stop-the-World → Mark → Compact → Resume
                 (long pause)

ZGC:             Application and GC run concurrently
                 (pointer coloring + load barriers for consistency)

Pointer Coloring:
  Upper bits of 64-bit pointers used for GC metadata
  [metadata bits][actual address bits]

  - Marked0 bit: first marking cycle
  - Marked1 bit: second marking cycle
  - Remapped bit: object has been relocated
  - Finalizable bit: finalizer pending

// Input: ES2022+
const greet = (name) => `Hello, ${name}!`;
const items = [1, 2, 3];
const doubled = items.map(x => x * 2);

// After Babel: ES5
"use strict";
var greet = function greet(name) {
  return "Hello, " + name + "!";
};
var items = [1, 2, 3];
var doubled = items.map(function (x) {
  return x * 2;
});

TypeScript Source
    ↓
  Parser → AST
    ↓
  Binder → Symbol Table
    ↓
  Type Checker → Type errors reported
    ↓
  Emitter → JavaScript + .d.ts + .map

# esbuild benchmark example
# Bundling 10,000 modules:
# Webpack:   40 seconds
# esbuild:    0.4 seconds