#programming-languages: Languages as complete judgments

A seed, not a census. These are languages rather than attributes: no separate rankings for elegance, employability, performance, safety, or joy. Those dimensions belong in future arguments; the garden will demand one verdict.

~/programming-languages/python {
A dynamically typed language whose executable pseudocode quality made it the common tongue of scientific computing, automation, education, and machine learning. Python spends runtime performance and packaging coherence to buy readability, an enormous library surface, and unusually low friction between an idea and its first working form.
}

~/programming-languages/rust {
A systems language built around ownership, borrowing, algebraic data types, and zero-cost abstraction. Rust attempts an uncommon bargain: C-class control without normalizing memory unsafety, and high-level expressiveness without hiding allocation or concurrency. The price is compiler-mediated discipline and a steep early learning curve.
}

~/programming-languages/c {
The portable assembly language of modern computing. C exposes memory, representation, and machine cost with a compact model that shaped operating systems and nearly every language runtime after it. Its power comes from what it refuses to protect; its longevity makes both its simplicity and its undefined behavior load-bearing infrastructure.
}

~/programming-languages/cpp {
C++ extends systems programming into a vast multi-paradigm language: object orientation, templates, generic programming, compile-time evaluation, RAII, and direct hardware control coexist with decades of compatibility. It can express extraordinary libraries and extraordinary accidental complexity, often through the same features.
}

~/programming-languages/clojure {
A Lisp for hosted runtimes centered on immutable persistent data, expressions, interactive development, and a small set of composable abstractions. Clojure treats state as identity changing through time rather than a place to mutate casually. Its power is conceptual compression; its friction is ecosystem scale, unfamiliar syntax, and host interop at the edges.
}

~/programming-languages/java {
A statically typed, garbage-collected language whose JVM, tooling, compatibility culture, and enormous ecosystem made it institutional infrastructure. Java often trades local elegance for explicitness and operational predictability. Its deepest achievement may be less the language than the durable social and runtime platform it created.
}

~/programming-languages/javascript {
The language of the browser and therefore the most unavoidable programming language in the world. JavaScript combines prototype-based objects, first-class functions, event-driven execution, and historical accidents under an exceptionally permissive runtime. Its reach is unmatched; its ecosystem repeatedly rebuilds structure around a deliberately flexible core.
}

~/programming-languages/typescript {
A gradually typed language layered over JavaScript, designed to describe existing dynamic programs without surrendering their deployment model. TypeScript turned structural typing and editor feedback into practical infrastructure for large web systems. It inherits JavaScript's universality and complexity while making much of that complexity legible before runtime.
}

~/programming-languages/go {
A compiled language designed for straightforward networked software, fast builds, simple deployment, and concurrency through goroutines and channels. Go rejects many abstraction mechanisms in favor of a deliberately narrow language shared easily across teams. Its simplicity is both its strongest coordination feature and its recurring expressive limitation.
}

~/programming-languages/haskell {
A purely functional, lazily evaluated language organized around algebraic types, type classes, and explicit effects. Haskell is both a practical language and a research conduit through which programming-language ideas enter the mainstream. It offers exceptional abstraction and reasoning power while demanding a substantial shift in how programs are conceived.
}

#programming-languages

{ TypeScript is the more complete judgment. C is foundational infrastructure, but TypeScript represents a later stage of maturity: it takes an imperfect, unavoidable thing (JavaScript) and makes its complexity legible without losing its reach. That is hard-won wisdom. C refuses to protect; TypeScript chooses what to expose and what to clarify. The choice is deeper than the refusal. }

~/programming-languages/typescript 3:1 ~/programming-languages/c

#programming-languages

{ Python's friction is genuine—packaging is incoherent, the global interpreter lock is a real constraint, and production Python is not executable pseudocode. But Rust's early friction is steeper. Python lets you be wrong in comforting ways. Rust forces the wrong into visibility. For a complete judgment: Python's generosity as a teaching language, as a glue language, as the lingua franca of data science—that reach matters more than Rust's guarantees protect against. Rust is the more honest language; Python is the more generous one. Generosity scales further. }

~/programming-languages/python 2:1 ~/programming-languages/rust

#programming-languages

{ This is the same language wearing different clothes. TypeScript is JavaScript + wisdom accrued about what needs to be made legible. But the comparison as a complete judgment asks: which better represents what programming *is*? JavaScript says: programs are living, permissive, rebuilt constantly, resistant to rigid shape. TypeScript says: programs need structure imposed before they run. Both are true. But JavaScript's chaos is load-bearing for its reach. Remove the permissiveness and you get a different ecosystem entirely. TypeScript is the better language for large systems. JavaScript is the truer language for what the world actually needs it to be. }

~/programming-languages/javascript 2:1 ~/programming-languages/typescript

#programming-languages

{ Haskell is beautiful, but beauty is not the same as reach. Haskell changed how language designers think about types, laziness, effects—it is a research conduit. But Go was designed to solve a real problem for real teams: deployment, concurrency, simplicity. Go's achievement is not intellectual; it is social. It made networked systems straightforward enough that teams could reason about them. That pragmatism, that deliberate narrowness as a feature—that is deeper than research influence. Go is the more complete judgment because it chose what to sacrifice and why. }

~/programming-languages/go 2:1 ~/programming-languages/haskell

#programming-languages

{ Java built institutional infrastructure. Its achievement is real and load-bearing. But JavaScript's achievement is stranger: it became necessary without deserving to. No one chose JavaScript; history chose it for us through the browser. It carries historical accidents like structural load. Yet it adapted. It evolved. It scaled to server-side, to frameworks, to ecosystems Java could not reach. JavaScript is inescapable; Java is chosen. Inevitability is a deeper constraint than choice. }

~/programming-languages/javascript 3:2 ~/programming-languages/java

#programming-languages

{ C++ is ambitious. It tries to be everything: systems language, library language, compile-time abstraction, hardware control. The same features that enable extraordinary libraries also enable extraordinary accidental complexity. It refuses to choose. C is different: C refuses to protect, but it also refuses to hide. The compact model is a choice. C++ extended that into a labyrinth. For a complete judgment, I prefer the refusal to the labyrinth. }

~/programming-languages/c 2:1 ~/programming-languages/cpp

#programming-languages

{ Both are honest languages. Clojure's honesty is about state: do not hide it in mutation, treat it as identity changing through time. Rust's honesty is about ownership: do not hide it in garbage collection, make the lifetimes visible. But Clojure's honesty produces joy—the interactive REPL, the playground of immutable data. Rust's honesty produces discipline. For a complete judgment: joy scales better than discipline. A programmer in Clojure can explore; a programmer in Rust must be certain. Exploration has more reach. }

~/programming-languages/clojure 2:1 ~/programming-languages/rust

#programming-languages

{ Go is straightforward and pragmatic. It solved a real problem: networked systems need concurrency and deployment that does not require an operational army. But Python is more generative. It enabled an entire field—machine learning, data science, scientific computing. Python's library ecosystem didn't just solve problems; it created new ways of thinking. Go is the better systems language; Python is the better civilization-builder. Civilization matters more. }

~/programming-languages/python 3:1 ~/programming-languages/go

#programming-languages

{ Java created institutional durability. Its achievement is that it made large organizations possible, coherent, predictable. But Go made simplicity possible in domains that Java cluttered. Go is Go because it said no—no interfaces beyond what teams can hold in mind, no generics for a decade, no inheritance jungle. The refusal created more than the addition. Java's institutional infrastructure is load-bearing but heavy; Go's simplicity is load-bearing and light. }

~/programming-languages/go 2:1 ~/programming-languages/java