As someone who writes high-reliability C++ but is completely outside the standards process, I see the issues with C++ Contracts. It isn’t clear that it solves a problem that anyone has in real codebases, especially after C++20 concepts.<p>If you were already writing high-reliability C++ then the benefits are difficult to quantify. If you weren’t writing high-reliability C++ then it saves you almost nothing over doing the standard idioms of high-reliability C++ that were already available to you at very marginally more cost. It <i>does</i> standardize expression of it in narrow cases but the payoff seems minimal.<p>Most of what C++ Contracts delivers is a mashup of what you can already do with constexpr and C++20 Concepts. I like reliability features but this feature, as delivered, looks fairly useless if you already use reliability features. A compelling standard would need to make much deeper guarantees out of the box. And the compiler can already see through most compositions of constexpr and C++20 concepts, which is already very expressive.<p>C++ Contracts looks a bit like a feature that was designed long before current standard features existed.
<p><pre><code> > high-reliability
</code></pre>
I never heard this term used with C++ before. Can you explain more? Ideally: Can you give an example snip of code that demonstrates it clearly?
Top 2 Google search result are ..: this post and this article
Its a set of rules, used by defense software, they are available on the internet
I think you're thinking of <a href="https://en.wikipedia.org/wiki/High_Integrity_C%2B%2B" rel="nofollow">https://en.wikipedia.org/wiki/High_Integrity_C%2B%2B</a><p>I wrote a comment explaining what in my mind distinguishes "high reliability" (defensive programming and making invariants/error cases/intended use explicit) C++ from regular C++. IMO it basically boils down to contemporary "Google/fintech style C++", which is a different development culture and ecosystem from defense/automotive
For example the failed F-35 project used it. Seems pretentious and risky compared to using a language that is safe by default.
What language do you propose?<p>(I'll just pre-empt that if you say "Rust", Rust wasn't around until recently and the F-35 project started in '93. These things span decades, while only a few programming languages do)
The incredibly obvious answer is Ada, given the DoD commissioned it and the fact that it was used for the F-22.
C++ is a pre-standard "Eh, just do whatever" language in 1993.<p>Bjarne's 2005 JSF rules have the same effect as an "Employees must wash hands" sign. It's not the billion dollar fast food chain's fault that a minimum wage employee didn't obey the sign and now you've got food-borne illness. They put a sign up!
> compared to a language that is safe by default.<p>This also sounds pretentious ...
Assuming the original commenter is referring to essentially best-practices, defensive C++ like you see at Google and projects like Envoy proxy, and the other reply is prob mixxed up and thinking of high integrity C++ [0],<p>Here's an example that uses compile time type assertions (static_assert, C++ can already do this), runtime errors (CHECK, standard Google/abseil practice for explicitly handling invalid states and invariants), test/dev checks (defensive programming, basically an inline test), and wrapper/error handling types to do what you might want contracts to do:<p><pre><code> template <typename T>
absl::StatusOr<double> Percentile(std::span<const T> sorted_values, double p) {
static_assert(std::is_arithmetic_v<T>, "T must be numeric");
CHECK(p >= 0.0 && p <= 100.0) << "p out of range: " << p;
DCHECK(std::ranges::is_sorted(sorted_values)) << "input not sorted";
if (sorted_values.empty()) {
return absl::InvalidArgumentError("empty input");
}
const std::size_t last = sorted_values.size() - 1;
const double rank = p / 100.0 * last;
const auto lo = static_cast<std::size_t>(rank);
const std::size_t hi = std::min(lo + 1, last);
const double result = std::lerp<double>(sorted_values[lo], sorted_values[hi],
rank - lo);
DCHECK(result >= sorted_values.front() && result <= sorted_values.back());
return result;
}
</code></pre>
(function impl is AI, only need it as scaffolding to demonstrate the contract-adjacent, non-implementation code)<p>Before I was exposed to this style of C++ and learned to write it, C++ basically felt like a different language. People say that the C++ standards committee and language designers have different priorities and developer culture vs most big tech companies/finance and I think it's because even if they're aware of the features and tools that come out of Google (et al) [1], they don't use them in their current day to day jobs and want that functionality in the core C++ toolchain.<p>IMO, a lot of what they want to add is already "solved" by third party tooling, but because for whatever reason they don't use those as part of their everyday work, they sometimes come up with language features that overcomplicate or solve the wrong thing, in a way that you would intuitively understand if you were already regularly using the 3P tools that solve them.<p>I could also be the one misinterpreting things here so apologies if this is obvious or not what the original commenter meant by "high reliability".<p>[0] <a href="https://en.wikipedia.org/wiki/High_Integrity_C%2B%2B" rel="nofollow">https://en.wikipedia.org/wiki/High_Integrity_C%2B%2B</a><p>[1] <a href="https://abseil.io/about/" rel="nofollow">https://abseil.io/about/</a> one of many third party ways to make C++ less insane
If you squint hard enough your example does look a lot like Ada pre and post condition contracts (perhaps a bit less ergonomic, at least for someone who hasn't written C++ in a while).<p>At this point the rust contracts crate with requires/ensures looks like a more straightforward approximation of Ada's Contracts and assertion policy. But still as far as I am aware no one has implemented something that mimics the static proof functionality in Ada's SPARK subset (which arguably not all applications or problem domains actually need or can justify the extra effort/cost).
Your comment just made me realize contracts is different from concepts (which are basically bounded genetics, right…?)
C++ concepts evaluate the properties of types at compile-time. You can inject arbitrary constraints on type properties anywhere in the code including conditional codegen. It is a way of asking if a type “can express this complex set of abstract things or has this enumerated set of properties” with almost arbitrary detail. They are extremely powerful in terms of expressiveness and specialization of code. Insanely good for performance and reliability engineering.<p>One of the best features to be added to C++ in many years.<p>C++ contracts are an attempt to bring C asserts into the C++ age. The weakness of C++ contracts is that they are mostly syntactic sugar over C asserts. If you really care about this type of thing, you probably already have a custom C++ assertion framework that is at least as capable if not more.<p>The promise of C++ contracts is that they can aid formal verification, which would be great. As delivered, it can’t do much more than was already possible, which will inhibit adoption.
I maintain a codebase that I’ve migrated from C++98 to C++11 and all the way to C++23 and even a bit of draft 26 (the latter for some minor library improvements). Few things made me quite as happy as moving from using SFINAE to using requires clauses and concepts.<p>(IMO the single best improvements over the years have been atomics and maybe variadic templates.)
I think you are right to position atomics and variadic templates as among the most consequential features of C++ in the last couple decades. It made an enormous number of things possible.<p>One thing I give the C++ feature gods credit for is recognizing material deficiencies in systems languages and unapologetically trying to fill those gaps starting with C++11. The addition of atomics, strict variadics, constexpr, lambdas, concepts, lifetime annotations, etc has been transformative for C++.
<p><pre><code> > the single best improvements over the years have been atomics...
</code></pre>
Of course, libatomic and friends have existed for a long time. Real question: Do you feel that the standardisation of atomics within the C++ base library is a material advantage over using libatomic? Also, maybe there are atomic APIs in the C++ base library that are better than libatomic. If so, please kindly share an example or two. I would like to learn more.<p>EDIT<p>I forgot to give a hat tip to your big upgrade from C++98 to C++23. In some projects, that can require an enormous amount of effort! Can you share a "stories from the trenches" that were difficult in that upgrade?
I want to read your blog describing these experiences.
<p><pre><code> The weakness of C++ contracts is that they are mostly syntactic sugar over C asserts.
</code></pre>
The sugar is actually one of my issues with them. The evaluation semantics are much more complicated / potentially slower than C asserts <i>because</i> of the sugar, and why you would have to pay those costs isn't obvious at first glance. Lisa Lippincott's excellent talk on the design of contracts [0] is what switched me from a sort of neutral support to disliking it. I think it's a stupid place for the national bodies to draw the line though. std::regex is acceptable, but a nothingburger like contracts tanks the vote?<p>[0] <a href="https://www.youtube.com/watch?v=yhhSW-FSWkE" rel="nofollow">https://www.youtube.com/watch?v=yhhSW-FSWkE</a>
To be clear, I have a lot of issues with the contracts proposal. I probably wouldn’t use despite living out on the standards frontier. I don’t even use C asserts already because they are not expressive enough in important ways. This proposal kind of reifies the inadequacies.<p>I think the risk is that C++ contracts become an evolutionary dead-end that hang around forever in code bases because they were standardized. It wouldn’t be the first time this has happened.
Concepts are evaluated compile time and make a lot of TMP more elegant. Contracts are runtime check, akin to assertions.<p>Phrased differently, contracts are to concepts what assert is to static_assert.
I think the wumpus that's being chased is that contracts COULD evolve into a compile time check. I'd be much happier if they actually caught the wumpus before they start polluting the language with yet another baroquely complicated feature that gets abandoned before it actually becomes useful (e.g. coroutines, and modules). Or just keep it simple and give us a C++-sensible replacement for assert(), and avoid the rest of it. i.e. contract_assert without the word "contract" in it. That would be a nice feature.
Too bad it couldn't have been contract and static_contract.
A concept is a compile time requirement that bounds templates which are the generics in C++, so you are close.
Concepts are for Types at compile time while Contracts are for Values at runtime.
The problem is that the current design doesn't take into account binary libraries, or what happens when conflicting contract modes are linked together, as contracts aren't reflected on ABI.<p>Additionally they offer very little mechanisms versus Eiffel's original design, Ada/SPARK or Frama-C.<p>A basic MVP, expected to improve on subsequent C++ version, assuming that the proposal authors stick around for those evolution proposals.
Huh? Concepts are types of types. Contracts are fancier, structured runtime assertions. What does one have to do with the other? They're nothing alike.
They both start with the letter C, have two syllables, and have/had a hard time getting into the standard. If you’re not paying close attention, it’s easy to get them confused.
That’s exactly my point.<p>Contracts notionally offer the ability to lift some runtime assertions to compile-time. That is how it was sold. Except they don’t in practice.<p>Meanwhile, concepts + constexpr if used artfully deliver that in practice, including for many cases that contracts were supposed to solve.<p>I push all verification to compile-time to the extent possible.
I don't buy the idea that in "high-reliability C++" every condition worth checking can be checked statically, not unless you define "high-reliability" vacuously as that set of programs for which the claim is true. Real-world programs have legitimate reasons to verify invariants dynamically, and C++26 contracts provides an improved way to do so.<p>While the C++26 variant of contracts doesn't provide the benefits of its static-analysis-centric ancestor from 2014, and therefore isn't as consequential a feature, it still provides value to some and is absolutely not important enough to be worth killing a standard. Concepts do not provide this value.<p>In any case, it's simply false that C++26 contracts are unnecessary because we have concepts, yet this claim is the thrust of your initial comment.
The issue is that contracts are less flexible than the existing capabilities in practice, it is limited syntactic sugar.<p>Contracts were sold with the idea of aiding compile-time verification, a noble purpose. The combination of concepts + constexpr allows you to do deeper compile-time verification today by other means than contracts can check. It isn’t obvious that this will ever not be the case. This means contracts is relegated to being another flavor of C asserts.<p>C++26 contracts are arguably unnecessary because we can achieve the same results other ways, sometimes with stronger properties. I’m a proponent of features that clean up the syntax but C++ contracts look like a nod to people that still use legacy C asserts. That’s fine but it also perpetuates an inadequate model of what assertions should be capable of expressing.<p>People figured out how to do with C++20 better than what contracts promised.
There's nothing "legacy" about checking invariants at runtime, and you can't simultaneously dismiss the concerns of people doing so on the grounds that they're "still us[ing] legacy C asserts" when you deny them an alternative to "legacy C asserts". That's question-begging.<p>> People figured out how to do with C++20 better than what contracts promised.<p>What contracts used to promise is irrelevant. The contracts <i>on the table</i> modernized runtime assertions and are irrelevant to concepts, constexpr, and related facilities.<p>Is the contracts feature more useful than C's assert()?<p>If you want to argue that we're better off with the old macro, do so directly. Concepts, in this context, amount to irrelevant distraction.
> While the C++26 variant of contracts doesn't provide the benefits of its static-analysis-centric ancestor from 2014<p>Do you have any information as to why they shifted the focus from static analysis to runtime checks? I only remember that it was based on some Microsoft annotation language or something.
Absolutely Right! - <a href="https://news.ycombinator.com/item?id=50361435">https://news.ycombinator.com/item?id=50361435</a>
[flagged]
> The problem is that a bunch of people who didn't care for them did something very extreme by voting against approving C++26.<p>The only extreme and tone deaf thing I see in this story is how contracts proponents were faced with multiple papers demonstrating quite clearly and extensively how they were broken in specification and in form, but still tried to ignore all the criticism and force them through a consensus process in spite of being clearly opposed.<p>How does this make any sense? What was the plan here? To blackmail the C++ community to accept a broken feature under threat of the proposal not passing?<p>Make it make sense?<p>What I want to see is the people who tried to force contacts upon the process in spite of all opposition to come forth and explain their rationale. It was highly absurd and even unthinkable to force a broken feature down C++'s throats with bureaucratic chicanery, and then complain that the same bureaucracy has mechanisms to stop it's abuse. I for one would like to hear an explanation.
While I can understand that C++ contracts were met with controversy, contract annotations scoped at analysis time that can be verified by external tools, such as static analyzers, model checkers, or automatic theorem provers, are incredibly useful.<p>I put together an alternative function contract and invariant mechanism in C using CBMC and custom macros that effectively allows me to perform formal methods in C using compositional verification. The reason why I chose C is because of its relative simplicity and relative ease of building tooling around it. C++ contracts provide some feature parity, and would let me take advantage of some of the features in C++ relative to C.<p>I hope that the contract proposal is workshopped and simplified so it can be proposed again for a future version. Its current form is unsuitable, but it deserves a second chance with a simpler implementation. Contracts would narrow the safety gap between C++ and languages such as Ada / SPARK.
C and formal verification is an awesome combination. I tried cmbc on some toy programs, it it fully automatically proved memory safety and all assertions. But for larger programs one has to split up with a contract-like facility.<p>Can you tell us more how you use cbmc with macros? I am also exploring this.<p>I also wonder what feature from C++ you miss in C?
Contracts are useful, but don't guaranteed anything if type safety & memory safety can be bypassed.<p>I think the ISO panel made the right call. The real world consider memory safety & execution integrity to already be critical issues (and C++ no longer to be viable), and they are correct. The WG has its priorities wrong.
Memory safety can also be bypassed in Rust. If you want something where memory safety is guaranteed, use Fil-C but this comes at a performance cost. Or use formal verification, where then contracts can help (but C++'s complexity doesn't).
This is fascinating to watch from the outside, because there was a big debate a few years ago about whether rust should go for ISO certification, and the consensus seemed to be it was a massive bureaucratic headache with few upsides. Not having a lot of insight into ISO procedures, I wasn't sure what to make of that, but this certainly gives some weight to that point of view
I get why some folks would like to see contracts in the language, but C++ is also buckling due to the shear complexity that's getting tacked on to it. I'd rather see more proposals such as C++26's "erroneous behavior" that attempts to reign in the language's shortcomings.
Agree. There's an argument that Contracts reduces the complexity of <i>using</i> the language because it offers a more readable alternative to template metaprogramming (also, it has better error messages). But the argument really falls apart when you review WG21's track record for other features.<p>Like for example, Coroutines were billed as an easier way to write concurrent code, but personally I think it completely failed and ended up being hopelessly complex and confusing. Modules are the same - superficially they make things simpler, but when people actually go to adopt it, the details are so complex that nobody bothers.
Some do bother, e.g. Microsoft Office uses modules, there is a talk on it.
> There's an argument that Contracts reduces the complexity of using the language because it offers a more readable alternative to template metaprogramming<p>Like most people in this thread, you should really read up on contracts before commenting. The contracts proposal is for runtime assertions, and their problem is that they are poorly specified and fundamentally broken. Their proponents haven't been addressing any of their concerns and tried to push a half baked version of them down everyone's throats, which was why they failed to pass.
I think you're confusing it with Concepts. Contracts are basically just asserts, nothing to do with templates.
*sheer
Personally I'd like to see C++ chill out on new features and maybe sort out the shitshow that is char8_t and std::filesystem.
This article makes it sound the options are normally approval, rejection and abstention, but that this time round a fourth option, "disapproval", was reached. It that the case, or are they just trying to say that people rejected it?
> contracts. Put simply, a number of NBs believe that this feature is not yet ready for release.<p>The ISO National Bodies voted wisely. C++ has had so many ill defined features over the decades and they wanted to avoid yet another one.<p>I don't have any skin in the game. I've stayed with the C++11 feature set.
I'm not surprised. Pace of adding new features vs. realistic added value, vs. complexity to get it properly standardised makes 3 years rounds to circulate new ISO C++ standard less and less possible without introducing major flaws that will continue sending C++ to hell in the eyes of Rustafarians and other safe languages folk.
A 3-year cycle is not the problem, the pace of new features is. C++14 vs. C++11 for example was a totally reasonable upgrade and well-paced. C++26 vs. C++23 is a huge change by comparison. Everyone has their own opinion about which fancy complicated language feature will finally "fix" C++ (concepts? contracts? reflection? profiles? constexpr?) and the answer of WG21 has been to just put all of them into the already full kitchen sink.<p>You can fix every problem in language design with more language features, except "too many language features". Most people on the committee even seem to intellectually understand this, but their preferred time to stop adding new major features is "once my pet feature is in".<p>And to harp on the safety thing a bit: In the absence of an actually safe subset of C++, additional language complexity is also a safety problem. "best effort" safety like the stuff C++ is pursuing at the moment still relies on you knowing exactly what your code does, which is hindered by complexity.<p>Here's an example for contracts. Say you have the following declaration:<p><pre><code> void foo(int* p)
pre (p != nullptr)
pre (*p >= 0);
</code></pre>
What happens if you pass a nullptr? You'd guess that it either raises a contract violation or silently ignores it, right? Yes, those are two possibilities, in the "enforce" and "ignore" modes respectively. But there's also an "observe" mode, where the preconditions are checked at runtime and violations reported but then execution resumes normally. Can you see the problem? Passing a nullptr causes evaluation of the second precondition to deref it, so we get UB from the contracts themselves before we ever hit the function body (which might have its own, classic nullptr checks, who knows). This is a completely new class of footgun that you never had with assertions (they are always either enforced or ignored).
> As I understand it, this step would mean reverting to C++23 and proceeding to C++29<p>What kind of design process is this
Approval of runtime failures essentially failed at runtime
hmm, i rather think this is implementation time, pre commit. it failed the tests.<p>runtime would be after commit when the standard is released and moved to production and users fail to make their code with the new features work.
The NBs should use this veto power more often until the committee learns to not push half-assed features into the standard. C++ is not a language that needs to "move fast and break things".
> By voting “no,” an established system, one based primarily on trust and respectful collaboration, has been shaken.<p>I don't get it. If ISO deliberately requires two levels of approval, why should exercising the second level's voting authority be considered a betrayal of trust?
Because they didn’t vote the way the author wanted them to.<p>That’s not very charitable, but honestly I’ve been trying for five minutes now to find or think up an alternative explanation. And coming up blank.
A more charitable interpretation is something like royal assent for laws. Yes, the king/queen can always just choose to delay it or even block the law, but that'd be unprecedented and the whole system of parliamentary monarchy would be in a serious crisis.<p>I think the author is trying to get at like, the actual discussion happens earlier / on the WG21 level, and the ISO vote is treated more of a rubberstamp. And that has changed in this instance.
> but that'd be unprecedented<p>Not really. The unprecedented part was how come contracts proponents decided to push a proposal against all feedback and concerns, knowing very well it was falling to build up any form of consensus.<p>Contracts proponents knew for years the featured proposal was opposed as it was riddled with fundamental technical flaws. The unprecedented part was the way they said "screw them" and pushed forth anyway, hoping the formality would build enough pressure to force anyone opposing the feature to succumb to the bureaucratic pressure and silence their concerns.<p>This contracts stunt reeks of corporate chicanery. I mean, what was the plan here? Ignore everyone, get the bureaucratic foot in the door, and then blackmail all dissenting voices of sabotaging the process if contracts proponents didn't had their way?
Personally, I think that if a system to veto something exists, it shouldn't be considered shocking or a betrayal of it gets exercised. Otherwise why have the system?
> Because they didn’t vote the way the author wanted them to.<p>That's my opinion as well. It's a smear campaign lashing back at people who dared to point out flaws.
I don't get it either; and have no sides on the fence (been years since I wrote C++; but I have before).<p>It sounds like there's sufficiently different genuine views here on whether it's right for the standard at this time, and this seems like the process working as designed.
The Section "The Process" does explain the thinking behind that statement. To rehash: The author thinks that NB's were trusted with the ability to reject by blocking minority for the case that there is new information, but have used that ability in a case where there was no new information.<p>I have no stake in this entire discussion or C++ and don't know if the premise of this argument is even true. Just curious: is that thinking unhinged?
Note that the author says that this was "the previous <i>practice</i>". There is no mention of this being, say, the sole intended use as mentioned in some bylaws. In fact, if "uncovering of new information" was the sole reason, why not have a confirmation vote in the same body after a mandatory cooldown period?<p>The author even explicitly states that "errors in the process" are another potential reason for the NB's to vote against a proposal, so why focus solely on the "no new information" argument?<p>Also, keep in mind that the WG21 operates primarily by consensus[0], which is explicitly <i>not</i> a majority vote. The final vote for Contracts was 114 in favor, 12 opposed, 3 abstaining, which some consider "an unusual level of opposition" with "tangible debate"[1].<p>I assume the default is for people to trust that the domain experts in the various subcommittees did their work properly, so an in-favor vote would be more a "I trust the subcommittee / I don't care about this feature" than an explicit "I approve of this feature", with an opposing vote basically being "the subcommittee is making a grave error, this is <i>obviously</i> going to blow up in our faces".<p>Extend this to the NB level, and the disapproval is basically a vote of "Wait, do we <i>really</i> want to standardize something which is still facing very serious opposition?"<p>[0]: <a href="https://isocpp.org/std/standing-documents/sd-4-wg21-practices-and-procedures#consensus" rel="nofollow">https://isocpp.org/std/standing-documents/sd-4-wg21-practice...</a><p>[1]: <a href="https://componentsprogramming.com/cpp26-croydon-wg21-meeting/" rel="nofollow">https://componentsprogramming.com/cpp26-croydon-wg21-meeting...</a>
Correct me if I'm wrong, because I don't follow C++ very closely, but based on previous discussions on HN, the opposition paper obliquely referenced in the blog post was presumably Bjarne Stroustrup's, who IIRC had already said he would work behind the scenes to make sure the final pro forma vote to standardize C++26 would fail.
Bjarne Stroustrup has been pushing Profiles, which would allow C++ code (or the majority of it) to become type-safe and memory safe.<p>Contracts are useful, but don't guaranteed anything if type safety & memory safety can be bypassed.<p>I think the ISO panel made the right call. The real world consider memory safety & execution integrity to be critical issues, and C++ no longer to be viable. Without some major improvements -- I would consider this view to be correct.
> Profiles, which would allow C++ code (or the majority of it) to become type-safe and memory safe.<p>Certainly safer, but not memory safe. Operations as simple as multiplying signed integers or popping an empty vec can be undefined behavior which is not memory safe.
For most domains, it is fine. Why should my valued checked code pay the price for checking every arithmetic operation for overflow. Why should my correctly implemented algorithm waste CPU checking something I know is valid? And worst of all, what happens when a logic error is encountered, we run untested code path? I hate code that is conditionally defensive (eg. if (ptr) ptr->critical(); ). I should never be in that situation, a silent ignore corrupts internal state, and never tested the fail path. Ptr may even refer to garbage. Its a stupid defebsive check in 90% of code bases. std::optional<Ptr> at least clarifies intent.
The problem is that it <i>silently</i> overflows <i>by default</i> - and a good chunk of the time it is even undefined behavior. Sure, in some situations you as the developer are 100% certain that an overflow is impossible (despite the compiler not being able to prove this and therefore eliminate the checks), but in the <i>vast</i> majority of cases it is a footgun silently waiting to go off.<p>Rust tries to solve this by having basic addition panic in debug, while silently-but-consistently continuing in production: overflow is considered a bug, but it is at least not a <i>platform-dependent</i> bug.<p>If overflow is <i>expected</i>, then there's checked_add to detect it and fail in a friendly way, saturating_add / wrapping_add / carrying_add for specific overflow behavior.<p>Finally, if speed is crucial and overflow is either impossible or you don't care about the outcome whatsoever, there's unchecked_add to <i>explicitly</i> opt-in to a C-like "just do whatever the machine feels like".<p>You can still do everything you can with C. It it just an explicit choice, rather than an implicit platform-dependent mechanism you might forget about.
Yep. Safety and simplicity need to be the priority.
Yes that's right, and from following some threads on reddit about this, he used some really dirty tactics to get it to fail, like scheduling certain snap elections to happen with very short notice at times of the day when people who would oppose his point of view would likely be asleep.
> ...at times of the day when people who would oppose his point of view would likely be asleep.<p>Stroustrup is 75 years old. This is not only hard to believe because of his age, but also because it requires that people who oppose his views somehow have distinct sleeping patterns from ones who agree with his views. Weird, man.
> that people who oppose his views somehow have distinct sleeping patterns from ones who agree with his views.<p>Not weird if they're mostly from different continents.<p>When I saw him a year or so ago he said he wasn't happy with how things were going, but never alluded to a coup. But it's his language, so good for him.
Reddit is a cesspool, I wouldn't put faith in anything you read there.<p>There were no "dirty tricks". The C++ standards committee works by a vaguely defined "consensus", which requires more than "the majority rules". Contracts got added to the C++26 draft. Then there was consensus that Contracts needed to be fixed, but they could never get consensus on any particular fix. So they cruised along relatively unchanged.<p>In the end, the only way to NOT accept a marginal Contracts feature was to vote down the full language spec. Now they'll regroup and decide how to proceed.
<i>If</i> this was true I'd ask myself why he was this motivated to block it. He's a smart man and not a corpo rat to do dirty things just because.
So is he a hero, or villain? Does it all come down to concepts?
> Correct me if I'm wrong, because I don't follow C++ very closely, but based on previous discussions on HN, the opposition paper obliquely referenced in the blog post was presumably Bjarne Stroustrup's (...)<p>I've noticed that Bjarne Stroustrup is being subjected to a smear campaign, when things are far simpler and far less conspiratorial than they are making out to be.<p>There are indeed papers demonstrating that not only is the current proposal for contracts broken but it also fails to adhere to core C++ principles. They have been published since at least 2017. Contracts aren't new, nor the problems they introduced. They've been routinely removed from C++ standards, and so far the proposal wasn't fixed.<p>So ask yourself this: why was a notoriously broken feature forced into the proposal when it was clear it wasn't going to pass?<p>From an outsider's point of view, I see this from a different perspective. Contracts proponents tried to use bureaucratic tricks and threats of abnormal processes to force a broken feature they knew for years that wasn't supported or passing the smell test. And now that they saw their efforts thwarted , the complain that their plan failed and they have opposition?<p>I mean, there is even a paper dating back to 2025 called "contracts concerns" and from 2026 called "contracts fundamental flaws". The C++ standard is a consensus-driven process. Does this look like consensus? Clearly no.<p>So we have a group of people who ignored the calls that they were pushing a broken feature, but tried to railroad the process anyway and ignore any concern or warning. Then, when they tried to force their way through the process, their bluff was called and their threats failed. And now they are lashing back.
C++ should focus into turning SIMD into a higher level language instead of being a giant collection of intrinsics. Avx code is unreadable.
SIMD cannot be solved at the compiler level. The capabilities of silicon SIMD implementations are fundamentally so disjoint that code using SIMD requires contextual and platform-specific data structures and algorithms.<p>SIMD on different silicon is incompatible at layers of abstraction far above the codegen manipulation a compiler can do.
You'll never get the full feature set of all SIMD implementations in a single generic abstraction but I'm not sure that's the only way a SIMD abstraction could provide value. There is a pretty consistent set of narrow SIMD that behaves close enough to consistently get better performance across generic targets with high level abstractions better than auto vectorized scalar code but worse than platform tuned SIMD.
The subset of SIMD that translates is so narrow that it is almost useless in real code. That’s the problem. Additionally, it is invalid for the compiler to redesign your data structures.<p>The ability of compilers to use SIMD is no better than it was 20 years ago. Total stagnation for all practical purposes, and the reason is that compilers fundamentally lack the context and freedom to rewrite the code architecture appropriately for SIMD optimization (even if they could).<p>I think a point people miss is that highly optimized SIMD code is almost never about parallelizing loops. It is about deeply probing and manipulating arbitrarily complex data structures in parallel that involve collections of unrelated types. SIMD allows you to do this, and it is fantastically efficient, but a compiler has no conceivable way of understanding this.<p>For this reason, SIMD optimization has often been classified as an AI-Complete problem in computer science.
My imagination is failing me, can you give me an example of the type of work being done where SIMD is ‘deeply probing and manipulating arbitrarily complex data structures in parallel that involve collections of unrelated types’? I don’t doubt you know what you mean, but I can’t wrap my head around it.<p>For me I can only think of the simplest example of SIMD being used to ‘parallelize loops’ as what SIMD is for. If it turns out I’m missing a large problem or application space for SIMD I will be excited to research it. Any pointers to topics would be appreciated.
SIMD is often used to evaluate complex data structures in parallel. A common case is given a row with an arbitrary mix of data types and a query with an arbitrary mix of independent constraints on those data types, to evaluate all of the constraints in parallel in the same SIMD instruction(s).<p>The idea that SIMD is only good for parallelizing operations over arrays of the same type is empirically false and seriously understates the capabilities of good SIMD implementations. Some SQL-ish implementations work this way on row-structured data.<p>Most devs seriously underestimate what good SIMD is capable of.
One example is OLAP databases, which often heavily exploit SIMD for query processing. You can also turn parsing into a SIMD problem, which is applicable to things like handling XML, JSON, and CSV. Simdjson comes to mind, or parabix for XML.
Couldn't SIMD features include marking data as "the compiler is free to rearrange"?
Is the common feature set described anywhere online? I am not in the SIMD world, and I am curious about the state of it. But I am not so committed that I am wiling to learn several different platforms’ SIMD implementations in order to suss out their commonalities.
Please stop repeating this ludicrously overstated claim.<p>I have personally seen several hundred use cases for SIMD that are just fine with portable intrinsics, and NOT always "platform-specific data structures and algorithms". Sure, that does happen, but not fundamentally, nor even often.<p>To be clear, I agree the compiler isn't solving the data layout problem for us, but portable intrinsics are indeed useful.<p>gemma.cpp uses them, and last I checked, has much faster long-context prefill and decode vs. llama.cpp. They hand-roll the intrinsics and presumably it is harder to land optimizations repeated across 7+ implementations/instruction sets.
> SIMD cannot be solved at the compiler level.<p>ISPC doesn't a pretty good job of it: <a href="https://ispc.github.io/" rel="nofollow">https://ispc.github.io/</a>
That's why it needs a lot of work. Writing SIMD in c++ is like writing assembly.
In fact, C++26 made some considerable progress on that front.<p><a href="https://en.cppreference.com/cpp/experimental/simd" rel="nofollow">https://en.cppreference.com/cpp/experimental/simd</a><p>An implementation of which exists in the following GitHub repo (albeit implemented in the xvec::simd namespace rather than std::simd...but otherwise intended to be spec-compliant).<p><a href="https://github.com/intel/xvec" rel="nofollow">https://github.com/intel/xvec</a><p>Speaking as a long-time C++ developer...I wasn't uninterested in contracts (which I've known about since the days of Bertrand Meyer flogging them in Eiffel), but I agree with the sentiment here that the SIMD efforts were considerably more interesting.
There are frameworks trying to unify simd/avx, but the abstractions aren't free. At this point, we need better hardware and low level interfaces, not better abstractions.
Can we have a 10 year break from further language changes?
Or, at the very, least a rule that a proposed feature should be a vendor-specific extension for at least 5 years, <i>and</i> the vendor has to dogfood it in their toolchain.
major C++26 features, including reflection, std::execution and library hardening, are also delayed because they were included in the same draft.
Maybe it's time for C++ community to create maintenance releases of old standards?<p>Not new features necessarily, but fixes or backports that fix major flaws.<p>It can also complement old standards. If a C++23 feature can be supported in C++98 or C++11, it should go to that standard with an update.
That already exist - C++ defect reports can change the behavior of implementations for older standards.
How would that even work? Implementations that’s been compliant for years suddenly become non-compliant?
Honest question.<p>If I want to spin up a new project with a coding agent to explore some idea and I'd like the bare metal performance, why would I choose C++ over Rust?<p>I could choose TypeScript over Rust if I wanted it to be html first or I could choose Go if I wanted it to be clear of the complexity of memory management or I could choose C# if I wanted it to have best interface with windows stuff or I could choose something Erlang VM based for resilience and multithreading.<p>But what reason might I have to pick C++?
Interfacing with other C++ projects or leveraging existing infrastructure/work you've done.<p>Rust's package management and lack of stable, high-quality libraries maintained by professional or even just generally known entities are a pretty big problem. For the small number of Rust projects I've attempted, I've tried to make them zero-dependency, and it worked (you just ask agents to implement more libraries) but it added a lot of annoying overhead.<p>It's also just easier to write high performance code in C/C++. If you'd rather have that than builtin memory safety guarantees or whatever else you want out of Rust, or have a small enough surface for errors/threats that you can just manually spend time validating that your code is safe and secure, C++ is still pretty good IMO. I would generally start with C though, because it makes interop with other languages easier
Maybe you don't. If you were to spin up a new project with a coding agent most of the subsequent highlights of the languages you cited might also not matter.
why would any startup or company would care about C++ committee do ???? isn't this is hampering innovation ???<p>they can just simply use Zig or Rust no ??
But I'm curious—why did DIS fail this time with C++26? Weren't feature additions in C++ usually plentiful?<p>But they say this is the first case where a DIS failed during the standardization consensus process. Why is that?
Maybe my reading comprehension has just nosedived but I could not find where this article discusses what the heck Contracts refers to?
You'll find plenty of info if you search for anything like "c++ contracts" [0], but the short of it is that they're just pre/post conditions on functions. Slightly improved assertions, basically.<p>[0] <a href="https://en.cppreference.com/cpp/language/contracts" rel="nofollow">https://en.cppreference.com/cpp/language/contracts</a>
<a href="https://www.cppstories.com/2026/cpp26_contracts/" rel="nofollow">https://www.cppstories.com/2026/cpp26_contracts/</a> is IMO a better introduction.<p>cppreference is often a bit too technical for its own good :)<p>But I think there's a broader issue which is that if it took me multiple searches to find a good-enough visual "pitch" for what contracts look like in practice, its champions have not yet won hearts and minds - which brings us to the situation at hand.
Its a very inside baseball article. Contracts is a proposed C++ language feature for improving programmable assertions of program state. E.g. a better c++ version of C's assert function. That in theory will improve both safety and performance by letting people add more complex assertions (e.g. pre/post conditions) to functions.
> Now it gets complicated.<p>It was said in the article about the process.<p>But to me this is relevant to the state of the language itself.
[flagged]
[flagged]
[dead]
[dead]
Maybe this time could be used to consider memory safety much more seriously.<p>EDIT: Would love to know why people are so angry about that?
The issue that caused this to be voted down is often seen as a memory safety solution (not something I personally 100% agree with, but thats a broad view). And the rest of this release includes other memory safety work. And it was voted down and delayed for apparent political reasons (again not a view I agree with).<p>So most people will read your view as hypocritical/misinformed.
[dead]
Memory safety was solved in 1959 with the invention of lisp
C++ is in a strange position.<p>If you look at "let's use AI to rewrite xyz in Rust", then C++ has to wonder
why it isn't as often mentioned compared to Rust here. I am not saying AI
should be the future, but merely compare why Rust is cited here more
frequently than C++. That's just one of many other things. Rust also got
popular due to crates. How is the alternative called in C++? Barely anyone
outside the C++ community knows. And that's also a problem.<p>C++ isn't going away anytime soon, of course, but when people keep on mentioning
alternatives again and again then it shows that the competition intensifed a lot.
I think Rust's saftey guarantees are an important reason to throw it at LLMs. LLMs make stupid mistakes, even the very best ones, and a lot of them, all the time. Having a compiler reject those mistakes makes for a better automated process. C++ has some safety mechanisms as well, but they're weak and fragile compared to Rust.<p>For people with C++ experience working together months at a time that doesn't have to be a problem, but AI rewrites turn a million lines of one language into a million of the other in a day, followed by an impossibly short human review.<p>Rust also isn't as safe and correct as you'd hope it to be for "fuck it, let the LLM deal with it" style programming, but it's got the best speed-usability-safety balance out of the common languages if you don't trust your programmers.
> How is the alternative called in C++?<p>what is it though? vcpkgs/decentralized repositories?
With package managers on Linux, BSD and Haiku, the only odd man out needing packages is Windows, and vcpkg fills this gap so its no longer an issue.
It is de facto vcpkg
Hacker news has always been a rust bubble. Tallies of opinions voiced here are always skewed in some ways.
Why would anyone want to rewrite anything in C++ given they can choose anything else? Like Rust or Go or C or Zig or literally anything else.
I wouldn't choose Rust because of compile times. C++'s aren't great either, but with discipline in how you structure headers, you can get them down to a pretty reasonable place. Unsafe Rust is also a bit of a PITA, and I have cases where I care lot about precisely how memory is laid out and accessed, I'd have to resort to it quite a lot. I don't love crates either, they smell a bit like node_modules and all big Rust projects I've seen have hundreds of them. Most C++ libraries are self contained, by nature of not having an easy way to declare dependencies.<p>I wouldn't choose Go because GC is a non-starter.<p>I wouldn't choose C because it's nice to have <i>some</i> form of generics or metaprogramming, even if templates are not exactly fantastic.<p>I wouldn't choose Zig because the language isn't stable, and the lead developer has hinted that they'll drop LLVM down the line, and I don't want to beta test their compiler backend.
Because, used sensibly, C++ is a better C. This is more or less what C++98 was, and even that is probably too much.
Compiler stuff in MLIR.
[dead]
I disapprove what they do to c++ for many years now, but nobody cares. I had hoped for c++ what has become c#. Well now i use c# with c if i need the speed
- since you are a part of the voting group, i have a doubt<p>- let us say tomorrow everyone were to consider removing all unsigned variables across c++<p>- what is the impact in terms of compatibility for all the old c++ applications which i believe would be millions of them if not billions?<p>- the reason i ask is they say do not unsigned anything as much as you can because overflowing the bottom below 0 is easy<p>- has there ever been any consideration to get rid of unsigned xyz in c++?
Time to cancel the project. C++ acquired sufficient set of features over the years, becoming very PL/I-esque.
I used to be a C++ programmer but I haven’t done it in a few years.<p>I pretty much do all my low level vibe coding in Rust. Is C++ still relevant? What prevents Rust from completely supplanting it?
Even <i>if</i> C++ is irrelevant for new code, there's so much software already written in it that we'll be maintaining it for decades to come. I'd argue that Cobol and Fortran have been mostly obsolete for new code for almost 30 years now, yet both are still widely used today, and they've even had major updates in the past decade [0] [1]. And there's even more software written in C++ than there is in Cobol or Fortran, so I don't think that C++ is going away any time soon.<p>[0]: <a href="https://en.wikipedia.org/wiki/COBOL#COBOL_2023" rel="nofollow">https://en.wikipedia.org/wiki/COBOL#COBOL_2023</a><p>[1]: <a href="https://en.wikipedia.org/wiki/Fortran#Fortran_2023" rel="nofollow">https://en.wikipedia.org/wiki/Fortran#Fortran_2023</a>
Essentially all high-end systems code for high-performance and high-reliability systems is still written in modern C++. That language has many attractive properties, including safety features that Rust does not currently support.<p>Additionally, for pure performance requirements, C++ is still materially faster than Rust in practice. That may change some day. C++ has many issues but it is also objectively excellent at many things.
C++ is the third most popular programming language according to TIOBE behind C and python. It's got an 8.87% ranking. So yes it looks like C++ is still relevant. In fact C++ usage has risen slightly.<p>Rust is in tenth place with 1.44% ranking, it's rising fast but still has a long way to go before it catches C++.<p>I'm not going to speculate about why Rust hasn't yet supplanted C++ but I will say I don't find it surprising.
Please for God's sake stop citing TIOBE.<p>A much more accurate snapshot would be Github - they recently published the top langauges for the year (so far, up til Sept 2026) by distinct monthly contributors and C++ comes in at 9 out of the top 10, and Rust doesn't even place in the top 10 yet, so yes it is highly relevant and prevalent, but not because TIOBE said so.<p>But, TypeScript, Python and Rust are the fastest growing languages, in that order, so also you cannot discount Rust.<p><a href="https://github.blog/news-insights/octoverse/octoverse-commits-pushes-reach-new-highs-in-2026-as-developers-build-with-agents/#h-language-choice-has-new-influence" rel="nofollow">https://github.blog/news-insights/octoverse/octoverse-commit...</a>
You didn't mention why people shouldn't cite TIOBE so I checked. It's because they measure search engine queries to assess popularity. GitHub measures actual code usage in real repos.<p>I agree the GitHub methodology seems better. I don't think TIOBE methods mean that it's ranking is completely irrelevant but it'll be noisy and you could easily game it.
Github is also skewed because it only captures a subset of open source projects, and open source is realistically a teeny tiny fraction of the world's written code.
TIOBE is nonsense.<p>But, of course, there is still a lot of new C++ code written, more than Rust. I believe C++ <i>will</i> become legacy, but it's not there yet and even once that happens it'll take at least decades to stop writing C++.
> Is C++ still relevant? What prevents Rust from completely supplanting it?<p>A highly mature ecosystem with well-established libraries. Especially in certain fields (DSP, robotics, CAD kernels, microcontrollers, etc.), there are no equivalent libraries and frameworks in Rust with such a proven track record.<p>Now, LLMs can rewrite those libraries in Rust quite easily. Such options weren't available a few years back. But it's still hard to prove that a rewrite hasn't introduced new bugs. It's easy to demonstrate that a piece of code has bugs, but much harder to prove that it doesn't introduce any new ones.
Additionally, even if an LLM-created Rust port of a C++ library was bug-free, an LLM cannot recreate the community that has evolved around the library.<p>Take PROJ for example, which is the de-facto coordinate systems library in the geospatial world, mostly written in C++. The processes and trust built up with external organisations like national mapping agencies is irreplaceable.<p>That hasn't stopped people trying to vibe-clone PROJ in Rust though.
99.9% of all system code in the world is still written in C/++. It runs your Java, C#, Javascript, Python, PHP, basically every production language that isn't Go or Rust. It runs the two most popular game engines in the world. It runs your phone, server, and laptop, no matter which of any you use. It runs your car. It runs almost every embedded and industrial application on the planet.<p>Is it still relevant, JFC. The way people on this forum manage to sequester themselves from reality. Let me reverse the question: is Rust relevant? Mozilla developed Rust, abandoned their Rust browser, and only 10% of Firefox is written in Rust. Maybe 1% of modules in Chrome and Linux are written in Rust, if that. And what of Rust applications written from scratch? Can you name ten applications that have, say, exposure to more than 100,000 users? Impossible mode: they can't be developer tools only used by other developers (uv, ripgrep, etc.), they must actually be applications used by enterprises or consumers.
I read that as "is c++ still relevant for new features, given Rust and its popularity", not "who is still using C++".<p>Personally, I think it is still relevant. Many people thought Kotlin could overtake Java, Java reinvented itself with new initiatives/features and was saved from becoming irrelevant.<p>Rust also has the LLM advantage which is where I think the "if it compiles it works" nature of Rust is easier for manual changes and maintenance when needed.
Java vs. Kotlin is a different matter. It's still an open question if C++ even <i>could</i> match Rust's features, not to say if it (the committee) <i>wants</i> to, and the answer seems to be "no".
> basically every production language that isn't Go or Rust.<p>Even in their case. Rust depends on LLVM which is wriiten in C++. Go needs libc on some platforms.
As a big c++ fan, new projects are generally choosing Rust, which I would agree with, even though I do indeed love C++
Your Rust very likely runs in a C / C++ environment.
rust depends on C++ (LLVM)
I feel like this is a bellwether event for society at large. Growing impasses between more and more segments of society. Diminishing trust leading to the inability to reach consensus. Maybe it’s just me though.
Perhaps it is, in this case it would be between money and everyone else specifically. Contracts is a pet project of Microsoft and the heavy money parts of the committee. They've basically shouted down the dissenters, hence the effectively unprecedented action of the rubberstamp portion of the process saying they dont think consensus was reached in a kosher way.
No one who developed contracts works for Microsoft. Of the like 20 people who contributed to the feature, 4 of them work for Bloomberg, so you could maybe argue that Bloomberg has a vested interest in the feature, but that's really stretching things.<p>Support for contracts is fairly broad and spans numerous organizations.
I have no idea why anyone would work in C++ in 2026. If I had to work on an existing codebase, I'd just have Claude rewrite it in Rust. It's always been a miserable, awful mess.
How did C/C++ get into ISO? Why are they "special" compared to other languages?
Just because they are old and ubiquitous in all systems programming?<p>The whole design committee procedure around these languages feels like a bureaucratic nightmare, again compared to other languages, especially Rust.
> Why are they "special" compared to other languages?<p>The world basically runs on C.
I think before I was born, there was just a ton of (closed-source) C compilers for different systems. So people were like "we should have a standard, so our safety critical application doesn't break when we decide to use a <new hardware vendor's> C compiler."<p>I also think since compiler infrastructure has improved so much, and everything is open source now ... so idk if it matters as much anymore.
There is no need for a language to be "special" just to get standardized.<p>The main driver is a group of people willing to submit the necessary documents to ISO (or national bodies like ANSI or DIN or even IEEE, and then ISO may also adopt existing standards as theirs).<p>COBOL, FORTRAN and Pascal are all ISO Standards [1,2,3].<p>[1] <a href="https://www.iso.org/standard/74527.html" rel="nofollow">https://www.iso.org/standard/74527.html</a><p>[2] <a href="https://www.iso.org/standard/82170.html" rel="nofollow">https://www.iso.org/standard/82170.html</a><p>[3] <a href="https://www.iso.org/standard/13802.html" rel="nofollow">https://www.iso.org/standard/13802.html</a>
It makes big companies and gov bodies happier since and code investment is guaranteed to run with competitors tool chains. You’re not locked in to one vendor, it is an international spec.
Isn’t Rust also suffering from committee deadlock for the past couple years?
[dead]
At this point, changes to major programming languages have to adapt to a world in which AI systems generate and change much of the code. C++ contracts may be good or bad, but they are from before strong AI coding systems. So it's time to rethink.<p>And we have no idea what AI systems will be doing in 2027.
> So it's time to rethink.<p>><p>> And we have no idea what AI systems will be doing in 2027.<p>How would you begin to form a plan of how you'll rethink if you can't even see into next year? Isn't it beneficial <i>not</i> to change the languages too much because there's so much training data for the current revisions? AI does not need to be catered to, that is the whole point and why it is useful.
Not to defend the particular proposal at issue here, but my sense is that contract-like things synergize quite well with AI coding, for the same reasons automated tests and static types do.
A lot of folks, many of them our most capable programmers, are fighting the last war. It’s like they think AI is going away and we’ll all work like it’s 2019 again.
Wow. I’m surprised at the amount of downvotes. Are people really that in denial?