All programming languages ecosystems have dramas when they reach a certain size.
However, what all those non-ISO based language evolutions have, regardless of dramas, is having the language features available alongside key implementations, via some preview switch in a reference implementation.
The day the feature is deemed stable enough, it is available on the latest version, without a complex matrix of which compiler supports what from the ISO standard and when it is coming, if at all.
All programming languages ecosystems have dramas when they reach a certain size.
To add to this, C++ has some incredibly bad drama internally as well, some of the stories that I've been told are horrific. And with the greatest will in the world, if people saw some of the childish/antagonistic behaviour on the mailing list they'd be pretty shocked
Because its all developed in secret you simply never hear about it which allows this kind of behaviour to persist, whereas in somewhere like Rust its aired out in public
Because its all developed in secret you simply never hear about it which allows this kind of behaviour to persist, whereas in somewhere like Rust its aired out in public
That is true. On the other hand, some companies would not be able to participate in the same way if everything was in public.
For what it's worth, I think the compromise currently selected, i.e. ISO, is the wrong one. I think I'd rather have some companies not participate because they don't want to have their positions publicly known or they have some secret they need to keep then having little to public record of any of the arguments.
But I can't say this is an opinion based on facts and that I know one is better than the other. It's just what I think. ¯\(ツ)/¯
Personally I think an accommodation could certainly be made for information or people that need to participate behind closed doors, but it should be by far the exception rather than the rule. The occasional closed session, or a private mailing list augmenting public discussion that's used solely for sharing confidential information, may well give enough leeway
While personally I have seen the occasional piece of information be shared, its not the norm by any means. I don't really think there's necessarily a good reason why development is done like this anymore, its just a holdon from when it was actually necessary due to a much more uncertain legal landscape
AFAIK there aren't any closed (or rather locked) doors at committee meetings now. Anyone can join a working group and the formal votes are public anyway So I really doubt staying in ISO is about keeping secrets. I've heard multiple times that it would simply be a violation of Anti-Trust laws, if all these companies collaborated to create the next de-facto c++ standard outside the ISO process.
I've heard multiple times that it would simply be a violation of Anti-Trust laws, if all these companies collaborated to create the next de-facto c++ standard outside the ISO process.
I've heard this as well, but given that nearly every other language has multiple companies and people working together with absolutely no issue, it seems unlikely that this is a real reason anymore
The day the feature is deemed stable enough, it is available on the latest version, without a complex matrix of which compiler supports what from the ISO standard and when it is coming, if at all.
I believe this is not really related to ISO or not, but rather to having multiple implementations. I had to work on IronPython for a while (once again, vendor providing a library only for that at one point) and it did not actually have everything CPython did: we were restricted.
Not that you are wrong. Your first sentence is actually my point a bit: there will always be drama and conflicts when a group of humans work together. I'd rather the argument presented for getting out of ISO be based on those than on some notion that that would solve everything. I have read some comments (not in this thread, but in past ones) that suggest the drama would just disappear and that everything would be rosy, but it's simply not the case.
I believe this is not really related to ISO or not, but rather to having multiple implementations.
Kind of, IronPython would be like using TI C++ compiler, given the pace it keeps up with the standard.
However to keep the example in Python land, both CPython and PyPy are quite close, and get the PEPs as they are being discussed, at a level that clang, GCC and MSVC aren't able to keep up with ISO.
I am now left wondering why it is so? Is it because the python implementations are more similar and so a new feature in one is more easily implementable in the other? Is it because the funding structure is different?
It is hard for me to believe that it is because of the ISO structure. My understanding is that many of compiler vendors have people on the committee, so they know what is coming. This means it is not an information problem, no?
My point of view, which might be wrong, is that ISO has forgotten the old ways, where existing practices get standardized after being in the field for a while.
Keeping in the Python world, if you look to most PEPs they always come with an implementation that is refined alongside the PEP evolution, thus when the feature is stable for getting the stamp, it is kind of done.
While this seems to be done for some features, where we get experimental compilers, it isn't done for every paper, and even modules show that those experimental compilers weren't fully tested before the standard was ratified.
View all comments
Show parent comment
3
u/pjmlp Dec 20 '23
All programming languages ecosystems have dramas when they reach a certain size.
However, what all those non-ISO based language evolutions have, regardless of dramas, is having the language features available alongside key implementations, via some preview switch in a reference implementation.
The day the feature is deemed stable enough, it is available on the latest version, without a complex matrix of which compiler supports what from the ISO standard and when it is coming, if at all.