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

• Do the four axes survive contact with a language chosen to break them? Every founding source is a general-purpose imperative or functional language. A logic language, an array language, or a proof assistant’s language might make the axes look parochial.
• What does ownership actually cost? rust‘s claim is compile-time safety with no runtime. The price everyone reports — work moved from debugging to fighting the compiler — appears in no source here.
• Is “removing choices” a real advantage? go‘s pitch is social: one formatter, one binary, few features, so teams converge. That is the most falsifiable claim in the corpus and the only one that would need evidence about people rather than programs.
• What happens when a corporate steward loses interest? language-governance has four models and none of the pages addresses succession. c‘s committee is the only one whose answer is structural.
• Does a language designed for a non-human author differ from one designed for people? zero-lang asserts it must, and demonstrates it only at hello-world scale. The test is whether the graph model survives a program big enough for the projection to stop being readable.
• Is a retrofitted paradigm worth what it costs? effect and fp-ts deliver most of functional programming to a language that guarantees none of it, and the only cost anyone reports is a learning curve in third-party blog posts. Nothing here measures runtime overhead, bundle size, error-message quality, or whether the defects the approach targets actually go down.
• Why did fp-ts stop? The abstraction-first library is merging into a production-runtime one, and both first-party sources state the fact without a reason. A retrospective from the people involved would say whether Haskell-in-TypeScript was abandoned on the merits or simply outgrown.
• Does macro-level extensibility help or fragment? clojure‘s code-as-data is either the deepest feature in the corpus or a licence for per-codebase dialects. One page cannot say.

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.

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

8. 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.
9. The mainstream absences. Ruby, Swift, Scala, Julia and R each own a domain and none appears. — needs: first-party language documentation, one page each.
10. 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.
11. 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.

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

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

• ../dev-tooling-wiki — owns the machinery around a codebase (compilers as build infrastructure, VCS, serialization, package tooling). The seam runs through each language’s own toolchain: Cargo, the go command and Composer are described here as evidence of design commitments; a source about the tool routes there. This spoke exists because that boundary kept parking language sources.
• ../engineering-education-wiki — owns curricula and roadmaps. A course teaching Rust routes there; Rust’s semantics route here.
• ../embedded-iot-wiki — c and rust name embedded as a target, and that spoke owns the device layer. The language routes here, the chip and the firmware stack route there.
• ../agentic-tooling-wiki — owns agent harnesses and orchestration. zero-lang is the seam: the language and its graph model are described here, and a source about a harness adopting it (or about agent editing loops in general) routes there.
• The frontend-architecture _inbox cluster — application architecture at scale is a different layer and stayed parked at spin-out.

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)

• programming-language — umbrella: the four decisions that actually separate languages (memory, concurrency, runtime ownership, governance), with the corpus laid out as one table · domain
• memory-management-model — manual (c) vs traced GC (go, php, clojure, elixir, V8) vs compile-time ownership (rust); the decision that sets where a language can be deployed at all · mechanism
• concurrency-model — five answers in eight sources: nothing built in, CSP channels, isolated supervised processes, an event loop, immutability plus STM — plus Rust’s static no-data-races guarantee; the axis under them is where isolation comes from and what happens on failure · mechanism
• hosted-language — languages that adopt someone else’s runtime (clojure on JVM/CLR/JS, elixir on BEAM) and the inversion (nodejs, a runtime that adopted a language); a language defines meaning, a runtime decides capability · architecture
• language-governance — ISO committee (c/WG14) vs foundation (rust, nodejs) vs public RFC (php) vs corporate stewardship (go, clojure, elixir); none of them documents what happens when the steward loses interest · practice
• logic-programming — the paradigm where a program is facts and rules and running it means proving a query; relations run backwards, and the evaluation strategy — not memory or concurrency — is the axis that matters · paradigm
• type-system — when the check happens (compile / run / gradual), how much the types are asked to prove (c nothing → kotlin one bug class → rust memory and races → spark by proof), and whether the type survives compilation · mechanism
• evaluation-strategy — strict (eight sources, none of them saying so), lazy (haskell), or resolution (prolog); the axis that only becomes visible when someone declines the default · mechanism
• design-patterns — the GoF catalog read as language deficiencies with names; if patterns dissolve into features, the catalog is a portrait of the languages that needed it · practice
• functional-programming — the axis is where the guarantee lives: in the type system (haskell), in the data model (clojure), in runtime isolation (elixir), or in a library over a host that guarantees nothing (typescript + effect) — four depths, not four degrees · paradigm

ComputerLanguage (sources)

• c — c-language.org: a language whose identity is a document (ISO/IEC 9899, WG14; C23 published 2024-10-31), not an implementation. Portability, interoperability, efficiency, stability; no concurrency in the language; the ABI everything else terminates at · source · T3 · c-language.org

