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
unsafein 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.