CppCon: My Proposed Talks (Part 1)

I’ve been watching the talk proposals rolling in for CppCon, now well over 100 of them, and I was already looking forward to this conference but I just keep getting more jazzed.

For my part, I’ve proposed five talks, with between 5 and 10 hours of material. I thought I’d share some of them here.

Note: The CppCon program committee will be considering the talk proposals to come up with a balanced program, so it’s possible that not all of these will be in the final program, but I have high hopes for most of these…

Below are three of the five proposed talks. These are the ones I’ve given publicly before, but they’re not retreads – all are fresh and up to date, with refreshed or new material.

I’ll cover the other two new talks in a separate post soon.

I hope to see you at CppCon this fall to talk about these and many more interesting topics by scores of great speakers!


Lock-Free Programming – or, How to Juggle Razor Blades (~2 hours)

Example-driven talk on how to design and write lock-free algorithms and data structures using C++ atomic<> – something that can look deceptively simple, but contains very deep topics. (Important note: This is not the same as my “atomic<> Weapons” talk; that talk was about the “what they are and why” of the C++ memory model and atomics, and did not cover how to actually use atomics to implement highly concurrent algorithms and data structures.)

This talk is about the “how to use them successfully” part of atomics, including:

  • Best practices and style for using atomic<>s
  • Three or more examples, including lock-free mail slots and iterations of a lock-free linked list, all in portable Standard C++
  • Defining and applying the different levels of “lock-freedom” (wait-free, lock-free, obstruction-free) to develop highly concurrent algorithms and data structures
  • Explaining and applying key concepts including especially: linearizability; trading off concurrency vs. promptness; and trading off concurrency vs. throughput/utilization
  • Demonstrating and solving the ABA problem, with clean and simple code – that’s right, did you know that in C++11 you can solve this without relying on esoterica like double-wide CAS (which isn’t always available) or hazard pointers (which are deeply complex) or garbage collection (which isn’t in the C++ standard… yet)?


Standardization Update: C++14 and the Seven Dwarfs (1 hour)

Standardization has accelerated: By the time we meet at CppCon, C++14 might already be ratified. But that’s only one of eight (so far) work items now in flight. In this session, I’ll give a brief summary of the new features coming in C++14 itself, and then a tour of the seven (7) near-term separate Technical Specifications already underway – think of these as the “C++14 wave” of deliverables.

The ISO C++ committee has transitioned to a “decoupled” model where updated versions of the standard are published more frequently, while at the same time major pieces of work can progress and be published independently from the Standard itself and delivered asynchronously in the form of Technical Specifications (TS’s) that are separate from the main Standard and can later be incorporated into the Standard. Come to this session to see how this is helping both the standard and C++ compiler implementations near you stay current with the latest in C++.

The topics covered will be:

  • C++14: What’s new in the new standard due this year
  • File System TS: Portable file system access
  • Library Fundamentals TS (small): string_view and optional<>
  • Array Extensions TS: Language and library dynamic arrays
  • Concepts Lite TS: Templates + constraints = ++usability and ++diagnostics
  • Concurrency TS: Nonblocking futures (.then, .when_*), executors, and (maybe) await
  • Parallelism TS: A whole new Parallel STL with both parallel and vector execution support
  • One of:
    – Networking TS (small): IP addresses, URIs, byte ordering
    – Transactional Memory TS: Language and library extensions for transactional memory instead of mutexes for many kinds of concurrency control

This session will present an overview of each set of features, what it looks like and how to use it, and why it’s important for the standard and for your own portable C++ code.


Modern C++ Style: Idioms of C++11/14 (1 to 3 hours)

This session will cover modern and current C++ style, focusing on C++14. It will 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 your 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 – and if hearing that makes you worry, worry not, just attend the session 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; it is feature-complete and in the final stages of standardization, and more importantly we are already seeing near-complete conforming implementations becoming widely available around the same time C++14 is expected to be 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.

8 thoughts on “CppCon: My Proposed Talks (Part 1)

  1. Based on my experience with C++11/14, BY FAR the most feared and controversial feature is “auto” and AAA (Almost Always Auto). Even after reading e.g. https://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/.

    So I’m looking forward to some new insights on this topic :)


    I love consistency so I tried to follow AAA but the resistance is huge from others. So I wonder if in the end AAE (Almost Always Explicit typing) wins the hearts and minds.

    Major arguments against auto:
    * Hinders code review: Code review tools are text based. Cannot get type info by hovering over variable names.
    * Hinders code understanding: Is “proper” variable/function naming enough to alleviate this?
    * Fear of unnoticed mixed integer arithmetic: Integral promotion and implicit integral conversion pitfalls.

    Minor arguments against auto:
    * Does not work for declaring arrays, pointers and non-copyable types (you have to have at least a non-implemented but declared copy constructor).

    Personally, I also prefer “very strong typing” which means “always use explicit conversion”. Unfortunately, especially for primitive types, it is hard to disallow implicit conversions.

    But I guess we may have no option but to wait and see how this AAA vs AAE debate settles in the end.

  2. I hope beyond hope that Visual C++ finally implements dynamic stack arrays. I’ve been waiting for this feature for a decade – that’s how long GCC has had it working as an extension. Clearly, the implementation can’t be *too* difficult, given that Visual C++ has had alloca for that long!

  3. Herb,
    We need “Modern C++ Style: Idioms of C++11/14 ” yesterday, perhaps as a channel 9 video, if you ask me.

    I can’t find any good book on c++1/14. Most, even the “completely rewritten for c++ xx” are just rehashes of c++0x books with a few additions here and there.

    I would like to be taught c++11/14 as a whole new language with only the new styles and idioms for simplicity and to help forget all the deprecated things I learned years before.

    The subtleties and the when to use this and that old feature / keyword /idom can be postponed to additional chapters / reference books such as Bjarne’s.

    As is, I find it really distracting when a c++11 feature is presented in a paragraph only to be followed by 10 pages of when to use the old way. It really breaks the narrative. You begin to forget about the whole new picture.

  4. “did you know that in C++11 you can solve this without relying on esoterica like double-wide CAS (which isn’t always available) or hazard pointers (which are deeply complex) or garbage collection (which isn’t in the C++ standard… yet)”
    Are we talking about a complete solution here that works under all circumstances or one of those “tag the pointers and hope we won’t have more than 2^k updates in-between”?

    I hope the talks are videotaped, but I’m particularly looking forward to hearing about this.

Comments are closed.