Executive Summary: 90 Years of Programming Language Design
A 30-minute distillation of a 145,000-word bundle, written for a language designer starting from a running prototype and needing to make the next round of high-leverage decisions.
How to read this document
This is the compressed layer. It restates the ideas that recur across nine decades of language history, sketches the modern landscape as of 2026, maps the eight design camps that structure the field, and closes with five insights specifically relevant to Mo. Every substantive claim links to a primary source that the deeper reports in this bundle already validated — those reports remain the authoritative reference; this file exists to fit the field in one sitting.
The seven ideas that keep recurring
1. Turing-completeness is cheap; useful properties come from removing expressiveness
The Church–Turing thesis established that any two Turing-complete languages compute the same class of functions, so a language’s value lies in ergonomics, safety, and performance rather than raw expressive power (Stanford Encyclopedia of Philosophy: The Church–Turing Thesis). Preserving decidability of interesting semantic properties — halting, type checking, program equivalence — therefore requires removing expressiveness, not adding features. Every totally functional language (Coq, Agda, Dhall), every strongly normalizing type system, and every terminating-by-construction DSL is a response to this observation. Rust’s borrow checker, Austral’s linear types, and Koka’s effect rows all buy their safety by ruling out programs a more expressive language would accept (Austral spec; Koka book).
2. Abstraction has a cost, but the cost is usually cognitive, not runtime
Bjarne Stroustrup’s “zero-overhead” thesis — abstractions you do not use should cost you nothing, and abstractions you do use should compile down to code as efficient as hand-written low-level code — has become mainstream, adopted by Rust, Swift, and (increasingly) modern C++ (Stroustrup, “Thriving in a Crowded and Changing World: C++ 2006–2020”). What is not zero-cost is the cognitive load of learning what the abstractions mean, and where the modern conversation now lives: Wirth’s “A Plea for Lean Software” and Rich Hickey’s “Simple Made Easy” both argue that unbounded feature accretion eventually breaks a language’s teachability, regardless of the runtime cost (Wirth, “A Plea for Lean Software”; Hickey, “Simple Made Easy”).
3. Safety and expressiveness are complementary, not opposed
The 1990s consensus was that dynamic languages (Python, Ruby, JavaScript) were more expressive and static languages (Java, C++) safer. The 2010s dissolved that dichotomy. Rust proved that a static type system can catch data races and use-after-free while remaining ergonomic enough for systems work (Rust 1.0 announcement, 2015; Aaron Turon, “Fearless Concurrency”). TypeScript proved that types can be added incrementally to a dynamic language without losing its expressiveness (TypeScript handbook). Elixir is now adding gradual set-theoretic types on top of a dynamic Erlang-descended language, chasing the same goal from the opposite direction (Elixir gradual types). Robert Harper’s polemic “Dynamic Languages Are Static Languages” — that a dynamic language is a static language with exactly one type — captures the underlying observation (Harper, “Dynamic Languages Are Static Languages”).
4. Ecosystem beats language
Rob Pike’s own defense of Go frames it as designed for “the software engineering done at Google” — not for language purists, but for programmers who need fast compilation, a working toolchain, and a package manager on day one (Pike, “Go at Google”). Cargo, published alongside Rust 1.0 in 2015, arguably did more for Rust’s adoption than any single language feature (Cargo announcement; Cargo documentation). Elm’s compiler-error essays and Rust’s colored diagnostics with structured JSON output made reading errors a design surface rather than a chore (Rust NLL by default announcement). Modern languages that ship without an LSP, formatter, package manager, and doc generator on day one lose momentum they will not recover — a point made vividly across the implementation report (implementation_engineering.md, §11.7).
5. Syntax matters less than semantics — but not zero
The Algol legacy — statement/expression separation, block structure, lexical scope, function abstraction — persisted essentially unchanged through C, Java, JavaScript, and TypeScript. Lisp’s S-expressions, ML’s expression-oriented syntax, and Python’s indentation are all alternative points that survived; APL/J symbolic terseness, Perl’s TIMTOWTDI, and Ruby’s optional-everything have receded as design ideals. What matters is not which family a language chooses but whether the choice supports unambiguous parsing, canonical formatting, and one obvious way for common patterns (Guy Steele, “Growing a Language”). Under LLM authorship, this shifts further: LL(1)/LALR(1) grammars, statement terminators, and single-canonical idioms noticeably outperform indentation-sensitive or heavily overloaded syntax when models incrementally generate code (Outlines documentation; XGrammar blog).
6. Concurrency models are the hardest thing to change later
Languages that pick their concurrency model early — Erlang’s per-process heaps with actors and supervision (Armstrong thesis, 2003), Go’s goroutines and channels (Go documentation), Rust’s Send/Sync on top of futures (Aaron Turon, “Zero-cost futures”) — build entire standard libraries and idioms around that choice. Bolting a new concurrency model onto an existing language is possible (Python’s asyncio, JavaScript’s Promises, C++20 coroutines) but produces the “colored function” problem: the whole ecosystem must be rewritten to interoperate. Choosing a concurrency model is a decision, not a default.
7. Package supply-chain security has become an existential design question
event-stream (npm, 2018), colors/faker (npm, 2022), ua-parser-js (npm, 2021), and above all the xz-utils backdoor (2024) established that a language ecosystem’s security is now inseparable from the language itself (SLSA blog, “Dependency confusion and typosquatting”). Deno’s permission flags, Cargo’s move toward OIDC “trusted publishers”, npm and PyPI’s mandatory 2FA for high-download packages, the SLSA v1.0 levels for build attestations (SLSA levels), and Sigstore’s keyless signing (Sigstore Cosign) are all attempts to retrofit defenses onto ecosystems designed for open trust. An emerging language has the rare freedom to design supply-chain safety in from the beginning.
Compressed timeline
| Decade | Dominant paradigm shift | Exemplar languages | Key insight |
|---|---|---|---|
| 1930s–40s | Formal foundations laid | Lambda calculus, Turing machines, combinatory logic | Computation has multiple equivalent mathematical models (Wikipedia: Lambda calculus) |
| 1950s | High-level notation displaces assembly | Fortran, Lisp, COBOL, Algol 58/60 | Compilation of expressions to efficient machine code is feasible (Wikipedia: Fortran) |
| 1960s | Types, structured programming, OO, logic | Algol 68, Simula 67, Pascal, PL/I | Language semantics can be given mathematical foundations (Dahl & Nygaard on Simula) |
| 1970s | Systems languages, ML/Scheme, “software crisis” | C, ML, Prolog, Scheme, Smalltalk, Forth | Type inference is possible; abstraction can be zero-cost; goto considered harmful |
| 1980s | OO mainstream; functional academia; declarative research | C++, Smalltalk-80, Eiffel, Haskell, Erlang, Perl | Design by contract (Eiffel), pure laziness (Haskell), fault tolerance (Erlang) enter the design vocabulary (Meyer, Eiffel; Peyton Jones, “Wearing the Hair Shirt”) |
| 1990s | Managed runtimes; scripting; the web | Java, Python, Ruby, JavaScript, C# | JIT + GC beats hand-tuned assembly for most workloads; the network is the runtime |
| 2000s | Static types return; DSL boom; concurrency crisis | Scala, Clojure, F#, Groovy, early Coq/Agda | Multicore ends the free lunch; type theory reaches proof assistants |
| 2010s | Systems safety; type inference; strong tooling | Go, Rust, Swift, Kotlin, Elixir, Julia, TypeScript | Memory safety without GC (Rust), gradual typing (TypeScript), and integrated toolchains (Go, Rust) become baseline expectations |
| 2020s | Effects, capabilities, verification, AI authorship | Zig, Koka, Unison, Roc, Austral, Vale, Hylo, Carbon, Mojo, Lean 4 | Effect systems, ownership, and capability discipline enter production; LLMs reshape the ergonomics conversation (history/03_2010_to_2026.md, §4) |
The current landscape (as of 2026)
What is hot
- Rust has cemented its position in kernels, browsers, databases, blockchains, and cloud infrastructure. Linux merges Rust drivers; Microsoft rewrote parts of Windows kernel components in Rust; Cloudflare, Discord, and Dropbox use it heavily (Rust 1.0 anniversary and adoption). The 2024 edition shipped in late 2024 (Rust 2024 edition guide).
- TypeScript now dominates new frontend and Node.js development; PEP 484 in Python, Sorbet in Ruby, and Hack in PHP all follow the TypeScript template of structural, gradual, erased typing (TypeScript handbook; Stripe Sorbet).
- Go remains the default for cloud infrastructure and CLI tooling. Go 1.22+ continues to invest in the standard library over the language (Go documentation).
- Elixir is finally shipping gradual set-theoretic types under José Valim’s leadership, extending the language’s reach without breaking Erlang compatibility (Elixir set-theoretic types).
- Zig shipped 0.14 with a self-hosted backend and is being used as a C toolchain replacement even in projects that don’t use the Zig language proper (Kelley, “Introduction to Zig”).
- Swift 6 shipped strict concurrency in September 2024, promoting data-race warnings to errors under the new mode.
- Lean 4 and its
mathlibcrossed one million lines of formal mathematics; Terence Tao’s 2023 formalization of the polynomial Freiman–Ruzsa conjecture drew mainstream mathematical attention (Lean mathlib community). - uv (Astral, 2024) replaced pip for many Python projects with a Rust-implemented resolver 10–100× faster, using PubGrub (uv launch).
What is declining
- Perl, Ruby on Rails, and Scala have receded from their peaks. Ruby remains beloved but has ceded new-project mindshare to Python and TypeScript; Scala’s migration from 2 to 3 lost users to Kotlin and Rust (twobithistory: The Ruby Story).
- Traditional OO frameworks (deep inheritance hierarchies, Java-style patterns) have lost intellectual momentum to composition-oriented and functional-influenced styles.
- Application-level dynamic typing without a static overlay is now unusual for new projects of any significant size.
- BDFL governance collapsed as a viable model for major languages after Guido van Rossum’s July 2018 resignation (LWN — Van Rossum’s resignation); steering councils and foundations are the new normal.
What is emerging
- Effect systems in mainstream languages: OCaml 5’s effect handlers (December 2022), Koka in production at Microsoft Research and elsewhere, Unison’s abilities (OCaml effect handlers; Koka book; Unison abilities).
- Capability-typed languages: Austral, Pony, Verona, revived interest in E/Monte, and capability-adjacent designs in Roc’s platforms (Austral capabilities tutorial; Pony capabilities; Roc “Fast”).
- Verified libraries in production: HACL* (used by Firefox, Linux, Python cryptography), miTLS, Dafny at AWS, Verus for Rust, F* at Microsoft (HACL* GitHub; Verus arxiv).
- WebAssembly Component Model with WIT interfaces, giving cross-language interop with strong types (Component Model; WASI 0.2 release).
- Grammar-constrained LLM decoding: Outlines, XGrammar, SynCode, PICARD have made LL(1)/LALR(1) grammars a design asset (XGrammar blog; PICARD paper).
- MCP (Anthropic, November 2024) has become the de facto tool-call schema between LLMs and language ecosystems (MCP introduction; Anthropic MCP announcement).
- Content-addressed code: Unison, Nix, and (potentially) Wasm Component Model artifacts eliminate whole classes of name-squatting attacks (Nix content-addressed store; Unison the big idea).
The eight camps in one page each
The camps report (camps/design_camps_and_tradeoffs.md) organizes the field into eight design dimensions. What follows is the compressed version — one paragraph per camp with the exemplar languages and the tradeoff each accepts.
Camp A — Paradigm
Imperative languages (Fortran, C, Zig, Odin, Jai) treat the machine model as truth and give the programmer explicit control over state and time (Kelley, “Introduction to Zig”). Class-based OO (Simula, C++, Java, C#) organizes programs around ADT-shaped units with inheritance (Stroustrup HOPL IV); message-passing OO (Smalltalk, Erlang) organizes around dynamic dispatch and late binding (Ingalls, “Design Principles Behind Smalltalk”); prototype-based OO (Self, JavaScript, Lua) rejects the class/instance distinction entirely (Ungar & Smith on Self); CLOS-style generic functions (Common Lisp, Dylan, Julia) let dispatch happen on arbitrary combinations of argument types. Pure functional (Haskell, Elm, Roc, PureScript) forbids mutation outside a controlled type (Peyton Jones, “Wearing the Hair Shirt”); impure functional (ML, OCaml, F#, Scheme, Clojure, Erlang, Elixir) allows it but discourages it. Logic (Prolog, Datalog, miniKanren), concatenative (Forth, Factor), array (APL, J, K, BQN), dataflow (Lucid, Lustre, FRP), constraint (Oz, MiniZinc), and actor (Erlang, Pony, Akka) each retain small but dedicated niches. The tradeoff every paradigm accepts is between how closely the surface matches the underlying computational substrate (imperative and array languages win here) and how far the surface stays from that substrate to preserve equational reasoning (functional and logic languages win here).
Camp B — Type system
The type-system continuum runs from untyped (assembly, Forth) through dynamically typed (Python, Ruby, JavaScript, Lua, Clojure), gradually typed (TypeScript, Sorbet, mypy, Hack, Typed Racket, Elixir), statically structurally typed (Go, TypeScript), statically nominally typed (Java, C#, Rust, C++), Hindley–Milner and descendants (ML, OCaml, Haskell, Elm), and into the frontier of dependent types (Agda, Idris, Coq/Rocq, Lean, F*, ATS), refinement types (Liquid Haskell, F*), linear/affine types (Clean, Linear Haskell, Rust’s borrow system, Austral, Granule), session types (mostly research), effect types (Koka, Eff, Frank, OCaml 5, Unison), typestate (Plaid, Rust patterns), ownership+borrowing (Rust, Cyclone, Vale, Hylo), and capability types (Pony, Wyvern, Austral, E). The static-vs-dynamic dispute — long an ideological war — has been dissolved by the observation that a dynamic language is a static language with exactly one type (Harper) and by the empirical success of TypeScript-style gradual typing at scale. The remaining tradeoff is maintenance cost vs. exploration cost: static types front-load discipline, dynamic types front-load velocity, and gradual types let projects choose per-file.
Camp C — Memory management
The memory-management menu now spans manual (C, C++, Zig), RAII (C++, Rust), reference counting (Objective-C ARC, Swift, CPython, Perl), tracing GC (Java, Go, Haskell, C#, JavaScript), region-based (Cyclone, MLKit, Vale) (Tofte & Talpin regions), ownership+borrowing (Rust, Vale), linear-types-for-memory (Clean, Austral, Granule), and hybrids (Nim ARC/ORC, Swift ownership, D, Roc platforms) (Nim memory management; Roc “Fast”). Modern production GCs (Go’s concurrent tri-color mark-sweep, JDK’s ZGC and G1, .NET’s Server GC, V8’s Orinoco) achieve sub-millisecond pause times but pay a throughput and memory-footprint cost (Go GC low-latency; G1 tuning docs). The tradeoff — control vs. convenience, determinism vs. throughput, static discipline vs. runtime cost — is by far the deepest single decision a language makes, because the standard library, the concurrency model, and even the syntax will be organized around the answer.
Camp D — Concurrency
The concurrency menu spans threads and locks (Java, C++, C#), CSP with channels (Go, Newsqueak, Alef, Limbo, Occam) (Hoare CSP paper), actors (Erlang, Elixir, Pony, Akka, Orleans) (Armstrong thesis), software transactional memory (Clojure, GHC Haskell), async/await (Rust, C#, JavaScript, Python, Swift), structured concurrency (Trio, Swift concurrency, Kotlin coroutines), data parallel (NESL, Data Parallel Haskell, Futhark), bulk synchronous parallel, fork-join (Cilk, Java ForkJoinPool), and effect-based concurrency (Koka, OCaml 5 domains). The dominant modern debate is between async/await’s colored functions — a sync function cannot easily call an async one — and the alternatives: structured concurrency (Swift, Trio), effect handlers (Koka, OCaml 5), and BEAM-style pre-emptively-scheduled processes (Erlang, Elixir). The tradeoff is between raw throughput (goroutines and BEAM processes scale to millions), latency-sensitive determinism (async/await with pinned executors), fault tolerance (actors with supervision), and reasoning simplicity (structured concurrency).
Camp E — Syntax and readability
Syntax families are stable enough to enumerate: C-family curly braces (C, C++, Java, C#, JavaScript, TypeScript, Rust, Go, Zig, Swift), ML-family expression-oriented (ML, OCaml, F#, Haskell, Elm, Scala expressions, Rust to a large extent), Lisp S-expressions (Common Lisp, Scheme, Clojure, Racket) with the extreme homoiconicity that enables Lisp macros (Steele, “Growing a Language”), Python-style indentation (Python, Haskell layout, Nim, F#, YAML), Ruby/Perl multi-way idiom, Haskell/OCaml minimal punctuation, APL/J symbolic terseness, verbose self-documenting (COBOL, Ada, SQL), and postfix (Forth, Factor, PostScript). The modern consensus — reinforced by LLM authorship — is that a language’s grammar should be LL(1) or LALR(1) parseable, use statement terminators over indentation, avoid heavy operator overloading, and provide a canonical formatter with no options so gofmt-style consistency emerges (users.rust-lang.org: gofmt vs. rustfmt).
Camp F — Compilation strategy
Modern compilation choices are AOT to native (C, Rust, Go, Swift, Zig via LLVM or their own backends), JIT (Java HotSpot, .NET RyuJIT, V8, LuaJIT, PyPy, Julia), pure interpretation (Bash, older Ruby, older Python), transpilation (CoffeeScript, TypeScript, Reason, Kotlin/JS), bytecode VM (Java, .NET, Python, Erlang BEAM, Lua), WebAssembly as a universal target (Grain, Roc, Component Model languages), and compilation to C (Nim, Chicken Scheme, Vala). The 2020s consensus for new production languages: LLVM for maximum backend maturity and portability, Cranelift for fast compile times (Cranelift page), MLIR if targeting heterogeneous compute or accelerators (MLIR paper), and a custom stack- or register-based bytecode VM for languages with unusual semantics (Erlang BEAM’s reduction counting for pre-emption; Lua’s compact register bytecode).
Camp G — Design philosophy
The philosophy camps are the sharpest disagreements. Worse is Better (Richard Gabriel) argues that simple, get-it-out-the-door design beats correct-but-late design every time — the C/Unix camp (Gabriel, “Worse is Better”). The Right Thing (MIT/Lisp/Scheme/Haskell) argues for correctness first. Wirthian minimalism (Pascal, Modula, Oberon) argues for the smallest language that does the job (Wirth, “Good Ideas”). Kitchen-sink maximalism (C++, Common Lisp, Perl, Scala) argues that a language should include everything a working programmer might need. Paul Graham’s Blub paradox argues that programmers can only see the value of features they have already used. Simple Made Easy (Rich Hickey) draws the distinction between what is easy (familiar, near-at-hand) and what is simple (uncomposed, independent) (Hickey, “Simple Made Easy”). Zero-cost abstractions (C++, Rust) demand that abstraction not carry runtime overhead. Growing a Language (Guy Steele) argues that any language must grow, so its extension mechanism is more important than its initial feature set (Steele, “Growing a Language”). Two new camps — G11 agent-authored language design and G12 capability-safe design — are the most relevant to Mo, and are treated at length in the Mo synthesis.
Camp H — Ecosystem philosophy
Ecosystem philosophy is where language projects most often win or lose. Package-manager-first (Cargo, npm, pip, gems) treats the ecosystem as the language and invests in third-party libraries. Standard-library-first (Go, Java, Python early days) invests in a canonical batteries-included core. Free-for-all repositories (npm, PyPI) maximize long-tail coverage; curated repositories (Stackage, Debian) prioritize baseline safety. Semantic versioning and backward-compatibility commitments (Go, Rust editions, Java) protect user investment at the cost of ossification (Rust editions; Go 1 compatibility promise). Microlibraries (npm, RubyGems) versus monorepo/stdlib (Go stdlib) is a running debate that npm’s left-pad incident sharpened. First-class documentation (Rust, Elixir, Racket) is a compiler engineering discipline in its own right; community governance varies from BDFL to steering council to foundation. Package security and supply-chain defense (Pony, Deno, Austral, and future entrants) is the emerging design surface — see the Mo synthesis for depth.
The five most important insights for Mo
Insight 1 — Annotation economics have inverted, and Mo’s central design bet should exploit that
In prior eras, annotation cost was paid by human authors. This capped the annotation density a language could demand: contracts (Eiffel), effect rows (Koka), linear types (Clean, Austral), refinement types (Liquid Haskell, F*), and dependent types (Idris, Agda) all remained niche because the marginal keystroke cost exceeded the marginal safety benefit for most programmers (Meyer on Eiffel; Peyton Jones, “Wearing the Hair Shirt”; Koka book). LLM authorship inverts the economics: an AI agent’s marginal keystroke is nearly free, but the marginal review cost on a human reviewer is high, and the marginal verification benefit to the whole team is high. Verus, designed to make Rust code machine-verifiable “at a level of annotation cost that would be prohibitive for most human teams but is acceptable for machine authors,” is the canonical statement of this observation (Verus arxiv; G11 in camps report). Mo should follow this bet: contracts, regions, modes, effects, and capabilities should be first-class and expected, because the agent will supply them.
Insight 2 — Package supply-chain security is the highest-leverage security decision Mo will make
Every existing language ecosystem inherited free-for-all package models from an era of open trust and is now painfully retrofitting defenses. event-stream, colors/faker, ua-parser-js, PyPI’s ctx/phpass, and above all the xz-utils backdoor established that unauthenticated ambient-authority packaging is now the primary attack vector on production software (SLSA blog). Mo has the rare freedom to design supply-chain safety in from day one: content-addressed identifiers (Unison big idea; Nix content-addressed store), declared capabilities visible in the manifest (Austral, Deno), OIDC trusted-publisher signing (Cargo trusted publishers goal), build-time execution controls (no arbitrary install scripts by default), release-age gates (uv, pip), and dependency-authority limits (Deno’s --allow-* flags) can all be composed in a way no existing ecosystem yet has. Beyond provenance — SLSA/Sigstore attestations prove origin, not intent (SLSA levels; Sigstore Cosign) — Mo needs to specify what a package is allowed to attempt, not merely who authored it.
Insight 3 — LL(1)/LALR(1) grammar, statement terminators, and one obvious idiom are cheap advantages Mo should keep
Grammar-constrained decoding (Outlines, XGrammar, SynCode, PICARD, Microsoft Guidance) has made grammar shape a first-order property of a language’s LLM-friendliness (Outlines documentation; XGrammar blog; PICARD paper; SynCode paper). A language with an LL(1)/LALR(1) grammar, explicit statement terminators, minimal operator overloading, and a canonical formatter (gofmt-style, no options) generates more consistently than indentation-sensitive or heavily overloaded competitors. This is not free — it constrains the surface — but the constraint is exactly the kind Mo already accepts (single obvious solution, structured errors). Rust’s structured JSON diagnostics (Rust NLL announcement) are the exemplar to imitate: the diagnostic protocol becomes an interface for LLM autofix loops, not just human readers.
Insight 4 — Effects, capabilities, and regions are complementary, not alternatives
The camps report treats effect types (B11), capability types (B14), and ownership/borrowing (B13) as separate camps, but Mo’s stated direction — contracts + capabilities + effects + regions — is not multiple picks from a menu; it is a coherent stack. Austral is the closest existing example: linear types for ownership, capability parameters for effects, and a formal semantics that ties them together (Austral spec; Austral capabilities tutorial). Roc’s platform model separates the “pure” language from platform-provided effects (Roc “Fast”). Koka rows effects into the type (Koka book); Unison abilities do the same (Unison abilities). Pony uses reference capabilities for data-race freedom (Pony capabilities paper). Vale combines regions with generational references (Vale regions). Mo’s opportunity is to pick a specific combination — most likely regions for memory, capabilities for external authority, effects for observable side effects, and contracts for functional correctness — and give the agent a single unified vocabulary for annotating them.
Insight 5 — Ship the tooling, not just the language
The most consistent lesson across the entire bundle is that a language without a first-class LSP, tree-sitter grammar, formatter, package manager, doc generator, and playground on day one loses adoption momentum it never recovers (implementation_engineering.md, §11.7). Rust, Go, Swift, Kotlin, TypeScript, and Elixir all shipped strong tooling from launch; Zig, Julia, and Gleam are catching up but paid for the delay. The corollary: Mo’s active dev repo (github.com/robertguss/mo-lang) should invest in LSP + tree-sitter + formatter + cargo-shaped project tool + doctest-integrated docgen before investing in speculative language features. The reversible design decisions (bytecode dispatch, parsing strategy, package cache format) can be revisited; the irreversible ones (syntax, memory model, effect discipline, package identifier scheme) demand caution — but the tooling ones are pure product engineering that should ship on the release-cadence critical path.
Where to go next
For each Mo design question that this executive summary compresses, the bundle contains a deeper treatment:
- Camp-level tradeoffs and exemplar languages:
camps/design_camps_and_tradeoffs.md. - Compiler and runtime engineering choices:
camps/implementation_engineering.md. - Specific historical lineage:
history/01_foundations_to_1970s.md,history/02_1980s_to_2000s.md,history/03_2010_to_2026.md. - Language-specific case studies:
deep_dives/01_c.mdthroughdeep_dives/15_dependent_types.md. - Mo-specific synthesis:
synthesis/mo_synthesis.md. - Decision matrix ready to work through:
synthesis/decision_matrix.md.
The five insights above are the concentrated advice; the deeper reports are the evidence.