[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7ARCMSF89WKCDDK98Z1JY5X":3,"skill-same:01M7ARCMSF89WKCDDK98Z1JY5X":48},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M7ARCMSF89WKCDDK98Z1JY5X","language-diagnostics-tooling-and-evolution",null,"Use when making a language usable and durable: what a good diagnostic contains and the rules for error messages, warnings, source locations; incremental compilation and IDE support (query-based compilation, salsa-style memoization, what the LSP needs from you); the compiler test pyramid and formal verification; standard library and ecosystem design; and language evolution — backward compatibility, editions as the best mechanism we have, governance (BDFL, committees, RFC processes), and multiple implementations.","the-vibey-project\u002Fvibey","the-vibey-project","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F329298758?v=4","01M7AJHGZ9722CTJ4JNQZVRH0Q","the vibey project","01M7AJHGZVMG2K7TGXQ6XFHVG3",5,"MIT","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fprogramming-language-development\u002Fskills\u002Flanguage-diagnostics-tooling-and-evolution\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: language-diagnostics-tooling-and-evolution\ndescription: \"Use when making a language usable and durable: what a good diagnostic contains and the rules for error messages, warnings, source locations; incremental compilation and IDE support (query-based compilation, salsa-style memoization, what the LSP needs from you); the compiler test pyramid and formal verification; standard library and ecosystem design; and language evolution — backward compatibility, editions as the best mechanism we have, governance (BDFL, committees, RFC processes), and multiple implementations.\"\n---\n\n# Programming Language Development: Diagnostics, Incremental Compilation and IDE Support, Testing, Standard Library, and Evolution\n\n> **Part 4 of 5** of the *Programming Language Development* reference (plugin `programming-language-development`), covering §10–§14. Sibling skills: `language-design-parsing-and-types` (§0–§4), `language-irs-optimization-and-backends` (§5–§7), `language-runtimes-interpreters-and-jits` (§8–§9), `language-development-reference` (§15–§20). Section numbers are shared across the set; a reference written as §N → `skill` points into that sibling skill.\n>\n> **Currency:** Verified August 2026. See §17 → `language-development-reference` for the currency snapshot and what goes stale first.\n\n> **How to read this.** Reference, not tutorial. Sections are independent. Three markers:\n> - **[DURABLE]** — theory, algorithms, or a lesson every language implementation has\n>   independently learned. Does not expire.\n> - **[VERSIONED]** — depends on a specific toolchain, standard, or project's current\n>   state. Verify against its docs.\n> - **[CONTESTED]** — competent language designers disagree, publicly and permanently.\n>   Both cases given.\n>\n> **⚠️ GOTCHA** boxes mark the design mistakes that are cheap to make on day one and\n> impossible to undo on day one thousand.\n>\n> **The framing that organizes everything below: a language is a set of promises you can\n> never take back.** Syntax you can deprecate. Semantics you cannot. Every hard decision\n> in this document is really the question *\"what am I willing to be permanently\n> responsible for?\"* — and the languages people love and the languages people resent are\n> distinguished mostly by how carefully their designers answered it early.\n\n---\n\n## §10. Diagnostics\n\n**[DURABLE] Error messages are the compiler's primary user interface.** For most users,\nmost of the time, the compiler is a machine that produces errors. Rust and Elm changed\nindustry expectations here permanently, and every new language is now judged against them.\n\n### 10.1 What a good diagnostic contains\n\n```\nerror[E0308]: mismatched types                    ← stable, searchable code\n  --> src\u002Fmain.rs:4:18                            ← precise primary location\n   |\n 3 |     let x: u32 = 5;\n   |            --- expected due to this type      ← SECONDARY span: the cause\n 4 |     let y: String = x;\n   |            ------   ^ expected `String`, found `u32`\n   |            |\n   |            expected due to this type\n   |\nhelp: try converting the value                    ← ACTIONABLE, ideally machine-applicable\n   |\n 4 |     let y: String = x.to_string();\n   |                      ++++++++++++\n```\nThe elements, in order of value: **precise primary span**, **secondary spans that explain\n*why*** (this is the biggest differentiator — showing the *other* end of the conflict),\n**plain language, no jargon-first**, **a concrete suggestion**, **machine-applicable fixes**\n(so `--fix` and the IDE quick-fix work), and a **stable error code** with extended\ndocumentation.\n\n### 10.2 The rules\n\n1. **Never cascade** (§2.3 → `language-design-parsing-and-types`). One root cause, one error.\n2. **Say what was expected, not just what was found.**\n3. **Point at the cause, not the symptom.** Type inference makes this genuinely hard: the\n   error surfaces where unification fails, which may be far from the mistake. Bidirectional\n   checking (§4.2 → `language-design-parsing-and-types`) helps because you know the expected type.\n4. **Suggest, but only when confident.** A wrong suggestion is worse than none.\n5. **Errors, warnings, and lints are different things** with different severity policies.\n   Let users configure lints; don't let them disable soundness errors.\n6. **Test your diagnostics.** Snapshot-test error output (rustc's `ui` tests, Elm's\n   approach). Untested diagnostics rot immediately.\n\n### 10.3 Warnings\n\n**[DURABLE] Warnings that everyone ignores are worse than no warnings**, because they train\nusers to ignore output. Keep the default set small and high-precision; put the rest behind\nopt-in lint groups; and provide a mechanism to acknowledge-and-silence a specific instance\n(`#[allow]`, `\u002F\u002F nolint`) so `-Werror` is survivable.\n\n### 10.4 Source locations\n\nKeep spans **everywhere** — in the AST, through desugaring, through IR, into debug info.\nMacro-expanded code needs a *chain* of locations (expansion site plus definition site) or\nmacro errors become unintelligible; Rust's `SyntaxContext`\u002Fexpansion-info machinery exists\nentirely for this. **This is much harder to add later than to design in.**\n\n---\n\n## §11. Incremental Compilation and IDE Support\n\n### 11.1 The requirement has changed\n\n**[DURABLE] A modern language needs a language server, and a batch compiler cannot become\none by accident.** The IDE's requirements are qualitatively different from the batch\ncompiler's:\n\n| Batch compiler | Language server |\n|---|---|\n| Complete, valid input | **Always-broken input** |\n| Whole program | One file changed, answer in \u003C100 ms |\n| Throughput | **Latency** |\n| Correct errors | Best-effort answers, always |\n| Can exit | Long-running, memory-bounded |\n\nTwo architectural answers: **one engine serving both** (rust-analyzer converging with\nrustc; Roslyn; the TypeScript compiler) or **two implementations** (which guarantees\ndivergent behaviour and double the bug surface). The first is right and expensive.\n\n### 11.2 The techniques\n\n- **Query-based \u002F demand-driven architecture.** Instead of running phases in order, express\n  everything as memoized queries (`type_of(def)`, `resolve(name)`) over a dependency graph;\n  on change, invalidate transitively and recompute only what's needed. This is rustc's\n  query system and rust-analyzer's **salsa**, and it is the dominant design.\n- **Red-green \u002F persistent trees** (§2.4 → `language-design-parsing-and-types`) for cheap structural sharing across edits.\n- **Firewalls**: hash intermediate results so that a change that doesn't alter a result\n  stops propagating (reformatting a function body shouldn't invalidate its callers).\n- **Laziness**: don't type-check function bodies you weren't asked about.\n- **Interning** everything (strings, types, spans) so comparison is pointer equality.\n\n**[DURABLE] Design your compiler as a query system from the beginning.** Retrofitting\nincrementality onto a phase-ordered compiler is one of the largest refactors a compiler\nteam can undertake, and several major projects have spent years on it.\n\n### 11.3 What the LSP needs from you\n\nCompletion (on broken input, ranked), go-to-definition, find-references (needs a\nreverse index), hover types, rename (needs to know *every* reference, including in\nmacros and strings-that-are-code), diagnostics on the fly, signature help, semantic\nhighlighting, code actions, formatting, and inlay hints. **Each one is a query your\ncompiler must be able to answer about a partial program.**\n\n---\n\n## §12. Testing and Verification\n\n### 12.1 The test pyramid for a compiler\n\n- **Unit tests** per pass.\n- **Snapshot\u002Fgolden tests**: source in, expected output (IR, diagnostics, or machine code)\n  out. Cheap, high-coverage, and the standard for diagnostics.\n- **Execution tests**: compile and run, check behaviour. The real correctness signal.\n- **Differential testing**: compare against another implementation or another optimization\n  level. `-O0` vs `-O2` disagreement is a miscompile, full stop.\n- **Metamorphic testing**: semantically equivalent programs must behave identically.\n- **Fuzzing**: **Csmith** (random valid C generation) and **YARPGen** found hundreds of\n  bugs in GCC and LLVM. **Alive2** does translation validation for LLVM peepholes — proving\n  optimizations correct with an SMT solver. **If you have an optimizer, you need a fuzzer.**\n- **Bootstrap tests**: compile the compiler with itself, compare stage2 and stage3 output.\n  Byte-identical output is a strong signal.\n- **Test suite reuse**: a new implementation of an existing language should run the\n  existing conformance suite.\n\n### 12.2 Formal verification\n\n- **CompCert** — a formally verified C compiler in Coq. **The Yang et al. Csmith study\n  found zero miscompiles in CompCert's verified middle end while finding hundreds in GCC\n  and LLVM.** This is the strongest empirical evidence in the field for verification.\n- **CakeML** — a verified ML compiler with a verified bootstrap.\n- **Translation validation** — verify each *compilation run* rather than the compiler\n  (Alive2). Far cheaper than full verification and applicable to existing compilers.\n- **Mechanized semantics**: K framework, Redex, Lean\u002FCoq formalizations. Even partially\n  formalizing your semantics finds design bugs.\n\n**[DURABLE] Full verification is expensive and mostly reserved for safety-critical\ndomains. Translation validation and fuzzing give most of the assurance for a fraction of\nthe cost** and should be in any serious compiler's CI.\n\n---\n\n## §13. Standard Library and Ecosystem\n\n**[DURABLE] A language is not a language; it's a language plus a standard library plus a\npackage manager plus a build tool plus a formatter plus a debugger plus documentation.**\nThe languages that succeeded in the last twenty years shipped the whole thing (Go, Rust);\nthe ones that struggled left it to the community and got fragmentation.\n\n**Standard library scope [CONTESTED]:** \"batteries included\" (Python, Go) versus minimal\ncore plus ecosystem (Rust, Node). *For batteries*: no dependency for common tasks, one\nobvious way, no supply-chain risk for basics. *Against*: **the standard library is where\ncode goes to die** — you can never break it, you can never move fast, and Python's\n`asyncio`\u002F`urllib`\u002F`distutils` history is the standard evidence. Rust's deliberate\nminimalism trades a large dependency graph for the ability to evolve.\n\n**Ship on day one**: a formatter (**with no options** — `gofmt` ended a category of\nargument permanently), a build tool and package manager (see the package-manager reference),\na test runner, a documentation generator, a linter, and a debugger story (DWARF, and\nactually test it).\n\n---\n\n## §14. Language Evolution\n\n### 14.1 Backward compatibility\n\n**[DURABLE] The core tension: every language must evolve, and every change breaks someone.**\nThe strategies actually used:\n- **Never break** (Java, C, Go 1.x). Maximum trust, permanent accumulation of mistakes.\n- **Deprecate then remove** (Python 2→3). The Python 3 transition took roughly a decade and\n  is the field's canonical warning about breaking changes at scale.\n- **Editions\u002Flanguage versions** (Rust editions, C++ standards). §14.2.\n- **Feature flags** (`from __future__ import`, `#![feature]`). Lets you ship unstable\n  features to consenting users and get feedback before committing.\n\n### 14.2 Editions — the best mechanism we have\n\n**Rust's edition model**: each crate declares its edition; editions may change syntax and\nidioms; **crates of different editions interoperate freely** in one program because the\nchange happens in the front end and the IRs unify. Combined with `cargo fix` for automated\nmigration, this lets a language change `async` from an identifier to a keyword without a\nPython-3 event.\n\n**[DURABLE] If you're designing a language and you expect to live for decades, design the\nedition mechanism early.** The constraint it imposes — editions cannot change the *type\nsystem* or the *runtime*, only surface syntax and lints — is exactly the constraint that\nmakes it work, and it's much easier to honour from the start.\n\n### 14.3 Governance\n\nOptions: BDFL (fast, coherent, has a bus factor and a succession crisis — Python's PEP 8016\ngovernance transition after Guido's resignation is the reference), committee (ISO C\u002FC++ —\nslow, stable, produces documents rather than implementations), foundation + teams (Rust,\nPython post-2018), corporate (Go, Swift, Kotlin — fast and coherent, with the community's\ninfluence bounded by the sponsor's interests).\n\n**[VERSIONED] The C++ committee's 2025–26 record is an instructive case**: C++26 was\nfinalized on 28 March 2026 after a six-day London meeting with 210 experts from 24 nations,\ndelivering reflection, contracts, `std::execution`, and a hardened standard library. It\nalso **rejected the \"Safe C++\" borrow-checking proposal** in favour of the Profiles\napproach, and **the `[[profiles::enforce]]` attribute was then deferred to C++29**. Herb\nSutter stepped down as convener. Read that sequence as a demonstration of what committee\ngovernance is good at (a large, coherent, multi-vendor standard shipping on schedule) and\nwhat it is bad at (deciding a contested safety strategy quickly).\n\n**Whatever the model, you need**: a public proposal process with a written record, a\nstability policy stated *before* you need it, a deprecation policy, and a security-response\nprocess.\n\n### 14.4 Multiple implementations\n\n**[CONTESTED]** A second implementation validates the specification, breaks vendor\nlock-in, and expands platform reach — but doubles the conformance surface and creates\n\"which one is right?\" ambiguity when the spec is incomplete.\n\n**[VERSIONED] `gccrs` is the live experiment.** A GCC front end for Rust, motivated by\nreaching every target GCC supports without depending on LLVM-based rustc. Its 2026 status\nis a useful reality check on how long a second implementation takes: the project stated its\n**2026 goal as being able to *mis*-compile the Linux kernel** — explicitly, an experimental\ncompiler that produces binaries that may not run correctly — with milestones ordered as\n\"embedded Rust compiler\" → \"Rust for Linux compiler\" → \"general-purpose compiler.\" As of\nmid-2026 it handles simple standalone programs, having spent the first half of the year\nfinding and fixing problems in attribute handling, name resolution, and resource\nmanagement by testing against kernel crates. The project began in earnest around 2020.\n**Budget five-plus years for a second implementation of a non-trivial language, and note\nthat gccrs deliberately targets Rust 1.49 semantics rather than chasing current Rust.**\n","# Programming Language Development: Diagnostics, Incremental Compilation and IDE Support, Testing, Standard Library, and Evolution\n\n> **Part 4 of 5** of the *Programming Language Development* reference (plugin `programming-language-development`), covering §10–§14. Sibling skills: `language-design-parsing-and-types` (§0–§4), `language-irs-optimization-and-backends` (§5–§7), `language-runtimes-interpreters-and-jits` (§8–§9), `language-development-reference` (§15–§20). Section numbers are shared across the set; a reference written as §N → `skill` points into that sibling skill.\n>\n> **Currency:** Verified August 2026. See §17 → `language-development-reference` for the currency snapshot and what goes stale first.\n\n> **How to read this.** Reference, not tutorial. Sections are independent. Three markers:\n> - **[DURABLE]** — theory, algorithms, or a lesson every language implementation has\n>   independently learned. Does not expire.\n> - **[VERSIONED]** — depends on a specific toolchain, standard, or project's current\n>   state. Verify against its docs.\n> - **[CONTESTED]** — competent language designers disagree, publicly and permanently.\n>   Both cases given.\n>\n> **⚠️ GOTCHA** boxes mark the design mistakes that are cheap to make on day one and\n> impossible to undo on day one thousand.\n>\n> **The framing that organizes everything below: a language is a set of promises you can\n> never take back.** Syntax you can deprecate. Semantics you cannot. Every hard decision\n> in this document is really the question *\"what am I willing to be permanently\n> responsible for?\"* — and the languages people love and the languages people resent are\n> distinguished mostly by how carefully their designers answered it early.\n\n---\n\n## §10. Diagnostics\n\n**[DURABLE] Error messages are the compiler's primary user interface.** For most users,\nmost of the time, the compiler is a machine that produces errors. Rust and Elm changed\nindustry expectations here permanently, and every new language is now judged against them.\n\n### 10.1 What a good diagnostic contains\n\n```\nerror[E0308]: mismatched types                    ← stable, searchable code\n  --> src\u002Fmain.rs:4:18                            ← precise primary location\n   |\n 3 |     let x: u32 = 5;\n   |            --- expected due to this type      ← SECONDARY span: the cause\n 4 |     let y: String = x;\n   |            ------   ^ expected `String`, found `u32`\n   |            |\n   |            expected due to this type\n   |\nhelp: try converting the value                    ← ACTIONABLE, ideally machine-applicable\n   |\n 4 |     let y: String = x.to_string();\n   |                      ++++++++++++\n```\nThe elements, in order of value: **precise primary span**, **secondary spans that explain\n*why*** (this is the biggest differentiator — showing the *other* end of the conflict),\n**plain language, no jargon-first**, **a concrete suggestion**, **machine-applicable fixes**\n(so `--fix` and the IDE quick-fix work), and a **stable error code** with extended\ndocumentation.\n\n### 10.2 The rules\n\n1. **Never cascade** (§2.3 → `language-design-parsing-and-types`). One root cause, one error.\n2. **Say what was expected, not just what was found.**\n3. **Point at the cause, not the symptom.** Type inference makes this genuinely hard: the\n   error surfaces where unification fails, which may be far from the mistake. Bidirectional\n   checking (§4.2 → `language-design-parsing-and-types`) helps because you know the expected type.\n4. **Suggest, but only when confident.** A wrong suggestion is worse than none.\n5. **Errors, warnings, and lints are different things** with different severity policies.\n   Let users configure lints; don't let them disable soundness errors.\n6. **Test your diagnostics.** Snapshot-test error output (rustc's `ui` tests, Elm's\n   approach). Untested diagnostics rot immediately.\n\n### 10.3 Warnings\n\n**[DURABLE] Warnings that everyone ignores are worse than no warnings**, because they train\nusers to ignore output. Keep the default set small and high-precision; put the rest behind\nopt-in lint groups; and provide a mechanism to acknowledge-and-silence a specific instance\n(`#[allow]`, `\u002F\u002F nolint`) so `-Werror` is survivable.\n\n### 10.4 Source locations\n\nKeep spans **everywhere** — in the AST, through desugaring, through IR, into debug info.\nMacro-expanded code needs a *chain* of locations (expansion site plus definition site) or\nmacro errors become unintelligible; Rust's `SyntaxContext`\u002Fexpansion-info machinery exists\nentirely for this. **This is much harder to add later than to design in.**\n\n---\n\n## §11. Incremental Compilation and IDE Support\n\n### 11.1 The requirement has changed\n\n**[DURABLE] A modern language needs a language server, and a batch compiler cannot become\none by accident.** The IDE's requirements are qualitatively different from the batch\ncompiler's:\n\n| Batch compiler | Language server |\n|---|---|\n| Complete, valid input | **Always-broken input** |\n| Whole program | One file changed, answer in \u003C100 ms |\n| Throughput | **Latency** |\n| Correct errors | Best-effort answers, always |\n| Can exit | Long-running, memory-bounded |\n\nTwo architectural answers: **one engine serving both** (rust-analyzer converging with\nrustc; Roslyn; the TypeScript compiler) or **two implementations** (which guarantees\ndivergent behaviour and double the bug surface). The first is right and expensive.\n\n### 11.2 The techniques\n\n- **Query-based \u002F demand-driven architecture.** Instead of running phases in order, express\n  everything as memoized queries (`type_of(def)`, `resolve(name)`) over a dependency graph;\n  on change, invalidate transitively and recompute only what's needed. This is rustc's\n  query system and rust-analyzer's **salsa**, and it is the dominant design.\n- **Red-green \u002F persistent trees** (§2.4 → `language-design-parsing-and-types`) for cheap structural sharing across edits.\n- **Firewalls**: hash intermediate results so that a change that doesn't alter a result\n  stops propagating (reformatting a function body shouldn't invalidate its callers).\n- **Laziness**: don't type-check function bodies you weren't asked about.\n- **Interning** everything (strings, types, spans) so comparison is pointer equality.\n\n**[DURABLE] Design your compiler as a query system from the beginning.** Retrofitting\nincrementality onto a phase-ordered compiler is one of the largest refactors a compiler\nteam can undertake, and several major projects have spent years on it.\n\n### 11.3 What the LSP needs from you\n\nCompletion (on broken input, ranked), go-to-definition, find-references (needs a\nreverse index), hover types, rename (needs to know *every* reference, including in\nmacros and strings-that-are-code), diagnostics on the fly, signature help, semantic\nhighlighting, code actions, formatting, and inlay hints. **Each one is a query your\ncompiler must be able to answer about a partial program.**\n\n---\n\n## §12. Testing and Verification\n\n### 12.1 The test pyramid for a compiler\n\n- **Unit tests** per pass.\n- **Snapshot\u002Fgolden tests**: source in, expected output (IR, diagnostics, or machine code)\n  out. Cheap, high-coverage, and the standard for diagnostics.\n- **Execution tests**: compile and run, check behaviour. The real correctness signal.\n- **Differential testing**: compare against another implementation or another optimization\n  level. `-O0` vs `-O2` disagreement is a miscompile, full stop.\n- **Metamorphic testing**: semantically equivalent programs must behave identically.\n- **Fuzzing**: **Csmith** (random valid C generation) and **YARPGen** found hundreds of\n  bugs in GCC and LLVM. **Alive2** does translation validation for LLVM peepholes — proving\n  optimizations correct with an SMT solver. **If you have an optimizer, you need a fuzzer.**\n- **Bootstrap tests**: compile the compiler with itself, compare stage2 and stage3 output.\n  Byte-identical output is a strong signal.\n- **Test suite reuse**: a new implementation of an existing language should run the\n  existing conformance suite.\n\n### 12.2 Formal verification\n\n- **CompCert** — a formally verified C compiler in Coq. **The Yang et al. Csmith study\n  found zero miscompiles in CompCert's verified middle end while finding hundreds in GCC\n  and LLVM.** This is the strongest empirical evidence in the field for verification.\n- **CakeML** — a verified ML compiler with a verified bootstrap.\n- **Translation validation** — verify each *compilation run* rather than the compiler\n  (Alive2). Far cheaper than full verification and applicable to existing compilers.\n- **Mechanized semantics**: K framework, Redex, Lean\u002FCoq formalizations. Even partially\n  formalizing your semantics finds design bugs.\n\n**[DURABLE] Full verification is expensive and mostly reserved for safety-critical\ndomains. Translation validation and fuzzing give most of the assurance for a fraction of\nthe cost** and should be in any serious compiler's CI.\n\n---\n\n## §13. Standard Library and Ecosystem\n\n**[DURABLE] A language is not a language; it's a language plus a standard library plus a\npackage manager plus a build tool plus a formatter plus a debugger plus documentation.**\nThe languages that succeeded in the last twenty years shipped the whole thing (Go, Rust);\nthe ones that struggled left it to the community and got fragmentation.\n\n**Standard library scope [CONTESTED]:** \"batteries included\" (Python, Go) versus minimal\ncore plus ecosystem (Rust, Node). *For batteries*: no dependency for common tasks, one\nobvious way, no supply-chain risk for basics. *Against*: **the standard library is where\ncode goes to die** — you can never break it, you can never move fast, and Python's\n`asyncio`\u002F`urllib`\u002F`distutils` history is the standard evidence. Rust's deliberate\nminimalism trades a large dependency graph for the ability to evolve.\n\n**Ship on day one**: a formatter (**with no options** — `gofmt` ended a category of\nargument permanently), a build tool and package manager (see the package-manager reference),\na test runner, a documentation generator, a linter, and a debugger story (DWARF, and\nactually test it).\n\n---\n\n## §14. Language Evolution\n\n### 14.1 Backward compatibility\n\n**[DURABLE] The core tension: every language must evolve, and every change breaks someone.**\nThe strategies actually used:\n- **Never break** (Java, C, Go 1.x). Maximum trust, permanent accumulation of mistakes.\n- **Deprecate then remove** (Python 2→3). The Python 3 transition took roughly a decade and\n  is the field's canonical warning about breaking changes at scale.\n- **Editions\u002Flanguage versions** (Rust editions, C++ standards). §14.2.\n- **Feature flags** (`from __future__ import`, `#![feature]`). Lets you ship unstable\n  features to consenting users and get feedback before committing.\n\n### 14.2 Editions — the best mechanism we have\n\n**Rust's edition model**: each crate declares its edition; editions may change syntax and\nidioms; **crates of different editions interoperate freely** in one program because the\nchange happens in the front end and the IRs unify. Combined with `cargo fix` for automated\nmigration, this lets a language change `async` from an identifier to a keyword without a\nPython-3 event.\n\n**[DURABLE] If you're designing a language and you expect to live for decades, design the\nedition mechanism early.** The constraint it imposes — editions cannot change the *type\nsystem* or the *runtime*, only surface syntax and lints — is exactly the constraint that\nmakes it work, and it's much easier to honour from the start.\n\n### 14.3 Governance\n\nOptions: BDFL (fast, coherent, has a bus factor and a succession crisis — Python's PEP 8016\ngovernance transition after Guido's resignation is the reference), committee (ISO C\u002FC++ —\nslow, stable, produces documents rather than implementations), foundation + teams (Rust,\nPython post-2018), corporate (Go, Swift, Kotlin — fast and coherent, with the community's\ninfluence bounded by the sponsor's interests).\n\n**[VERSIONED] The C++ committee's 2025–26 record is an instructive case**: C++26 was\nfinalized on 28 March 2026 after a six-day London meeting with 210 experts from 24 nations,\ndelivering reflection, contracts, `std::execution`, and a hardened standard library. It\nalso **rejected the \"Safe C++\" borrow-checking proposal** in favour of the Profiles\napproach, and **the `[[profiles::enforce]]` attribute was then deferred to C++29**. Herb\nSutter stepped down as convener. Read that sequence as a demonstration of what committee\ngovernance is good at (a large, coherent, multi-vendor standard shipping on schedule) and\nwhat it is bad at (deciding a contested safety strategy quickly).\n\n**Whatever the model, you need**: a public proposal process with a written record, a\nstability policy stated *before* you need it, a deprecation policy, and a security-response\nprocess.\n\n### 14.4 Multiple implementations\n\n**[CONTESTED]** A second implementation validates the specification, breaks vendor\nlock-in, and expands platform reach — but doubles the conformance surface and creates\n\"which one is right?\" ambiguity when the spec is incomplete.\n\n**[VERSIONED] `gccrs` is the live experiment.** A GCC front end for Rust, motivated by\nreaching every target GCC supports without depending on LLVM-based rustc. Its 2026 status\nis a useful reality check on how long a second implementation takes: the project stated its\n**2026 goal as being able to *mis*-compile the Linux kernel** — explicitly, an experimental\ncompiler that produces binaries that may not run correctly — with milestones ordered as\n\"embedded Rust compiler\" → \"Rust for Linux compiler\" → \"general-purpose compiler.\" As of\nmid-2026 it handles simple standalone programs, having spent the first half of the year\nfinding and fixing problems in attribute handling, name resolution, and resource\nmanagement by testing against kernel crates. The project began in earnest around 2020.\n**Budget five-plus years for a second implementation of a non-trivial language, and note\nthat gccrs deliberately targets Rust 1.49 semantics rather than chasing current Rust.**\n",{"name":5,"description":7},"develop","ae32736a1aabddabca5d2c96d665aa0ebc7d8700","src\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fprogramming-language-development\u002Fskills\u002Flanguage-diagnostics-tooling-and-evolution",3,"https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey","https:\u002F\u002Fthe-vibey-project.github.io\u002Fvibey\u002F","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project","https:\u002F\u002Fvibewithadam.matthewsteinberger.com","freedom for software engineers","2026-11-15 05:47:42",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add the-vibey-project\u002Fvibey --skill language-diagnostics-tooling-and-evolution",{"tool":40,"command":41},"bunx","bunx skills add the-vibey-project\u002Fvibey --skill language-diagnostics-tooling-and-evolution",{"tool":43,"command":44},"pnpm","pnpm dlx skills add the-vibey-project\u002Fvibey --skill language-diagnostics-tooling-and-evolution","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fprogramming-language-development\u002Fskills\u002Flanguage-diagnostics-tooling-and-evolution\u002FSKILL.md",true,[],[49,56,63,70,77,84],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":19},"01M7AT1FQJAE1FQYAMDTF490Y4","white-paper-writing","Use when writing white papers, technical reports, policy documents, thought leadership pieces, or any long-form authoritative document. Triggers on requests to write, structure, outline, or review white papers, technical reports, position papers, policy briefs, or evidence-driven arguments. Also use for B2B content marketing strategy, technical documentation requiring authority, academic-style reports, or any document that must educate while persuading. Use when someone asks \"how should I structure this\" for a long-form document.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fwhite-paper-writing\u002FSKILL.md",[],[],{"skillNo":57,"name":58,"nameZh":6,"description":59,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":60,"categories":61,"keywords":62,"publishedAt":19},"01M7AT16BJRJJKK2MASXRZS76G","prose-technical-mechanics","Use when editing or writing prose at a technical\u002Fmechanical level: choosing between Anglo-Saxon and Latinate diction, placing information in topic vs stress positions, writing periodic vs cumulative sentences, handling sentence rhythm, punctuation as logic, transitions, paragraph structure, or phonesthetics. Use when someone wants to understand WHY prose works or doesn't, not just surface-level style advice. Triggers on word choice, sentence structure, emphasis, rhythm, diction, or any deep writing mechanics question.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fprose-technical-mechanics\u002FSKILL.md",[],[],{"skillNo":64,"name":65,"nameZh":6,"description":66,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":19},"01M7AT0W9HT0ZZ9Y287NW99MR3","prose-mechanics","Use when writing, editing, or analyzing prose style; when trying to avoid generic AI-sounding writing; when applying specific prose styles such as journalistic, academic, narrative, KJV biblical, Hemingway plain, Latinate\u002FJamesian, Orwellian, Augustan, Victorian, Early Modern (Bacon, Browne, Milton), or free indirect discourse; or when coaching someone on writing voice and mechanics. Triggers on any request to improve, analyze, or write in a specific prose style, to fix \"AI-sounding\" writing, to make prose more vivid or concrete, to vary sentence rhythm, or to understand how a particular writer achieves their effects.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fprose-mechanics\u002FSKILL.md",[],[],{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":76,"publishedAt":19},"01M7AT0KR635JX66X2X6F3E2CP","narrative-structure","Use when structuring stories, pitches, presentations, white papers, or any persuasive narrative; analyzing the hero's journey in fiction or non-fiction; applying StoryBrand for business communication; designing narrative arcs for thought leadership; or understanding Vogler, Snyder, Propp, or Campbell frameworks. Triggers on any narrative structure, storytelling, pitch structure, StoryBrand, hero's journey, three-act structure, Freytag, Save the Cat, narrative arc, or \"how should I structure this story\u002Fpitch\u002Fpresentation\" request.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fnarrative-structure\u002FSKILL.md",[],[],{"skillNo":78,"name":79,"nameZh":6,"description":80,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":81,"categories":82,"keywords":83,"publishedAt":19},"01M7AT0AKGW09NKKZDYBT8VRDE","legal-brief-writing","Use when writing legal briefs, motions, or any court filing; when analyzing judicial cognition and persuasion; when applying elite brief-writing techniques from Roberts, Clement, Kagan, Garner; or when structuring legal arguments for maximum persuasion. Also use for autistic\u002Fneurodivergent advocates who need to understand how their natural communication style maps to elite legal advocacy. Triggers on any legal writing, brief drafting, motion preparation, or legal argument structuring request.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Flegal-brief-writing\u002FSKILL.md",[],[],{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":19},"01M7AT00VWPS4Q8B5VEMXX9NQT","journal-publishability-criteria","Use whenever a research paper, article or preprint is being written, revised, reviewed or published, and specifically before every publication of docs\u002Fpaper.md. Covers what legitimate journals actually gate on, in order of gating — the editor's desk screen (scope, novelty, package problems), what reviewers judge (methodological soundness, claims the evidence can carry, statistical and qualitative reporting), EQUATOR reporting guidelines, the ICMJE authorship criteria, COPE's view of text recycling, the near-universal generative-AI policy (no AI author, disclosure, author responsibility), TOP 2025 transparency standards, how to verify a journal is legitimate, submitting without an institution, and a pre-submission checklist. Triggers on requests to evaluate, review, prepare or submit a paper, to judge publishability, to write a declarations or data-availability section, to disclose AI use, or to check a journal.","https:\u002F\u002Fgithub.com\u002Fthe-vibey-project\u002Fvibey\u002Fblob\u002Fdevelop\u002Fsrc\u002Fvibey_tools\u002Fskills\u002Fplugins\u002Fwriting-craft\u002Fskills\u002Fjournal-publishability-criteria\u002FSKILL.md",[],[]]