Code as Data - early release (Bryan Friedman, Pat Johnson etc.)（Z-Library）

# Code as Data: Governing and Evolving Large-Scale Codebases in the Era of AI ## 【One-Line Pitch】 A practical framework for engineering leaders and architects who need to govern sprawling, multi-repository software estates by treating source code as structured, queryable data—enabling precise analysis, automated transformation, and reliable AI agent oversight. ## 【Book Arc】 - **Opening (~0%–12%)**: Introduces the core problem—modern software estates span thousands of repositories with billions of lines of code, yet existing tools (grep, static analysis, SCA, spreadsheets) provide incomplete representations that can't answer critical questions about dependencies, vulnerabilities, or upgrade paths. - **Early (~12%–29%)**: Examines the "code intelligence gap" through concrete questions organizations routinely fail to answer, and shows how AI agents inherit these limitations—reconstructing context from scratch, inferring instead of knowing, and scaling uncertainty with velocity. - **Middle (~29%–41%)**: Makes the case for a new operating model: compiler-accurate semantic representation of code as the foundation for both human and agent understanding, positioning this shift as the infrastructure challenge of the AI era. - **Middle (~41%–53%)**: Introduces the Lossless Semantic Tree (LST)—a code representation that preserves formatting, fully resolves types and symbols across the classpath, and honestly represents its own knowledge limits—as the technical solution underpinning OpenRewrite and Moderne's platform. - **Late (~53%–65%)**: Demonstrates LSTs in practice: building artifacts through compiler phases, serializing them as persistent portfolio-scale assets, and using deterministic "recipes" for search and transformation across repositories simultaneously. ## 【Key Takeaways】 - **Text-based code analysis is fundamentally insufficient** (Early): Grep and syntax tools strip away executable meaning—types, symbols, resolved call targets—making precise reasoning across an estate impossible. The IDE's compiler-accurate model was a breakthrough, but it stopped at repository boundaries. - **The multi-repo estate exceeds human cognitive capacity** (Early): Mid-sized companies manage thousands of repositories; enterprises have tens of thousands with billions of lines of code and millions of transitive dependencies. No single team can hold this structure in their head. - **Existing governance tools carry a persistent tax** (Early): Static analysis, SCA, and architecture catalogs produce false positives, alert fatigue, and stale data because their underlying representations are inherently incomplete—they show declarations, not reachable behavior. - **AI agents amplify the problem rather than solving it** (Early–Middle): Agents reason in the dark without authoritative context, reconstructing understanding from scratch each time—expensive, inconsistent, and disconnected from how the system actually fits together. - **The Lossless Semantic Tree (LST) is the key representation** (Middle): It achieves compiler-accurate type resolution—every node knows its fully-qualified type, resolved return types, and argument types—while preserving formatting so transformations produce output indistinguishable from original source. - **Honest representation of knowledge limits matters** (Middle): When types can't be resolved or files can't be parsed, the LST holds placeholders rather than fabricating answers—knowing precisely what you don't know is as useful as knowing what you do. - **Serialized LSTs enable portfolio-scale analysis** (Late): Storing LSTs as persistent, versioned artifacts alongside compiled bytecode transforms them from ephemeral build outputs into queryable assets—parse once, query many times across dozens of repositories. - **Deterministic recipes enable safe automated transformation** (Late): Unlike ad hoc scripts or probabilistic AI suggestions, recipes produce identical output for identical input, are composable into complex workflows, and emit structured data tables for governance. ## 【Reading Tips】 - **Deep-read Chapter 1's "Impossible Questions" list** (~24%–29%): Use it as a self-assessment for your organization—if you can't answer three or more within an hour, you have a code intelligence gap worth addressing. - **Focus on the LST specification section** (~47%–53%): The three-layer model (markers, syntax, type attribution) and the vulnerability example (logger.info call sites) are the conceptual core—understand these before moving on. - **Skim the early history of IDEs and grep** (~12%–18%): The historical framing is useful context but not essential; the key insight is that repository-boundary thinking is obsolete. - **Pay attention to the "honest limits" discussion** (~53%): This is a differentiator from other analysis approaches and critical for trusting automated systems—note how placeholders signal gaps deliberately. - **Note what's missing**: The early release covers only Chapters 1–2; chapters on unified codebase views, SBOMs, security analysis, AI governance, and automated action are listed but unavailable in this edition. ## 【Coverage Limits】 This guide covers the available early-release content (Chapters 1–2, approximately 65% of the book). The table of contents indicates later chapters on unified codebase views, security analysis, AI model governance, and automated action, but those sections were not available in the source material. ##