C++ is an absolute blast

Original Article ↗ Hacker News Discussion ↗

Enthusiasm over “modern C++” collides with deep skepticism as programmers weigh its power and expressiveness against its complexity, legacy baggage, and safety pitfalls. Many praise C++11/20 features, performance, and vast libraries—especially for systems, games, and existing codebases—while others argue that memory-safe languages like Rust, or simpler stacks like C, Python, or Zig, better balance productivity, correctness, and long‑term maintainability. Tooling, build systems, headers vs. modules, and package management emerge as persistent pain points, even among those who still find C++ genuinely fun to write.

Overall Mood: C++ Is Powerful, Fun for Some, Exhausting for Others

  • Many describe modern C++ (≥C++11, especially C++20) as expressive, fast, and “a blast” when used on greenfield or hobby projects.
  • Others, after years in the language, say they’re “done” with it: too much complexity, cognitive load, and legacy baggage.

Strengths Highlighted

  • Expressiveness: lambdas, auto, smart pointers, ranges, STL algorithms, constexpr, concepts, and RAII are praised when used well.
  • Control & performance: C++ remains favored where low-level control and latency matter (games, HFT, embedded, audio, engines).
  • Ecosystem: massive body of high‑performance libraries and existing code; cppreference is repeatedly lauded.

Complexity, Footguns, and Safety

  • Complaints: multiple initialization forms, confusing iostreams, pointer/array decay, undefined behavior, template error messages, std::optional UB on *opt when empty.
  • Memory safety: strong concern that unsafe C++ is always available; critics echo calls to move to memory-safe languages for new code.
  • Some argue “modern C++ subsets” are fine; others counter that novices and legacy codebases inevitably use unsafe patterns.

Legacy Code vs Modern Style

  • Sharp divide between:
    • New codebases using modern idioms, RAII, smart pointers, value types, and limited feature sets.
    • Large, old codebases mixing every era’s features, heavy templates, manual memory, and convoluted class hierarchies.
  • Several note the misery of maintaining the latter and insist the problem is often “bad software, not the language” — but others say C++ makes bad software easier.

Tooling, Build, and Packaging Pain

  • Persistent gripes about:
    • Headers, preprocessor, slow builds, fragile CMake, and inconsistent compilers/IDEs.
    • Immature or awkward package managers (Conan, vcpkg, etc.) vs smoother Python/Rust/JS tooling.
  • C++20 modules are seen as promising but incomplete and poorly supported in practice.

Comparisons to Other Languages

  • Rust: widely cited as “C++ done right” (traits, borrow checker, Option types, better errors), but also described as verbose, less “fun,” and with a smaller ecosystem.
  • C: loved for simplicity but criticized for strings/arrays and lack of safety; C23 borrowing C++ features is debated.
  • C#/Java/Kotlin/Python/JS: often preferred for higher-level work, better tooling, and productivity, but lack C++’s raw power or low‑level control.

Learning & Coping Strategies

  • Recommendations: use sanitizers (ASAN/UBSAN), stick to a safe modern subset, leverage references like cppreference, and watch “Back to Basics” CppCon talks.
  • Some use LLMs to decipher template errors and complex compiler messages.