11:00am

constexpr: in C++11, a curiosity; in C++14, viable for more uses; now with added power, in C++17 will it become an important tool in the programmer's toolkit?

In this talk we will examine the possibilities and power of constexpr and explore what can (and what should) be done at compile-time with C++17. We'll present techniques for building constexpr data structures and algorithms, and look at what the standard provides and where it can improve. We'll also explore constexpr use of user defined literals for expressive compile-time abstractions.

Compile-time computation offers perhaps the ultimate zero-cost abstraction, and this talk attempts to gauge the power available with C++17 constexpr.

Ben was in the game industry for 23 years, at companies like EA and Blizzard. He's always looking for useful new techniques in C++, and hegeeks out on algorithms, APIs, types and functional programming.

Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http://cppbestpractices.com.I'm... Read More →

11:00am

Coroutines are coming. They're coming for your asynchronous operations. They're coming for your lazy generators. This much we know. But once they're here, will they be satisfied with these offerings? They will not. They will require feeding, lest they devour our very souls. We present some fun ways to keep their incessant hunger at bay. I, for one, welcome our new coroutine overlords.

The Coroutines Technical Specification is an experimental extension to the C++ language that allows functions to be suspended and resumed, with the primary aim of simplifying code that invokes asynchronous operations. We present a short introduction to Coroutines followed by some possibly non-obvious ways they can help to simplify your code.

Have you ever wanted to elegantly compose operations that might fail? Coroutines can help. Have you ever wished for a zero-overhead type-erased function wrapper? Coroutines can help. We show you how and more.

Toby Allsopp has been using C++ for over 20 years and hasn't given up yet. His interests include cutting edge language features, functional programming, and solving the hard problems. Toby lives in Auckland, New Zealand, where he organizes the Auckland C++ Meetup.

2:00pm

The feature set for the C++17 release is set, and the release of the standard is just around the corner. In this session, we'll discuss all the new C++ features in C++17 and how they'll change the way we write C++ software. We'll explore the new standard in breath, not width, covering a cornucopia of core language and library features and fixes:

Bryce Adelstein Lelbach has spent nearly a decade developing libraries in C++. Bryce is passionate about C++ evolution and is one of the leaders of the C++ community. He is an officer of ISO/IEC JTC1/SC22/WG21, the C++ Standards Committee. Bryce chairs both the C++ Committee's Tooling... Read More →

3:15pm

The feature set for the C++17 release is set, and the release of the standard is just around the corner. In this session, we'll discuss all the new C++ features in C++17 and how they'll change the way we write C++ software. We'll explore the new standard in breath, not width, covering a cornucopia of core language and library features and fixes:

Bryce Adelstein Lelbach has spent nearly a decade developing libraries in C++. Bryce is passionate about C++ evolution and is one of the leaders of the C++ community. He is an officer of ISO/IEC JTC1/SC22/WG21, the C++ Standards Committee. Bryce chairs both the C++ Committee's Tooling... Read More →

4:45pm

Value semantics has been promoted in the C++ community for a long time, for reasons such as referential transparency, avoidance of memory management issues, and even efficiency in some cases. Move semantics in C++11 was a big step in language-level support for value semantics. In this talk, we’ll cover steps taken in C++17 for enhanced library-support for value semantics. Specifically, we’ll focus on `std::optional`, `std::variant`, and `std::any`.

We’ll discuss what they are, their motivating use cases, and most importantly, identify existing patterns that can be improved by replacing it with one of these utilities. We’ll also cover some of the details such as: `std::monostate`, `std::variant`’s `valueless_by_exception` state, subtle difference in behavior between `std::optional＜T＞` and `std::variant＜std::monostate, T＞`, etc.

The goal of the talk is to inform you of new library features in C++17, and to convince you of their usefulness and ultimately to add them to your toolbox.

8:30pm

Join us for a panel discussion with the leaders of the C++ standards committee where the audience asks the questions.

This we've got the the chairs of the Core Evolution and Language Evolution working groups, joined by the primary authors of such major upcoming features as concepts, metaclasses, ranges, modules, coroutines, compile time programming, and the spaceship operator.

Jon has been programming in C++ for almost three decades and does onsite training for teams that want to up their C++ game.Jon chairs C++Now, CppCon, the C++ Track of the Silicon Valley Code Camp, and the Boost Steering Committee. He also serves on the board of directors for... Read More →

Louis is a math and computer science enthusiast who got swallowed by the C++ monster when he was a naive, unsuspecting student. He now works for Apple, where he is responsible for libc++, the Standard Library shipped with LLVM/Clang. He is a member of the C++ Standards Committee and... Read More →

I've been doing C++ professionally for the past 20 years, first for Microsoft, then as an independent consultant. Right now, I'm working on bringing the power of "concepts" and "ranges" to the Standard Library with the generous help of the Standard C++ Foundation. Ask me about the... Read More →

Gor Nishanov is a Principal Software Design Engineer on the Microsoft C++ team. He works on design and standardization of C++ Coroutines, and on asynchronous programming models. Prior to joining C++ team, Gor was working on distributed systems in Windows Clustering team.

Andrew Sutton is an owner of Lock3 Software, LLC, a software research and development company in Kent, Ohio. His spends his days working on C++ language extensions in Clang and GCC and working on various WG21 language proposals.His past work included the design, specification, and... Read More →

Ville Voutilainen is the Chair of the Evolution Working Group, and also a gcc/libstdc++ developer. He's the Finnish representative in the C++ committee, and has contributed to numerous C++11 and C++14 facilities, including override/final, lambda init-captures, aggregate NSDMIs, and... Read More →

Titus Winters has spent the past 6 years working on Google's core C++ libraries. He's particularly interested in issues of large scale software engineer and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Along... Read More →

