May 2013

A Committee Draft for C++14 was adopted in April, so we now have a good idea of what the next revision of C++ will look like. On the language side, headliner features include significantly increased lambda and constexpr functionality, return type deduction for “normal” (i.e., non-lambda) functions, and templates for variables. In the standard library, significant additions include support for reader/writer locks, std::make_unique, std::optional, std::dynarray, and IO operations that preserve the value of quoted strings.  These lists are not exhaustive, but they should suffice to make clear that C++14 is far more than a C++11 bugfix release.

By the time C++ and Beyond takes place in December, we expect that some of these features will have started to appear in compilers and standard libraries, so knowing about them will be eminently practical. But we have a second reason for offering this talk: it will permit us to assume that everybody’s up to speed on C++14 basics. That will allow us to use those basics in later talks at C&B. Given that C++ and Beyond takes place just a month before 2014 begins, demonstrating how to incorporate C++14 features in real code bases is only natural.

Andrei and Herb and I have agreed that this is a talk we’ll definitely give at C&B, but we haven’t yet decided who will give it. In fact, it may end up being a joint presentation by two or even all three of us.  We’ll figure that out later. For now, rest assured that if you attend C&B in December 2013, you’ll leave well prepared for C++ in 2014.



This session will cover modern and current C++ style, focusing on C++14. I’ll demonstrate how major features and idioms from C++98 are now entirely replaced or subsumed and should be used no more; how other major features and idioms have been dramatically improved to the point where you code is cleaner and safer and you’ll even think in a different style; and how pervasive styles as common as variable declarations are changed forever, and not just for style but for serious technical safety and efficiency benefits. For one thing, you’ll never look at ‘auto’ the same way again (there, I said it; bring out the lederhosen and pitchforks! or attend the session and challenge in person to dig deep into the good reasons for the new reality).

Why C++14? Two reasons: First, it really does “complete C++11” with small but important consistency features like generic lambdas and make_unique that let us teach modern C++ style with fewer “except for” footnotes. Second, C++14 “is” C++ for the next several years and it’s real; as of last month it’s feature-complete, and I expect we will have at least two complete major commercial implementations available next year around the same time C++14 is formally published.

C++14 is a small but important improvement on C++11 that really does complete the language. What this means is that we’re going to have a complete and simpler set of idioms and styles to learn and use.

I’m planning to spend at least two hours in these highly interactive sessions. Be prepared to interact, challenge, and otherwise participate, and to discover new and useful information even if you’ve already been heavily using C++11.

This is a gentle reminder that the deadline for C&B 2013 early bird registration is fast approaching and June 9th will be here before you know it.  What is early bird registration? For those who register by June 9th, you will receive a $300 discount!

If you’ve been procrastinating about getting authorization to attend or have been putting off the necessary paperwork, now would be a good time to tackle those tasks.  The early-bird period will not be extended, so you’ll want to get in under the June 9th deadline if you possibly can.

For those of you who have already registered, you can sit back and relax. Or lean forward and tense up, your choice.  In any case, please contact me if you have any questions about registration or need information to complete paperwork. I’m here to help!

Lisa Wells
C&B Coordinator

I was recently invited to deliver a talk at an upcoming conference, and that meant I had to come up with a topic. I wrote up a talk description, but when I was done, I decided that I wanted to save it for this year’s C++ and Beyond.  As a result, I now have a topic to announce for this December’s C&B:

Concurrent Data Structures and Standard C++

Concurrent data structures permit multiple writers to simultaneously modify a single data structure. Used properly, they can avoid scalability bottlenecks in multithreaded systems. Used improperly, they can decrease program performance.

There are no concurrent data structures in the C++98 standard library. The C++11 standard library is similarly bare, and C++14 is unlikely to change that.  Nevertheless, concurrent data structures for C++ developers are widely available from sources such as Microsoft’s PPL, Intel’s TBB, and Boost. In this talk, I’ll examine the motivation and use cases for concurrent data structures, discuss their limitations, survey offerings common to PPL and TBB, and contrast concurrent APIs with those of seemingly similar serial counterparts (e.g., concurrent_vector vs. std::vector). I’ll also explain why writing your own concurrent data structure is much more complicated and error-prone than most people initially imagine.  (If you’re not familiar with the ABA problem, this presentation will explain why you should be.)


PS - I still don’t know what I’ll talk about at the other conference :-)