The ISO committee is becoming increasingly less relevant. It's ineffectiveness has pushed numerous groups to create a successor to C++.
It's no doubt a lot of work but if any of the successors to C++ such as Carbon, Circle, or cpp2 manage to release a solid compiler that is mostly compatible with C++17, I think you'll see a large migration towards it.
The ISO committee is becoming increasingly less relevant. It's ineffectiveness has pushed numerous groups to create a successor to C++.
Maybe it is becoming less relevant, but language proposals and attendance has grown tremendously since 2010, with no signs of slowing down. The real issue is that it's functionally impossible for a single group to meet the needs of the entire community.
It's no doubt a lot of work but if any of the successors to C++ such as Carbon, Circle, or cpp2 manage to release a solid compiler that is mostly compatible with C++17, I think you'll see a large migration towards it.
Only time will tell, however I would bet against C++ successors. In particular, C++ is fundamentally hostile to cross-language interopt, to the degree that even C++ compilers struggle to maintain compatibility between themselves. For a language to work with C++, its compiler basically needs to contain a C++ compiler as well (as Carbon does). Moreover, simply being "compatible with C++17" is only the very first step to practical usage, e.g. consider how much work the Clang developers put into reverse engineering GCCisms. And that is before considering more exotic language extensions and APIs like OpenMP (and perhaps SYCL at some point as well). All the while C++ continues to change and evolve.
> In particular, C++ is fundamentally hostile to cross-language interopt
C++ adheres to Itanium C++ ABI [1] which in turn adheres to SystemV ABI [2].
> to the degree that even C++ compilers struggle to maintain compatibility between themselves.
"Struggle" is to follow the Itanium C++ ABI spec.
> For a language to work with C++, its compiler basically needs to contain a C++ compiler as well (as Carbon does). Moreover, simply being "compatible with C++17" is only the very first step to practical usage, e.g. consider how much work the Clang developers put into reverse engineering GCCisms.
I think you're conflating different terms. Carbon and other similar C++-like frontends are essentially transpilers from C++-like grammar to C++.
Being "compatible" requires no reverse engineering but as I said above it's just a matter of following the C++ ABI spec (for interop between C++ compilers) and following the SystemV ABI spec (for interop between fundamentally different languages).
* C++ adheres to Itanium C++ ABI [1] which in turn adheres to SystemV ABI [2].*
Uh.. MSVC does not adhere to the Itanium C++ ABI. ISO C++ does not specify any name mangling scheme, in fact I doubt the standard even mentions name mangling.
I think you're conflating different terms. Carbon and other similar C++-like frontends are essentially transpilers from C++-like grammar to C++.
Carbon resembles Rust far more than C++, to say the least. In my experience C++ developers criticize its difference in syntax more than anything else.
Anyway, setting aside the differences in syntax, the point I was trying to convey is that C++ is especially difficult to call from other languages, largely due to templates and/or sheer complexity. For a language to take a C++ header and be able to understand something as basic as std::vector, it needs to have quite a sophisticated understanding of C++ and its implementation. By comparison, Java is readily available in other JVM languages like Kotlin and Clojure, albeit those are managed languages.
Being "compatible" requires no reverse engineering but as I said above it's just a matter of following the C++ ABI spec
Not at all. A C++ ABI does not make it possible to magically understand C++ code. If you disagree, then please explain how a platform’s C++ ABI is sufficient to understand a type like std::string from another language. In particular even a vocabulary type like std::string is not compatible between libc++ and libstdc++, i.e. the two most binary compatible C++ standard library implementations available today.
Now we have 300+ people voting on features that are never tested on a real compiler, before being set in stone.
Compilers now are in different states of ISO C++ compliance, between ISO C++14 and ISO C++23.
Several of those on paper features, deemed not quite right when implemented, and had to be redone between revisions, but naturally old ones kind of stay in, backwards compatibility.
All languages are hostile to cross language interop, that is why everyone pretends to be C, or uses OS IPC.
Now we have 300+ people voting on features that are never tested on a real compiler, before being set in stone.
Would you prefer that only 30 people should be allowed to hold up the acceptance of half-baked proposals? How could lower participation in C++ language evolution and/or standardization possibly do anything to improve the rigor and field testing of proposals?
Compilers now are in different states of ISO C++ compliance, between ISO C++14 and ISO C++23.
And? MSVC didn’t even do two-phase name lookup correctly until 2017, a fundamental feature of C++, yet the non-conforming behavior was little more than a nuisance. It’s really no concern of mine that Clang/libc++ hasn’t completed pstl support for C++17 because I wouldn’t be using it anyway. It is concerning when implementations half-asses a feature to pencil whip their “compliance” with new C++ standards (particularly when it only takes one implementation to make a feature useless for portable code).
Several of those on paper features, deemed not quite right when implemented, and had to be redone between revisions, but naturally old ones kind of stay in, backwards compatibility.
The developers behind major C++ implementations are acutely aware of every wart and failure, more so than virtually any end user. If they could they would choose to test every proposal on multiple compilers, across thousands of projects, targeting as many platforms as possible. But the resources and expertise to do so simply aren’t there. At some point the committee must hope for the best, take a leap of faith, and commit to a decision. It’s admirable that the C++ committee chooses to prioritize the needs of end users over the interests of implementations.
All languages are hostile to cross language interop,…
Managed languages do it every day (Kotlin and Java). But yes, the situation is quite different for native languages. What’s different about C++ is that it’s a remarkably difficult language to wrangle. C bindings are almost trivial to write or generate, but C++ introduces a mountain of complexity and ambiguity.
There are dozens of projects which have incrementally rewritten C in Rust. But it’s practically impossible to do anything similar with C++.
…that is why everyone pretends to be C, or uses OS IPC.
No language wants to bear the cross of a stable ABI, much less an ossified ABI. A platform’s C implementation has already paid the price, everyone is welcome to freeload.
That said, nothing good is ever free and the poverty of C ABIs prove it. With hardly any exceptions, describing a type C ABI as “fragile” is an understatement at best.
Try to call Kotlin co-routines from Java to see how well it goes, even bytecode doesn't help when semantics aren't there, or languages build their little islands on top of the underlying platform.
Yes, a smaller group of people, and like any sane language evolution process, papers without implementations don't go in.
Words aren't a replacement for proper field testing.
I can't really evaluate your comment on relevance -- some things do seem to inexplicably bog down, but on others they move usefully and quickly. And the conservatism of compatibility really is incredibly important, which I say as someone who'd be happy (and relieved!) to blow away API compatibility (actually to use the API step capabilities already available behind the scenes, at least for ELF).
But the part about "numerous groups to create a successor" doesn't really make your case: one of the best ways for things to get into any standard is to have multiple efforts that can be used as experience and starting points for the evolution of a standard. This has already happened a lot in the history of C++
It's no doubt a lot of work but if any of the successors to C++ such as Carbon, Circle, or cpp2 manage to release a solid compiler that is mostly compatible with C++17, I think you'll see a large migration towards it.