Spokes.wiki Search About

Synthesis — Programming Languages

The evolving thesis. Spun out of the hub _inbox software-design cluster on 2026-08-05 with eight sources: seven project front pages (c, rust, go, clojure, php, elixir, nodejs) and one article about program design (rethinking-java-design-patterns).

Current thesis

A language is a small number of decisions taken early and paid for everywhere else. The founding corpus makes this legible because eight sources describe themselves independently and keep answering the same four questions: how memory is reclaimed, what concurrency looks like, whether the language owns its runtime, and who is allowed to change it. Everything else on those pages — syntax, libraries, adoption logos — varies without predicting anything. The four axes predict a great deal.

The decisions are not independent. rust is the clearest case: ownership was designed to manage memory, and rejecting data races falls out of the same rules, so one decision answers two axes. elixir gets fault tolerance out of a concurrency model it inherited from BEAM, and per-process garbage collection turns a memory decision into a latency claim. clojure's immutability makes concurrent sharing safe by removing mutable state rather than by scheduling. The axes are a way to read a language, not a menu it chose from.

Most of what a language advertises belongs to its runtime. hosted-language is the spoke's sharpest early finding, and nodejs is what makes it undeniable: a runtime, not a language, in a corpus of languages, supplying the concurrency model, the memory behaviour, the deployment shape and half the standard library for code whose semantics were fixed elsewhere. clojure and elixir chose their hosts deliberately and take the same deal from the other direction. So "language X is fast / safe / concurrent" is usually a claim about an implementation, and the front pages do not distinguish.

The one axis that is a genuine fork is failure. Seven sources describe doing many things at once. Only elixir describes what happens when one of them dies, and supervision is a designed-for state rather than an error path. go's page stops at scale, rust's at correctness, nodejs's at throughput. Whether that reflects the languages or the genre of front pages is the question this corpus cannot answer.

And patterns are language features that have not arrived yet. rethinking-java-design-patterns shows five GoF patterns dissolving into constructor references, sealed types and exhaustive switch — which reframes the catalog as a portrait of what C++ and early Java could not express (design-patterns). The corollary is testable and untested: a language with different primitives should need different patterns, not fewer.

Open questions

The no-owner governance model, stated by an insider

cpp and cpp-hopl add the roster's biggest absence and land squarely on language-governance rather than on the memory or concurrency axes.

C++ is the corpus's clearest case of a language nobody owns. go has Google, clojure has Nubank's funding, elixir has Dashbit, rust has a foundation; C++ has an ISO committee where up to 250 people meet three times a year and decide by consensus. Stroustrup names the three demands that process holds at once — make it simpler, add these features now, don't break my code — and the third wins every time, because no participant has the standing to impose a migration cost on everyone else. Compatibility here is not a stated value so much as the only outcome the structure can produce.

That reframes what c's stability meant. Both languages are documents rather than implementations, and both are extremely stable, but for different reasons: C stays small by declining features, C++ stays compatible while accumulating them, so it now contains several eras of style at once and can retire none of them.

The adoption number is the part worth arguing with. 3 million to 4.5 million developers between 2006 and 2020, against much better-funded competitors, is real growth and it comes from the language's designer writing its authorized history. The mechanism he proposes — that people delivering large applications want stability and familiarity, and "invariably confuse familiarity with simplicity" — is plausible and untested here; the paper offers no counterfactual, and this spoke should treat it as a hypothesis about the whole roster rather than a finding about one language.

A paradigm can arrive as a library, and it arrives incomplete (2026-08-12, research pass)

Four sources on functional programming in typescript — effect, fp-ts, lightweight-hkt and records-and-tuples — produce the spoke's first account of a paradigm being retrofitted rather than designed in, and of exactly where the retrofit stops.

The new axis is where the guarantee lives (functional-programming). haskell puts it in the type system, clojure in the data model, elixir in runtime isolation, and TypeScript in a library sitting on a type layer that deletes itself. Those are four different depths, not four degrees of the same thing. The founding synthesis lumped "imperative/functional" into one axis; this splits it.

