News for hackers. Stuff that matters.
Re:C++26 Disapproved by dizzant on Wednesday November 04, 2026 @10:21AM (#50366866)
I'm sorry you don't like std::regex. That isn't a problem with C++'s specification practice.

C++'s separation of spec from implementation is clearly functional. There are several major open-source standard library implementations that compete on the basis of performance, ABI stability over versions, quality, etc.

C++'s core ethos is "only pay for what you use". std::regex does this. In my experience, the "problem" with std::regex is that it provides more features by default than most people want, and you pay for using those features. Specifically, std::regex respects the runtime locale. There are good reasons a standard library feature might do this (e.g. it simplifies the interface, it's broadly applicable, etc.), but it's obviously not going to give optimal performance. This is a necessary tradeoff for any standard library.

Locale handling requires dynamic memory allocation, virtual function dispatch, sometimes system calls. Locale handling also prevents some low-level optimizations based on the character encoding. If you need that kind of performance, std::regex probably isn't for you, go grab a non-standard library that suits your needs.

Re:C++26 Disapproved by forrestthewoods on Wednesday November 04, 2026 @12:23PM (#50368687)
locale is a great example of a concept that is catastrophically bad, provides zero value, and shouldn’t exist at all in the spec.

std::regex is so worthless that no one uses it. My codebase gives CI warnings when it’s used. so it’s not even really a problem. It is indicative of a larger problems.

> C++'s separation of spec from implementation is clearly functional.

Your bar of “clearly functional” is is not a compelling or meaningful bar. What a weird fallacy.

C++11 was pretty great and meaningfully modernized the language. The amount of useful good things in each following release got smaller and smaller. Maybe just one or two useful improvements in C++20. Almost nothing in C++23. And now C++26 has failed to pass. It’s grinding to a halt. The biggest recent features such as concepts and modules have been catastrophic failures.

Those failures aren’t all due to my specific complaint of “battery specs are a bad idea”. But “functional” is the lowest possible bar. And one could argue that as a whole isn’t being met.

Re:C++26 Disapproved by dizzant on Monday November 09, 2026 @02:06PM (#50430083)
> catastrophically bad, provides zero value, and shouldn’t exist

Again, if you don't like it, don't use it. Can I assume that you would agree that `std::format`, which does not use locales, was a good addition in C++20?

> Your bar of “clearly functional” is is not a compelling or meaningful bar.

I pointed to the existence of multiple widely adopted, successful, competing implementations as evidence that the standard does functionally achieve the explicit goal of standardization, i.e. to support multiple implementations.

> Those failures aren’t all due to my specific complaint of “battery specs are a bad idea”. But “functional” is the lowest possible bar. And one could argue that as a whole isn’t being met.

You recognize that you're moving the goalposts here, right? Your overall point appears to be that the benefit of multiple implementations is not worth the costs of standardization, and that centralizing to a single specific implementation would be better in certain ways. In particular, it seems you think that more features per release ("each following release got smaller and smaller"), different features that what we got ("just one or two useful improvements in C++20"), and less community input about proposed changes ("C++26 has failed to pass") would be better than the status quo.

That's a fine opinion, but it's not an argument that standardization isn't functional.

> concepts and modules have been catastrophic failures

You're right about modules. C++26 failed to pass because some in the community don't want to repeat the mistake with contracts. This is a victory for standardization, not a loss. Further evidence that the process is working: the other improvements in C++26 (like reflection) are so desirable that this delay meaningfully hurts. If nobody wanted the changes, we'd all still be using C++11. And as always, if it's C++11 you want, the existence of the standard makes it possible.