The seven programming ur-languages (2022)

Original Article ↗ Hacker News Discussion ↗

A proposed taxonomy of seven “ur-languages” that underpin most modern programming sparks debate over what truly counts as fundamental: ALGOL vs. Fortran and COBOL for imperative roots, Smalltalk vs. Self for object orientation, and whether theorem provers, scripting and dataflow systems, or languages like jq deserve their own families. Commenters share learning resources and course experiences that use multiple paradigms (Lisp, ML, Prolog, Forth, APL, Smalltalk) to shape how programmers think, not just what they code in. There is also a recurring tension over how valuable it remains to deeply learn many language families in an era of AI-assisted coding, with some arguing that conceptual breadth matters more than ever for using such tools effectively.

Reactions to the “seven ur-languages” framing

  • Many like the idea of a small set of “families” as mental tools; others argue the article is reductive and historically loose.
  • Some think going back from ALGOL to assembly as a single “imperative family” is a stretch; they see ALGOL, Fortran, COBOL as distinct early branches.
  • One commenter calls the article “full of gross mistakes,” e.g., mis-expanding “Caml” and making dubious lineage claims.

Disputed classifications and omissions

  • Debate over whether COBOL and Fortran really sit in the ALGOL family; some suggest Fortran/COBOL are parallel lineages or “living fossils,” yet still actively standardized and commercially relevant.
  • Several argue Fortran (1957) deserves explicit “ur” status, with ALGOL (1958) more influential in design but not first.
  • Ruby is argued to belong squarely in the Smalltalk-style OO family, not “Algol,” while Python is noted as “pure OOP” under the hood.
  • Some prefer Smalltalk over Self as the OO ur-language; others say Self’s prototype model is different enough to warrant its own slot.

Logic, proof, and type-theoretic languages

  • Multiple comments propose a separate family for proof-oriented / dependently typed languages (Lean, Agda, Idris, F*, Dafny, ACL2).
  • There is disagreement over whether these are just “ML with extensions” or require removing general recursion to be sound proof systems.
  • Dispute over whether “true” programming languages must be Turing complete; several reject Turing completeness as a necessary criterion.

Beyond the seven: other paradigms and niches

  • Calls to recognize additional semantic families:
    • Hardware/parallel: Verilog, Petri nets, Kahn process networks, process calculi, reactive systems, dataflow, propagators.
    • Term rewriting (e.g., dedicated languages and Mathematica), constraint solving, probabilistic programming.
    • Scripting/pipeline languages (sh, awk, sed, Perl, PowerShell, Python/R, SQL) as a distinct family; dataflow tools like Excel and LabVIEW.
    • Stream/value-set languages like jq, where every expression yields zero or more values, presented as a distinctive model.

Learning languages vs. the LLM era

  • One view: investing heavily in multiple languages is “rapidly redundant” as LLMs improve; focus should be one main language, software engineering, and AI tooling.
  • Counterview: paradigmatic variety is a “tool for thinking,” improves problem selection and LLM prompt quality, and differentiates developers even if AI is ubiquitous.

Education, resources, and practice

  • Several reminisce about university courses that systematically covered paradigms (imperative, functional, OO, logic, etc.), often building small interpreters.
  • Extensive resource lists are shared for learning Forth, Lisp/Scheme, ML-like languages, Prolog-style logic, and PL design texts.
  • Benchmarks comparing modern compiled languages (F#, C++, Rust, others) show relatively close performance, with nuances in parallelism strategies highlighted.