The three walls are of different kinds, and only two are library problems. No higher-kinded types — worked around by defunctionalization, at the price of kind checking, per the technique's own authors. No effect tracking — worked around by Effect<Success, Error, Requirements>, a userland rebuild of what haskell's IO is in the language. No immutable values — not worked around, because TC39 withdrew Records and Tuples on 14 April 2025 and a compile-time annotation cannot make a runtime guarantee.

That third wall is a governance finding wearing a type-system costume. What a paradigm can be in JavaScript was capped by a standards committee reaching consensus on performance grounds, with no functional-programming constituency in the room. language-governance has so far been about who may change a language; this is the first case in the corpus of a governance decision setting the ceiling on what programs can mean.

And the corpus's own claim about patterns generalizes. design-patterns read the GoF catalog as language deficiencies with names. effect and fp-ts are the same phenomenon one level up: not a pattern standing in for a missing feature, but a whole paradigm standing in for a missing language. The tell is in the marketing — effect's homepage sells reliability and typed failure, never purity, which is an accurate description of what it can actually deliver.

Two independent languages, one wall. ocaml needed brands-and-app in 2014 for the same reason TypeScript needs it now. The limitation belongs to *-only type systems, not to either community, which is the first time this spoke has been able to attribute a constraint to a class of language rather than to a design choice.

Ownership is a fifth governance model, and it has no exit (2026-08-12)

mojo arrived the day after its 1.0 release and forces a distinction the four models blur.

The four models all assume the implementation is available. An ISO committee (c, cpp), a foundation (rust, nodejs), a public RFC process (php), a corporate steward (go, clojure, elixir) — in every case the compiler or runtime is open, so the governance model describes who decides, while the code remains a floor under everyone. Mojo's standard library is Apache 2.0 and its compiler is closed, promised as open source "in 2026". That removes the floor. Governance stops being about who decides and becomes about who owns.

And ownership transfers. Modular was acquired by Qualcomm two weeks before the 1.0 release. A language marketed as the escape from one chip vendor's platform is now the property of another chip vendor, and the assurance offered is chris-lattner's expectation of good behaviour rather than a structure that would survive a change of mind. The spoke's oldest governance question asked what happens when a steward loses interest; the harder case turns out to be a steward who stays interested under new ownership.

A three-year-old language cites C++ as its stability model. Mojo 1.0 promises additive change and allows breaking changes "following the standards of how mature languages (e.g. C++) evolve over time." cpp-hopl showed why C++ cannot break anything: a consensus committee where nobody can impose a migration cost on everyone else. Mojo has adopted that outcome as a policy without the structure that produces it. Compatibility as a promise from an owner is a different object from compatibility as a structural inevitability, and the corpus now holds both.

Python as a host of a third kind. typescript compiles into the language it extends; clojure and elixir adopt someone else's runtime. Mojo compiles natively and keeps python's libraries reachable across a boundary — the ecosystem is the host, not the runtime or the syntax. hosted-language now has three distinct shapes rather than one.

Growth edges

