9 ms·

Trip report: Fall ISO C++ standards meeting

88 points by matt_d 8y ago

stabbles 8y ago
C++20 must be exciting with ranges, concepts, modules and easier metaprogramming. Are there any numbers/graphs on how many proposals are being submitted over time? I feel like they are exploding.
- th0br0 8y ago
  > This week’s meeting was extraordinary. The pre-meeting mailing had 274 papers, about twice as many as any previous meeting, and we had 180 people attending, making this the largest C++ committee meeting ever. https://www.reddit.com/r/cpp/comments/9vwvbz/2018_san_diego_iso_c_committee_trip_report_ranges/ https://www.reddit.com/r/cpp/comments/9vwvbz/2018_san_diego_...
Someone 8y ago
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0907r4.html#survey http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p090..., concludes ”the only machine the author could find using non-two’s complement are made by Unisys, and no counter-example was brought by any member of the C++ standards committee. Nowadays Unisys emulates their old architecture using x86 CPUs with attached FPGAs for customers who have legacy applications which they’ve been unable to migrate. These applications are unlikely to be well served by modern C++, signed integers are the least of their problem. Post-modern C++ should focus on serving its existing users well, and incoming users should be blissfully unaware of integer esoterica.” That led to the decision that ”Signed Integers are Two’s Complement” in C++ 20. That makes it too easy to write portable code :-)
- thestoicattack 8y ago
  A talk by that paper's author: https://www.youtube.com/watch?v=JhUxIVf1qok https://www.youtube.com/watch?v=JhUxIVf1qok
- favorited 8y ago
  Really cool that this change is likely to make it through WG14 as well.
  - xenadu02 8y ago
    Unfortunately the working group rejected the author's proposal that signed integers have wrapping behavior, so signed overflow/underflow remain undefined: > Status-quo If a signed operation would naturally produce a value that is not within the range of the result type, the behavior is undefined. The author had hoped to make this well-defined as wrapping (the operations produce the same value bits as for the corresponding unsigned type), but WG21 had strong resistance against this. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0907r4.html http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p090...
    - saagarjha 8y ago
      I consider this less of a shoo-in, in my opinion, since it's more complicated to implement this in the case where your integer type doesn't actually match the register size of your hardware (which is true with int on LP64). With unsigned integers you can just mask off the extra bits when overflow occurs, but with signed integers this is more complicated. Having this be implementation-specific behavior might be useful, so you don't have undefined behavior in your program, but I am generally of the opinion that overflowing an int is usually a bug rather than a feature.
      - chrisseaton 8y ago
        > it's more complicated to implement this in the case where your integer type doesn't actually match the register size of your hardware (which is true with int on LP64) If you do arithmetic on a 32 bit register on AMD64 you still get 32 bit wraparound don't you?
        saagarjha 8y ago
        This is generally an issue with loops that involve memory accesses, because it causes annoying problems when optimizing: https://gist.github.com/rygorous/e0f055bfb74e3d5f0af20690759de5a7 https://gist.github.com/rygorous/e0f055bfb74e3d5f0af20690759...
- reality_czech 8y ago
  "Post-modern" C++? Finally someone admits that the language was all a huge prank.
  - arximboldi 8y ago
    https://www.youtube.com/watch?v=y2___qaG_9Q https://www.youtube.com/watch?v=y2___qaG_9Q https://www.youtube.com/watch?v=QTLn3goa3A8 https://www.youtube.com/watch?v=QTLn3goa3A8
  - Koshkin 8y ago
    C++ is more like a drug - having used it makes it impossible to go back to C.
    - kazinator 8y ago
      It is absolutely possible. I did C++ development as a regular job years ago, now I'm coding in C (for that type of coding). What will get you off the C++ drug easily is Lisp. Once I discovered Lisp, C++ had no place in my "personal spectrum" any more, but C (including the C-like subset of C++) still did. Well, it wasn't so sudden, mind you. More like: the more Lisp I knew, the less interest I had in C++. (Idiotic lambda implementations and whatnot will not woo me back, sorry.)
      - svnpenn 8y ago
        Sorry if this is a hated question - but are all Lisp the same rats nest of parenthesis? ive always been interested in Lisp but that is so ugly - i would a JavaScript/Ruby/Python method chaining to 5 levels of nested parenthesis
        billsix 8y ago
        I implemented a compile-time test framework in Gambit Scheme in 7 lines of code, and Python's yield in about 20 or so. http://billsix.github.io/bug.html#_make_generator http://billsix.github.io/bug.html#_make_generator Lisp code has few wasted moves. Programming in it does require changing your mindset of syntactic beauty. And once your mindset changes, you can make whatever syntax you want. Perhaps the biggest hurdle is that the code is not best read linearly. The reader must understand the order of evaluation, which follows very simple rules, in order to understand the code correctly. That hurdle is definitely worth the jump.