• cpp — isocpp.org: identity is a document (ISO/IEC 14882, C++23 = work finished 2023, published :2024), three-year revisions since C++11, standard sold not published. Committee of up to 250 people three times a year, and the three demands it holds at once — simpler / add features / don’t break my code, where the third always wins · source · T1 · isocpp.org

• rust — rust-lang.org: memory and thread safety with no GC and no runtime, enforced by ownership at compile time; Cargo/crates.io; CLI, WASM, network services, embedded; Rust Foundation; v1.97.1. The no-runtime claim is a deployment claim, and it puts Rust in C’s space · source · T1 · rust-lang.org

• go — go.dev: goroutines + channels, static typing, GC, fast compiles, single static binary; formatter, test/bench/profile built in; cloud services, CLIs, DevOps, microservices; Google. Nearly every feature is the same move — remove a choice — and the pitch is social, aimed at teams · source · T1 · go.dev

• clojure — clojure.org: Rich Hickey’s dynamic Lisp — immutable persistent data structures, STM, macros, protocols, REPL — hosted on JVM/CLR/JS; Nubank funds it since the 2020 Cognitect acquisition. Removes the sharing hazard from the data model instead of scheduling around it · source · T1 · clojure.org

• php — php.net: 8.5.9 (2026-07-30) with four supported branches patched the same day; fibers, enums, attributes, generators; the corpus’s only public RFC process. A release board more than a feature list — the language whose problem is the installed base · source · T1 · php.net

• elixir — elixir-lang.org: functional language on BEAM; supervised processes that recover from failure, Erlang distribution, per-process GC, Phoenix/LiveView, Nerves on embedded; Dashbit; v1.20 (2026-06-03). The only source here with a story about things going wrong · source · T1 · elixir-lang.org

• lisp — Wikipedia: McCarthy, MIT, 1958; s-expressions, the first language whose code was a standard data structure of the language itself; GC invented before 1962; the dialect family (Common Lisp/ANSI X3.226-1994, Scheme, Clojure, Emacs Lisp, Racket) and the 1990s decline no first-party page mentions · source · T2 · en.wikipedia.org

• scheme — scheme.org: minimalism as a stated rule — design “not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary”; 20+ implementations catalogued against R6RS/R7RS; sells nothing · source · T3 · scheme.org

• haskell — haskell.org: purity, immutability, laziness, and static types with bidirectional-unification inference presented as one commitment; STM over lightweight threads (the corpus’s first repeated mechanism, shared with clojure); 6,900+ packages; Haskell.org, Inc. · source · T1 · haskell.org

• erlang — erlang.org: “massively scalable soft real-time systems” — processes, !/receive, distribution, hot code loading, and OTP shipping design principles with the language; Erlang/OTP 29 (2026-05). The host beneath elixir, closing that pair from both ends · source · T1 · erlang.org

• ocaml — ocaml.org: “industrial-strength functional programming”, with non-exhaustive pattern match as the headline compiler error; native + bytecode compilers, GC kept alongside compile-time safety, opam, 5.5.0. fsharp‘s parent, described independently · source · T1 · ocaml.org

• fsharp — Wikipedia: Don Syme at microsoft Research, OCaml core on .NET; Hindley–Milner inference plus three things nothing else here has — units of measure, type providers, computation expressions; F# Software Foundation with a BDFL · source · T2 · en.wikipedia.org

• javascript — Wikipedia: Eich at Netscape, 1995, Java-like syntax as “a marketing ploy”; weak dynamic typing, prototypes, one thread over a message queue; Ecma TC39 with annual snapshots — the corpus’s best-documented change process — and the name is an Oracle trademark · source · T2 · en.wikipedia.org

• java — java.com: a download page. Oracle as “the stewards of Java”, cost and timelines, no version, no language. The emptiest source in the corpus, and four pages here define themselves against it · source · T1 · java.com

• lua — Wikipedia: PUC-Rio 1993, built to be embedded in any C program; tables as the only composite type, metatables, coroutines, register VM, MIT. Roblox/Neovim/Redis/Nginx — most of its users never chose it; versions break compatibility and the ecosystem pinned itself to 5.1 · source · T2 · en.wikipedia.org

• emacs-lisp — Wikipedia: the dialect an application is written in and extended in; dynamic scoping by default with the bugs stated plainly, lexical binding optional since v24, no TCO — the property scheme made mandatory · source · T2 · en.wikipedia.org

• nim — Wikipedia: Rumpf, 2008; statically typed, compiles to C by default (also C++/JS/ObjC), AST macros — and memory management chosen per build (ARC/ORC/GC/manual), which moves the corpus’s defining decision out of the language · source · T2 · en.wikipedia.org

