Programming language
A notation for describing computation that a machine can execute, together with the semantics that fix what each construct means. That definition is uncontroversial and nearly useless for telling two languages apart. What separates them is a small number of decisions taken early and then paid for everywhere:
- How memory is reclaimed — memory-management-model. Manual in c, traced garbage collection in go, php, nodejs, clojure and elixir, compile-time ownership in rust.
- What concurrency looks like — concurrency-model. Nothing in the language (c), CSP-style goroutines and channels (go), isolated processes passing messages (elixir), a single-threaded event loop (nodejs), transactional memory over immutable values (clojure).
- Whether it owns its runtime — hosted-language. clojure and elixir deliberately do not.
- Who is allowed to change it — language-governance. A standards committee, a foundation, a company, or a core group with an RFC process.
The founding corpus of this spoke is eight sources, seven of which are a language’s own front page. Those pages are where a language states which of these decisions it made and what it thinks the decision buys. They are also sales material, which is the standing caveat here.
The corpus so far
| Language | Memory | Concurrency | Runtime | Governance |
|---|---|---|---|---|
| c | manual | none in the language | its own, minimal | ISO committee (WG14) |
| rust | ownership, no GC | threads without data races | its own | Rust Foundation |
| go | GC | goroutines + channels | its own | |
| clojure | host’s GC | STM over immutable values | JVM / CLR / JS | company-funded core |
| elixir | BEAM’s GC, per process | supervised message-passing processes | BEAM (Erlang) | company-founded core |
| php | GC | fibers | its own | PHP Group, RFC process |
| nodejs | V8’s GC | event loop + worker threads | V8 (is a runtime, not a language) | OpenJS Foundation |
| erlang | BEAM’s GC, per process | processes + messages, hot code loading | BEAM (its own) | Ericsson lineage, Erlang Ecosystem Foundation |
| haskell | parallel GC (GHC) | lightweight threads + STM | GHC | Haskell.org, Inc. (non-profit) |
| common-lisp | not stated on the site | not stated | implementations under ANSI | ANSI standard, held still |
| scheme | not stated on the site | not stated | 20+ implementations | Revised Reports (RnRS) |
| java | (its page says nothing) | — | the JVM | Oracle, “the stewards of Java” |
| typescript | none of its own | none of its own | whatever runs the JavaScript | Microsoft |
| javascript | engine’s GC | one thread over a message queue | whatever embeds the engine | Ecma TC39, annual snapshots | | lua | GC | coroutines, scheduled by the program | its own small VM, made to be embedded | PUC-Rio team | | nim | chosen per build (ARC/ORC/GC/manual) | not the pitch | emits C, C++, JS | community, Rumpf leading | | python | GC | not on its page | its own | Python Software Foundation | | perl | GC | not on its page | its own | Perl Foundation |
Rows added 2026-08-06 (the full catalog is in index.md; this table keeps the sources that say enough
to fill a row). Several leave columns blank, and that is a result rather than a gap in the reading: a
language’s site fills in the axes it wants to compete on and stays silent on the rest. nim is the
one that breaks the table honestly — its memory model is a build flag, not a language property.
The table is the spoke’s founding claim in the smallest form it can be stated, and every row traces to that project’s own page.
The table has a hole, found within hours of writing it. prolog fits every column and none of them says anything about it: what defines a logic language is its evaluation strategy (logic-programming), an axis eight imperative-and-functional sources gave no reason to ask about. spark stretches a different column, since its answer to safety is neither a collector nor an ownership discipline but a proof. Treat the four axes as a reading of this corpus, not a theory of languages.
A fifth thing the axes assume: that the program is text. zero-lang stores the program as a semantic graph the compiler owns and generates text files only so a human can read a diff. All four questions above are asked of source text — what its declarations mean for memory, what its statements do concurrently, which runtime executes it, who is allowed to change its definition. None of them asks what the program is stored as, or who edits it directly. clojure is the nearest earlier case and a weaker one: its code-as-data lets a program rewrite itself, but the artefact on disk is still text.
A sixth: a language can decline the other axes entirely. typescript answers none of the four — it has no memory model, no concurrency model, no runtime of its own, and it disappears at compile time into the language it extends. What it does have is a type-system, which the four axes never asked about because the founding eight all had one and none of them made it the point. Added 2026-08-06.
And a seventh, arriving the same day: who is allowed to add to the language. common-lisp answers “whoever is writing the program” — macros make a library indistinguishable from a language feature, and CLOS is an object system bolted onto a language that shipped without one. clojure inherits the mechanism and spends it differently, on removing choices rather than adding them.
Related
memory-management-model · concurrency-model · hosted-language · language-governance · type-system · design-patterns · zero-lang · common-lisp · synthesis