- kazinator 8y ago
  ... but overflowing them is still UB? One advantage of pinning down two's complement is that the result of arithmetic is known down to the bit level, even when it overflows. Also, certain bit operations. For instance, if we know that the representation is two's complement, we are justified in expecting sign extension on a right shift: the sign bit is repeated to fill the top bit positions. (The shift of a signed number should be "arithmetic"; that of unsigned "logical".) Also, truncations (converting a wider type to a narrower type) should have predictable results. For instance if we chop the value -238 to 8 bits, we should get 18, because -238 is 0xFF..FF12, which truncates to 0x12.
  - ameliaquining 8y ago
    Signed integer overflow being UB enables compiler optimizations. Most famously, when compiling for (int i = 0; i < bound; i++) in an LP64 environment (i.e., one where the native machine word is 64 bits but int is 32 bits, as is the case in most modern compilers targeting most modern architectures), it allows i to be represented by a native machine word, increasing performance. You can, and people constantly do, argue about whether this is worth it, but I suspect it's the primary reason why a lot of the committee didn't want to change this behavior.
    - kazinator 8y ago
      If it's okay to screw programs that make nonportable assumptions, then int should just be 64 bits. After all, int is supposed to be the machine's natural integer. The current fashion is that we like programs that assume int is 32 bits, and don't like ones that assume wraparound arithmetic.
      - slededit 8y ago
        32-bit ints have a more compact encoding in x86 because it was assumed they would be the most common. The "native" size isn't a simple matter these days. Back in the old dark days of 8 and 16-bits common values regularly exceeded the size. But 4 billion is large enough to still be the default.
    - 8y ago
KerrickStaley 8y ago
I'm really exited for the addition of ranges to C++20. Ranges are objects that contain both a start and an end iterator. So you can simplify the APIs of functions that take start and end iterators as separate arguments.
- Sharlin 8y ago
  It's been a long journey; the first version of Boost.Range dates back to 2003. It's been understood for a long time that functions taking iterator pairs compose very poorly, but as always, the devil is in the details. But compared to modern composable abstractions such as Rust iterators, the STL paradigm feels positively archaic.
