With the CppCon talk submission deadline upon us, we're starting to get glimpses of the potential CppCon conference program. In today's post, Herb Sutter mentions three of his five talk proposals (note: pending review and selection by the program committee, so this is not final -- they may or may not be selected if there is stronger material).

CppCon: My Proposed Talks (Part 1)

by Herb Sutter

From the post:

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.