2:00pm

C++17 adds many new features: structured bindings, deduction guides, if-init expressions, fold expressions, if constexpr, and enhanced constexpr support in the standard library. Each of these features are interesting, but what will be their cumulative effect on real code? We'll explore how each feature may (or may not) help in real code for enhanced readability, compile time performance and runtime performance.

Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http://cppbestpractices.com.I'm... Read More →

3:15pm

C++17 is often quoted as “just a better C++14”, suggesting that nothing is new, nothing is changing the way we program. This talk presents class template argument deduction as a counterexample, a hidden gem in the new standard.

Saves typing? A replacement for the `make` functions? If that’s your frame, then you should come to this talk. The true power of class template argument deduction is underestimated. It’s a new point of abstraction but requiring creativity, insights, and understanding about the language details to manage.

This talk will start by introducing all matters about this feature to build up sufficient background knowledge, followed by teaching how to write deduction guides by examples, and finally explain how to build abstractions using the whole feature in a top-down approach, with patterns categorized.

Zhihao Yuan is a Parallel Computing Engineer at SimpleRose Inc. He participated in standardizing designated initializers in C++20. When freed from CMake, he enjoys a fair amount of anime and light novels.

4:45pm

C++17 is adding parallel overloads of most of the Standard Library algorithms. There is a TS for Concurrency in C++ already published, and a TS for Coroutines in C++ and a second TS for Concurrency in C++ in the works.

What does all this mean for programmers? How are they all related? How do coroutines help with parallelism?

This session will attempt to answer these questions and more. We will look at the implementation of parallel algorithms, and how continuations, coroutines and work-stealing fit together. We will also look at how this meshes with the Grand Unified Executors Proposal, and how you will be able to take advantage of all this as an application developer.

9:00am

This session is intended to help the advanced programmer to understand what coroutines and fibers are, what problems they solve and how they should be applied in practice. The session begins with an overview of these concepts, comparing them with threads, and demonstrating how they are exposed by the Boost libraries. Apart from being clean and succinct as Boost libraries typically are, the authors of these libraries have gone to great lengths to ensure that fibers and coroutines expose a programming model consistent with that of threads. This will make them seem very familiar. During the session I will demonstrate how fibers and coroutines can be used together with the powerful Boost.Asio library to solve some commonly occurring problems. To conclude, I will provide some practical tips and guidelines for those who are adding fibers and coroutines to their programming diet.

David is an experienced C++ and .Net developer and lectures on advanced topics in these languages. He is a great believer in the need to apply good engineering practices and clean code and assists his customers to implement them. He delivered a 90 minute session at ACCU 2015 on the... Read More →

From my days at the university, I hold a PHD in physics (although that was in the previous century and seems like a different life by now). Ever since then I have been developing software and/or managing engineering teams. In 2008, I started to learn C++ because I could not believe... Read More →

10:30am

Two years ago, I started to focus on exploring ways that we might evolve the C++ language itself to make C++ programming both more powerful and simpler. The only way to accomplish both of those goals at the same time is by adding abstractions that let programmers directly express their intent—to elevate comments and documentation to testable code, and elevate coding patterns and idioms into compiler-checkable declarations. The work came up with several potential candidate features where judiciously adding some power to the language could simplify code dramatically, while staying true to C++'s core values of efficient abstraction, closeness to hardware, and the zero-overhead principle.

The first two potential candidate features from that work to be further developed and proposed for ISO C++ are the ＜=＞ unified comparison operator (minor) and what I've provisionally called "metaclasses" as a way to generatively write C++ types (major). This talk is about the latter, and includes design motivation, current progress, and some live online compiler demos using the prototype Clang-based compiler built by Andrew Sutton and hosted at godbolt.org.

3:15pm

Based on similar concepts found in Boost.Asio, the Networking TS provides a rich API for synchronous and asynchronous network communications. The library boasts an impressive TTHW indicator (Time To Hello World); however, implementing robust client and server solutions often baffles newcomers and seasoned practitioners alike. Inspiration for this talk comes from the questions we have received on IRC, Slack, reddit, private emails, and classes we teach.

In this tutorial, Michael will provide a quick crash-course on using the Networking TS for asynchronous communication and then present patterns and idioms used at Ciere to address subjects including:

This session will be of interest to individuals wanting to get started with the Networking TS or who need some inspiration in building robust systems. Many of the techniques presented will also be applicable with Boost.Asio and the standalone Asio libraries.

Michael Caisse has been crafting code in C++ for 29-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project... Read More →

3:15pm

C++ Coroutines come naked. Just the language feature, no library support apart from a few traits that allow developing coroutine adaptors.

In this session we will start with just a compiler that implements a coroutine TS and a reference networking TS implementation and through (mostly) live coding together we will develop a cool, efficient and beautiful async networking app.

Gor Nishanov is a Principal Software Design Engineer on the Microsoft C++ team. He works on design and standardization of C++ Coroutines, and on asynchronous programming models. Prior to joining C++ team, Gor was working on distributed systems in Windows Clustering team.

4:45pm

This presentation describes the C++17 standard library parallel algorithms and how they are used. The algorithms are intended for the general software development community rather than addressing a few specialists.

Different kinds of parallelism are exposed using corresponding execution policies. Each execution policy implies specific constraints for the use of algorithms to enable the respective parallel approaches. The interface for execution policies is described together with the constraints of the defined execution policies. This presentation discusses the model behind the parallel algorithms and the associated constraints. Some example uses are shown together with results to motivate the importance of enabling parallelism in programs.

Dietmar Kühl is a senior software developer at Bloomberg L.P. working on the data distrubtion environment used both internally and by enterprise installations at clients. In the past, he has done mainly consulting for software projects in the finance area. He is a regular attendee... Read More →