Ranked; each names the kind of source that would close it.

  1. Everything is a self-description. Substantially closed 2026-08-06 by eleven third-party encyclopaedic sources in one batch, which brought the corpus's first records of a language failing in the field (bash's Shellshock), a documented decline (lisp), and design regrets stated plainly (emacs-lisp). Residual, and now the real edge: still no specification and no benchmark with a method. — needs: ISO C, the Rust reference, an ECMA-262 reading, or a measured comparison. Original framing kept below for the record. Seven of eight founding sources were the project's own front page. They are T1 — first-party is what the ladder measures — and the tier says nothing about whether anyone checked the claims, which nobody has. — needs: an independent comparative study, a benchmark with method, or a specification (ISO C, the Rust reference, a JVM spec): still primary, but written to define rather than to persuade.
  2. No paradigm outside imperative/functional. Closed the same day by prolog and the-power-of-prolog — and the axes did not survive intact (see below). Residual: still no array language and no dependently typed language.
  3. Java is a hole in the middle of the wiki. Four pages (clojure, kotlin, jank, rethinking-java-design-patterns) define themselves against it and java's public page says nothing about the language. — needs: the JEP process and a JDK release page, which would close this and the edge below together. Narrowed 2026-09-07 by java-news-roundup-aug31-2026 (InfoQ, T3): the spoke now has one week of Java's own ecosystem — two JDK trains in early access at once (27 b35, 28 b14), and a runtime change visible through its downstream (tornadovm dropping JVMCI for JDK 27 compatibility). Still no JEP and no design argument, so the edge stands; what changed is that Java is no longer described here only by the languages that borrow its runtime.
  4. No account of a language changing — narrowed 2026-08-06. javascript supplies the process (TC39 stages, annual snapshots); what is still missing is a single proposal followed from motivation to shipped feature. — needs: one TC39 or PHP RFC read end to end.
  5. Gradual typing has no evidence, only a vendor's old surveys. typescript is now the corpus's most-adopted language and its claims are the least checked (2020 Stack Overflow / State of JS, quoted by Microsoft in 2026). — needs: a study of defect rates in typed vs untyped JavaScript, or a current independent survey. CLOSED 2026-09-14 (research pass) by to-type-or-not-to-type (Gao, Bird & Barr, ICSE 2017, T1): 400 fixed public bugs from 398 GitHub projects, annotated by hand for ≤10 minutes each — Flow 0.30 catches 59, TypeScript 2.0 catches 58, 15% either way, with only six bugs where the two disagree. The annotations were added after the fact by people who knew where the bug was, so it measures the ceiling a type checker could reach, not a team's practice. Successor (5a): the number is from 2017 tooling and post-hoc annotation — needs: a study of projects written in TypeScript from the start against comparable JavaScript ones (Bogner & Merkel 2022 is the named candidate, unread).
  6. The functional retrofit has no measurement — new 2026-08-12. Four sources describe what pure FP in typescript can and cannot do; none measures what it costs or buys. — needs: a benchmark of effect against plain TypeScript, a bundle-size or overhead study, or a team retrospective with defect data. Related to the gradual-typing edge above and failing for the same reason.
  7. The design-patterns thread has one source. — needs: a second, ideally arguing the counter-position that patterns are vocabulary and survive the features that implement them.

