The videos of CppCon 2015 are coming online. You can see them all here: Youtube

Here are the most recent ones:

• Evolving Legacy Code
• Functional programming: functors and monads
• Benchmarking C++ Code
• Transactional Memory in Practice
• Declarative Control Flow

Evolving Legacy Code, by Rachel Cheng & Michael VanLoon

We will be presenting on the evolution of a legacy monitoring subsystem modernized to C++11 with enhanced interfaces and better programming techniques. The presentation will cover some abstracted example problem areas, the solutions, and talk about the strategy employed to modernize the code.

Functional programming: functors and monads, by Michał Dominiak

Following the 'Applying functional programming in code design' session from Wednesday, I'd like to conduct a 'crash course' on functors and monads, and why they are important - and useful - regardless of the language you are writing code in.

Benchmarking C++ Code, by Bryce Adelstein-Lelbach

With the ending of Moore's Law and the rise of multicore systems, programmers from across the industry are increasing forced to develop and maintain highly performance sensitive software. For C++, a language frequently used for performance sensitive projects, benchmarking and performance analysis is especially important. Developing good benchmarks can be tricky; gathering and analyzing data from benchmarks can be an even greater challenge.

This talk will discuss techniques and best practices for writing C++ benchmarks using facilities from the standard library and Boost. We'll also cover the development of performance unit/regression tests. We'll discuss the statistical best practices for gathering data, as well as techniques for benchmarking a variety of different metrics - time, memory, algorithmic complexity, etc.

The main topics which will be covered:

* Statistical Best Practices (dealing with uncertainty, achieving statistical confidence, how to sample)
* Time-Based Benchmarking (best practices for timing, derived time-based metrics)
* Non-Time-Based Benchmarking (memory, algorithmic complexity in time and space, etc)
* Techniques for C++-specific Performance Metrics (counting copies/moves, allocator tricks)
* Converting Benchmarks into Tests

Transactional Memory in Practice, by Brett Hall

Transactional memory has been held up as a panacea for concurrent programming in some quarters. The C++ standardization committee is even looking at including it in the standard. But is it really a panacea? Has anyone used it in a shipping piece of software? There are scattered examples, mostly from the high-performance and super-computing realms. On the other end of the spectrum, at Wyatt Technology we've been using transactional memory in a desktop application that does data acquisition and analysis for the light-scattering instruments we build. That application is called Dynamics and we've been using a software transactional memory system in it for four years now. This talk will detail how our system works, how well it worked, and what pitfalls we've run into. Prior experience with transactional memory will not be assumed, though it would help if you have experience programming threads with locks and an open mind about alternatives and why we're looking for them.

Declarative Control Flow, by Andrei Alexandrescu

Getting exception handling right is a perennial problem in C++ that has eluded systematization. Not for much longer. New language and library developments make it possible to handle exceptions in a declarative manner, leading to drastic code simplification.

This talk discusses an alternative approach to handling exceptional flow that eliminates the need for small ancillary RAII classes, try/catch statements that rethrow, and other cleanup mechanisms. The popular Scope Guard idiom gets a spectacular generalization. Statements specify in a declarative manner actions to be taken if the current scope is left normally or via an exception. The resulting code is simpler, smaller, and easier to maintain.