Bjarne Stroustrup Quotes

Original Article ↗ Hacker News Discussion ↗

Quotes from C++ creator Bjarne Stroustrup spark a wide-ranging exploration of programming language design, from backward compatibility with C and the proliferation of “footguns” to the rise of safer alternatives like Rust. Commenters drill into technical pain points such as string representation, garbage collection, memory safety, and the difficulty of adding safety to a decades‑old ecosystem without breaking existing code. The exchange also touches on cultural factors—zealotry around languages, gaps between academia and industry, and the way real-world constraints shape both language usage and software architecture.

C++ and C Compatibility & Legacy

  • Debate over how “backwards compatible” C++ really is with C:
    • Some say most real-world C code compiles as C++ with minor changes.
    • Others argue many idiomatic C programs fail without nontrivial fixes (e.g., malloc without casts, use of C++ keywords).
  • Consensus that C++ inherited many of C’s “warts” for compatibility, and later drifted so it now has the warts without full compatibility.
  • Reflection that early C++ decisions were made by a few people; now the standard is committee-driven, which changes how design choices land.

Language Design, Details, and Strings

  • Strong agreement that language design is mostly about countless interacting details, not just grand ideas.
  • Wide-ranging discussion of string design:
    • UTF‑8 vs UTF‑16 vs “array of code points” vs “bytes as characters”.
    • Rust/Go-style “UTF‑8 only; no O(1) character indexing” seen as a big simplification.
    • Some argue for byte-strings as the default and separate Unicode types; others call this Anglocentric and dangerous in a world of emoji and non‑ASCII names.
    • Many point out that “character”, “code point”, and “grapheme” differ; operations like length, indexing, truncation are inherently tricky.
  • Broader point: APIs tied to mutable global encodings (e.g., locale defaults) are seen as design failures.

Humor, Footguns, and Garbage Collection

  • Linked parody pieces about C++’s complexity and “footguns” spark mixed reactions:
    • Some find them insightful about how powerful abstraction came with heavy pitfalls.
    • Others see them as unfunny or superficial.
  • Discussion of historical predictions that automatic garbage collection would become part of C++:
    • Optional GC made it into the standard but was never widely implemented or used, then removed.
    • Real-world C++ mostly relies on RAII and smart pointers rather than tracing GC.

Rust, Safety, and Competing “Successors”

  • Famous quote about “only two kinds of languages: those people complain about and those nobody uses” is debated:
    • Some use it to dismiss Rust vs C++ arguments.
    • Others criticize that as shallow; Rust is widely used and, like C++, heavily criticized by its own users.
  • Discussion of proposals to add “safe/unsafe” profiles to C++:
    • Skeptics argue that safety that doesn’t compose and arrives decades late can’t match Rust’s model.
    • Others believe C++ can and will evolve enough to keep many domains (HPC, games, compilers) without mass migration.

Education, Culture, and Professionalism

  • Commenters highlight that many CS programs still teach outdated architecture and project practices (heavy OO, naive “agile”), misaligned with modern industry experience.
  • Concern that academics who move directly from student to professor may perpetuate obsolete patterns.
  • One quoted line about “only knowing one language” spurs debate:
    • Some argue real breadth comes from building substantial systems in multiple languages.
    • Others counter that concepts matter more than tool count.