mehrdadn 8y ago
Does anyone have examples of well-written modern C++ code out there? I used to consider myself a C++ expert like circa 2011 but it's advanced to so quickly that it's almost like a foreign language to me... (though I have tried to keep up a bit... but it's hard without nontrivial examples)
- detaro 8y ago
  I don't really have experience to properly judge it myself, but Jason Turner is highly regarded in this area and references his ChaiScript project a lot in his talks (which are worth looking up on YouTube): https://github.com/ChaiScript/ChaiScript https://github.com/ChaiScript/ChaiScript
- KerrickStaley 8y ago
  Effective Modern C++ by Scott Meyer is a good tour of new features in the language. I highly recommend it. It's maybe a little too in-the-weeds in some parts but you can just skim those. It only goes up to C++14 but there's not all that much that's new in C++17. C++20 looks like it's going to be a bigger update, hopefully Scott will come out with a new revision of Effective C++ to address the changes.
  - MetallicCloud 8y ago
    Unfortunately, that's not likely: http://scottmeyers.blogspot.com/2015/12/good-to-go.html http://scottmeyers.blogspot.com/2015/12/good-to-go.html
- pjmlp 8y ago
  Bjarne's book "A Tour of C++" 2nd, then all the Channel 9, CppCon, NDC and C++NOW videos.
- VHRanger 8y ago
  I'd say tiny-dnn[1] is a good example. Minimal, understandable yet useable neural network library [1] https://github.com/tiny-dnn/tiny-dnn/blob/master/tiny_dnn/nodes.h https://github.com/tiny-dnn/tiny-dnn/blob/master/tiny_dnn/no...
saagarjha 8y ago
I'm very excited to see Ranges and Concepts being adopted, since this makes writing and working with templated code that deals with containers much easier.
adamnemecek 8y ago
The concept syntax is actually somewhat pleasant. The previous one was such a monstrosity.
zamadatix 8y ago
> at this meeting we decided to target merging Networking into C++ for soon post-C++20 (i.e., targeting C++23). It'll be nearing a decade of "next release" now as it's own TS and near two decades of proposal since TR2. Edit: The Reddit trip report lists 23 as optimistic and 26 as the conservative.
pfarnsworth 8y ago
C++ is changing way too fast to be useful anymore. I spent the first 15 years of my life loving C++ but in the last 8 years or so, the C++ committee has vastly outpaced its supply lines. I've been out of the language since then and I might as well learn a new language rather than try to re-understand the differences between C++ back then and now. The only people that can keep up are the hobbyists and the language purists. It's become a circle jerk and that's a shame because they are modernizing themselves out of existence, in my opinion. No one in real software can keep up with the biannual changes and it's getting to the point where migrating to another language like Go or Java is a lot more stable and less risky.
- slededit 8y ago
  C++11 was the big change these are more window dressing. If you like your current language that's fine but as a C++ programmer who had to learn C++11 it was well worth it. The more recent additions are more along the lines of "I can't believe that wasn't already in the standard!" rather than new things to learn.
- pjmlp 8y ago
  Then good luck keeping up with those languages as well, which release new versions every 6 months nowadays. Programming languages are just like any other software product.
  - nikbackm 8y ago
    C seems to be pretty stable at least. Even if it too has a new version in the works.
    - pjmlp 8y ago
      C is mostly confined to UNIX derived OSes and embedded devs that won't change to anything else even at gun point. Yet, even C just got ISO C17 this year, even though it was a minor update. https://www.iso.org/standard/74528.html https://www.iso.org/standard/74528.html Languages either die or get updated to fulfill their customer requirements.
fourthark 8y ago
Looks like switching to regular releases of the standard 10 (!) years ago, and all the work they put into proposal workflow, has really paid off. C++ stagnated for a long time, but IMO Boost's metaprogramming reinvigorated the language and community. Now they are following through with concepts, metaprograms that can do everything runtime programs can do, and soon reflection. Wow.
eps 8y ago
> So fasten your seat belts, and stay tuned. C++ programming is likely to evolve more, and in better ways, in the upcoming 5 years than it already has in the past 20. Yeah, that's the problem isn't? You do in fact need damn seat belts to cope with all the changes to what used to be a very predictable and simple to understand language.
- Kenji 8y ago
  > to what used to be a very predictable and simple to understand language. Are we talking about the same C++ language? I mean, I get what you're saying, they're introducing new concepts fast, but C++ was never "very predictable and simple to understand". There is a staggering amount of corner cases and ancient obscure features.
- de_watcher 8y ago
  What? C++ has always been one of the rare languages that don't mindlessly add stuff that drives them into a corner.
  - pjmlp 8y ago
    C++ has this fame of being a bloated language, which it kind of is. However it isn't really that much bigger than Java, .NET + VB/C#/F#, Python, Ada, Common Lisp,... when one looks at the size of printed language, library and implementation specifications. It is just that others are more beginner friendly and most devs forget they have a pile of features on their own languages as well.
  - eps 8y ago
    And what would these numerous languages be - the ones that did mindlessly add stuff and drove themselves in a corner?
grandinj 8y ago
Is it not time that specifications for additional features for C++ came with a test-suite? Preferably something shared via git somewhere that people can contribute to. Would make bootstrapping some of these new features to a usable level much quicker. Speaking as a dev that needs features to span 3 major compilers (clang/gcc/vs) before I can use them.
- pjmlp 8y ago
  You can buy a ISO C or ISO C++ certification suite. http://www.plumhall.com/suites.html http://www.plumhall.com/suites.html https://www.opengroup.org/testing/testsuites/perenial.htm https://www.opengroup.org/testing/testsuites/perenial.htm http://modena.us/ http://modena.us/ https://peren.com/pages/cppvs_set.htm https://peren.com/pages/cppvs_set.htm Ah just needing the support across 3 major compilers! I guess you haven't enjoyed the glory days of writing portable C, C++ or Pascal code during the 1990's.
  - grandinj 8y ago
    I work on a codebase (LibreOffice) that has seen those days (and I worked through them on other projects, but thankfully without needing cross-platform support). I note that there is some sharing of test-suites between the different compiler vendors, certainly they occasionaly run their compilers against some of each others test. But a central shared resource that is updated by multiple people to catch edge cases would be first prize. (And hopefully, seeded by the proposal authors, to act as a useful starting point)

88 points by matt_d 8y ago

C++20 must be exciting with ranges, concepts, modules and easier metaprogramming. Are there any numbers/graphs on how many proposals are being submitted over time? I feel like they are exploding.

th0br0 8y ago
> This week’s meeting was extraordinary. The pre-meeting mailing had 274 papers, about twice as many as any previous meeting, and we had 180 people attending, making this the largest C++ committee meeting ever. https://www.reddit.com/r/cpp/comments/9vwvbz/2018_san_diego_iso_c_committee_trip_report_ranges/ https://www.reddit.com/r/cpp/comments/9vwvbz/2018_san_diego_...

Someone 8y ago

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0907r4.html#survey http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p090..., concludes ”the only machine the author could find using non-two’s complement are made by Unisys, and no counter-example was brought by any member of the C++ standards committee. Nowadays Unisys emulates their old architecture using x86 CPUs with attached FPGAs for customers who have legacy applications which they’ve been unable to migrate. These applications are unlikely to be well served by modern C++, signed integers are the least of their problem. Post-modern C++ should focus on serving its existing users well, and incoming users should be blissfully unaware of integer esoterica.” That led to the decision that ”Signed Integers are Two’s Complement” in C++ 20. That makes it too easy to write portable code :-)

thestoicattack 8y ago
A talk by that paper's author: https://www.youtube.com/watch?v=JhUxIVf1qok https://www.youtube.com/watch?v=JhUxIVf1qok
favorited 8y ago
Really cool that this change is likely to make it through WG14 as well.
- xenadu02 8y ago
  Unfortunately the working group rejected the author's proposal that signed integers have wrapping behavior, so signed overflow/underflow remain undefined: > Status-quo If a signed operation would naturally produce a value that is not within the range of the result type, the behavior is undefined. The author had hoped to make this well-defined as wrapping (the operations produce the same value bits as for the corresponding unsigned type), but WG21 had strong resistance against this. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0907r4.html http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p090...
  - saagarjha 8y ago
    I consider this less of a shoo-in, in my opinion, since it's more complicated to implement this in the case where your integer type doesn't actually match the register size of your hardware (which is true with int on LP64). With unsigned integers you can just mask off the extra bits when overflow occurs, but with signed integers this is more complicated. Having this be implementation-specific behavior might be useful, so you don't have undefined behavior in your program, but I am generally of the opinion that overflowing an int is usually a bug rather than a feature.
    - chrisseaton 8y ago
      > it's more complicated to implement this in the case where your integer type doesn't actually match the register size of your hardware (which is true with int on LP64) If you do arithmetic on a 32 bit register on AMD64 you still get 32 bit wraparound don't you?
      - saagarjha 8y ago
        This is generally an issue with loops that involve memory accesses, because it causes annoying problems when optimizing: https://gist.github.com/rygorous/e0f055bfb74e3d5f0af20690759de5a7 https://gist.github.com/rygorous/e0f055bfb74e3d5f0af20690759...
reality_czech 8y ago
"Post-modern" C++? Finally someone admits that the language was all a huge prank.
- arximboldi 8y ago
  https://www.youtube.com/watch?v=y2___qaG_9Q https://www.youtube.com/watch?v=y2___qaG_9Q https://www.youtube.com/watch?v=QTLn3goa3A8 https://www.youtube.com/watch?v=QTLn3goa3A8
- Koshkin 8y ago
  C++ is more like a drug - having used it makes it impossible to go back to C.
  - kazinator 8y ago
    It is absolutely possible. I did C++ development as a regular job years ago, now I'm coding in C (for that type of coding). What will get you off the C++ drug easily is Lisp. Once I discovered Lisp, C++ had no place in my "personal spectrum" any more, but C (including the C-like subset of C++) still did. Well, it wasn't so sudden, mind you. More like: the more Lisp I knew, the less interest I had in C++. (Idiotic lambda implementations and whatnot will not woo me back, sorry.)
    - svnpenn 8y ago
      Sorry if this is a hated question - but are all Lisp the same rats nest of parenthesis? ive always been interested in Lisp but that is so ugly - i would a JavaScript/Ruby/Python method chaining to 5 levels of nested parenthesis
      - billsix 8y ago
        I implemented a compile-time test framework in Gambit Scheme in 7 lines of code, and Python's yield in about 20 or so. http://billsix.github.io/bug.html#_make_generator http://billsix.github.io/bug.html#_make_generator Lisp code has few wasted moves. Programming in it does require changing your mindset of syntactic beauty. And once your mindset changes, you can make whatever syntax you want. Perhaps the biggest hurdle is that the code is not best read linearly. The reader must understand the order of evaluation, which follows very simple rules, in order to understand the code correctly. That hurdle is definitely worth the jump.
kazinator 8y ago
... but overflowing them is still UB? One advantage of pinning down two's complement is that the result of arithmetic is known down to the bit level, even when it overflows. Also, certain bit operations. For instance, if we know that the representation is two's complement, we are justified in expecting sign extension on a right shift: the sign bit is repeated to fill the top bit positions. (The shift of a signed number should be "arithmetic"; that of unsigned "logical".) Also, truncations (converting a wider type to a narrower type) should have predictable results. For instance if we chop the value -238 to 8 bits, we should get 18, because -238 is 0xFF..FF12, which truncates to 0x12.
- ameliaquining 8y ago
  Signed integer overflow being UB enables compiler optimizations. Most famously, when compiling for (int i = 0; i < bound; i++) in an LP64 environment (i.e., one where the native machine word is 64 bits but int is 32 bits, as is the case in most modern compilers targeting most modern architectures), it allows i to be represented by a native machine word, increasing performance. You can, and people constantly do, argue about whether this is worth it, but I suspect it's the primary reason why a lot of the committee didn't want to change this behavior.
  - kazinator 8y ago
    If it's okay to screw programs that make nonportable assumptions, then int should just be 64 bits. After all, int is supposed to be the machine's natural integer. The current fashion is that we like programs that assume int is 32 bits, and don't like ones that assume wraparound arithmetic.
    - slededit 8y ago
      32-bit ints have a more compact encoding in x86 because it was assumed they would be the most common. The "native" size isn't a simple matter these days. Back in the old dark days of 8 and 16-bits common values regularly exceeded the size. But 4 billion is large enough to still be the default.
  - 8y ago

KerrickStaley 8y ago

I'm really exited for the addition of ranges to C++20. Ranges are objects that contain both a start and an end iterator. So you can simplify the APIs of functions that take start and end iterators as separate arguments.

Sharlin 8y ago
It's been a long journey; the first version of Boost.Range dates back to 2003. It's been understood for a long time that functions taking iterator pairs compose very poorly, but as always, the devil is in the details. But compared to modern composable abstractions such as Rust iterators, the STL paradigm feels positively archaic.

mehrdadn 8y ago

Does anyone have examples of well-written modern C++ code out there? I used to consider myself a C++ expert like circa 2011 but it's advanced to so quickly that it's almost like a foreign language to me... (though I have tried to keep up a bit... but it's hard without nontrivial examples)

detaro 8y ago
I don't really have experience to properly judge it myself, but Jason Turner is highly regarded in this area and references his ChaiScript project a lot in his talks (which are worth looking up on YouTube): https://github.com/ChaiScript/ChaiScript https://github.com/ChaiScript/ChaiScript
KerrickStaley 8y ago
Effective Modern C++ by Scott Meyer is a good tour of new features in the language. I highly recommend it. It's maybe a little too in-the-weeds in some parts but you can just skim those. It only goes up to C++14 but there's not all that much that's new in C++17. C++20 looks like it's going to be a bigger update, hopefully Scott will come out with a new revision of Effective C++ to address the changes.
- MetallicCloud 8y ago
  Unfortunately, that's not likely: http://scottmeyers.blogspot.com/2015/12/good-to-go.html http://scottmeyers.blogspot.com/2015/12/good-to-go.html
pjmlp 8y ago
Bjarne's book "A Tour of C++" 2nd, then all the Channel 9, CppCon, NDC and C++NOW videos.
VHRanger 8y ago
I'd say tiny-dnn[1] is a good example. Minimal, understandable yet useable neural network library [1] https://github.com/tiny-dnn/tiny-dnn/blob/master/tiny_dnn/nodes.h https://github.com/tiny-dnn/tiny-dnn/blob/master/tiny_dnn/no...

saagarjha 8y ago

I'm very excited to see Ranges and Concepts being adopted, since this makes writing and working with templated code that deals with containers much easier.

adamnemecek 8y ago

The concept syntax is actually somewhat pleasant. The previous one was such a monstrosity.

zamadatix 8y ago

> at this meeting we decided to target merging Networking into C++ for soon post-C++20 (i.e., targeting C++23). It'll be nearing a decade of "next release" now as it's own TS and near two decades of proposal since TR2. Edit: The Reddit trip report lists 23 as optimistic and 26 as the conservative.

pfarnsworth 8y ago

C++ is changing way too fast to be useful anymore. I spent the first 15 years of my life loving C++ but in the last 8 years or so, the C++ committee has vastly outpaced its supply lines. I've been out of the language since then and I might as well learn a new language rather than try to re-understand the differences between C++ back then and now. The only people that can keep up are the hobbyists and the language purists. It's become a circle jerk and that's a shame because they are modernizing themselves out of existence, in my opinion. No one in real software can keep up with the biannual changes and it's getting to the point where migrating to another language like Go or Java is a lot more stable and less risky.

slededit 8y ago
C++11 was the big change these are more window dressing. If you like your current language that's fine but as a C++ programmer who had to learn C++11 it was well worth it. The more recent additions are more along the lines of "I can't believe that wasn't already in the standard!" rather than new things to learn.
pjmlp 8y ago
Then good luck keeping up with those languages as well, which release new versions every 6 months nowadays. Programming languages are just like any other software product.
- nikbackm 8y ago
  C seems to be pretty stable at least. Even if it too has a new version in the works.
  - pjmlp 8y ago
    C is mostly confined to UNIX derived OSes and embedded devs that won't change to anything else even at gun point. Yet, even C just got ISO C17 this year, even though it was a minor update. https://www.iso.org/standard/74528.html https://www.iso.org/standard/74528.html Languages either die or get updated to fulfill their customer requirements.

fourthark 8y ago

Looks like switching to regular releases of the standard 10 (!) years ago, and all the work they put into proposal workflow, has really paid off. C++ stagnated for a long time, but IMO Boost's metaprogramming reinvigorated the language and community. Now they are following through with concepts, metaprograms that can do everything runtime programs can do, and soon reflection. Wow.

eps 8y ago

> So fasten your seat belts, and stay tuned. C++ programming is likely to evolve more, and in better ways, in the upcoming 5 years than it already has in the past 20. Yeah, that's the problem isn't? You do in fact need damn seat belts to cope with all the changes to what used to be a very predictable and simple to understand language.

Kenji 8y ago
> to what used to be a very predictable and simple to understand language. Are we talking about the same C++ language? I mean, I get what you're saying, they're introducing new concepts fast, but C++ was never "very predictable and simple to understand". There is a staggering amount of corner cases and ancient obscure features.
de_watcher 8y ago
What? C++ has always been one of the rare languages that don't mindlessly add stuff that drives them into a corner.
- pjmlp 8y ago
  C++ has this fame of being a bloated language, which it kind of is. However it isn't really that much bigger than Java, .NET + VB/C#/F#, Python, Ada, Common Lisp,... when one looks at the size of printed language, library and implementation specifications. It is just that others are more beginner friendly and most devs forget they have a pile of features on their own languages as well.
- eps 8y ago
  And what would these numerous languages be - the ones that did mindlessly add stuff and drove themselves in a corner?

grandinj 8y ago

Is it not time that specifications for additional features for C++ came with a test-suite? Preferably something shared via git somewhere that people can contribute to. Would make bootstrapping some of these new features to a usable level much quicker. Speaking as a dev that needs features to span 3 major compilers (clang/gcc/vs) before I can use them.

pjmlp 8y ago
You can buy a ISO C or ISO C++ certification suite. http://www.plumhall.com/suites.html http://www.plumhall.com/suites.html https://www.opengroup.org/testing/testsuites/perenial.htm https://www.opengroup.org/testing/testsuites/perenial.htm http://modena.us/ http://modena.us/ https://peren.com/pages/cppvs_set.htm https://peren.com/pages/cppvs_set.htm Ah just needing the support across 3 major compilers! I guess you haven't enjoyed the glory days of writing portable C, C++ or Pascal code during the 1990's.
- grandinj 8y ago
  I work on a codebase (LibreOffice) that has seen those days (and I worked through them on other projects, but thankfully without needing cross-platform support). I note that there is some sharing of test-suites between the different compiler vendors, certainly they occasionaly run their compilers against some of each others test. But a central shared resource that is updated by multiple people to catch edge cases would be first prize. (And hopefully, seeded by the proposal authors, to act as a useful starting point)