The CppCon 2015 conference program has been posted for the upcoming September conference. We’ve received requests that the program continue to be posted in “bite-sized” posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.

C++, it is also a language that we like to discover and master always more.

The following interrelated CppCon 2015 talks tackle these issues and more (part 3).

In this post:

• Generic Lambdas from Scratch
• Large Scale C++ With Modules: What You Should Know
• Shared_Future from Scratch
• Comparison is not simple, but it can be simpler
• The Importance of Being const
• Intro to the C++ Object Model

Generic Lambdas from Scratch by Arthur O'Dwyer, software engineer, Mixpanel

Lambdas (even those mysterious generic lambdas) are just syntactic sugar atop constructs that are perfectly understandable when approached from the right direction.

We'll start with the implementation of C-style functions, then move to overloading, function templates, non-static member functions, C++11 lambdas, and then demystify C++14 generic ("auto") lambdas. Finally, we'll detour into the implementations of std::function and std::bind to show how they're different from lambdas.

Large Scale C++ With Modules: What You Should Know by Gabriel Dos Reis, Principal Software Development Engineer, Microsoft

To be completed.

Shared_Future from Scratch by Arthur O'Dwyer, software engineer, Mixpanel

The contents of header are probably still a bit mysterious to most people. Sure, we know that setting the value of a promise causes the corresponding future to resolve; but how does that happen behind the scenes in a way that allows us to move futures around? How are we going to implement the new features in the Concurrency TS, such as .then() and .when_all()? How (if at all) do futures interact with std::thread, std::async, and "executors"?

We'll present an extremely simplified implementation of futures and shared_futures, without the template metaprogramming that comes along with future and future and so on, but showing all the pointers and synchronization primitives.

Comparison is not simple, but it can be simpler by Lawrence Crowl

The standard's algorithms typically require a 'strict weak ordering'. I will explain what this really means and show that even simple uses of sort can have latent failures. Programmers can avoid the problems today with a bit of work. Changes to the standard will reduce errors and programming effort.

The Importance of Being const by Richard Powell, Audio Software Engineer

Why do we use const? It helps the compiler enforce program invariants, find trivial bugs, and generally makes code better. But with C++11 has an extended meaning, specifically in regards to multi-threaded code.

This talk will be an intro to the const keyword and what it means to declare objects, pointers and member functions as const. We will also explore some subtle issues encountered with const, mutable, and multithreaded code.

Intro to the C++ Object Model by Richard Powell, Audio Software Engineer

This talk is to help you learn about how objects are represented in C++. I find it very helpful to have a mental model of how objects exist in the program memory space to understand how my code operates within program execution.