The state of Rust trying to catch up with Ada [video]

Original Article ↗ Hacker News Discussion ↗

Why Ada Didn’t “Win” Broad Adoption

  • Historical timing: universities were teaching Fortran, Simula, Pascal, etc. long before Ada; if Ada was your “first language” that likely means a late-starting CS program.
  • Unix shipped with C and its own source; C was easy to bootstrap and port, Ada compilers were heavy, slow, and often expensive extras on Unix.
  • Commercial compilers: high prices, opaque licensing, and hardware demands limited hobbyist and startup use.
  • Ecosystem bias: Ada positioned as “mission critical / aerospace / defense,” not for web, games, or general apps, so it never built broad mindshare.
  • Chicken‑and‑egg: mainly “specialists” use it, so tooling and UX for newcomers lagged, which in turn discouraged wider adoption.
  • ACATS public conformance suite is both a strength and barrier: a new compiler starts with thousands of failing tests and no customers until it passes.

Safety Features, Subtypes, and Pattern/Liquid Types

  • Ada has long had range types and subtypes (and later dynamic predicates), allowing types like “angles 0..360” or “UUID_String” with embedded format checks.
  • These constraints can be enforced at runtime and, with SPARK/verification tools, often proven at compile time.
  • Rust’s “pattern types” / liquid types proposal aims for similar refinement-style types, expressed as patterns over existing types.
  • Current Rust niches (e.g., NonZeroI8, Option<&T> occupying same size as T) rely on compiler magic; pattern types would let users define such optimized, constrained types themselves (e.g., “BalancedI8” excluding INT_MIN).
  • Debate over utility: some see runtime-checked subranges as crucial for invariants; others find them historically underused or awkward without good verification tooling.

Rust vs Ada: Domains, Tooling, and Safety-Critical Use

  • Many see Rust and Ada as overlapping in “C/C++ replacement” and safety‑critical domains; Ada additionally has deep roots in hard real‑time control loops where post‑init allocation is forbidden.
  • Others argue Ada’s memory management model makes “browser‑like” workloads awkward, while Rust is built for heavy dynamic allocation with graceful failure.
  • Safety‑critical industries require certified/qualified toolchains; Ada vendors already offer such compilers and proof tools, largely proprietary.
  • Rust is building similar infrastructure (Ferrocene, safety‑critical consortium, MISRA‑aligned guidelines, model checkers like Loom).
  • Integer overflow semantics are contrasted: Ada treats overflow as a constraint violation; Rust uses debug‑panic vs release‑wrap plus explicit checked/saturating APIs, which some consider too opt‑in.

Syntax, Ergonomics, Adoption, and Community

  • Strong disagreement over readability: some find Pascal/Ada “BEGIN/END” clearer than C braces; others say that syntax “hurts their eyes” and prefer C‑style.
  • Rust deliberately adopted C‑like surface syntax as “weirdness budget” management to ease onboarding; internally it borrows heavily from ML/FP ideas.
  • Several commenters argue Rust’s success owes more to marketing, large‑company backing, platform roles (like Swift/Kotlin), and ecosystem investment than to purely technical merit.
  • Rising interest in Rust and “memory‑safe C replacements” has renewed attention to Ada as prior art; some are annoyed by Rust evangelism that appears to rediscover decades‑old ideas without credit.
  • Rust’s learning curve is widely acknowledged as steep; advice includes treating it initially like a mostly immutable, value‑passing language and adding advanced features later.