C++ Committee Ditches "Safe C" for Profiles: What's Behind the Shift?

The C++ Committee's Dilemma: Prioritizing Profiles Over Safety In the world of programming languages, few decisions have sparked as much debate and curiosity as the recent decision by the C++ committee to prioritize "Profiles" over the proposed "Safe C" safety model. The move has left many in the developer community wondering what this means for the future of memory safety in C++. As we delve into the story behind this decision, it becomes clear that there's more at play than just a simple vote. For those who may not be familiar with the inner workings of the C++ committee, let us start with some context. The C++ language has been around for decades and has become an essential tool in many industries, from finance to gaming. However, as the language has evolved, so have its challenges. Memory safety issues have long plagued developers, leading to costly bugs and security vulnerabilities. Enter Sean Baxter, a renowned expert in C++ and author of the cutting-edge Circle C compiler. In 2022, he proposed "Safe C," a rigorously safe subset of the language that would enable developers to write memory-safe code without having to learn an entirely new language. The idea was to create a bridge between the existing C++ ecosystem and the safety features of languages like Rust. Baxter's vision for Safe C was ambitious: it would include compile-time intelligence, such as borrow checking and initialization analysis, to prevent use-after-free bugs and type safety issues. This would allow developers to incrementally migrate their code to the safe subset, while existing unsafe code could continue to run without interruption. However, not everyone on the committee shared Baxter's enthusiasm for Safe C. As reported by The Register, a vote was held in June 2023, with the Safety and Security working group opting to prioritize Profiles over Safe C. According to Sean Baxter himself, "The decision was made to prioritize Profiles over Safe C." But what exactly are Profiles? And why did the committee choose them over Safe C? Profiles: The New Priority To understand the significance of this decision, we need to look at the concept of Profiles in C++. Essentially, Profiles are a way for developers to create custom subsets of the language that cater to specific use cases or requirements. This allows for more flexibility and adaptability within the existing C++ ecosystem. While Profiles offer many benefits, including improved maintainability and performance, they don't necessarily address the memory safety concerns that Safe C aimed to solve. In fact, some critics argue that prioritizing Profiles over Safe C sends a mixed message about the committee's commitment to memory safety. Multiple Perspectives We spoke with Erich Keane, a C committee member and co-chair of the C Evolution Working Group (EWG), who provided insight into the decision-making process. "Sean's proposal got a vote of encouragement where roughly 12 people encouraged Sean's paper, and 3045 encouraged work on profiles," he explained. Keane emphasized that the committee is committed to improving memory safety in C++, but acknowledged that there are different approaches to achieving this goal. "We're not abandoning Safe C entirely," he said. "However, we need to prioritize our efforts and resources." Implications for Society The decision to prioritize Profiles over Safe C has significant implications for the developer community and beyond. As more developers rely on C++ for critical applications, memory safety becomes an increasingly pressing concern. While some may argue that Profiles offer a more practical solution in the short term, others worry that this decision will ultimately hinder progress towards safer programming practices. "We need to prioritize memory safety," said Simone Bellavia, a developer who has been following the Safe C proposal closely. "It's not just about writing code; it's about ensuring the security and reliability of our systems." Conclusion The C++ committee's decision to prioritize Profiles over Safe C is a complex issue that reflects the ongoing debate within the programming community. As we move forward, it will be essential for developers, researchers, and industry leaders to engage in open discussions about memory safety and the future of C++. While the road ahead may be uncertain, one thing is clear: the need for safer programming practices has never been more pressing. By prioritizing Profiles over Safe C, the committee has sent a signal that they are committed to improving maintainability and performance, but also acknowledges the challenges in achieving memory safety. As we continue to navigate this landscape, it's essential to remember that the future of programming is not just about technology; it's about people, processes, and priorities. By working together, we can create safer, more reliable systems that benefit society as a whole. *Based on reporting by Developers.*