• assembly-language — Wikipedia: one statement per machine instruction; Kathleen Booth (1947), EDSAC/Wheeler (1948). All four axes read null, portability inverts, and it carries the corpus’s first argument that language-level speed is the wrong question (Linux 4.9: ~2% asm, >97% C) · source · T2 · en.wikipedia.org

• awk — Wikipedia: Aho/Weinberger/Kernighan, Bell Labs 1970s; pattern–action with the read-test-act loop built in, records and fields as the world’s default shape; POSIX-mandatory, with nawk/gawk/mawk beneath the standard; absorbed by Perl · source · T2 · en.wikipedia.org

• bash — Wikipedia: Brian Fox / GNU, 1989; one grammar for the prompt and the script, POSIX plus “bashisms” with the implementation as the definition; 5.3 (2025); macOS left for zsh over the licence; Shellshock is the corpus’s first field failure · source · T2 · en.wikipedia.org

• zsh — zsh.org + manual index + Wikipedia: Paul Falstad, Princeton 1990, named after a TA’s login; “a cross between ksh and tcsh”, Bourne-compatible and deliberately not fully POSIX; programmable completion, extended globbing, history shared live across sessions, ZLE, loadable modules; MIT-variant licence, 5.9.2 (2026-07-12); Oh My Zsh (2,300+ contributors); macOS default since Catalina 2019. The interactive pole opposite bash — and the case where two first-party pages were four years stale on their own version · source · T1+T2 · zsh.org, en.wikipedia.org

• jq — Wikipedia: Stephen Dolan, 2012; filters composed into pipelines, purely functional and tacit, “sed for JSON”; three independent reimplementations and no specification; originally written in Haskell · source · T2 · en.wikipedia.org

• python — python.org: a front page that argues in code (five snippets) rather than in adjectives; clean syntax and indentation as the claim, PSF governance, seven application areas; 3.14.7. No benchmark, no adoption number — the mildest claims in the corpus from its most-used language · source · T1 · python.org

• perl — perl.org: sells duration — “over 37 years of development” — plus CPAN’s 25,000+ modules and 230+ local groups; 5.44.0; Raku named as a sister language, explicitly not a replacement. The successor to awk‘s text processing, not mentioning text processing · source · T1 · perl.org

• picolisp — picolisp.com: Alexander Burger, 1988–; one internal data type, the cell, three visible types, “nothing is hidden behind the scenes”; Pil21 is an interpreter written in PicoLisp emitting LLVM IR; ships a persistent OO database, web GUI, coroutines, native C calls · source · T1 · picolisp.com

• common-lisp — lisp-lang.org: the community site’s single argument is extensibility — macros collapse the gap between a library and a language feature (SxQL as SQL syntax), CLOS is an object system added to a language that shipped without one, SLIME/REPL instead of a compile-debug cycle. The ANSI standard sold as stability rather than as a revision series; Grammarly / ITA / SISCOG named and undated · source · T3 · lisp-lang.org

• prolog — Wikipedia: Colmerauer & Roussel, 1972; unification, backtracking, SLD resolution, the cut; WAM; ISO/IEC 13211. The corpus’s first third-party language description, and the only source that reports what a language is bad at — performance, sub-100k-line adoption, module divergence, and the procedural reasoning the declarative story was supposed to remove · source · T2 · en.wikipedia.org

• spark — AdaCore: Ada minus undefined behaviour, plus contracts as language constructs and deductive proof (Hoare triples via GNATprove) of no runtime errors; ownership and borrow-checking derived from Rust; DO-178 / ISO 26262, avionics to space. A fourth answer to safety — prove the bug cannot occur · source · T1 · adacore.com

SoftwareSourceCode (sources)

• effect — effect.website: “Reliable TypeScript for the AI era” — Effect<Success, Error, Requirements> puts failure and dependencies in the type, plus fibers, schema and OpenTelemetry; v4.0 RC, Effectful Technologies Inc., MIT; Cloudflare/OpenCode/X named. Sells reliability, never purity — a library doing a language designer’s job · source · T1 · effect.website
• fp-ts — Canti‘s Haskell-in-TypeScript (11.5k★, MIT, 2.x): Option/Either and type classes from Haskell, PureScript and Scala, with higher-kinded types emulated via lightweight-hkt‘s brands-and-app encoding. Now merging into effect, which its README calls “the successor to fp-ts v2” · source · T1 · gcanti.github.io

ScholarlyArticle (sources)

