Trip report: Fall ISO C++ standards meeting

https://herbsutter.com/2018/11/13/trip-report-fall-iso-c-standards-meeting-san-diego/

by matt_d • 8 years ago

88 76 8 years ago

herbsutter.com

stabbles• 8 years 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• 8 years 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_...

Someone• 8 years ago

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• 8 years ago

A talk by that paper's author: https://www.youtube.com/watch?v=JhUxIVf1qok

favorited• 8 years ago

Really cool that this change is likely to make it through WG14 as well.

xenadu022• 8 years 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/p090...

reality_czech• 8 years ago

"Post-modern" C++? Finally someone admits that the language was all a huge prank.

arximboldi• 8 years ago

https://www.youtube.com/watch?v=y2___qaG_9Q

https://www.youtube.com/watch?v=QTLn3goa3A8

Koshkin4• 8 years ago

C++ is more like a drug - having used it makes it impossible to go back to C.

de_watcher2• 8 years ago

Try not to flood the topic with empty comments.

kazinator6• 8 years 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• 8 years 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.

Joky2• 8 years ago

Actually I discourage my colleague to use unsigned especially because they can overflow. The problem with overflow is that most of the time it is a program bug if there is an overflow that wasn't intended.

Using signed arithmetic means that you can actually trap on overflow and catch these bugs (using fuzzing for instance).

Chandler explained it nicely in his CPPCon 2016 talk "Garbage In, Garbage Out: Arguing about Undefined Behavior...". I encourage to watch the full talk but here is one relevant example:

https://youtu.be/yG1OZ69H_-o?t=2006

And here he mentions how Google experimented with this internally: https://youtu.be/yG1OZ69H_-o?t=2249

KerrickStaley2• 8 years 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• 8 years 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• 8 years 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• 8 years 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

KerrickStaley2• 8 years 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• 8 years ago

Unfortunately, that's not likely: http://scottmeyers.blogspot.com/2015/12/good-to-go.html

pjmlp9• 8 years ago

Bjarne's book "A Tour of C++" 2nd, then all the Channel 9, CppCon, NDC and C++NOW videos.

VHRanger• 8 years 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/no...

Koshkin4• 8 years ago

std:: is not bad.

wyldfire• 8 years ago

This slideshow [1] was a really great, simple intro to some advanced c++14-and-beyond idioms.

[1] https://speakerdeck.com/olvemaudal/42-silly-ways-to-say-hell...

agallego• 8 years ago

abseil, folly and seastar are pretty great.

romed• 8 years ago

abseil targets c++11. Its modernity is arguable.

saagarjha4• 8 years 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• 8 years ago

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

zamadatix• 8 years 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• 8 years 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.

slededit2• 8 years 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.

pjmlp9• 8 years 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• 8 years ago

C seems to be pretty stable at least. Even if it too has a new version in the works.

ketzu• 8 years ago

The good part is, you can (mostly) still program as if it was c++03, but you can move on from that part by part. Start adding auto, continue to lambdas, start using range for loops.

Or you can go on and, whenever you have a question about c++, start googling it as "c++17 <question>" instead of "c++ <question>" to find more modern answers, you might actually like, as some of them are safer to use, e.g., less off-by-one errors, and easier to read.

I personally felt overwhelmed from all the changes, but watching some videos I saw syntax I really liked and wanted to use! For the most part it was easy to understand, too. Being able to gradually change (at least in smaller projects) was a really nice experience.

fourthark• 8 years 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.

eps2• 8 years 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.

de_watcher2• 8 years ago

What? C++ has always been one of the rare languages that don't mindlessly add stuff that drives them into a corner.

pjmlp9• 8 years 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.

eps2• 8 years ago

And what would these numerous languages be - the ones that did mindlessly add stuff and drove themselves in a corner?

grandinj2• 8 years 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.

pjmlp9• 8 years ago

You can buy a ISO C or ISO C++ certification suite.

http://www.plumhall.com/suites.html

https://www.opengroup.org/testing/testsuites/perenial.htm

http://modena.us/

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.

grandinj2• 8 years 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)

Trip report: Fall ISO C++ standards meeting

Related Stories