Compilers Roadmap

Trace a program from the characters you typed to the moment something executes, name which stage would report a given error before you look, and choose an execution strategy for a new language — interpreter, bytecode VM, ahead-of-time native — from the constraints rather than from taste.

Write a grammar that settles precedence and associativity instead of leaving them ambiguous, hand-write a lexer and either a recursive-descent or a Pratt parser against it, and recover from a syntax error well enough to report the second one — with a message that names what was expected.

Design AST nodes that later passes can pattern-match on without knowing the grammar, build a symbol table that resolves every identifier to a declaration under shadowing, and say for any given error whether it belongs to the parser, the resolver or the type checker.

Apply a typing rule by hand, run unification far enough to infer a type nobody wrote down, decide between erasure, reification and monomorphization knowing what each costs at run time, and read an ownership or lifetime error as the proof obligation it actually is.

Lower an AST to three-address code, split it into basic blocks and build the dominator tree, insert phi nodes in the right places and leave SSA again without breaking the program, and run a data-flow analysis to a fixed point on paper.

Apply the classic transformations by hand and state the precondition that makes each one legal, predict which of them a compiler will decline to apply to your code and why, and explain a surprising result in terms of undefined behavior or the as-if rule rather than in terms of cleverness.

Follow IR through instruction selection and scheduling to encoded bytes, allocate registers under pressure and predict which value spills before you run the allocator, and read an ABI closely enough to explain why two objects that both compiled will not link.

Diagnose a link failure from the symbol it names, design a bytecode instruction set and the dispatch loop that runs it, explain a JIT deoptimization from the guard that failed, and lower a closure, an exception or an async function to ordinary control flow with pencil and paper.

Describe the actual route from source to behavior for Python, JavaScript, TypeScript, C++, Rust and Go without flattening six different stories into one, use LLVM and WebAssembly as the things they are rather than as brand names, and turn down a DSL proposal for reasons you can defend.

Test a compiler the way its own authors do, work inside an optimized build without being defeated by debug info, keep a large build proportional to the change rather than to the codebase, validate a model-generated plan as the untrusted program it is, and finish AtlasLang end to end.