• lightweight-hkt — Yallop & White, Lightweight higher-kinded polymorphism, FLOPS 2014 (LNCS 8475, pp. 119–135; T1): abstraction over type constructors in a *-only type system, via an app type and uninhabited brands — type defunctionalization. States its own cost: the checker cannot catch ill-kinded encodings. The mechanism under fp-ts, written for ocaml a decade earlier · source · T1 · cl.cam.ac.uk
• cpp-hopl — Stroustrup, Thriving in a Crowded and Changing World: C++ 2006–2020, HOPL IV / Proc. ACM PL 4(HOPL):70, June 2020 (T1, 168pp): the designer’s own history — community 3M → 4.5M developers, WG21 at up to 250 people per meeting, and a first-party admission of “design by committee, bureaucratic paralysis, and excessive enthusiasm for language fashions.” Causal story is his argument, not a measurement · source · T1 · stroustrup.com

Book (sources)

• the-power-of-prolog — Markus Triska (1.4k★, taught in nine countries): modern, pure declarative Prolog — dif/2, declarative arithmetic, constraints instead of cuts; “Restez purs!”. The corpus’s first normative source, arguing with the older canon rather than describing a language · source · T2 · github.com/triska

• dart — dart.dev: Google‘s general-purpose language with a compile-everywhere toolchain — AOT to native ARM/x64/RISC-V, JS and Wasm, plus a JIT that powers Flutter’s hot reload; the JIT-for-iteration / AOT-for-release split. Arrived from dev-tooling-wiki 2026-08-05 · source · T1 · dart.dev

• kotlin — Wikipedia: JetBrains’ statically-typed multi-target language (JVM with Java interop, JS, LLVM-native, Wasm-beta, Multiplatform); null safety in the type system, coroutines; K2 compiler rewrite. The corpus’s second third-party language description · source · T2 · en.wikipedia.org

• typescript — typescriptlang.org: microsoft‘s “JavaScript with syntax for types” — a static type layer that compiles by deleting itself, adopted per file via // @ts-check and JSDoc. Answers none of the four axes; its host is another language, not a runtime. v7.0; adoption numbers are 2020 surveys quoted in 2026 · source · T1 · typescriptlang.org

• zero-lang — zerolang.ai + vercel-labs/zero: Vercel Labs’ agent-first experiment where the program is a compiler-owned semantic graph and .0 text files are only a projection for human review; edits are checked patches addressed by node hash. Apache-2.0, ~5.2k★, self-declared experimental with security issues. The first source here whose intended author is not a person · source · T1 · zerolang.ai

• jank — jank-lang.org: Wilkerson‘s Clojure dialect re-hosted on C++ — same semantics, Java interop swapped for C++ interop, LLVM JIT for the REPL and AOT for shipping. One language on two runtimes, next to clojure itself · source · T1 · jank-lang.org

WebPage (sources)

• kotlin-and-android — Google’s official “Kotlin-first” Android page: 60%+ of professional Android developers, “20% less likely to crash,” Jetpack Compose. First-party numbers, uncontrolled · source · T1 · developer.android.com

SoftwareApplication (sources)

• nodejs — nodejs.org: JavaScript runtime on V8 — event loop, non-blocking I/O, worker threads, and node: built-ins (test, crypto, streams, http) absorbing what npm used to supply; LTS v24.19.0 / current v26.7.0; OpenJS Foundation. Not a language, and that is the point: it shows how much of a “language” is really its host · source · T1 · nodejs.org

TechArticle (sources)

• records-and-tuples — tc39/proposal-record-tuple #394: deeply immutable #{} / #[] primitives, withdrawn at the plenary of 2025-04-14 (stage 2, “unable to gain further consensus for adding new primitives”; repo archived 2025-04-15, successor = composites). The wall no library can climb — typescript‘s readonly is erased, so pure FP there has no runtime guarantee · source · T1 · github.com/tc39
• rethinking-java-design-patterns — Nicolas Duminil (DZone): five GoF patterns rewritten in functional Java — Factory as a constructor reference on the enum constant, Visitor as a compiler-proven exhaustive switch over a sealed type. The corpus’s only source about program design rather than a language · source · T3 · dzone.com

Person (entities)

• paul-graham — author of ANSI Common Lisp; cited by common-lisp‘s site as the authority for its extensibility claim, with no stewardship role in the language · entity
• john-mccarthy — designed lisp at MIT in 1958; his eval became an interpreter when Steve Russell hand-compiled it, which is where the REPL and the self-hosting compiler come from · entity
• jeaye-wilkerson — individual creator of jank, funded by community sponsors (Clojurists Together, Nubank); a language built and maintained outside a company or a foundation · entity
• giulio-canti — author of fp-ts, now joining the Effect organization as the library merges into effect; the absorbed-into-a-company ending against jeaye-wilkerson‘s stayed-independent one · entity

Synthesis

• synthesis — the thesis: a language is a small set of early decisions paid for everywhere; most of what a front page claims belongs to the runtime; the founding corpus is eight self-descriptions and no measurements