Coverage edges (added 2026-08-08, at the curator's request for a wider backlog). These widen what the spoke covers instead of answering an open question above; one ordinary solid source closes any.

  1. C++. CLOSED 2026-08-09 (research pass) — cpp from the committee's own site plus cpp-hopl (Stroustrup, HOPL IV 2020, T1), which carried the adoption half (3M → 4.5M developers, 2006–2020). Successor: C++'s answer to memory safety. The spoke now holds rust's guarantee and C++'s compatibility constraint with nothing on how the language proposes to close the gap — profiles, epochs, or the argument that it cannot. — needs: a WG21 paper or safety-profile document, T1. CLOSED 2026-08-22 (research pass) by three sources: cpp-safety-profiles (P3081R2, WG21, T1) for the proposal, wg21-croydon-2026 (T3) for what the committee did with it — deferred to C++29 — and cpp-library-hardening (ACM Queue, T3) for what shipped in C++26 instead and how it performed in production. Successor, edge 12: the only deployment numbers anyone has for retrofitted C++ safety (0.3% overhead, ~30% fewer segfaults) were produced by the engineers who wrote the library and ran the rollout. — needs: an independent measurement of hardened-libc++ overhead, or a second organisation's rollout report.

  2. The mainstream absences. Ruby, Swift, Scala, Julia and R each own a domain and none appears. — needs: first-party language documentation, one page each.

  3. Languages that are not general-purpose. SQL and WebAssembly shape more running code than several members of the current roster, and programming-language's definition never has to account for them. — needs: the specifications.

  4. How a language runs. memory-management-model, type-system and evaluation-strategy are concept pages implying an implementation layer — parsing, compilation, garbage collection — that has no page. — needs: a compilers text or a GC survey.

  5. Retrofitted safety, measured by someone else. (new 2026-08-22, successor to edge 8) cpp-library-hardening's figures — 0.3% average overhead, ~30% fewer segfaults, five opt-outs across hundreds of millions of lines — are the corpus's only deployment evidence for any safety claim, and they were produced by the libc++ maintainers and the team that ran the rollout. Nobody independent has measured hardened-libc++ overhead, and no second organisation's rollout is published here. — needs: an independent benchmark of hardening overhead, or another company's report. Related to edge 1 and failing in the same way typescript's gradual-typing claims do.

The axes were a portrait of the sample (added 2026-08-05)

prolog arrived hours after the founding eight and did something more useful than adding a row. The four axes programming-language proposed — memory, concurrency, runtime, governance — are answerable for Prolog and uninteresting for it. What defines a logic language is the evaluation strategy: unification, backtracking, and a search whose shape the programmer has to reason about even though the program reads as declarative relations (logic-programming). No axis derived from eight imperative-and-functional sources was going to ask about that.

So the honest status of the framework is: a good reading of the sample it came from, already amended once. The next paradigm — array, dependently typed, dataflow — should be expected to break it again.

prolog is also the corpus's first third-party source, and the difference is stark enough to be a finding about method rather than about Prolog. Seven front pages produced no weaknesses between them. One encyclopedia article produced four, and the sharpest is not a benchmark number but a design admission: programmers add cuts for performance and lose bidirectional execution, which was the reason to use the language. The founding corpus's problem was never that the pages lied — it is that nobody asks a project's own page what its language costs. Which is also the clearest demonstration in this hub that tier and trust are different axes: the T1 sources here are the ones with no weaknesses on record.

Safety has four answers now, and one of them proves things (added 2026-08-05)

The standing tension below records three positions on what safety is for. spark adds a fourth and sharpens the disagreement: prove the bug cannot occur — contracts as first-class constructs, subprograms as Hoare triples, GNATprove discharging obligations for absence of runtime errors, sound and precise until the prover times out. Not a type system excluding a class of errors but a proof about this program.

Two details make it more than a curiosity. Its ownership and borrow-checking are, by AdaCore's own account, derived from Rust — a safety idea moving from a general-purpose language into a certification-driven one, the reverse of the usual direction. And its cost is the one ../research-wiki's formal-verification page names for the entire field: a proof needs a specification, so the guarantee is only as good as the contracts somebody wrote. Both spokes reached that limit the same day from opposite ends.

One language, two runtimes (added 2026-08-05, five pages from ../dev-tooling-wiki)

The curator narrowed ../dev-tooling-wiki to build-and-ship infrastructure and moved its language pages here: dart, kotlin (with kotlin-and-android), jank and the creator node jeaye-wilkerson. They arrive with a thread the founding eight could not have produced, because it needs two languages that differ only in their host.

jank is a Clojure dialect re-hosted on C++. Same syntax, same semantics, Java interop swapped for C++ interop, LLVM JIT for the REPL and AOT for shipped binaries. Set beside clojure itself — a language whose own page says it targets the JVM, the CLR and JavaScript — the pair is the cleanest evidence this spoke has for the claim hosted-language makes on the strength of two sources: a language and its runtime are separable, and most of what a language appears to be belongs to the host. jank keeps Clojure's meaning and changes what it can do — no JVM startup, direct C++ interop, a different deployment space entirely.

dart and kotlin come at it from the other side. Neither swaps hosts; each targets many at once — Dart to native, JS and Wasm, Kotlin to the JVM, JS, LLVM-native and Wasm. So the corpus now holds three arrangements of the same relationship: one language on one host it chose (go, rust), one language on several hosts at once (Dart, Kotlin), and one language moved from one host to another (jank, against Clojure). The axis hosted-language proposed is real, and it has more positions on it than "hosted" and "not".

The JIT-for-iteration / AOT-for-release split that Dart and jank both ship is worth keeping as a second finding, and it is not a language-design decision at all — it is the same language compiled twice for two audiences, the developer and the user. Which is one more thing a front page attributes to a language and a runtime actually provides.

Tier note. These pages arrived already graded T1 (dart.dev, jank-lang.org) — the grading this spoke adopted on the same day for the rest of its official sites, which is a small independent check that the curator's call matches how the hub was already treating first-party sources. kotlin stays T2: its source is Wikipedia, not the language's own site.

The host-swap repeated, and this time it shipped (added 2026-09-06)

jolt-clojure compiles Clojure to Scheme — a host-neutral IR emitted onto Chez by default, or Gambit compiled to JavaScript — with a self-hosted compiler and an AOT-only build. That is the second independent re-hosting of one language in this corpus, beside jank's onto C++, and it does something the section above could only assert: it publishes the seam as a compatibility list. No Java interop, no reflection, (count "😀") is 1, irregex instead of java.util.regex, partial clojure.core. Every item is a JVM property that had been read as a Clojure property. The claim hosted-language built out of two front pages is here written down by an implementation as release notes.

The new axis is when code becomes machine code. jank and dart both ship JIT-for-iteration and AOT-for-release, which this spoke recorded as the dev-vs-ship split. Jolt declines the JIT entirely — Chez owns main, nothing is generated at run time — and recovers the interactive loop from the other side, with an nREPL attached to the already-built program. Same language, same swap question, opposite answer, and both answers keep a working REPL. So the split is not JIT-versus-AOT; it is where the interactivity lives, in the compiler or in the running process.

And a host-swap finally produced a deployment fact. raylib-ios runs Clojure on an iPhone 17 Pro: raylib 6.0 built PLATFORM=SDL because raylib has no iOS backend, both libraries -force_loaded as static archives, every draw call a libffi call, live-coded over the network — at a mean of 17.02 ms per frame, worst 17.1 over 5,400 frames. Until now every deployment-space claim in this corpus was a sentence on a front page ("targets native, JS and Wasm"). This is the first one with a device, a version and a number attached, and it is the exact claim hosted-language says the host decides rather than the language.

Two cautions travel with it, neither fatal. The number is the author's, from one device and one build, which is why the page is T3. And the artifact's own headline is looser than its measurements: "60 fps" for a 17.02 ms mean that works out to 58.8, and "seventeen scenes" where the README says forty-eight. The corpus records the measurement, not the headline.

The reader stopped being a person (added 2026-08-06)

zero-lang is the first source in this corpus written for a language whose intended author is not human. Vercel Labs stores the program as a semantic graph the compiler owns, generates .0 text files only as a projection for review, and makes editing a checked patch — a change addressed to a node by hash, rejected if built against a stale view. The argument is not about expressiveness. It is that the text-file loop makes an agent write, guess, run a separate tool, and find out afterwards, and that moving the compiler inside the edit removes the guessing.

This breaks the four axes in a different way than prolog did. Prolog showed the axes were the wrong questions for a paradigm they were not drawn from. Zero shows they share a premise: all four ask what source text means. Zero changes what the program is stored as and who may edit it directly, and both answers sit below the level where memory, concurrency, host and governance are argued.

Two things keep it from being a finding yet. The examples are hello-world scale, so nothing here shows a graph-first program at a size where the model would either pay off or hurt — and the properties claimed (token efficiency, fewer wrong edits) are exactly the ones that only appear at scale. And the whole case is first-party: no agent has been measured working in it against anything else, which is growth edge 1 arriving in a new form rather than being closed. Its self-reported state — experimental, breaking changes, security issues, do not point it at production — is more candid than the front pages this spoke usually gets, and is the only reason the page can say what it costs.

The adjacency is live rather than academic: ../agentic-tooling-wiki owns the coding harnesses that would have to adopt a representation like this, and it holds the opposite bet — every harness there improves how an agent handles text.

A language can decline every axis (added 2026-08-06)

typescript answers none of the four questions the corpus was built on. No memory model, no concurrency model, no runtime, and a governance story that is simply "Microsoft ships it". Its entire contribution is a type-system, and it deletes even that before the program runs. The thesis above says a language is a small set of early decisions paid for everywhere; TypeScript's single decision is to make no decisions that would cost migration, which is why the site's four selling points are about editors, inference, output you can trust, and adopting it one file at a time.

That gives the spoke a new axis with real spread in the existing corpus, now written up in type-system: what the types are asked to prove, from c (nothing) through kotlin (one bug class) to rust (memory and data races) and spark (absence of runtime errors, by proof). It also bends hosted-language — TypeScript's host is another language, not a runtime, so it inherits its execution properties from wherever the emitted JavaScript lands.

Growth edge 1 recurs in its sharpest form yet. TypeScript's case for gradual typing rests on 2020 surveys, quoted by the vendor, on a page read in 2026. Nothing in the corpus measures whether opt-in static typing catches the defects it promises to catch.

Extensibility is a governance answer in disguise (added 2026-08-06)

common-lisp arrived an hour after typescript and pushed in the opposite direction. TypeScript's design is about not asking the user to change anything; Common Lisp's is about letting the user change the language itself. lisp-lang.org argues one property — macros collapse the distance between a library and a feature, so CLOS can be an object system added to a language that shipped without one.

That belongs next to language-governance rather than beside the memory and concurrency axes. Every governance model in the corpus so far answers "who may change the language" with an institution: a committee, a foundation, a core team with a vote, a company. This answers "the person writing the program", and it makes the institutional question smaller — you need a revision less often if you can extend locally. clojure is the control case: same mechanism, and Rich Hickey spent it on removing choices rather than opening them up.

Two cautions recorded on the page. It is a community site (T3, like c-language.org) with a 2015–2025 copyright line and undated benchmarks. And its three industrial claims — Grammarly, ITA Software, SISCOG — are the corpus's first deployment stories of any kind, and they are unsourced. Notable that all three are algorithm-heavy back ends, not the web and mobile work the other front pages chase.

Six sources in twenty minutes, and what a batch shows that a page cannot (added 2026-08-06)

After typescript and common-lisp, the curator sent scheme, lisp, haskell, erlang and java in quick succession. Read together they do something no single ingest has:

The family is now a control group. lisp (Wikipedia, T2) gives the ancestor and the dates the community sites omit — 1958, McCarthy, eval turned into an interpreter by hand, garbage collection invented before 1962, ANSI X3.226-1994. common-lisp and scheme then split the same inheritance in opposite directions: extensibility as room to add versus as permission to leave out, from one mechanism and one design rule. clojure and jank were already here. Five sources, one lineage, and the differences are attributable rather than assumed.

A mechanism repeated is worth more than a mechanism claimed. haskell and clojure both answer concurrency with immutability plus software transactional memory, arrived at independently on different runtimes. Nothing else in the corpus repeats. On the axis where the founding eight disagreed most, that is the closest thing to corroboration front pages can produce.

A host finally has a page, and the important one still does not. erlang closes the BEAM pair from underneath elixir — the guest's best claims are inherited, and both pages admit it. The JVM gets the opposite treatment: clojure, kotlin and jank all define themselves against Java, and java's public page is a download page that argues cost and timelines and never mentions the language. The emptiest source in the corpus is the one four pages depend on.

A fifth axis, now general. evaluation-strategy was a Prolog peculiarity this morning; Haskell's laziness makes it corpus-wide, and the finding is that eight sources made the strict choice without one of them naming it. An axis is invisible exactly while everyone agrees on it — the same shape as the type-system page written earlier today.

Growth edge 1 moved. lisp is a third-party source that reports a decline: use fell through the 1990s, MIT replaced Scheme with Python, present-day use is specialized. common-lisp's site says an extensible language "does not go out of style." Both can be true, and only the encyclopaedia wrote the second half down. That is the first time the corpus has held a self-description and an outside account of the same language.

The batch kept coming: sixteen sources, and the corpus changed shape (added 2026-08-06)

After the first six the curator sent assembly-language, awk, bash, emacs-lisp, fsharp, javascript, jq, lua, nim, ocaml and picolisp — plus Csound and Pure Data, which went to ../music-tech-wiki because their substance is sound. Four things this wiki could not say yesterday:

The tier problem is largely gone. The founding corpus was eight front pages. This batch is mostly Wikipedia (T2), and third-party sources report what vendors do not: Bash's Shellshock, JavaScript's coercion and XSS criticisms, Emacs Lisp's dynamic scoping "can easily lead to bugs in large programs", Lisp's 1990s decline, Lua's version breakage. Growth edge 1 asked for sources written to describe rather than to persuade, and it now has eleven of them.

Two axes were missing, not merely unstated. type-system and evaluation-strategy both got written today because a source finally made them the point. A third is forming and has no page yet: what a language commits to as its data model. awk assumes records and fields, jq assumes JSON, lua has one composite type, picolisp has one internal type, assembly-language has whatever the register file holds. That is not memory management and not typing; it is a prior decision about what the world is made of, and five sources now turn on it.

Governance finally has a working process. javascript's TC39 — staged proposals, annual snapshots, a standard under a different name from the language, and an Oracle trademark on the name itself — is the documented change process growth edge 4 wanted, alongside its opposite in java's "stewards" page. And the de-facto pole is now populated too: bash and jq both have competing implementations with no specification, where the reference build is the definition.

Small languages borrow big toolchains. nim emits C, picolisp emits LLVM IR, typescript and fsharp emit JavaScript, jank re-hosts on C++. assembly-language explains why: the thing a high-level language buys is portability, and the cheapest way to buy it is to make somebody else's back end responsible. The corpus's oldest source and its newest agree on this and nothing else.

One correction to the entry above this. The morning's note said haskell and clojure sharing STM was the corpus's first repeated mechanism. Coroutines now repeat too — lua and picolisp — and so does macro-based extension across four Lisps. Repetition is no longer rare, which means the corpus is finally large enough for agreement between independent sources to mean something.

A first-party page can be wrong about itself (added 2026-08-06)

zsh arrived as three sources in an hour, and the sequence is the useful part. zsh.org gives one sentence and a mirror list, calling 5.9 current as of October 2022. The documentation index gives file formats. Wikipedia then supplies everything both withheld — Falstad, Princeton, 1990, the MIT-variant licence, Peter Stephenson maintaining, the feature set, Oh My Zsh, macOS Catalina — and the current version: 5.9.2, 12 July 2026.

The standing caveat in CLAUDE.md says a project's own page is authoritative on design intent and unverified on performance and adoption. Zsh sharpens it. The vendor page was not merely unverified on the claims it wanted believed; it was four years stale on the single checkable fact it carried, the version number — the thing a project is supposed to be the last word on. Every freshness: volatile version in this spoke came from a page of that kind, so this belongs in the next quality pass as a re-check task, not just as a note.

Re-verified the same day (2026-08-06). Every version number in the spoke was checked against a current source. Eleven claims: nine were correct, two were imprecise, one page had a major fact missing. typescript 7.0 is real — shipped 8 July 2026 — and it is a rewrite of the compiler in Go, which typescriptlang.org does not mention on the page selling "trustworthy output". erlang's "OTP 29" is the major line; the actual current release is 29.0.5 with CVE fixes in the patch stream the front page does not show. zsh remains the only outright stale claim, and it is a vendor page.

So the failure mode is not usually a wrong number. It is a front page that stops at the announcement — the major version is advertised, the patch stream where the security work happens is elsewhere, and a compiler rewrite can go unmentioned entirely. php is the exception that proves it: its front page is the patch stream.

The other half is what three sources on one subject buy. Each page alone would have been thin or partial; together they produced a claim neither could support on its own. Worth remembering the next time a subject looks finished after one ingest.

C++ answered the safety question, and the answer was shaped by its governance (added 2026-08-22)

Three sources close the spoke's oldest coverage successor and, between them, they say something the rust-versus-cpp framing does not.

Two proposals, and the committee's constraint chose between them. P3081 proposes compiler-enforced profiles whose every rule must be decidable at compile time and must not touch C++'s object model. Safe C++ (P3390) proposed a borrow checker and a new dialect. The second was refused — not on whether it works, but because it requires a model change, which is precisely what cpp-hopl says this committee cannot impose. The governance model wrote the technical answer, and this spoke now has the receipt.

Then even the compromise was deferred. wg21-croydon-2026: profiles slip to C++29; what C++26 ships is undefined behaviour removed for uninitialized locals plus a hardened standard library, both of which land on existing code by recompiling. The rule underneath is visible in one meeting — contracts shipped 114–12 over a sustained objection, while profiles, which would change what existing code compiles to, did not ship at all. A consensus committee can overrule a minority; it cannot bill everyone for a migration.

And the thing that shipped is the spoke's first measured safety claim. cpp-library-hardening: 0.3% average production overhead, more than 1,000 bugs found, a ~30% drop in the segfault rate across Google's fleet, and five opt-outs across hundreds of millions of lines. Every other safety position in this corpus — rust's compiler, spark's prover, elixir's runtime — is argued from design. Growth edge 1 asked for someone who checked; here they are, and they are the same people who built it (T3, recorded on the page, and edge 12 written).

What it does not buy. Hardening is spatial safety — bounds. Use-after-free, the class ownership exists for, is untouched, and the lifetime profile that would address it is the deferred half. So the honest summary of the retrofit is: most of the crash reduction for a recompile, and the part rust is actually about still needs the language change nobody can pass.

The host is under revision, and its guests never say so (added 2026-09-07)

hosted-language has treated runtimes as fixed ground: a guest picks a host and inherits its garbage collector, threads and deployment space. Every source that built that page is a guest describing what it got. None of them describes the host changing.

java-news-roundup-aug31-2026 supplies the missing side by accident. tornadovm 6.0.0 replaced JNI with the Foreign Function & Memory API and removed its JVMCI dependency, the second one explicitly "for JDK27+ backwards compatibility." One release, two interfaces to the JVM re-plumbed, because the JVM moved. The JVM is the corpus's most-depended-on host — clojure, kotlin and jank all define themselves against it — and this is the first time the corpus sees it as a moving object rather than a backdrop.

TornadoVM also adds a direction this spoke had not recorded. The host-swap cases change the guest: Clojure onto C++ (jank), Clojure onto Scheme (jolt-clojure), Kotlin and Dart onto four backends apiece. TornadoVM changes where the host can go — Java methods compiled out to GPUs, multi-core CPUs and FPGAs, with the language untouched. So a runtime's deployment space is not a fixed property either; somebody outside the language can widen it.

The finding is small and the source is thin — a weekly trade column, T3, reporting release notes. What makes it worth a section is that the corpus had no way to see this at all. A guest's home page will never tell you its host is being rewritten underneath it, because the guest's whole pitch is that the host is solved.

The type system gets a number, and it is a ceiling (2026-09-14)

to-type-or-not-to-type gives typescript the measurement the spoke said it lacked: 15% of public JavaScript bugs are caught by Flow or TypeScript once the right annotation is in place, on 400 bugs sampled to a stated confidence from 3.9 million. Two things about the number. It is a ceiling — the annotators knew the fix and had ten minutes to make the checker fire — so what a team catches while writing is at most this. And it is a floor for the argument, because the bugs the checker catches are real ones that shipped. The result sits well with the spoke's reading of TypeScript as adoption-led rather than evidence-led: the evidence existed the whole time, is nine years old, and Microsoft's own 2026 page quotes surveys instead of it. Successor 5a asks for the from-the-start comparison the design cannot give.

Contradictions / tensions

No factual conflicts yet — eight sources describing themselves rarely disagree, which is itself the problem the first growth edge names. The nearest thing to a contradiction is what safety is for: rust locates it in the compiler (prevent the bug), elixir in the runtime (survive the bug), spark in a prover (show the bug is impossible, at the price of writing the specification), and c declines the question in favour of stability and interoperability. These are not compatible positions and no source here argues them against each other.

A standard as motion vs. a standard as ballast (added 2026-08-06). c and common-lisp are governed the same way — a language defined by a document, implementations competing beneath it — and their sites sell opposite virtues from it. c-language.org lists the revision series; lisp-lang.org calls the specification a rock-solid foundation and never dates it. Not a factual conflict; a conflict about what committee governance is for, and the corpus cannot settle it from two secondary sites.

Cross-spoke adjacency

Index — Programming Languages Wiki

Catalog of every page, grouped by schema.org @type. Spine: synthesis (thesis), log.md (history), this file (catalog). Spun out of the hub _inbox software-design cluster on 2026-08-05 (8 sources). Official language sites are T1 per ../QUALITY.md (curator's call, 2026-08-05) — primary about design intent, and still marketing surfaces whose performance and adoption claims carry no measurement. Versions and release dates decay; see CLAUDE.md.

DefinedTerm (concepts)

ComputerLanguage (sources)

SoftwareSourceCode (sources)

ScholarlyArticle (sources)

Book (sources)

WebPage (sources)

SoftwareApplication (sources)

TechArticle (sources)

NewsArticle (sources)

Person (entities)

Organization (entities)

Synthesis

Related pages

Links to

Linked from