Compilers

Alfred V. Aho, M. S. L., Sethi, R., Jeffrey D. Ullman, C. P., & Tools, 2. e. (2006). Compilers: Principles, Techniques, and Tools. Pearson.

Type

Book chapter

Intellectual base

Textbook

Year

2006

ISBN

9780321486813

Link

https://www.pearson.com/en-us/subject-catalog/p/Aho-Compilers-Principles-Techniques-and-Tools-2nd-Edition/P200000003472

Cited from

chemistry_materials, computer_science, literature_literary_theory, mathematics

Cited by

16 citations across 16 artifacts.

Each citation links to the sentence it supports in the citing article.

Primes

• Bootstrapping
  • Computing and operating systems: the firmware boot sequence (a tiny boot sector loads a larger loader that loads the kernel), the compiler bootstrap (a language's compiler written in itself), and meta-circular interpreters, trust chains, and blockchain genesis blocks.

    This sourceDescribes compiler bootstrapping: a self-hosting compiler is built from a minimal initial compiler written in another language, the later fuller compiler compiled by the earlier minimal one — the chicken-and-egg lift requiring a seed that is itself generable from something smaller (T-diagram / bootstrapping notation).

• Dependency
  • Software build systems (Aho, Lam, Sethi, and Ullman 2006; Lattner and Adve 2004). A modern build system like Bazel, Make, or Ninja represents a project as a directed acyclic graph of build targets, where each target depends on input files and other targets.

    This sourceThe "Dragon Book": develops graph-theoretic dependency analysis (data/control dependence, DAGs) used for instruction scheduling and optimization — the compiler-design tradition cited in marker 212 and the software-build examples.

• Directed Acyclic Graph
  • Compilers build expression and control-flow DAGs and static single-assignment forms.

    This sourceExpression and control-flow DAGs (§6.1.1) and static single-assignment form (§6.2.4).

• Fabula And Syuzhet
  • Systems and compiler design. Logical schema versus physical view, abstract syntax tree versus source text: the what held apart from the order of access or rendering.

    This sourceStandard reference for the abstract syntax tree held apart from the concrete source text — the underlying-versus-presented duality in compiler design.

• Operationalization
  • In compilation, source-language programs (spec: behaviour in high-level constructs) are lowered to machine code (procedure: runnable instructions).

    This sourceThe standard reference ("the Dragon Book") on lowering high-level source programs into machine code through a refinement/code-generation pipeline.

• Parsing
  • In computing lexing and parsing source code against a grammar yields an abstract syntax tree, the prerequisite for type-checking, optimization, and code generation, with a family of algorithms trading grammar expressiveness against efficiency.

    This sourceThe standard 'Dragon Book' reference on lexing and parsing source code to an abstract syntax tree, grammar classes, ambiguity, and precedence-as-disambiguation.

• Reaction Intermediate
  • Cell and molecular biology — mRNA between gene and protein, transcribed, translated, then degraded, its concentration regulated independently of either DNA or protein; many diseases are diseases of intermediate dysregulation. Compilers and software — intermediate representations (IR, AST, bytecode) between source and machine code, with internal structure neither endpoint shares and on which most optimizations operate.

    This sourceThe standard compilers text on intermediate representations between source and machine code as the locus of most optimizations.

• Transformation
  • Computer science & data engineering: Abstract syntax tree (AST) transformations in compilers, ETL (extract/transform/load) pipelines in data warehousing, data normalization, feature engineering in machine learning, code refactoring, API transformations (REST to GraphQL, etc.), image transformations (rotation, scaling, color space conversion), as Aho, Lam, Sethi, and Ullman (2006) develop systematically in the canonical "Dragon Book" treatment of source-to-target program transformations.

    This sourceThe "Dragon Book": canonical reference on systematic source-to-target program transformation, including AST rewrites, intermediate representations, and optimization passes.

Domain-specific

• Common operator notation
  • … demonstrates that token classes, operator spellings, arity, fixity, precedence, associativity, grouping, separators, overloading, error recovery, and resulting syntax tree are explicit. to An applied instance preserves the same invariant under a changed scale, notation, jurisdiction, dataset, or implementation..
• Context-Free Grammar
  • Grammar transformations can remove useless symbols, eliminate certain productions, or convert to normal forms while preserving the generated language under stated qualifications.

    This sourceStandard treatment of CFG-based syntax specification and parsing.

• Formula Calculator
  • Exponentiation is often right-associative, so 2^3^2 may mean 2^(3^2)=512; the calculator’s specification controls
• Intermediate representation
  • An intermediate representation is the compiler- or VM-internal program form positioned between source text and final execution or target code.
• Non-local variable
  • A variable occurrence is non-local relative to a program unit when its binding is not declared in that unit's local environment; in the central lexical-scope case, the declaration is found in an enclosing textual scope rather than in the global environment or caller-selected environment.
• Reaching definition
  • The result supports use–definition chains, constant propagation, dead-store reasoning, and other analyses, but path correlation is lost at union joins.
• S-attributed grammar
  • … distinction between constitutive identity and a convenient observable transfers from An expression grammar synthesizes each subtree's numeric value from the values of its operand children. to A compiler verifies dependency acyclicity and distinguishes stored parser-stack values from inherited contextual information..

Mechanisms

• Parser Delimiter Stack
  • Its strength is catching malformed nesting

    This sourceUses syntax analysis to catch malformed parenthesis nesting when the offending delimiter is encountered.

Verification

This reference passed the adversarial substantiation pipeline: it was checked to exist and to support the claim it is attached to. See how references were verified.

Links previously used in the corpus

Before the registry existed this work was also linked 3 other ways.

• https://www.pearson.com/en-us/subject-catalog/p/compilers-principles-techniques-and-tools/P200000003472/9780133002140 ×3
• https://www.pearson.com/en-us/subject-catalog/p/compilers-principles-techniques-and-tools/P200000003472 ×2
• https://www.pearson.com/en-us/subject-catalog/p/compilers-principles-techniques-and-tools/P200000003472/9780321486813 ×1

Registry ID ref:cb901edbf861 · see in the full table