C++ creator rebuts White House warning

C++ Safety vs Guidelines

• Many argue C++ remains fundamentally unsafe: safety “guidelines” are optional, unevenly enforced, and hard to retrofit onto existing code.
• Others say C++ can be “safe enough” with strict discipline: limited feature subsets, smart pointers, value semantics, sanitizers, max warnings, and linters aligned with the core guidelines.
• Several note that newer features (e.g., string_view, iterators) are themselves easy to misuse and can introduce subtle lifetime bugs.

Performance Debates (C++ vs Others)

• One side claims modern Java and other managed languages often match or exceed “real-world” C++ performance, especially when typical C++ projects lack advanced build/optimization setups (PGO, LTO, etc.).
• Opponents counter that high‑performance domains (AI/ML, HPC, GPU workloads) overwhelmingly rely on C/C++, and that Java/GC constraints make it unsuitable at those extremes.
• Some stress that C++ only reliably wins when experts aggressively manage memory layout, allocation, and cache behavior—effort most codebases never see.

Real‑World C++ Codebases

• Distinction is drawn between “idealized modern C++” and messy, legacy, mixed‑style code that dominates industry.
• Older C++03‑era systems are seen as especially hard to evolve safely; a few elite shops manage, but many others have failed or migrated away.
• Even in “modern” code, contributors report crashes from standard library quirks, iterator invalidation, and subtle UB that the compiler doesn’t flag.

Rust and Memory‑Safe Alternatives

• Many view Rust (and to a lesser extent Go, Java, Swift, etc.) as clearly safer by construction, eliminating large classes of memory bugs.
• Others argue the safety gap between well‑written C++ and Rust is small, emphasizing Rust’s own unsafe blocks and dependence on C libraries.
• Concerns are raised about Rust’s async “coloring,” ecosystem maturity, and heavy use of third‑party crates (supply‑chain and complexity risks).

Government Guidance and Response

• Some see the White House’s push away from C/C++ as overdue recognition that decades of memory‑safety issues show the language itself is a core problem.
• Others emphasize pragmatism: C++ is deeply entrenched (OSes, browsers, robotics, finance, embedded), cannot simply be dropped, and must be made safer via tooling and profiles.
• There is skepticism that ongoing C++ safety proposals (profiles, “C++ v2”) will arrive or be adopted fast enough compared to just choosing Rust or other safer languages for new projects.