Compilers and Interpreters

Translation of high-level languages to executable code.


foundation tier

Compilers and Interpreters addresses translation of high-level languages to executable code. It sits within Programming and Languages and inherits that area’s core questions about correctness, scale, and tractability. This page surveys the conceptual axes of the topic and points to the references that frame ongoing research and teaching. The intent is to be useful both as an entry point for newcomers and as an index for practitioners cross-checking their mental model against the field’s primary sources.

Work on compilers and interpreters can be organised around a few interlocking concerns: the formal objects under study, the algorithms or systems that compute over them, the resource trade-offs (time, memory, communication, statistical efficiency), and the empirical or theoretical guarantees that practitioners rely on. The sources cited below approach the topic from a mix of these angles.

Foundational references

Aho, Compilers: Principles, Techniques, and Tools (2006) is a standard reference for this material and is used both as a curriculum anchor and as a long-form survey of techniques. Cooper, Engineering a Compiler (2011) is a standard reference for this material and is used both as a curriculum anchor and as a long-form survey of techniques.

Open methodological questions in compilers and interpreters cluster around how to compose the techniques above under realistic constraints — scale, adversarial inputs, partial observability, and shifting workloads. The cited references give the precise statements, proofs, and empirical evaluations that this overview only sketches; downstream topic pages drill into specific subfields.

Prerequisites

Sources

  • textbook · primary · 2006
    Compilers: Principles, Techniques, and Tools
    aho-2006
  • textbook · primary · 2011
    Engineering a Compiler
    cooper-2011

In context

Where this topic sits in the prerequisite graph. Click any node to jump.

Open in full atlas →

Explore

  1. 01

    Lexical Analysis

    Tokenization and finite-automata-based scanners.

  2. 02

    Parsing

    LL, LR, GLR, and PEG parsers.

  3. 03

    Intermediate Representations

    SSA, CPS, and MLIR-style multi-level IRs.

  4. 04

    Dataflow Analysis

    Lattice-based static analyses and constant propagation.

  5. 05

    Abstract Interpretation

    Sound approximate semantics for program analysis.

  6. 06

    Code Generation

    Instruction selection, scheduling, and register allocation.

  7. 07

    Compiler Optimization

    Loop, peephole, and interprocedural optimizations.

  8. 08

    Just-In-Time Compilation

    Tracing JITs, tiered compilation, and dynamic specialization.

  9. 09

    Garbage Collection

    Mark-sweep, generational, concurrent, and region-based GC.

  10. 10

    Superoptimization

    Search-based generation of provably optimal code sequences.

  11. 11

    Machine Learning Compilers

    XLA, TVM, MLIR, and tensor-program compilation.

  12. 12

    GPU Compilation

    CUDA, Triton, and compilation pipelines for accelerators.


Review this topic

This page was drafted by an agent and is waiting on expert review. Spotted a wrong prerequisite, a missing concept, a misattributed source, or a factual slip? Tell us — your review opens a tracked issue maintainers act on.