Compilers

Aho, A. V. (2006). Compilers: Principles, Techniques, and Tools. Pearson.

Type

Book

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

15 citations across 15 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

• Abstract Syntax Tree
  • Compiler and interpreter construction — the canonical home: the AST is the single intermediate form consumed after lexing and parsing, lowered toward machine code by compilers or walked directly for evaluation by interpreters

    This sourceCompiler-construction text in which parsing yields a syntax tree whose nodes represent operators and operands, and from which intermediate representations and then target code are generated.

    Supported in partVerified against the work's full text

    “kind of tree called a syntax tree is used, in which each node represents an”

    Read by an automated reader; not a human review. How support was checked

• 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.

• 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

Does it exist? Confirmed. This work's ISBN resolves to a registered record, which fixes its identity. That is all it fixes.

Does it back the claim? Read against the text for 1 of 15 citations: 1 supported in part. Each verdict is shown under its citation below, with what in the work backs the sentence.

Support is checked per citation rather than per work — the same source can be cited soundly in one article and wrongly in another. Per-citation recording began recently, so a citation with no recorded check is a gap in the record rather than evidence it went unchecked.

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:798f2760952b · see in the full table