Event - GoingNative_CppCon-2017


C++17 Features (part 1 of 2)[MP4] [0:48:59] [2018/01/09]
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…


C++17 Features (part 2 of 2)[MP4] [0:54:25] [2018/01/09]
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…


Runtime Polymorphism: Back to the Basics[MP4] [1:08:03] [2018/01/09]
C++ solves the problem of runtime polymorphism in a very specific way. It does so through inheritance, by having all classes that will be used polymorphically inherit from the same base class,…


Multidimensional Index Sets for Data Locality in HPC Applications[MP4] [0:57:45] [2018/01/09]
The proposed range concepts for the standard library are a significant improvement but are designed for the mental model of iterating and mapping values, not hierarchical domain decomposition. Even…


Undefined Behaviour is awesome![MP4] [0:53:58] [2018/01/09]
Undefined behavior (UB) is one of the features of C++ that is both loved and hated. Every C++ developer cares about performance, which is why it is very important to understand what…


How to break an ABI and keep your users happy[MP4] [0:49:42] [2018/01/09]
Technical debt is the bane of most established libraries, whether it is standard library or boost or local library developed in house. Paying this debt is expensive and in many cases seems infeasible.…


C++17 ParallelSTL: A Standardization Experience Report for CPU and GPU on SYCL[MP4] [1:10:14] [2018/01/09]
The most significant improvement in C++17 will be Parallel Algorithms in the STL. But it is meant only for CPUs, as C++ does not define heterogeneous devices yet (though SG14 is…


Meta[MP4] [1:00:44] [2018/01/09]
For the past several years, I have been researching new languages to support safe and efficient network protocol processing, specifically for software-defined networking applications. The unfortunate…


My Little Object File: How Linkers Implement C++[MP4] [0:47:50] [2018/01/09]
Ever wonder how the linker turns your compiled C++ code into an executable file? Why the One Definition Rule exists? Or why your debug builds are so large? In this talk we'll take a deep dive…


Adding C++ modules-ts to the GNU Compiler[MP4] [0:59:45] [2018/01/09]
C++ modules-ts[1] proposes a module system, with defined interfaces, implementations and importing. I shall outline the new semantics, their impact on the ABI and build systems, and discuss…


C++/WinRT and the Future of C++ on Windows[MP4] [1:04:46] [2018/01/09]
This talk highlights efforts by Kenny Kerr, Herb Sutter, Gabriel Dos Reis, and others to make Windows a great place for C++ developers, replacing proprietary extensions and tools with standard…


The Future of Texture Compression[MP4] [0:38:24] [2018/01/09]
Textures and images are everywhere in today's world. Compressing those images well improves streaming performance, video, dramatically reduces the size and download times of apps. It can give you more…


Customizing the Standard Containers[MP4] [1:00:01] [2018/01/09]
Almost all of the the standard containers have “customization points”, ways that users can modify their behaviors. Three of the common ones are: Allocators Comparison predicates Hash functors In this…


Going Nowhere Faster[MP4] [1:00:57] [2018/01/09]
You care about the performance of your C++ code. You have followed basic patterns to make your C++ code efficient. You profiled your application or server and used the appropriate…


Curiously Recurring C++ Bugs at Facebook[MP4] [0:52:00] [2018/01/09]
I've spent the last few years watching Facebook's C++ codebase grow by several orders of magnitude. Despite constantly improving abstractions, constantly improving tooling, frequent internal…


Free Your Functions![MP4] [1:01:41] [2018/01/09]
You are devoted to minimize coupling and duplication? You are taking care to maximize cohesion, flexibility, extensibility, encapsulation, testability, and even performance in order to achieve the…


Designing a Unified Interface for Execution[MP4] [1:02:51] [2018/01/09]
If you were to ask a C++ developer the question "what is execution?" you may get a different answer depending on who you asked. This is because execution means something different to…


C++ Exceptions and Stack Unwinding[MP4] [0:51:11] [2018/01/09]
Exceptions are often described as 'slow', and the standard advice is to use them only in exceptional circumstances. In this talk, we'll find out how slow exceptions really are by exploring the Itanium…


Allocators: The Good Parts[MP4] [1:00:48] [2018/01/09]
Memory allocators have a bad rap. Sure, they give us control, sometimes vital control, over how and where memory is allocated, but they seem so hard to use correctly. The allocator model that was…


Performance Benchmarking with Celero[MP4] [0:44:42] [2018/01/09]
Developing consistent and meaningful benchmark results for code is a complex task. Measurement tools exist (Intel® VTune™ Amplifier, SmartBear AQTime, Valgrind, etc.) external to applications, but…


There Will Be Build Systems: I Configure Your Milkshake[MP4] [0:58:01] [2018/01/09]
C++ (and C) have always had unique challenges when it comes to build systems. In addition to discussing the common problems that C++ build systems face, this talk will discuss the…


C++17 Parallel Algorithms[MP4] [0:57:06] [2018/01/09]
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…


I Wish I Could Use C++ 1x/y/z[MP4] [0:55:18] [2018/01/09]
C++11, C++14 and C++17 provided a sensible amount of new libraries and language features. However, for some reasons ranging from inertia or even resistance to change, up to…


Objects, Lifetimes, and References, oh my: the C++ Object Model, and Why it Matters to You [MP4] [0:51:52] [2018/01/09]
How does the C++ abstract machine really work at the lowest levels? Why does the committee design its rules the way they do? Gain insight into the object model of C++, from references…


Tools and Techniques To Stay Up-to-date With Modern C++[MP4] [0:40:53] [2018/01/09]
Since 2011, C++ has been on a massive roll. New C++ standards in 2011, 2014 and 2017. A growing number of new TSes and proposals for new features to be standardized. Following even…


An Interesting Lock-free Queue - Part 2 of N[MP4] [1:05:05] [2018/01/09]
This is the long awaited continuation of a previous CppCon talk ("Lock-free by Example") on an "interesting" lock-free queue. ("interesting"? Well, "multi-producer,…


A Soupçon of SFINAE[MP4] [1:01:16] [2018/01/09]
Following on Arthur's "Template Normal Programming" from CppCon 2016, this will be a concise cookbook of SFINAE recipes — ways of getting the compiler to do one thing in one circumstance and…


A Type, by Any Other Name[MP4] [0:45:38] [2018/01/09]
No offense to Shakespeare, but in C++ there is a lot in a type name. A name represents a set of data and behaviors, and changing names is an often difficult and painful process. This could be…


End-to-end Deadlock Debugging Tools at Facebook[MP4] [0:27:54] [2018/01/09]
Facebook has developed tooling to help quickly find and debug several classes of concurrency bugs in Facebook's large C++ codebase. In this talk, we will focus specifically on deadlocks and…


What C++ developers should know about globals (and the linker)[MP4] [0:35:02] [2018/01/09]
Most C++ developers know that using globals (or singletons) excessively in code is usually a poor decision. But it is also hard to deny their usefulness in more than one situation: for…


Higher-order Functions in C++: Techniques and Applications[MP4] [1:02:19] [2018/01/09]
Higher-order functions are functions that take other functions as arguments. This is very frequently used in functional languages, somewhat less so in C++, although this is slowly changing…


Traveling the Solar System with C++: Programming Rocket Science[MP4] [0:54:19] [2018/01/09]
Spacecraft travel our solar system with exquisite accuracy. It is almost commonplace to learn that a spacecraft hit bullseye to within a few seconds after over a decade of space travel. How do we do…


Postmodern immutable data structures[MP4] [1:05:59] [2018/01/09]
The C++ elites have been talking for years about value semantics, immutability, and sharing by communicating. A better world without mutexes, races, observers, command patterns and so more…


Fantastic Algorithms and Where To Find Them[MP4] [0:46:57] [2018/01/09]
Come dive into some exciting algorithms — tools rare enough to be novel, but useful enough to be found in practice. Want to learn about "heavy hitters" to prevent DOS attacks? Come to this…


Microcontrollers in Micro-increments : A Test-driven C++ Workflow for Embedded Systems [MP4] [1:01:17] [2018/01/09]
Baby steps are safe steps. Making small moves in code, driven by tests, and continuously refactoring helps to keep embedded development on the right track. With test-driven development we can move…


Designing a Fast, Efficient, Cache-friendly Hash Table, Step by Step[MP4] [0:59:33] [2018/01/09]
Hash tables consume a large volume of both compute resources and memory across Google's production system. The design for hash tables in C++ traces its origins to the SGI STL implementation…


Howling at the Moon: Lua for C++ Programmers[MP4] [0:32:32] [2018/01/09]
C++ is a great tool for solving complex problems in a thorough way. But every once in a while, the desire for a simpler language emerges. For those parts of our code where performance is of…


Inside the Qt Object Model[MP4] [0:29:46] [2018/01/09]
Programming your application with Qt means that you will sooner or later encounter the central QObject class, signal & slot connections, or generic properties. The object model makes it safe and…


Understanding the runtime behaviors of C++ programs using uftrace tool[MP4] [0:30:06] [2018/01/09]
This talk will present the uftrace function graph tracing tool, which was first introduced at CppCon last year. The uftrace tool utilizes function instrumentation techniques from compilers to provide…


Optimizing compilation times with Templates[MP4] [0:28:45] [2018/01/09]
At Facebook, the main bottlenecks in build times are caused by auto-generated code from our core RPC Framework. Through the use of templates we were able to obtain up to 50% build speedup in our…


The Holy Grail! A Hash Array Mapped Trie for C++[MP4] [0:51:23] [2018/01/09]
C++ has a handful of associative containers. We started with set and map, both based on node-based red-black trees. These are fine but are not the most efficient and, in particular, suffer…


Eight Ways to Handle Non-blocking Returns in Message-passing Programs: from C++98 via C++11 to C++20 [MP4] [0:58:30] [2018/01/09]
Shared-Nothing approach of "sharing memory by communicating" (instead of "communicating by sharing memory") gets more and more traction in the development world; this is not to…


So, you inherited a large code base...[MP4] [0:54:34] [2018/01/09]
This is a talk about solving the most difficult problem a software engineer ever faces, converting a large codebase with antiquated designs and spotty quality into a state-of-the-art, modern system.…


LauncherOne rocket with C++ engine[MP4] [1:01:43] [2018/01/09]
Abstract: The most important aspects of rocket safety software development, from an idea, design, implementation to testing. Safe design patterns and critical error handling in fault tolerant systems.…


Naked coroutines live (with networking)[MP4] [1:04:00] [2018/01/09]
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…


C++ and Persistent Memory Technologies, Like Intel's 3D-XPoint[MP4] [1:08:26] [2018/01/09]
With the advent of a new, persistent-memory-enabled world, the current software industry must prepare for changes. Looking forward to meet the new requirements set by this new type of hardware, a new…


A Tour of Deep Learning With C++[MP4] [0:55:00] [2018/01/09]
Deep Learning is a subfield of artificial intelligence that employs deep neural network architectures and novel learning algorithms to achieve state of the art results in image classification, speech…


How to Write a Custom Allocator[MP4] [1:03:39] [2018/01/09]
You'd like to improve the performance of your application with regard to memory management, and you believe this can be accomplished by writing a custom allocator. But where do you start? Modern…


Practical Techniques for Improving C++ Build Times[MP4] [0:55:51] [2018/01/09]
Slow builds block all C++ developers from the work being done. At Facebook we have a huge codebase, where the time spent compiling C++ sources grows significantly faster than the size…


Mix Tests and Production Code With Doctest - Implementing and Using the Fastest Modern C++ Testing…[MP4] [0:51:20] [2018/01/09]
Not a typical talk about testing. Here are some quotes from the Program Committee about it: "Seeing a talk proposal about a new unit test framework made me quite skeptical. But then I looked at…


The Asynchronous C++ Parallel Programming Model[MP4] [1:06:45] [2018/01/09]
With the advent of modern computer architectures characterized by — amongst other things —many-core nodes, deep and complex memory hierarchies, heterogeneous subsystems, and power-aware components, it…


Reader-Writer Lock versus Mutex - Understanding a Lost Bet[MP4] [0:42:00] [2018/01/09]
Mutexes have frequently been observed to outperform reader-writer locks in domains where, logically, reader-writer locks should dominate. I was recently given an opportunity to address this…


Make Classes Great Again! (Using Concepts for Customization Points)[MP4] [0:43:58] [2018/01/09]
Learn new ways to think about class design, that you can apply to your own projects! In this talk we'll start with a simple class that models an HTTP message. We’ll go over the limitations of the…


Effective Qt (2017 edition)[MP4] [1:01:07] [2018/01/09]
The title of this talk pays tribute to the "Effective Qt" columns, a series of blog posts started by Marc Mutz many years ago, whose title was in turn inspired by Scott Meyer's book series.…


Practical Patterns with the Networking TS[MP4] [1:01:04] [2018/01/09]
Networking is coming to a standard near you — but how do you use it? Based on similar concepts found in Boost.Asio, the Networking TS provides a rich API for synchronous and asynchronous network…


Reflection[MP4] [1:00:53] [2018/01/09]
For the past year or so, I have worked with Herb Sutter on language support for compile-time programming, reflection, metaclasses, and code injection for the C++ programming language. This…


Building for the Best of Us: Design and Development with Kids in Mind[MP4] [0:58:17] [2018/01/09]
Building an API easy enough for kids to understand (in C++) is a challenge. Every design decision, from the circuit board to the plastic can effect the results. We'll talk about product…


Compile-time reflection, Serialization and ORM[MP4] [0:36:13] [2018/01/09]
We will discuss what reflection is and how it can be implemented in Modern C++. The techniques used will include a mix of C++11/14 features (void_t, tuple, index_sequence, variadic…


Game Audio Programming in C++[MP4] [0:51:12] [2018/01/09]
Game audio programming is a sort of dark art practiced and understood by its few practitioners, but audio is an important and vibrant part of any game. There is a huge body of knowledge and history…


Type Punning in C++17: Avoiding Pun-defined Behavior[MP4] [1:05:07] [2018/01/09]
Type punning, treating a type as though it is a different type, has a long and sordid history in C and C++. But, as much as we'd like to deny its existence, it plays an important role in…


A Test a Day Keeps Your Manager Away![MP4] [1:00:35] [2018/01/09]
This session will present how to leverage C++'s diverse set of analysis tools with existing Continuous Integration services to increase a project's quality continuously over time. In…


Building C++ Modules[MP4] [1:06:45] [2018/01/09]
C++ Modules TS is now implemented (to various degrees) by GCC, Clang, and MSVC. The aim of this talk is to provide practical information on the mechanics of creating and consuming modules with…


Undefined Behavior in 2017 (part 2 of 2)[MP4] [0:26:00] [2018/01/09]
Undefined behavior is a clear and present danger for all application code written in C++. The most pressing relevance is to security, but really the issue is one of general software…


Undefined Behavior in 2017 (part 1 of 2)[MP4] [0:49:22] [2018/01/09]
Undefined behavior is a clear and present danger for all application code written in C++. The most pressing relevance is to security, but really the issue is one of general software…


Read, Copy, Update, then what? RCU for non-kernel programmers[MP4] [1:08:01] [2018/01/09]
RCU (Read, Copy, Update) is often the highest-performing way to implement concurrent data structures. The differences in performance between an RCU implementation and the next best alternative can be…


Local ('Arena') Memory Allocators (part 1 of 2)[MP4] [1:00:04] [2018/01/09]
Are allocators worth the trouble? What situations merit their use? How are they applied effectually? What’s the performance impact? This practical talk by large scale C++ expert Dr. John Lakos…


C++ Templates Revised[MP4] [1:00:40] [2018/01/09]
In 2003 we published "C++ Templates - The Complete Guide". Now, 14 years and 3 major C++ versions later, we are publishing the second edition. The content grew and changed…


Naivety of Creating Cross-Platform, Modern C++ Libraries: A Tour Of Our Challenges and Successes [MP4] [0:57:45] [2018/01/09]
The AWS SDK for C++ was designed with a few important tenets. Modern C++ (versions 11 and later), Cross-Platform, User Customization with sane defaults, and no dependencies. A year…


Driving Into the Future With Modern C++: A Look at Adaptive Autosar[MP4] [0:56:50] [2018/01/09]
Software development of automotive control units has long been in the hands of hardcore C developers. With the increasing need for high-performing, multi-core processors and for applications that can…


Boost Your Programs Health by Adding Fibers to your Coroutine[MP4] [1:03:57] [2018/01/09]
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…


10 Core Guidelines You Need to Start Using Now[MP4] [1:02:32] [2018/01/09]
The C++ Core Guidelines were announced at CppCon 2015, yet some developers have still never heard of them. It's time to see what they have to offer for you, no matter how much C++…


API & ABI Versioning: How to Handle Compatibility With Your C++ Libraries [MP4] [1:00:15] [2018/01/09]
Software keeps changing, but not always as fast as its clients. A key to maintaining a library in the long run is to ensure a proper versioning of the API and ABI. Not only does this gives a clear…


Bringing Clang-tidy Magic to Visual Studio C++ Developers[MP4] [1:00:34] [2018/01/09]
“A 14 year old code base under active development, 2.5 million lines of C++ code, a few brave nerds, two powerful tools and one hot summer…”, or “How we managed to clang-tidy our whole code…


Seventeenification: Porting sqlpp11 to C++17[MP4] [0:50:59] [2018/01/09]
The ink on C++17 has merely dried, but the major compilers support most features already. It's high time for a reality check! This talk is a report about the ongoing effort of porting sqlpp11…


Web | C++[MP4] [0:41:20] [2018/01/09]
Have you ever tried writing a web application with C++? Can opening a file and serving it via HTTP be as simple as writing 20 lines of python? With the undeniable importance of web…


ThinLTO: Scalable and Incremental Link-Time Optimization[MP4] [1:01:59] [2018/01/09]
Whole program optimization enables higher performance in C++ applications, because of the expanded scope for analysis and optimization. However, the memory and time required to optimize the…


Delegate this! Designing with delegates in modern C++[MP4] [0:58:10] [2018/01/09]
Designing a fast IP stack from scratch is hard. Using delegates made it all easier for IncludeOS, the open source library operating system written from scratch in modern C++. Our header-only…


Class Template Argument Deduction: A New Abstraction[MP4] [0:48:05] [2018/01/09]
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…


Tools from the C++ eco-system to save a leg[MP4] [0:52:03] [2018/01/09]
C++ gives you enough rope to shoot your leg off. Readable (and thus easy to maintain, easy to support) and error-free code in C++ is often hard to achieve. And while modern C++…


Hands-On With Abseil[MP4] [0:58:53] [2018/01/09]
An introduction to the design and compatibility goals for Abseil - Google's new common C++ libraries project. I'll summarize some style points and policies that affect Abseil and its users,…


Practical C++17[MP4] [1:00:48] [2018/01/09]
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…


Postmodern C++[MP4] [0:51:17] [2018/01/09]
The term "Modern C++" can be traced back to Andrei Alexandrescu's "Modern C++ Design", published in February 2001. Much has changed since then. Alexandrescu is off…


Local ('Arena') Memory Allocators (part 2 of 2)[MP4] [1:01:53] [2018/01/09]
Are allocators worth the trouble? What situations merit their use? How are they applied effectually? What’s the performance impact? This practical talk by large scale C++ expert Dr. John Lakos…


Designing A Feature That Doesn't Fit[MP4] [0:51:23] [2018/01/09]
C++ is a wonderful and expressive language, that gives programmers a lot of freedom even though it actively seeks to let programmers obtain the maximal performance from their hardware. It so…


Using Functional Programming Patterns to build a clean and simple HTTP routing API[MP4] [0:55:28] [2018/01/09]
Web services are flourishing, and C++ has some great libraries (such as Boost/Asio + Beast or CppRestSdk) which we can use as the basis to build such services. Yet it is still relatively…


Multithreading is the answer. What is the question? (part 2 of 2)[MP4] [0:49:29] [2018/01/09]
The main focus of this talk will be about the importance of lockless containers and RCU technology. The value of this approach will be explained and why it was added to libGuarded. I will also cover…


Agent based class design[MP4] [0:58:36] [2018/01/09]
Abstracting a set of functionalities into a class which provides a higher level interface often requires tough design decisions. Users who do not have the exact requirements for which the abstraction…


CNL: A Compositional Numeric Library[MP4] [1:00:25] [2018/01/09]
CNL is a numerics library born out of efforts to standardize fixed-point arithmetic. It provides number types which increase precision, enforce correctness and maintain efficiency. And by designing…


Recreational C++[MP4] [1:02:50] [2018/01/09]
C++ is a language full of curiosities, and entices the curious. This session will will walk through half a dozen little code explorations of ideas that might have been solved in 5 minutes, but…


Concurrency, Parallelism and Coroutines[MP4] [1:05:23] [2018/01/09]
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…


Multithreading is the answer. What is the question? (part 1 of 2)[MP4] [0:46:51] [2018/01/09]
The main focus of this talk will be about the importance of lockless containers and RCU technology. The value of this approach will be explained and why it was added to libGuarded. I will also cover…


Using Modern CMake Patterns to Enforce a Good Modular Design[MP4] [0:57:39] [2018/01/09]
CMake is the build system chosen by most open-source C++ projects. While it is fully capable of helping you enforce a good modular design, those features are usually not well known or…


MPark.Patterns: Pattern Matching in C++[MP4] [1:00:12] [2018/01/09]
Pattern matching brings a declarative approach to destructuring and inspecting complex data types. It’s a very powerful abstraction provided by many programming languages such as Haskell and OCaml,…


dynamic_cast From Scratch[MP4] [0:58:48] [2018/01/09]
This session will introduce you to the C++ object model: the rules by which C++ class objects are translated into memory layouts. We'll quickly cover polymorphic class types and…


Cross-Platform Apps with Dropboxs Djinni: In-Production Architecture Examples[MP4] [0:48:49] [2018/01/09]
Djinni is a tool developed by Dropbox for cross-platform C++ development. This session will give an overview of mobile cross-platform C++ development, an explanation of what Djinni…


Mocking Frameworks considered harmful[MP4] [1:01:18] [2018/01/09]
However, you might have existing code bases or want to rely on external libraries that may make writing effective and fast unit tests hard or even near to impossible. A typical work-around for these…


Function default arguments: Slingshot or Shotgun?[MP4] [1:00:29] [2018/01/09]
On the surface, function parameter default arguments seem like a very simple feature of the C++ language. This session explores how (not) true that is. If you like the dark corners of…


Everything You Ever Wanted to Know about DLLs[MP4] [1:02:27] [2018/01/09]
If you build software for Windows, you use DLLs, and it’s likely that you may build DLLs of your own. DLLs are the primary mechanism for packaging and encapsulating code on the Windows platform. But…


The Nightmare of Move Semantics for Trivial Classes[MP4] [0:57:15] [2018/01/09]
Assume, we implement a very simple class having just multiple string members. Even ordinary application programmer prefer to make it simple and fast. You think you know how to do it? Well beware! It…


Design Patterns for Low-Level Real-Time Rendering[MP4] [0:54:32] [2018/01/09]
In recent years, the GPU graphics community has seen the introduction of many new GPU programming APIs like Khronos' Vulkan, Microsoft's Direct3D 12, and Apple's Metal. These APIs present much more…


How to Write Effective Documentation for C++ Libraries with Minimal Effort [MP4] [1:02:18] [2018/01/09]
With the success of GitHub, everybody and his brother is a library developer. Programmers love to create code, upload it to GitHub and hope for immortality. Most projects get only the most cursory…


Grill the Committee[MP4] [1:28:18] [2018/01/09]
What would you like to know about the C++ standard? Join us for a panel discussion with the leaders of the C++ standards committee where the audience asks the questions. This we've got…


Fuzz or lose: why and how to make fuzzing a standard practice for C++ [MP4] [0:30:36] [2018/01/09]
Fuzzing is a family of testing techniques in which test inputs are generated semi-randomly. The memory unsafety of C++ has made fuzzing a popular tool among security researchers. Fuzzing also…


folly::Function: A Non-copyable Alternative to std::function[MP4] [0:31:17] [2018/01/09]
We have often found it limiting that std::function cannot store callable objects if they are not copyable, so we developed and open-sourced folly::Function, a function wrapper that can store move-only…


Enough x86 Assembly to Be Dangerous[MP4] [0:30:58] [2018/01/09]
This tutorial is an introduction to x86 assembly language aimed at C++ programmers of all levels who are interested in what the compiler does with their source code. C++ is a…


From security to performance to GPU programming: exploring modern allocators [MP4] [0:27:21] [2018/01/09]
Want to make fast linked lists? Want to store sensitive data in memory? Want to place std::unordered_map in thread-local memory? Shared memory? How about GPU memory? You can do that in today’s…


Migrating a C++03 library to C++11 case study: Wt 4[MP4] [0:24:03] [2018/01/09]
In this talk, we will describe the effort of migrating the API of a reasonably large open source library to C++11. During the migration we wanted to benefit from as many new C++…


C++ atomics, from basic to advanced. What do they really do?[MP4] [1:14:21] [2018/01/09]
C++11 introduced atomic operations. They allowed C++ programmers to express a lot of control over how memory is used in concurrent programs and made portable lock-free concurrency…


Enhanced Support for Value Semantics in C++17[MP4] [1:00:06] [2018/01/09]
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.…


Esoteric Data Structures and Where to Find Them[MP4] [0:30:04] [2018/01/09]
We already have array, vector, and unordered_map, what other data structures could we possibly need? As it turns out, there are a lot of them and they come from all areas of software! Curious to learn…


Building Better Worlds: Developing a Procedural City Tool for Alien: Covenant [MP4] [0:29:38] [2018/01/09]
When MPC was asked to create a massive CG city for the film Alien: Covenant, they looked to leverage procedural generation as a means for iterating on the overall shape and structure of the city, in…


Faster Delivery of Large C/C++ Projects with Conan Package Manager and Efficient Continuous…[MP4] [1:08:27] [2018/01/09]
Dependency information together with the smart management of binaries and binary compatibility of Conan package manager can be used to implement a modularized, fast and efficient Continuous…


A modern formatting library for C++[MP4] [1:00:54] [2018/01/09]
Come learn about the intricacies of C++ formatting, from stdio to iostream to the new standard proposal P0645R0: Text Formatting. The new proposal combines variadic templates with a…


An allocator model for std2[MP4] [0:57:15] [2018/01/09]
C++17 reserves the namespace std2 (and others) for future iterations of the standard library that may not be 100% compatible in design with the current namespace std. This session will suggest…


Deconstructing the OS: The devils In the side effects[MP4] [0:58:17] [2018/01/09]
IncludeOS is a library operating system, where your C++ application pulls in exactly what it needs and turns it into a bootable binary. But once you have your standalone program with standard…


Is Parallel Programming still hard? PART 2 of 2[MP4] [0:47:56] [2018/01/09]
Most embedded devices are multicore, and we see concurrency becoming ubiquitous for machine learning, machine vision, and self-driving cars. Thus the age of concurrency is upon us, so whether you like…


Is Parallel Programming still hard? PART 1 of 2[MP4] [0:59:27] [2018/01/09]
Most embedded devices are multicore, and we see concurrency becoming ubiquitous for machine learning, machine vision, and self-driving cars. Thus the age of concurrency is upon us, so whether you like…


Unicode Strings: Why the Implementation Matters[MP4] [0:58:49] [2018/01/09]
We will provide a brief overview including an explanation of what Unicode is, string terminology, and how Unicode supports non US languages. We will cover the pros and cons of various String formats…


When a Microsecond Is an Eternity: High Performance Trading Systems in C++[MP4] [1:00:06] [2018/01/09]
Automated trading involves submitting electronic orders rapidly when opportunities arise. But it’s harder than it seems: either your system is the fastest and you make the trade, or you get nothing.…


Almost Unlimited Modern C++ in Kernel-Mode Applications[MP4] [0:51:07] [2018/01/09]
Rian Quinn's "Making C++ and the STL Work in the Linux/Windows Kernels" from CppCon 2016 showed the difficulty of making C++ code work correctly in kernel mode. For some…


EAs Secret Weapon: Packages and Modules[MP4] [0:55:32] [2018/01/09]
A lot of people hate build systems. What if using a library was just as easy as header-only libraries? EA has had a Secret Weapon called “packages” for over 14 years. EA's Packages are like Ruby’s…


Time Travel Debugging: Root Causing Bugs in Commercial Scale Software [MP4] [1:00:34] [2018/01/09]
We’ve all heard horror stories about bugs that were near-impossible to root-cause, and many of us have at least a few stories of our own. Corrupted or uninitialized memory. Resource leaks. API misuse…


constexpr ALL the Things![MP4] [1:10:12] [2018/01/09]
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…


Coroutines: what can't they do?[MP4] [0:48:18] [2018/01/09]
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?…


Modern C++ Interfaces: Complexity, Emergent Simplicity, SFINAE, and Second Order Properties of Types[MP4] [0:56:28] [2018/01/09]
We examine how the increasing complexity of language features related to interfaces in modern C++ has somewhat surprisingly produced increasing simplicity in the interfaces themselves. One of…


C++ Development with Visual Studio Code[MP4] [1:00:55] [2018/01/09]
If you’re looking for a fast and lightweight code editor, Visual Studio Code has you covered. Come get an overview of Visual Studio Code along with the C++ extension that enables editing,…


The Quiet Little Gem in Modern C++: system_error[MP4] [1:13:44] [2018/01/09]
Amongst the loud fanfare of C++11 arrived this quiet little gem of <system_error>, with std::error_code and std::error_condition born from the heart of boost::asio. With Committee input they…


New standards to the rescue: the view through an IDEs glasses[MP4] [0:30:47] [2018/01/09]
We often talk about how new language features can help developers to write more accurate and concise code. There is another type of discussion to be had on how tools help leverage language issues and…


Latest & Greatest in Visual Studio for C++ developers[MP4] [1:01:37] [2018/01/09]
Visual Studio 2017 was released this year and brings all sort of new functionality for C++ developers on any platform, not just Windows. In this talk, we'll cover many of the new features of…


Which Machine Am I Coding To?[MP4] [0:49:16] [2018/01/09]
When writing a C++ program, we tend to think of the strengths and weaknesses of our computer, just as we think of our algorithms, data structures, and probably of language features we want to…


Programming with C++ Constraints: Background, Utility, and Gotchas[MP4] [1:02:49] [2018/01/09]
Compile-time constraints will likely soon become part of our routine C++ programming vocabulary. Why? Such constraints are induced by new core language features (requires-clauses and…


Designing (New) C++ Hardware[MP4] [0:59:56] [2018/01/09]
You can run C++ on any computer you want, as long as it pretends it is an 80’s computer. Conveniently most computers pretend to be 80’s computers – with extras, but nothing too radical –…


What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid[MP4] [1:15:45] [2018/01/09]
In 2012, Matt and a colleague were arguing whether it was efficient to use the then-new-fangled range for. During the discussion a bash script was written to quickly compile C++ source and…


Qt as a C++ Framework: History, Present State and Future[MP4] [1:30:04] [2018/01/09]
Qt is one of the largest and most widely used C++ frameworks. It is fully cross-platform, covering all functionality required to develop advanced graphical applications. The talk will go…


Meta: Thoughts on generative C++[MP4] [1:47:44] [2018/01/09]
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…


C++ as a "Live at Head" Language[MP4] [1:31:13] [2018/01/09]
Engineering is programming integrated over time. That is to say, as much as it can be difficult to get your code to build and run correctly, it is manifestly harder to keep it working in the face of…


Learning and Teaching Modern C++[MP4] [1:38:40] [2018/01/09]
We – attendees at CppCon – are all teachers. Some teach for a living; many occasionally teach a course or give a lecture; essentially all give advice about how to learn C++ or how to use…