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