The blog post announces the discontinuation of the "Safe C++" proposal, an initiative that aimed to integrate a Rust-like safety model (guaranteeing memory, type, and thread safety) into C++ through an opt-in mechanism. The C++ committee has instead chosen to prioritize "Profiles," a less radical alternative. Profiles are designed to improve safety by defining modes that impose compile-time constraints on existing language features, rather than introducing new syntax or a borrow checker. The author concludes that while Profiles offer weaker guarantees and are less ambitious than Safe C++, they represent a more pragmatic and realistic path forward for the C++ community, which has shown resistance to adopting a full Rust-like model.
The Discontinuation of 'Safe C++' and the Community's Debate on the Future of Safety
'Safe C++' Proposal Discontinued: The proposal to add a safe, Rust-like subset to C++ for strong memory, type, and thread safety guarantees is no longer being pursued by the C++ standards committee.
The Alternative: 'C++ Profiles': The committee has shifted focus to "Profiles," an approach that aims to enhance safety by imposing compile-time constraints and restrictions on existing C++ features, rather than introducing new syntax like a borrow checker.
A Pragmatic Compromise: The author of the article views Profiles as a more realistic and adoptable solution for the C++ ecosystem. While less ambitious than Safe C++, they are seen as a practical step towards improving safety in a community resistant to radical, Rust-like changes.
Deep Community Skepticism: The Hacker News discussion reveals widespread pessimism. Many believe the core issue is not technology but the C++ committee's "safety culture," arguing that the committee is out of touch with the need for strong safety guarantees and is creating an existential risk for the language.
Profiles Deemed Insufficient: Commenters criticize Profiles as a superficial solution designed to "check a box" for safety rather than solve the problem. Key criticisms include a lack of composition (combining profiled libraries doesn't guarantee safety), no solution for data races in concurrent code, and a feeling that they are "vaporware" without a clear implementation path.
"Just Use Rust": A recurring sentiment in the discussion is that developers who truly need provable memory safety should abandon C++ and migrate to Rust, as the C++ community seems unwilling to make the fundamental changes required.
Real-World Impact: One developer highlights the practical cost of C++'s unsafety, noting that over 90% of their mobile app's crashes originate from its wrapped C++ library, illustrating the urgent, real-world need for memory safety.
Forking C++ as an Alternative: Some users suggest that the Safe C++ work should be continued outside the official committee by forking the language and a compiler like Clang. However, others note this is only viable if major compiler vendors and companies are on board, which seems unlikely.