When a language's creator and its owners strongly disagree [pdf]

A failed attempt to add “contracts” to the upcoming C++26 standard has exposed deep rifts between the language’s original designer, its ISO standards committee, and the broader C++ community. Commenters debate who really “owns” a programming language—the standards body, implementers, or users—and whether committee‑driven evolution is producing an unmanageably complex, unsafe language compared with newer options like Rust or Zig. The episode is seen as a test case for C++’s long‑term viability, the limits of backward compatibility, and how programming languages should be governed in an era of multicore hardware and AI-assisted development.

Language ownership and governance

  • Debate over whether anyone “owns” a language:
    • One side: the standards committee “owns” the standard and thus the language’s future; a governing body avoids divergence or stagnation.
    • Other side: they only own the document; real ownership lies with compiler implementers and users, who can ignore the standard when it’s impractical.
  • Discussion of committee vs “benevolent dictator for life” (BDFL) models:
    • Pro‑BDFL: yields more coherent, unified design; committee design produces oddities and complexity.
    • Anti‑BDFL: doesn’t scale or survive retirement/death; successful languages have moved to councils or more distributed governance.

C++ complexity, learning curve, and design

  • Several posters describe trying to learn modern C++ and giving up, citing:
    • Multiple overlapping ways to do things (pointers, iteration, containers, algorithms).
    • Constant evolution and historical baggage; “archaeological dig” feel.
  • Others argue:
    • You only need a subset; treat C++ as a toolbox and add features as needed.
    • Many languages have legacy warts; C++ is just more visible and widely used.
  • There is disagreement on how many pointer/reference types a newcomer must mentally juggle, and whether “no pointer unless necessary” is realistic.

Contracts feature and C++26 stalemate

  • The thread focuses heavily on the proposed contracts facility and the failed C++26 vote:
    • The creator’s objections to the current design (e.g., semantics, lack of implementation, lack of real‑world use) are widely seen as substantive.
    • Some view contracts as unnecessary compared to existing assert‑style checks.
  • Proposed paths: skip C++26, drop contracts, tweak contracts (e.g., guaranteed enforcement), revote, or move standardization away from ISO.
  • Disagreement over “guaranteed enforcement”:
    • Pro: needed for reliability in mixed codebases and hardened libraries.
    • Con: might be too expensive or disruptive; compilers and tools aren’t ready.

Safety, Rust, and other languages

  • Strong criticism that C++ is inherently unsafe and poorly suited to a world of pervasive exploitation and automated bug‑hunting.
  • Counterpoints:
    • Modern idioms and tools (including LLMs) can find and fix many bugs.
    • Alternative systems languages (e.g., Rust) are also complex and rely on unsafe in hard domains.
  • Some argue that if redesigning from scratch, much of C++’s complexity wouldn’t be necessary.

Concurrency and hardware

  • Mention of the classic “free lunch is over” argument and C++’s role in defining a memory model used by other languages.
  • Disagreement over how impactful those ideas were and whether languages have really “caught up” with multicore:
    • Some want concurrency as a first‑class language construct (structured concurrency, core affinity).
    • Others argue concurrency is best hidden in runtimes/stdlibs; most developers don’t want to deal with low‑level scheduling or weak memory models.

LLMs and C++ practice

  • Several posters report good experiences using LLMs as mentors or pair‑programmers for C++.
  • Others note that C++’s intricacies still cause LLM‑generated code to trip linters and tools.
  • There is light meta‑discussion about LLMs being used to write standards‑adjacent documents and whether their stylistic tics are recognizable.

Outlook for C++

  • Some claim C++ is “overdone” or “on its last legs”:
    • Unsafe by design, increasingly complex, and facing pressure from safer alternatives.
    • Roadmap seen as bloated; new big features (modules, contracts) perceived as half‑baked.
  • Others expect C++ to persist for decades:
    • Immense existing codebases and library ecosystems.
    • Broad compiler support and performance profile that remains attractive.
  • Overall tone: growing fatigue with large, complex additions; skepticism that the current process can balance evolution with coherence.