Loading…
CppCon 2016 has ended

Log in to bookmark your favorites and sync them to your phone or calendar.

lecture [clear filter]
Monday, September 19
 

9:00am PDT

Keynote: The Evolution of C++: Past, Present, and Future
This is a philosophical talk. It deals with ideals, aims, and ways of approximating those. It deals with practical constraints and risks. It gives short examples. It presents a perspective of what drives the evolution of C++. What is C++ and what it must become over the next years for its success to continue? This involves both social and technical points. Towards the end, I discuss the direction of C++ future evolution, give some opinions, point to urgently needed new features, and discuss how to manage until they are part of the standard.

Speakers
avatar for Bjarne Stroustrup

Bjarne Stroustrup

Technical fellow, morgan stanley
C++: history, design, use, standardization, future; performance, reliability; software developer education;distributed systemsBio: www.stroustrup.com/bio.html


Monday September 19, 2016 9:00am - 10:45am PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center

11:00am PDT

Embracing Standard C++ for the Windows Runtime
Believe it or not, avoiding language extensions and embracing modern C++ will make it easier for you to write code for Windows. The Universal Windows Platform in Windows 10 provides the ability for developers to write apps for many devices in many languages. To achieve this goal, it uses the Windows Runtime platform technology to expose functionality from the operating system into languages, including C++. Microsoft wants to make the Windows Runtime naturally and easily available to standard C++ developers. "C++/WinRT" (formerly moderncpp.com) is a standard C++ library and toolset currently under development at Microsoft. It includes a standalone compiler, which converts Windows Runtime metadata into a header-only library. The source code uses standard syntax consumable by any C++ compiler, making it easier for developers to use Windows Runtime APIs from C++.

We will begin this session with the goals of the "C++/WinRT" project. We'll look at the primitives of the Windows Runtime ABI and how this C++ library provides a natural projection of those primitives. We'll look at how C++11 and C++14 language features make it easier to encapsulate the COM infrastructure that underpins the Windows Runtime. Finally, we'll look at how we've optimized the implementation and discuss how a handful of compiler optimizations can make this C++ library efficient and effective for building a wide range of applications.

Speakers
avatar for Kenny Kerr

Kenny Kerr

Microsoft
Kenny Kerr is an engineer on the Windows team at Microsoft, an MSDN Magazine contributing editor, Pluralsight author, and creator of moderncpp.com (C++/WinRT). He writes at kennykerr.ca and you can find him on Twitter at @kennykerr.
avatar for James McNellis

James McNellis

Principal Software Engineer, Microsoft Corporation
James McNellis is a Principal Software Engineer at Microsoft where he works on the Time Travel Debugging (TTD) reverse debugging toolkit. Prior to joining the Windows Debuggers team in 2016, he worked on the Visual C++ team and was responsible for the Microsoft C Runtime (CRT) and... Read More →


Monday September 19, 2016 11:00am - 12:00pm PDT
Kantner (Room 403) Meydenbauer Center

11:00am PDT

Instruction Re-ordering Everywhere: The C++ 'As-If' Rule and the Role of Sequence
This is an introductory (i.e., "First Principles") dive into instruction re-ordering (at compile-time, and at run-time) due to conspiring by the compiler and CPU to make most efficient use of execution units and resources within the CPU processor core. Discussion is made of the role for sequence, for tracing of data flows and control flows, how "out-of-order" execution occurs within the compiler and CPU, and why that's a "good thing". The importance of the C++ "As-If" rule that allows these optimizations is explained.

Exploration is made of imperative versus sequential devices, physical versus logical sequences, and the role of the CPU cache line. At the end of this talk, it will be obvious for how and why instruction re-ordering occurs, and the programmer's need to consider logical dependencies (and not instruction order) when defining algorithms.

This talk is ideal for any programmer confused after observing instruction reordering in their running systems, and provides a solid basis to begin reasoning about how to leverage parallelism and be concerned with concurrency.

Speakers
avatar for Charley Bay

Charley Bay

Charley Bay
Charley is a software developer with over three decades of experience using C++ in multiple regulated and high-performance fields focused on large-scale and distributed systems in performance-sensitive environments including time-sensitive processing of large data sets, performance... Read More →


Monday September 19, 2016 11:00am - 12:00pm PDT
Prince Theater (2nd Floor) Meydenbauer Center

11:00am PDT

Regular Expressions in C++, Present and Future
Regular expressions are widely used in application development and data processing, yet it is challenging to design and implement a regular expression library that is expressive, efficient and safe.

In this talk, Tim Shen, the current maintainer of libstdc++'s <regex>, will introduce the basics of implementing regular expressions in C++, the status of existing implementations, and what is expected from the standardization process.

For the implementation, several data structures and algorithms will be introduced, with pros and cons listed; we will show how several popular implementations (Boost.Regex, Boost.Xpressive, <regex> from standard library implementations, RE2, etc) pick their algorithms. Several popular features/patterns that hurt performance will be explained, with a "safe" regex usage suggested. Finally a wishlist of features will be presented, in order to deliver a more efficient and usable regex library.

Speakers
avatar for Tim Shen

Tim Shen

Software Engineer, Google
Tim Shen is a compiler engineer in Google LLVM team. His major focus is the performance of C++ on various LLVM backends. He also maintains libstdc++'s .


Monday September 19, 2016 11:00am - 12:00pm PDT
White (Room 407) Meydenbauer Center
  lecture

11:00am PDT

WG21-SG14 – Making C++ better for games, embedded and financial developers
SG14 is the ISO C++ study group dedicated to programmers in the games, embedded and financial domain, focusing on a particular subset of use-cases: low-latency, real-time requirements and performance/efficiency. Convened in June 2015, it is the newest addition to the WG21 Study Group family, and it is the first to focus on an industrial domain rather than on a particular aspect of software development. We need your input: learn why and how at this talk.

With a thriving google group and regular, well attended teleconferences, several areas of investigation are subject to research. Expect discussion on cache-coherent containers, fixed-point representation, heterogeneous programming, and of course exception handling, as well as one or two diversions into the history of game development.

You may even come away with a desire to join this or any of the other study groups, and contribute ideas and papers to improve the language.

Speakers
avatar for Guy Davidson

Guy Davidson

Principal Coding Manager, Creative Assembly
avatar for Nicolas Guillemot

Nicolas Guillemot

MSc Student, University of Victoria
Nicolas is a master's student at the University of Victoria, where he searches for solutions to the game industry's real-time rendering problems at the intersection of software and hardware. In the past, Nicolas has worked at Electronic Arts, and in Intel's Visual and Parallel Computing... Read More →
SM

Sean Middleditch

Lead Engineer, Wargaming Seattle
I make games.
avatar for Michael Wong

Michael Wong

DE, Codeplay
wongmichael.com/about


Monday September 19, 2016 11:00am - 12:00pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

2:00pm PDT

Cache Optimised Hash library
Hashes and caches, why another hash library ?
Problems,shortcomings and advantages of current open source hash libraries. Includes split between open and closed addressing methods and how these can be combined to give a better solution without much trade off by exploiting the strengths of each.

Benchmarks
Benchmarks of the library with high and medium entropy data, mostly pictures.

Analogies
A short description of the algorithms employed and why they work. This will include a short history of the library and why certain design decisions where made. Use of the birthday problem to model the low memory use evident from the benchmarks.

Practical uses
Demonstrate use cases of the library in treestore MySQL storage engine. Uses include concurrent version control algorithms and a mostly lock free allocation pool. This will include a short session with facebook link bench to illuminate possible advantages.

Speakers
avatar for Christiaan Pretorius

Christiaan Pretorius

Technical Lead, Retro Rabbit
Writer maintainer of treestore MySQL storage Engine and Rabbit hash table library. https://github.com/tjizep/treestore \rabbit


Monday September 19, 2016 2:00pm - 3:00pm PDT
White (Room 407) Meydenbauer Center
  demonstration  lecture

2:00pm PDT

C++17 in Breadth (part 1 of 2)
This talk will cover every feature addition, removal, and change in the next version of the C++ standard, provisionally going by the name C++17. Covering both the language and the library, the coverage of any given feature must necessarily brief. The goal is to come away with an understanding of what each feature is, and why you might want to use it, with an overall impression of how the new language might fit together. It is not intended to be an detailed tutorial on any individual feature, but rather, a jumping off point for further sessions on the topics that seem most interesting.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

Senior Developer, BloombergLP
Alisdair Meredith is a software developer at BloombergLP in New York, and the C++ Standard Committee Library Working Group chair.He has been an active member of the C++ committee for just over a decade, and by a lucky co-incidence his first meeting was the kick-off meeting for the... Read More →


Monday September 19, 2016 2:00pm - 3:00pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

2:00pm PDT

Standards Proposals for SG6 - Integers
This presentation describes the necessity, utility and usage for a library of safe integer types.  These types function in all respects the same way as built-in integers, but guarantee that no integer expression will return an incorrect result.  The library can be reviewed at the boost library incubator.

Speakers
avatar for John McFarlane

John McFarlane

Senior Software Engineer, Jaguar Land Rover
John McFarlane is co-chair of SG14 and writes numeric types for fun. His expertise is in games development and automotive and he currently works at the rapidly expanding Jaguar Land Rover center for software excellence in idyllic Co Clare, Ireland with his beautiful wife and horrible... Read More →
avatar for Robert Ramey

Robert Ramey

Software Developer, Robert Ramey Software Development
Robert Ramey is a freelance Software Developer living in Santa Barbara, California. (See www.rrsd.com.)  His long and varied career spans various aspects of software development including business data processing, product, embedded systems, custom software, and C++ library development. Lately, he has been mostly interested in C++ library design and implementation related to Boost... Read More →


Monday September 19, 2016 2:00pm - 3:00pm PDT
Robinson (Room 409) Meydenbauer Center
  lecture

2:00pm PDT

What is the basic interface? (part 1 of 2)
When we read a function declaration, what expectations do we have of the function? What requirements and limitations do we take for granted? Our unspoken assumptions about function interfaces present an obstacle to precise reasoning about programs.

Here, I will delve into the nitty-gritty procedural logic of function calls in C++, with particular emphasis on the things that often go without saying. I will present some suggestions about how we can make these implicit expectations precise, and how we can express deviation from these expectations in current and future versions of C++.

This material was previously presented at C++Now 2016, where it was named best presentation. It is a companion to my C++Now 2015 talk, "How we reason about procedural programs," but no knowledge of that material will be necessary.

Speakers
avatar for Lisa Lippincott

Lisa Lippincott

Software Architect, Tanium
Lisa Lippincott designed the software architectures of Tanium and BigFix, two systems for managing large fleets of computers. She's also a language nerd, and has contributed to arcane parts of the C++ standard. In her spare time, she studies mathematical logic, and wants to make computer-checked... Read More →


Monday September 19, 2016 2:00pm - 3:00pm PDT
Kantner (Room 403) Meydenbauer Center
  lecture

3:15pm PDT

C++17 in Breadth (part 2 of 2)
This talk will cover every feature addition, removal, and change in the next version of the C++ standard, provisionally going by the name C++17. Covering both the language and the library, the coverage of any given feature must necessarily brief. The goal is to come away with an understanding of what each feature is, and why you might want to use it, with an overall impression of how the new language might fit together. It is not intended to be an detailed tutorial on any individual feature, but rather, a jumping off point for further sessions on the topics that seem most interesting.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

Senior Developer, BloombergLP
Alisdair Meredith is a software developer at BloombergLP in New York, and the C++ Standard Committee Library Working Group chair.He has been an active member of the C++ committee for just over a decade, and by a lucky co-incidence his first meeting was the kick-off meeting for the... Read More →


Monday September 19, 2016 3:15pm - 4:15pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

3:15pm PDT

Colonies, performance and why you should care
In game development and many other high-performance, highly-modular development architectures, maintaining valid references to container elements regardless of erasure and insertion is often crucial. While there are many workarounds for this, typically using std::vector<> with various methods to avoid invalidation, to date there exist no generalized solutions to the problem which also provide strong cache performance.

plf::colony<>, a proposed unordered container class from the SG14 working group, is one attempt to remedy this situation: it provides fast insertion, erasure and iteration performance while maintaining pointer stability to non-erased elements, which is unaffected by both insertion and erasure.

In this talk we’ll explore both the structure and comparative performance of plf::colony<>, contrasting it with other standard library containers and their potential modifications, showing how it can outperform many typical alternatives where large amounts of insertions and erasures are concerned. This will include details on:


If you’re not interested in new containers, you may still pick up a few concepts to help you with improving your own implementations and high-performance C++ code. If you are interested in better containers, or better container usage, you should definitely attend this talk.

Speakers
avatar for Matthew Bentley

Matthew Bentley

Computer Engineer
Matt Bentley was born in 1978 and never recovered from the experience. He started programming in 1986, completing a BSc Computer Science 1999, before spending three years working for a legal publishing firm, getting chronic fatigue syndrone, quitting, building a music studio, recovering... Read More →


Monday September 19, 2016 3:15pm - 4:15pm PDT
White (Room 407) Meydenbauer Center
  lecture

3:15pm PDT

Latest and Greatest from the Visual Studio Family for C++ Developers
In this session, we’ll cover what’s new in the last year in the Visual Studio updates and our cross platform editor and debugger, VS Code. We’ll talk about and demo the features that are coming in the next version of Visual Studio and VS Code. This will include our ongoing roadmap for compiler and library conformance, major (and massive) improvements in performance and code quality and how to get the most out of it. We'll also cover cross platform development including Linux, Mac, iOS, and Android, and demo all the latest productivity features for C++ developers.

Speakers
avatar for Steve Carroll

Steve Carroll

Director of Development, Microsoft
Steve Carroll is the dev manager for the Visual C++ team and previously the dev manager for the Visual Studio debuggers and profilers.
avatar for Daniel Moth

Daniel Moth

Group Program Manager, Microsoft
Visual Studio


Monday September 19, 2016 3:15pm - 4:15pm PDT
Frey (Room 406) Meydenbauer Center
  lecture

3:15pm PDT

Parallelism in Modern C++
The traditionally used and well established parallel programming models OpenMP and MPI are both targeting lower level parallelism and are meant to be as language agnostic as possible. For a long time, those models were the only widely available portable options for developing parallel C++ applications beyond using plain threads. This has strongly limited the optimization capabilities of compilers, has inhibited extensibility and genericity, and has restricted the use of those models together with other, modern higher level abstractions introduced by the C++11 and C++14 standards.
The recent revival of interest in the industry and wider community for the C++ language has also spurred a remarkable amount of standardization proposals and technical specifications being developed. Those efforts however have so far failed to build a vision on how to seamlessly integrate various types of parallelism, such as iterative parallel execution, task-based parallelism, asynchronous many-task execution flows, continuation style computation, or explicit fork-join control flow of independent and non-homogeneous code paths.

In this talk we present the results of developing higher level parallelization facilities in HPX, a general purpose C++ runtime system for applications of any scale. The developed higher-level parallelization APIs have been designed aiming at overcoming the limitations of today's prevalently used programming models in C++ codes.
HPX exposes a uniform higher-level API which gives the application programmer syntactic and semantic equivalence of various types of on-node and off-node parallelism, all of which are well integrated into the C++ type system. We show that these higher level facilities are fully aligned with modern C++ programming concepts, they are easily extensible, fully generic, and enable highly efficient parallelization on par with or better than what existing equivalent applications based on OpenMP and/or MPI can achieve.

Speakers
HK

Hartmut Kaiser

STE||AR Group, CCT/LSU
Hartmut is a member of the faculty at the CS department at Louisiana State University (LSU) and a senior research scientist at LSU's Center for Computation and Technology (CCT). He received his doctorate from the Technical University of Chemnitz (Germany) in 1988. He is probably best... Read More →


Monday September 19, 2016 3:15pm - 4:15pm PDT
Prince Theater (2nd Floor) Meydenbauer Center

3:15pm PDT

What is the basic interface? (part 2 of 2)
When we read a function declaration, what expectations do we have of the function? What requirements and limitations do we take for granted? Our unspoken assumptions about function interfaces present an obstacle to precise reasoning about programs.

Here, I will delve into the nitty-gritty procedural logic of function calls in C++, with particular emphasis on the things that often go without saying. I will present some suggestions about how we can make these implicit expectations precise, and how we can express deviation from these expectations in current and future versions of C++.

This material was previously presented at C++Now 2016, where it was named best presentation. It is a companion to my C++Now 2015 talk, "How we reason about procedural programs," but no knowledge of that material will be necessary.

Speakers
avatar for Lisa Lippincott

Lisa Lippincott

Software Architect, Tanium
Lisa Lippincott designed the software architectures of Tanium and BigFix, two systems for managing large fleets of computers. She's also a language nerd, and has contributed to arcane parts of the C++ standard. In her spare time, she studies mathematical logic, and wants to make computer-checked... Read More →


Monday September 19, 2016 3:15pm - 4:15pm PDT
Kantner (Room 403) Meydenbauer Center
  lecture

4:45pm PDT

#Include : from bootloader to REST API with the new C++
IncludeOS is a brand new open source library operating system that turns your modern C++ source code into a minimal, self contained virtual machine. No Linux inside, just your service and whatever your service needs from the operating system library. Creating the virtual machine is just as fast as compiling a binary and the resulting virtual machine image can run unchanged on Linux, Windows or Mac.

Early in the design process we made a hard choice; no C interfaces and no blocking POSIX calls. We’ve done everything from scratch with modern C++ 11/14 - Including device drivers and the complete network stack all the way through ethernet, IP and ARP, up to and including UDP, TCP and recently also an http / REST API framework. To achieve maximum efficiency we decided to do everything event based and async, so there's plenty of opportunities to use lambdas and delegates.

In this talk you’ll get the first overview of our first feature-complete release and the first application built with IncludeOS. We’ll show you what we’re proud of and what we’d like your help to improve. And of course, we’ll show you how to write an application for IncludeOS, deploy it locally on your PC or in an IaaS cloud such as OpenStack, and then hook it up to the internet.

Speakers
avatar for Alfred Bratterud

Alfred Bratterud

CEO, IncludeOS
MSc. in mathematical logic from the dept. of Informatics, University of Oslo. Employed since 2011 as Assistant professor at Oslo and Akershus University College of Applied science, the largest institution for engineering education in Norway , where I taught an undergrad course in... Read More →


Monday September 19, 2016 4:45pm - 5:45pm PDT
Kantner (Room 403) Meydenbauer Center

4:45pm PDT

Beyond the Issaquah Challenge: High-Performance Scalable Complex Updates
Highly performant and scalable techniques such as RCU have been quite successful in read-mostly situations. However, there do come times when updates are necessary. It would be convenient if there was some general update-side counterpart to RCU, but sadly there is not yet any such thing. Nevertheless, there are a number of specialized update-side techniques whose performance and scalability rival that of RCU. This talk will discuss several of them and provide an outlook into the future of low-overhead scalable updates.

One technique is the solution to the Issaquah Challenge, which was put forward at the C++ standards committee meeting in early 2014 at Issaquah, WA, USA. This challenge requires a performant and scalable technique to atomically move elements back and forth between a pair of search trees, but without using transactional memory. This talk will give an overview of a solution to a more general problem, that of atomically moving groups of elements among a group of several different types of linked data structures, including simple linked lists, hash tables, and skiplists, while still permitting lockless searches before, during, and after this atomic move.

Speakers
PE

Paul E. McKenney

Software Engineer, Facebook
Paul E. McKenney has been coding for almost four decades, more than half of that on parallel hardware, where his work has earned him a reputation among some as a flaming heretic. Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present... Read More →


Monday September 19, 2016 4:45pm - 5:45pm PDT
Frey (Room 406) Meydenbauer Center

4:45pm PDT

High Performance C++ Concurrent Transactional Data Structures: Concept, Design, and Implementation
The field of computer science is ever evolving. Not long ago, software developers were able to get "free" performance upgrades with every bit of advancement in CPU architectures. Frequency boost, cache capacity increase, and more sophisticated pipeline all brought significant performance improvements in sequential execution. Now computing has hit the power wall and the performance of a single core has been pushed past the point of diminishing returns. The hardware design begins to shift towards massive parallelism on both chip level. Exploiting thread level parallelism is thus essential for software developers. C++ provides the capability to operate on powerful hardware synchronization primitives such as compare_and_swap, which is indispensable for building concurrent libraries to facilitate the development of high-performance parallel applications.

With the growing availability of concurrent libraries such Boost.Lockfree, Intel TBB, and LibCDS, more and more programmers embrace the concept of lock-free programming. Lock-free data structures provides scalable thread-safe concurrent accesses and guarantee that at any moment at least one thread will make progress. Compared with traditional lock-based approaches, lock-free algorithms utilize fine-grained synchronizations and tolerate thread faults. However, none of the existing lock-free data structures supports transactions yet, which require that a sequence of method calls on the data structures appears to complete in an atomic step and in isolation with regards to other ongoing transactions. Because of this, the users of lock-free libraries who need transaction executions often are forced to fall back to coarse-grained locking which has a negative impact on performance and annihilates the non-blocking progress guarantee provided by the libraries. We propose a holistic approach for developing future non-blocking transactional data structures — an open source library of transactional data structures based on existing non-blocking data structures.
This library will be built on three of the presenters' research works: 1) multi-resource lock (MRLock), which is a scalable lock manager with efficient FIFO conflict revolve scheme; 2) lock-free transactional transformation (LFTT), which is a methodology for transforming high-performance lock-free base data structures into high-performance lock-free transactional data structures; and 3) multi-dimensional linked list (MDList), which is a novel logarithmic search data structure optimized for concurrent accesses.

In the session, we will discuss two strategies for implementing scalable transactional data structures using both locks and lock-free synchronizations. The locking strategy employs MRLock, which is a novel shared-memory resource allocation lock for multi-core processors. It uses a lock-free FIFO queue to manage locking requests in batches, which minimizes memory contention among threads. It is fast and designed as a drop-in replacement for the two-phase locking methods in C++11 and Boost library (std::lock() and boost::lock()). When combined with existing lock-based transaction synchronization techniques such as semantic locking and transaction boosting, it can be used by programmers who prefer lock-based code to implement high-performance transactional data structures on familiar grounds. The lock-free strategy is based on lock-free transactional transformation (LFTT), which uses transaction descriptor object to announce the transaction globally so that delayed threads can be helped. It is applicable to linked data structures such as linked lists and skip lists. The logical status of any node in the data structure depends on the status of the transaction descriptor that was embedded in it. Conflict transactions do not need to revert their operations as required in some of the existing methodologies. We will demonstrate the application of this strategy to existing lock-free lists and skip lists.

We will also introduce a lock-free logarithmic search data structure based on multi-dimensional linked list. This brand new data structure is designed from ground up to achieve full potential for concurrent accesses. It has a distributed memory layout which alleviates contention. Write operations modify at most two nodes so interference among operations are brought down to a minimum. This data structure implements the collection/dictionary abstract data type, which is ubiquitous in modern applications. When combined with the above mentioned transactional strategies, this work could greatly benefit application developers who deal with data intensive scenarios such as in memory databases.


Preliminary version of source code can be accessed from https://ucf-cs.github.io/tlds/. The research work mentioned in this presentation can be accessed from http://cse.eecs.ucf.edu/bios/delizhang.html.

Speakers
DD

Damian Dechev

Associate Professor, University of Central Florida
Dr. Damian Dechev is an Assistant Professor at the EECS Department at the University of Central Florida and the founder of the Computer Software Engineering - Scalable and Secure Systems Lab at UCF. He specializes in the design of scalable multiprocessor data structures and algorithms... Read More →
avatar for Deli Zhang

Deli Zhang

Software Development Engineer, Microsoft
Deli Zhang received his Ph.D. in Computer Science at the University of Central Florida. He worked as a research assistant under the guidance of Dr. Damian Dechev. Deli specializes in developing non-blocking data structures and algorithms, applying non-blocking synchronization in existing... Read More →



Monday September 19, 2016 4:45pm - 5:45pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center

4:45pm PDT

My Little Optimizer: Undefined Behavior is Magic
Compiler exploitation of undefined behavior has been a topic of recent discussion in the programming community. This talk will explore the magic of Undefined Behavior, Covering how and why modern optimizers exploit undefined behavior in C++ programs.

Speakers
avatar for Michael Spencer

Michael Spencer

Compiler Engineer, Apple


Monday September 19, 2016 4:45pm - 5:45pm PDT
White (Room 407) Meydenbauer Center
  lecture

4:45pm PDT

variant: Past, Present and Future
What are variants, why are they important, and how I use them? Once available to a developer, variants become one of the most commonly used tools in everyday programming. This talk will explore the venerable Boost.Variant library, discuss the improvements made by C++17’s std::variant<>, and close with a discussion of the exciting new language-based variant and pattern matching papers (proposed for C++20). This talk aims to be of practical utility in variant library usage and informative as to where things are heading.

Speakers
avatar for David Sankel

David Sankel

Bloomberg
David Sankel is a Software Engineering Manager/TL at Bloomberg and an active member of the C++ Standardization Committee. His experience spans microservice architectures, CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography... Read More →


Monday September 19, 2016 4:45pm - 5:45pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture
 
Tuesday, September 20
 

9:00am PDT

An Introduction to C++ Coroutines
One of the most interesting new features being proposed for C++ standardization is coroutines, formerly known as “resumable functions”. C++ coroutines are designed to be highly scalable, highly efficient (no overhead), and highly extensible, while still interacting seamlessly with the rest of the C++ language.

This session will consist of an in-depth introduction to C++ coroutines. We will begin by looking at the rationale for adding coroutines to the C++ language. We will then demonstrate and explain a sequence of coroutines that gradually introduce the features of C++ coroutines. This part of the talk will show both how to write various forms of coroutines and also how the coroutines extensibility model enables existing libraries to be non-invasively adapted to work with C++ coroutines.

Speakers
avatar for James McNellis

James McNellis

Principal Software Engineer, Microsoft Corporation
James McNellis is a Principal Software Engineer at Microsoft where he works on the Time Travel Debugging (TTD) reverse debugging toolkit. Prior to joining the Windows Debuggers team in 2016, he worked on the Visual C++ team and was responsible for the Microsoft C Runtime (CRT) and... Read More →


Tuesday September 20, 2016 9:00am - 10:00am PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

9:00am PDT

High Performance Code 201: Hybrid Data Structures
Modern programs’ performance characteristics are often dictated by their data. Whether the cache locality of data access, the size of working set, or avoiding costly memory allocation overhead. Unfortunately, the standard C++ library data structures range from adequate to terrible at controlling these aspects, and they don’t provide any of the core mechanisms needed for extremely efficient data structure design.

This talk will present the core concepts of designing high performance data structures in C++. It is based on years of experience in the LLVM compiler as well as several other large code bases. From these principles, the talk will propose a suite of data structures that provide performance without loss of generality or functionality. As much as this talk will present specific data structure designs, its primary intent will be to give an understanding of what makes these structures have greater performance than more naive approaches.

Speakers
avatar for Chandler Carruth

Chandler Carruth

Software Engineer, Google
Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is... Read More →


Tuesday September 20, 2016 9:00am - 10:00am PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center

9:00am PDT

SPMD Programming Using C++ and ISPC
Love writing blazing fast SIMD code on CPU? Tired of dealing with ugly intrinsics and clumsy SIMD float4 classes? Has your compiler's auto-vectorization ever stopped working, causing unpredictable performance regressions? Wish you could write efficient SIMD code without locking yourself into a specific instruction set, while still taking advantage of a range of hardware from old desktops to new Intel Xeon Phi rigs?

The solution is here, and it's called SPMD!

SPMD is an elegant parallel programming technique for writing SIMD code, which automates the tedious constructions normally required when using intrinsics or assembly, breaks free of ties to specific instruction sets, and still allows you to work at the granularity of SIMD vectors when necessary.

This talk will first review the underlying theory of SPMD, then introduce the ISPC programming language as an example of what SPMD code looks like. We'll also look at how SPMD is used on GPUs like AMD's GCN. Finally, we will see how SPMD code can be written in unextended C++.

Speakers
avatar for Nicolas Guillemot

Nicolas Guillemot

MSc Student, University of Victoria
Nicolas is a master's student at the University of Victoria, where he searches for solutions to the game industry's real-time rendering problems at the intersection of software and hardware. In the past, Nicolas has worked at Electronic Arts, and in Intel's Visual and Parallel Computing... Read More →


Tuesday September 20, 2016 9:00am - 10:00am PDT
Frey (Room 406) Meydenbauer Center
  lecture

9:00am PDT

std::accumulate: Exploring an Algorithmic Empire
What is the most powerful algorithm in the STL? In the world? There are many cases to be made. But this talk explores what I think is a pretty good candidate, which C++ calls std::accumulate(). Tucked away in <numeric>, perhaps relatively unregarded when compared with workhorses like std::find_if() and std::partition(); nevertheless, std::accumulate() is in some sense the ur-algorithm on sequences.

Let’s explore the result of looking at code through an accumulate-shaped lens, how tweaking the algorithm for better composability can unlock many more uses, and how it can be further genericized with applications to parallelism, tree structures, and heterogeneous sequences.

std::accumulate(): it’s not just for adding things up!

Speakers
avatar for Ben Deane

Ben Deane

Quantlab
Ben was in the game industry for 23 years, at companies like EA and Blizzard. For the last couple of years he's been working in the finance industry at Quantlab. He's always looking for useful new techniques in C++, and he geeks out on algorithms, APIs, types and functional progr... Read More →


Tuesday September 20, 2016 9:00am - 10:00am PDT
White (Room 407) Meydenbauer Center
  lecture

9:00am PDT

The Exception Situation
Exceptions have been a part of C++ for a long time now, and they are not going away. They allow programmers to concentrate on the meaningful parts of their code and treat the things that happen infrequently as… well, exceptional situations, to be dealt with when and where the context makes it reasonable or useful.

On the other hand, some significant parts of the C++ programming community either dislike this mechanism or outright reject it, for a number of reasons. Work in SG14 has raised performance issues in some cases; there are those who dislike the additional execution paths introduced in programs that rely on exceptions; some programmers raised issues with respect to exceptions and tooling, integration with older codebases, writing robust generic code, etc.

This talk will be neither for not against exceptions. It will present a perspective on cases where they make sense, cases where they are less appropriate, alternative disappointment handling techniques presented along with client code in order to show how the various approaches influence the way code is written. Performance measurements will be given along the way. Some creative uses of exceptions will also be presented in order to spark ideas and discussions in the room.

Speakers
avatar for Patrice Roy

Patrice Roy

Professeur, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 25 years. After a few years doing R&D and working on military flight simulators, he moved on to academics and has been teaching computer science since 1998. Since 2005, he’s... Read More →


Tuesday September 20, 2016 9:00am - 10:00am PDT
Kantner (Room 403) Meydenbauer Center
  lecture

9:00am PDT

Two practical applications of the Brigand TMP library
Metaprogramming isn’t always easy to apprehend and the purpose of this talk is to show through the resolution of two real life problems where it can be applied to increase productivity and reliability. The first case study will exhibit how we can use TMP to allocate at compile time the required memory for serializing simple structures such as a pair of integers. The second case study will be about generating a memory layout for array of structures perfectly fit for the targeted platform. The examples are based on the Brigand TMP library and will be an opportunity to see how MP constructs such as collection of types and compile time algorithms are made and when they should be used. The talk might contain obscure jokes related to pastries naming.

Speakers
avatar for Edouard Alligand

Edouard Alligand

CEO, quasardb
Edouard has more than thirteen years of professional experience in software engineering. After years hacking the kernel of various operating systems, Edouard founded Bureau 14, the home of the hyperscalable database quasardb. Combining an excellent knowledge of low level programming... Read More →
avatar for Joel Falcou

Joel Falcou

CTO, Numscale
Joel Falcou is NumScale CTO. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems. He is also an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique... Read More →


Tuesday September 20, 2016 9:00am - 10:00am PDT
Robinson (Room 409) Meydenbauer Center

10:30am PDT

Keynote: extern "C": Talking to C Programmers About C++
Most of us have heard this story. We’ve even told it ourselves…

C++ is nearly all of C, plus a whole lot more. Migrating code from C to C++ is pretty easy. Moreover, the migration itself can yield immediate benefits by exposing questionable type conversions that can be sources of latent bugs. After migration, the code performs as well in C++ as in the original C. And now that it’s C++, you have ready access to a wealth of advanced features you can (but don’t have to) use to implement enhancements.

Who wouldn’t want that? Legions of C programmers, apparently.

Despite the success of C++ in numerous application domains, C remains considerably more popular, especially in embedded, automotive, and aerospace applications. In many cases, projects resist C++ because their managers think the risks outweigh the benefits. In other cases, the resistance comes from programmers who persist in believing bad things about C++, even when those things aren’t true.

What can the C++ community do to overcome this resistance? Drawing on lessons from cognitive science, linguistics and psychology, and (of course) computer science, this talk offers suggestions about how to make the case for C++ more persuasive to C programmers.

Speakers
avatar for Dan Saks

Dan Saks

President, Saks & Associates
Dan Saks is the president of Saks & Associates, which offers training and consulting in C and C++ and their use in developing embedded systems. Dan used to write the “Programming Pointers” column for embedded.com online. He has also written columns for numerous print publications... Read More →


Tuesday September 20, 2016 10:30am - 12:00pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center

12:30pm PDT

Debugging In the Large
In 2009, Microsoft published the paper "Debugging in the (Very) Large", which describes Microsoft's Windows Error Reporting (WER), a post-mortem investigation platform.  We'll go in-depth into the design of their system, its benefits, and noted shortcomings. To finish things off, we'll talk through available third-party systems and the benefits they can provide. 

Speakers
avatar for Abel Matthew

Abel Matthew

CEO/ Co-Founder, Backtrace I/O
Abel is a co-founder of Backtrace, a startup focused on improving the way software is debugged. Prior to Backtrace, Abel spent way too much time debugging (and writing) software at Appnexus, IBM and being a server monkey at AMD. Abel enjoys jazz, long walks on concrete sidewalks... Read More →


Tuesday September 20, 2016 12:30pm - 1:00pm PDT
Kantner (Room 403) Meydenbauer Center

2:00pm PDT

Advanced Levelization Techniques (part 1 of 3)
Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, one also needs a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. In this talk we begin by briefly reviewing the basics of physical design. We then present a variety of levelization and Insulation techniques, and apply them in present-day, real-word examples to avoid cyclic, excessive, or otherwise inappropriate dependencies. Along the way, we comment on how to make the best use of what the C++ language has to offer.

Speakers
avatar for John Lakos

John Lakos

Software Engineer, Bloomberg Lp
John Lakos, author of Large-Scale C++ Software Design, serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide.  He is also an active voting member of the C++ Standards Committee’s Evolution Working Group. Previously, Dr... Read More →


Tuesday September 20, 2016 2:00pm - 3:00pm PDT
White (Room 407) Meydenbauer Center

2:00pm PDT

C++ Coroutines: Under the covers
Coroutines feel like magic. Functions that can suspend and resume in the middle of the execution without blocking a thread! We will look under the covers to see what transformations compilers perform on coroutines, what happens when a coroutine is started, suspended, resumed or cancelled. We will look at optimizations that can make a coroutine disappear into thin air.

Speakers
avatar for Gor Nishanov

Gor Nishanov

Software Engineer, Microsoft
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.


Tuesday September 20, 2016 2:00pm - 3:00pm PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

2:00pm PDT

The Continuing Future of Concurrency in C++
An overview of the additions to the standard C++ concurrency libraries in the Technical Specifications for Concurrency and Parallelism and the C++14 and C++17 standards. These additions include: continuations, latches, barriers, atomic smart pointers, shared ownership mutexes, executors, concurrent queues, distributed counters, coroutines, parallel algorithms and more.

Speakers
avatar for Anthony Williams

Anthony Williams

Just Software Solutions Ltd
Anthony Williams is the author of C++ Concurrency in Action.


Tuesday September 20, 2016 2:00pm - 3:00pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

2:00pm PDT

Towards Heterogeneous Programming in C++
Current semiconductor trends show a major shift in computer system architectures towards heterogeneous systems that combine a CPU with other processors such as GPUs, DSPs and FPGAs; that work together, performing different tasks in parallel. This shift has brought a dramatic change in programming paradigms in the pursuit of a common language that will provide efficiency and performance portability across these systems. A wide range of programming languages and models has emerged over the last decade, all with this goal in their sights, and the trend is converging on C++ as the language of choice.

This new world of heterogeneous systems brings with it many new challenges for the C++ community and for the language itself, and if these were to be overcome then C++ would have the potential to standardize the future of heterogeneous programming. In fact this work has already begun in SG14 in form of a mandate to support massive parallel dispatch for heterogeneous devices in the C++ standard using recent models such as SYCL and HPX. A recent approach to solving these challenges comes in the form of SYCL, a shared-source C++ programming model for OpenCL. SYCL takes a very different approach from many before it, in that it is specifically designed to be standard C++ without any extensions to the language.

This talk will present the recent rise in demand for heterogeneous programming in C++ and the new challenges that this brings to the C++ community. It will then take a look at some of the different programming languages and models that have arrived in the heterogeneous landscape, the motivations behind them, how they have attempted to solve those challenges and what we can learn from them. Finally it will take a look at the future of heterogeneous programming in C++ and what that might look like.

Speakers
avatar for Gordon Brown

Gordon Brown

Software Engineer, Codeplay Software
Gordon Brown is a software engineer specializing in SYCL technologies and has been involved in the standardization of the Khronos standard and the development of Codeplay's implementation from it's inception.
avatar for Michael Wong

Michael Wong

DE, Codeplay
wongmichael.com/about


Tuesday September 20, 2016 2:00pm - 3:00pm PDT
Kantner (Room 403) Meydenbauer Center
  lecture

2:00pm PDT

Want fast C++? Know your hardware!
As C++ evolves, it provides us with better and more powerful tools for optimal performance. But often, knowing the language very well is not enough. It is just as important to know your hardware. Modern computer architectures have many properties that can impact the performance of C++ code, such as cache locality, cache associativity, true and false sharing between cores, memory alignment, the branch predictor, the instruction pipeline, denormals, and SIMD. In this talk, I will give an overview over these properties, using C++ code. I will present a series of code examples, highlighting different effects, and benchmark their performance on different machines with different compilers, sometimes with surprising results. The talk will draw a picture of what every C++ developer needs to know about hardware architecture, provide guidelines on how to write modern C++ code that is cache-friendly, pipeline-friendly, and well-vectorisable, and highlight what to look for when profiling it.

Speakers
avatar for Timur Doumler

Timur Doumler

JUCE Senior Software Engineer, ROLI Ltd.
Timur Doumler is Senior Software Developer at London-based technology company ROLI. He is currently working on JUCE, the leading cross-platform framework for creating audio applications used by hundreds of companies in the audio industry. After five years of writing high-performance... Read More →


Tuesday September 20, 2016 2:00pm - 3:00pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

3:15pm PDT

What happened to...: Deprecated and Removed Features of C++
Removing a feature from a programming language can be difficult. The amount of code that will no longer compile is always weighed against whether the language provides a better alternative with an easy migration path. For the next C++ standard, quite a few features have been removed or deprecated. From auto_ptr and binary_function to register and trigraphs, this talk will present the motivation for removing and deprecating features in C++ as well as the alternatives that may be used.

Speakers
avatar for Billy Baker

Billy Baker

Software Architect, FlightSafety International
Billy Baker has developed deterministic real-time flight simulation software using C++ for FlightSafety International, Evans and Sutherland and Boeing since 1997. At C++ committee meetings, he can be found in library groups including chairing SG18, Library Evolution Working Group... Read More →


Tuesday September 20, 2016 3:15pm - 3:45pm PDT
Kantner (Room 403) Meydenbauer Center
  lecture

3:15pm PDT

What We've Learned From the C++ Community
For over a year and a half Rob and Jason have been engaging with the speakers, library authors, bloggers and luminaries of the C++ community for their podcast, CppCast. In this talk they'll share the most interesting tools, insights and lessons they have learned from interviewing and interacting with the C++ community

Speakers
avatar for Robert Irving

Robert Irving

Host, CppCast
avatar for Jason Turner

Jason Turner

Owner, Jason Turner
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 →


Tuesday September 20, 2016 3:15pm - 3:45pm PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

3:15pm PDT

Advanced Levelization Techniques (part 2 of 3)
Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, one also needs a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. In this talk we begin by briefly reviewing the basics of physical design. We then present a variety of levelization and Insulation techniques, and apply them in present-day, real-word examples to avoid cyclic, excessive, or otherwise inappropriate dependencies. Along the way, we comment on how to make the best use of what the C++ language has to offer.

Speakers
avatar for John Lakos

John Lakos

Software Engineer, Bloomberg Lp
John Lakos, author of Large-Scale C++ Software Design, serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide.  He is also an active voting member of the C++ Standards Committee’s Evolution Working Group. Previously, Dr... Read More →


Tuesday September 20, 2016 3:15pm - 4:15pm PDT
White (Room 407) Meydenbauer Center

3:15pm PDT

Bringing Clang and C++ to GPUs: An Open-Source, CUDA-Compatible GPU C++ Compiler
GPU computing has gone mainstream. It is a dominant part of the performance landscape, providing the initial 10x performance lift to a wide variety of applications. However, programing for GPUs can be extremely challenging. C++ is rarely available in an unmodified form, and there are few portable and open source approaches available. One of the most popular platforms, CUDA, has no production quality open source implementation. As a consequence, its C++ support has lagged behind and it has been a less appealing area for researchers and others that weren’t comfortable relying on NVIDIA’s tooling.

However, today things are different. Clang is now a fully functional open-source GPU compiler. It provides a CUDA-compatible programming model and can compile most of the awesome CUDA libraries out there ranging from Thrust (the CUDA-enabled parallel algorithms library that gave rise to the new parallelism technical specification) to Eigen and TensorFlow.

In this talk we will give an overview of how LLVM and Clang support targeting C++ to GPUs, how they work to be compatible with existing CUDA code, and how you can build your code today to run on GPUs with this open source compiler.

Speakers
avatar for Justin Lebar

Justin Lebar

Software Engineer, Google
I lead the GPU compilers team at Google. (We work on CUDA/GPU support in Clang and LLVM.)


Tuesday September 20, 2016 3:15pm - 4:15pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

3:15pm PDT

Putting Coroutines to Work with the Windows Runtime
Coroutines are one of the hot new features that are being proposed for C++ standardization. They have the potential to revolutionize how we C++ developers work with asynchronous operations, both in terms of consuming long-running operations and in formalizing the way in which asynchronous operations are described by the developer and implemented by the compiler.

The theory is interesting, and "Hello, World" examples are fun, but how does the proposed coroutines feature fare when applied to a major library or operating system? How well does the coroutines feature work in practice with real-world user interface code and background tasks?

In this session, we'll explore the application of the C++ coroutines feature to C++ for the Windows Runtime. We'll look at the coroutine types that we designed for the "C++/WinRT" language projection, with a focus on their usability and performance. Most importantly, we'll look at how coroutines can be used with a sophisticated platform library and discover how various problems are greatly simplified in the face of real platform complexities like UI and threading models.

Speakers
avatar for Kenny Kerr

Kenny Kerr

Microsoft
Kenny Kerr is an engineer on the Windows team at Microsoft, an MSDN Magazine contributing editor, Pluralsight author, and creator of moderncpp.com (C++/WinRT). He writes at kennykerr.ca and you can find him on Twitter at @kennykerr.
avatar for James McNellis

James McNellis

Principal Software Engineer, Microsoft Corporation
James McNellis is a Principal Software Engineer at Microsoft where he works on the Time Travel Debugging (TTD) reverse debugging toolkit. Prior to joining the Windows Debuggers team in 2016, he worked on the Visual C++ team and was responsible for the Microsoft C Runtime (CRT) and... Read More →


Tuesday September 20, 2016 3:15pm - 4:15pm PDT
Frey (Room 406) Meydenbauer Center

3:45pm PDT

Python & C++: the Beauty and the Beast, dancing together. Introduction to C++ python extensions and embedding Python in C++ Apps.
C and C++ languages are the best for high performance, and probably have the largest quota among programming languages, implementing the backbone of all of the existing computing infrastructure, including those other programming languages. On the other hand, python usage is also very popular and growing, with its amazing simplicity, and it is being adopted as the generic language for learning and many other tasks ranging from BigData and systems to web sites. Python is also being widely used in development and systems automation “devops”, being the language of choice for many scripting tasks (build systems as SCons are written in python) or as glue between subsystems.

This talk will introduce how both C++ and Python languages can work together. As many of the methods to write python extensions typically use a raw C API, we’ll focus on how to use C++ in such extensions, and the C++ code itself.

First, I’ll briefly present the canonical python C API, and how different aspects of C++ (as Exceptions) have to be handled. Then, I will describe and compare a couple of pure C++ ways to build extensions: the reference Boost.Python and the modern, but very active and popular successor, Pybind11.

Finally, I will conclude explaining how to embed a python interpreter in a C++ application. This allows C++ programs to introduce a powerful and known language to let the users define extensions or configuration of our C++ application without requiring them to build anything.

All presented examples will be complete and working, with build scripts included, in a public repository.

Speakers
avatar for Diego Rodriguez-Losada Gonzalez

Diego Rodriguez-Losada Gonzalez

Lead Architect, JFrog
Diego's passions are robotics and SW engineering and development. He has developed many years in C and C++ in the Industrial, Robotics and AI fields. Diego was also a University (tenure track) professor and robotics researcher for 8 years, till 2012, when he quit academia to try... Read More →


Tuesday September 20, 2016 3:45pm - 4:15pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

3:45pm PDT

The strange details of std::string at Facebook
Standard strings are slowing you down. Strings are everywhere. Changing the performance of std::string has a measurable impact on the speed of real-world C++ programs. But how can you make strings better? In this talk, we'll explore how Facebook optimizes strings, especially with our open-source std::string replacement, fbstring. We'll dive into implementation tradeoffs, especially the storage of data in the struct; examine which standard rules can and cannot be flouted, such as copy-on-write semantics; and share some of the things we've learned along the way, like how hard it is to abolish the null-terminator. War stories will be provided.

Speakers
avatar for Nicholas Ormrod

Nicholas Ormrod

Software Engineer, Facebook
Nicholas is a infrastructure engineer at Facebook. If he talks too much, disable him with a well-placed nerd snipe.


Tuesday September 20, 2016 3:45pm - 4:15pm PDT
Prince Theater (2nd Floor) Meydenbauer Center

4:45pm PDT

Advanced Levelization Techniques (part 3 of 3)
Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. To be successful, one also needs a grasp of physical design concepts that, while closely tied to the technical aspects of development, include a dimension with which even expert software developers may have little or no experience. In this talk we begin by briefly reviewing the basics of physical design. We then present a variety of levelization and Insulation techniques, and apply them in present-day, real-word examples to avoid cyclic, excessive, or otherwise inappropriate dependencies. Along the way, we comment on how to make the best use of what the C++ language has to offer.

Speakers
avatar for John Lakos

John Lakos

Software Engineer, Bloomberg Lp
John Lakos, author of Large-Scale C++ Software Design, serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide.  He is also an active voting member of the C++ Standards Committee’s Evolution Working Group. Previously, Dr... Read More →


Tuesday September 20, 2016 4:45pm - 5:45pm PDT
White (Room 407) Meydenbauer Center

4:45pm PDT

Game engine using STD C++ 11
This session is going to give an account of the process and features used to create a game engine focusing on using std C++11 features and concurrency. We will go through the architecture of the engine design and the specifics of the C++11 features being used. We will also go through optimization choices and design mentalities that are being used to keep the code base simple, but powerful in game usage. The engine architecture we will be going through will be using parallelism as a way to distribute work and get performance out of the available hardware that can scale into the future.

While completing a full engine with cutting edge graphics techniques and a game to push the engine to its limits will take a while this session will go over the current state of the project and lessons learned. The ultimate goal of the project is to show the validity of using C++11 (and beyond) features in game engines to simplify code and improve stability while maintaining the performance and memory usage games demand.

Speakers
avatar for Jason Jurecka

Jason Jurecka

Senior Software Engineer, Blizzard Entertainment
Jason Jurecka is a 12+ year engineering veteran of the game industry that has worked on titles in the full range of platforms from PC to next-gen consoles. He has done a wide range of tasks that include engine architecture, asset management, asset pipelines, gameplay features, task... Read More →


Tuesday September 20, 2016 4:45pm - 5:45pm PDT
Kantner (Room 403) Meydenbauer Center
  lecture

4:45pm PDT

Make Friends with the Clang Static Analysis Tools
This talk is an overview of the open source static analysis tools for C++. The emphasis is on Clang based tools. While this talk is not intended to be a tutorial how to develop such tools I will cover the algorithms, methods and interesting heuristics that are utilized by them. Understanding these methods can be really useful as it helps us write more static analysis friendly code and understand the cause of false positive results. It will also help to understand limitations of the currently available tools. I will also present some guidelines how to make a library static analysis friendly, to make clients interested in such tools happy. I will also give a short tutorial on how to use these tools and how to integrate them into the work flow.

Speakers
avatar for Gábor Horváth

Gábor Horváth

PhD Student, Eötvös Loránd University
Gabor started a Ph.D. in 2016. He is a contributor to research projects related to static analysis since 2012. He is a clang contributor, participated in Google Summer of Code twice as a student and twice as a mentor, interned for Apple and Microsoft. He teaches C++ and compiler construction... Read More →


Tuesday September 20, 2016 4:45pm - 5:45pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

4:45pm PDT

The speed of concurrency (is lock-free faster?)
This talk takes the “ultimately practical” approach to concurrent programming, with a focus on lock-free programs: after all, in reality such programs are almost always written in the hopes of getting better performance. We’re going to measure performance of the individual concurrent primitives and their effect on the overall performance of the whole program.

The goal of the talk is two-fold. On one hand, I will show a set of tools and practices that can be used to get quantitative measurements of the performance of different implementations under various load conditions. Mastering these techniques will allow the attendees to choose their concurrent algorithms and implementations based on solid data instead of guesswork or “common knowledge” (which is often wrong or outdated). On the other hand, even with the focus on real-life applications we can learn a few things about the fundamental nature of concurrent programs. This understanding comes especially useful when dealing with the “common knowledge” and “simple logic”. For example, it’s “common knowledge” that lock-free programs are faster than lock-based (not always). It’s also a “simple logic” that the hardware must protect shared memory access in a multi-core system, so ultimately locking is always present (sometimes true, sometimes true but misleading, and sometimes false). It is both “common knowledge” and “simple logic” that a wait-free program does not wait (but if your definition of wait is “will I have to wait for the results after I finish my coffee?” then it definitely does).

We will explore practical examples of (mostly) lock-free data structures, with actual implementations and performance measurements. Even if the specific limitations and simplifying assumptions used in this talk do not apply to your problem, the key point to take away is how to find such assumptions and take advantage of them in your specific application: after all, in reality it’s almost always about performance.

Speakers
avatar for Fedor Pikus

Fedor Pikus

Chief Scientist, Mentor Graphics
Fedor G Pikus is a Chief Engineering Scientist in the Design to Silicon division of Mentor Graphics Corp (Siemens business). His earlier positions included a Senior Software Engineer at Google and a Chief Software Architect for Calibre PERC, LVS, DFM at Mentor Graphics. He joined... Read More →


Tuesday September 20, 2016 4:45pm - 5:45pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center

4:45pm PDT

tuple: What's New and How it Works
std::tuple<> has been gaining new abilities, like get-by-type in C++14 and conditionally-explicit constructors in C++17. This talk will begin by briefly summarizing what you can do with tuples in C++11 and C++14. Next, we’ll explore what’s new in C++17, and how it can improve your code. We’ll also delve into how this magic is implemented, with new metaprogramming tools like std::conjunction<>. Finally, we’ll look at active issues in tuple’s design, and what the Library Working Group is doing about them.

Speakers
avatar for Stephan T. Lavavej

Stephan T. Lavavej

Principal Software Engineer, Microsoft
Stephan T. Lavavej is a Principal Software Engineer at Microsoft, maintaining Visual C++'s implementation of the C++ Standard Library since 2007. He also designed a couple of C++14 features: make_unique and the transparent operator functors. He likes his initials (which people can... Read More →


Tuesday September 20, 2016 4:45pm - 5:45pm PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

4:45pm PDT

Welcome To The Time Zone
This talk builds on the date/time library presented last year and shows how one can handle conversions among multiple time zones in a type-safe manner.

The entire library is very much chrono-centric, and so inherits desirable features from chrono such as type safety and arbitrary precision.

This time zone libraries have divided themselves by structure and concepts such as absolute time and civil time. While these concepts are useful, and found in this library, this library cuts in other dimensions.

This library draws a clear distinction between calendars and times. Thus this library has been designed from the ground up to not only work well with the Gregorian calendar, but with other calendars as well. Even with calendars written by you. It accomplishes this by using the chrono library  as its chief communication channel with the calendar.

This talk is a sequel to my Cppcon 2015 talk a date/time library: https://www.youtube.com/watch?v=tzyGjOm8AKo

If you can, see my talk earlier this week about chrono, and my talk about an example calendar from last year: https://www.youtube.com/watch?v=tzyGjOm8AKo. This talk builds upon these foundational tools.

Speakers
avatar for Howard Hinnant

Howard Hinnant

Senior Software Engineer, Ripple
Lead author of several C++11 features including: move semantics, unique_ptr and . Lead author on three open source projects: A std::lib implementation: http://libcxx.llvm.org An Itanium ABI implementation: http://libcxxabi.llvm.org A date/time/timezone library: https://git... Read More →



Tuesday September 20, 2016 4:45pm - 5:45pm PDT
Robinson (Room 409) Meydenbauer Center
  lecture
 
Wednesday, September 21
 

9:00am PDT

Building Software Capital: How to write the highest quality code and why
This talk discusses the ins and outs of how to write software that is at such a high standard that it gets reused everywhere. It covers organization, design, infrastructure, testing, documentation, reviews, and general suggestions based on my experience in the industry.

Speakers
avatar for David Sankel

David Sankel

Bloomberg
David Sankel is a Software Engineering Manager/TL at Bloomberg and an active member of the C++ Standardization Committee. His experience spans microservice architectures, CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography... Read More →


Wednesday September 21, 2016 9:00am - 10:00am PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

9:00am PDT

From Zero to Iterators: Building and Extending the Iterator Hierarchy in a Modern, Multicore World
You've likely used the STL before, and you are probably comfortable using std::vector some algorithms, but you may not be quite so comfortable with STL iterators. What even are "single pass writable iterators"? What does that mean to me as a user of the STL?

In this talk, we will motivate the iterator concept hierarchy as it exists in the STL today by looking at useful algorithms and how they traverse their input and output ranges. We will take these concrete examples and slowly begin to abstract, building up the STL iterator concepts, step-by-step.

After presenting the iterator concepts that exist in the STL today, we will build up to two further iterator concepts by looking at useful algorithms and then generalizing from them. First, we will motivate contiguous iterators, which have been voted into the C++17 working draft. Then, we will motivate a less-commonly known iterator concept, segmented iterators, and show how they can help us write parallel and cache-aware algorithms.

You should come away from this talk with an appreciation for generic programming, experience with the syntax in the Concepts Lite Technical Specification, and a better understanding of why iterators are fundamental to the algorithms you write every day.

Speakers
avatar for Patrick Niedzielski

Patrick Niedzielski

Patrick is a Senior at Cornell University, pursuing a BA in Linguistics and Computer Science. In particular, he is interested in compiler technologies and building high-level, easy-to-use abstractions that maintain well-defined performance characteristics. With over ten years experience... Read More →


Wednesday September 21, 2016 9:00am - 10:00am PDT
Prince Theater (2nd Floor) Meydenbauer Center

12:30pm PDT

Working at Globalscape: Building successful enterprise solutions with C++ on Windows!

Learn about the software development process at Globalscape, where a company that started with CuteFTP has "grown up" into a very successful public company that builds enterprise class Windows-based Secure File Transfer and Workflow Automation solutions using Modern(ish) C++ on Windows.   We tackle delightful challenges of multithreaded high performance file transfer over TCP/IP based networks; cryptography various flavors; authentication and access controls that run the gamut from password hashes to distributed SAML based SSO; and development of modular and extensible platforms delivered to some of the largest enterprises in the world.



Speakers
avatar for Gregory Hoffer

Gregory Hoffer

VP, Engineering and Test, Globalscape, Inc.
At Globalscape, we build industry award winning solutions for secure file transfer and workflow automation. The development team works on exciting and challenging tasks in the fields of multi-threading, tcp/ip based communications, cryptography, and others -- all in highly performant... Read More →


Wednesday September 21, 2016 12:30pm - 1:30pm PDT
Frey (Room 406) Meydenbauer Center

2:00pm PDT

A C++ MQTT Message Broker for the Enterprise
Description

Modern applications in enterprise software comprise a complex web of streaming data sources and sinks. Data is constantly flowing across the network generated by a disparate set of clients, written in a multitude of programming languages, intended for local and/or remote resources. From the smallest devices in the Internet of Things (IoT) to the largest mainframes or connected subnets in Banking and Finance systems, the core abstraction used at the heart of all of this technology has been the message. However, messaging is an overloaded term with many meanings depending on the connotation and context. But we are going to focus on how C++ and the MQTT protocol can participate in the polyglot programming languages of the modern Enterprise Messaging landscape. Our focus will be on a scalable server-side framework that can provide messaging in any context from an IoT device all the way up to a large Banking mainframe.

Abstract

In the context of Enterprise Messaging the MQTT protocol and the design of a C++ MQTT Message Broker provide a perfect mixture of language support and features to build a scalable, extensible, high-quality Enterprise Messaging solution. In order to demonstrate how this is possible I will introduce Enterprise Messaging Systems and enough of the concepts of Enterprise Messaging to be able to create a shared understanding of the role and features needed to implement a basic Message Broker using modern advanced C++ idioms. I will then demonstrate how data integration using a Message Broker, with specific messaging models, can support several message integration use-cases.

The talk will focus on demonstrating how C++ fits into the context of Event Driven-Architecture (EDA) at the enterprise-level and how the language's newer idioms allow it to excel at the task. The talk will utilize C++ 14 making extensive use of Template Metaprogramming, multi-threading, asynchronous I/O, correct usage of move semantics and examples of cross-platform networking abstractions. It is geared to the intermediate to advanced developer wanting to learn more about messaging and EDA, MQTT, and extending C++ deeper into the enterprise as a serious language addition to the polyglot movement in enterprise development today.

The talk piggy-backs on another MQTT talk about a client-side framework for an IoT project being proposed by Michael Caisse. The two are not dependent upon each other as Michael's talk covers client-side programming and mine covers server-side though the two can be used as endpoints for the other's demo portion.

Speakers

Wednesday September 21, 2016 2:00pm - 3:00pm PDT
White (Room 407) Meydenbauer Center

2:00pm PDT

C++, Abstract Algebra and Practical Applications
Modern C++ includes ample facilities for manipulating types a compile time. These facilities have evolved from a small bag of miscellaneous tricks to an large bag of miscellaneous tricks. It turns out we can select a subset of these tricks to build a representation of abstract algebra within the C++ type system. This methodology will help programmers select and exploit the C++ type manipulation facilities to create more transparently correct, efficient and maintainable programs.

This session does not presuppose and particular mathematical background. It depends upon only the most basic and key ideas of abstract algebra which will be explained as part of the presentation.

This work was initially inspired by work by Barton and Nackman as well as some ideas from Denotational Semantics.

Speakers
avatar for Robert Ramey

Robert Ramey

Software Developer, Robert Ramey Software Development
Robert Ramey is a freelance Software Developer living in Santa Barbara, California. (See www.rrsd.com.)  His long and varied career spans various aspects of software development including business data processing, product, embedded systems, custom software, and C++ library development. Lately, he has been mostly interested in C++ library design and implementation related to Boost... Read More →


Wednesday September 21, 2016 2:00pm - 3:00pm PDT
Kantner (Room 403) Meydenbauer Center
  lecture

2:00pm PDT

Developing C++ @ Facebook Scale
Writing correct C++ is hard. Period. Full stop. Even if a small change to a simple 2,000-line program compiles, has tests, and passes the tests, the code might still be broken. When the code spans hundreds of thousands of files across many different projects, making sure your change is safe is orders of magnitude harder. This talk is about all of the things that make that problem manageable for a Facebook engineer to tackle.

Speakers
avatar for Mark Isaacson

Mark Isaacson

Software Engineer, Facebook
Mark Isaacson is a Software Engineer at Facebook, where he works on improving the developer experience for all C++ programmers at Facebook.


Wednesday September 21, 2016 2:00pm - 3:00pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

2:00pm PDT

Garbage In, Garbage Out: Arguing about Undefined Behavior with Nasal Demons
There has been an overwhelming amount of tension in the programming world over the last year due to something that has become an expletive, a cursed and despised term, both obscene and profane: **undefined behavior**. All too often, this issue and the discussions surrounding it descend into unproductive territory without actually resolving anything.

In this talk, I'm going to try something very bold. I will try to utterly and completely do away with the use of the term "undefined behavior" in these discussions. And I will unquestionably fail. But in the process of failing, I will outline a framework for understanding the actual root issues that the software industry faces here, and try to give constructive and clear paths forward, both for programmers and the programming language.

And, with luck, I will avoid being joined on stage by any unruly nasal demons.

Speakers
avatar for Chandler Carruth

Chandler Carruth

Software Engineer, Google
Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is... Read More →


Wednesday September 21, 2016 2:00pm - 3:00pm PDT
Prince Theater (2nd Floor) Meydenbauer Center

2:00pm PDT

Message Handling in Modern C++ Applications

Message handling is frequently used in GUI applications to process user interactions reactively. In this presentation, I'll demonstrate how C++ can be used to rapidly develop performant messaging handling libraries using lambdas and type erasure without the need for polymorphic object creation.


Speakers
avatar for Brett Searles

Brett Searles

Principal Architect, Attobotics


Wednesday September 21, 2016 2:00pm - 3:00pm PDT
Frey (Room 406) Meydenbauer Center
  lecture

2:00pm PDT

STL Algorithms - why you should use them, and how to write your own
One of the most powerful features of the C++ standard library is the collection of basic algorithms. Everyone knows about sort and copy, but there are is a lot of powerful capabilities in the other algorithms as well. In this talk, I will explore some of the algorithms in the library, and give a rationale for writing your own, along with examples.

The motivation for writing your own algorithms is that you can create generic building blocks that can be used over and over again in your library or application, and which will allow your to program at a higher level of abstraction. Instead of thinking, "how do I sort this vector", you just call std::sort. The same should apply to the algorithms that are specific to your domain - once you write them.


Speakers
avatar for Marshall Clow

Marshall Clow

Principal Engineer, CPPAlliance
Marshall has been programming professionally for 35 years. He is the author of Boost.Algorithm, and has been a contributor to Boost for more than 15 years. He is the chairman of the Library working group of the C++ standard committee. He is the lead developer for libc++, the C++ standard... Read More →


Wednesday September 21, 2016 2:00pm - 3:00pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center

3:15pm PDT

Experiences with Facebook's C++ library
Facebook has open sourced Folly, its core C++ Library and the
foundation of all of Facebook's C++ code. Folly builds practical,
efficient, and novel components on top of the standard library.
Facebook engineer Dave Watson will do a deep dive on the core
components, and investigate how they have changed over time. We will
compare its design with previous talks and proposals, and highlight
insights learned from real-world usage in Facebook's large production
codebase.

Topics include:
* Singletons in a world with fork
* Useful ThreadLocals
* Pragmatic exceptions
* Easy type conversions
* Optimizing primitives, such as shared_mutex, vector, and atomic_shared_ptr

Speakers
avatar for David Watson

David Watson

Engineer, Facebook
Dave Watson is an infrastructure engineer at Facebook. He has been focused on improving the application server stack, including improvements in RPC, load balancing, memory management, and asynchronous programming. He has contributed to many of Facebook's core services and OSS projects... Read More →


Wednesday September 21, 2016 3:15pm - 4:15pm PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

3:15pm PDT

Introduction to Vector Parallelism
Parallel programming is a hot topic, and everybody knows that multicore processors and GPUs can be used to speed up calculations. What many people don't realize, however, is that CPUs provide another way to exploit parallelism -- one that predates recent multicore processors, has less overhead, requires no runtime scheduler, and can be used in combination with multicore processing to achieve even more speedup. It's called vector parallelism, and the hardware that implements it goes by brand names like SSE, AVX, NEON, and Altivec. If your parallel program does not use vectorization, you could be leaving a factor of 4 to 16 in performance on the floor.

In some ways, Vector programming is easier than thread-based parallel programming because it provides ordering guarantees that more closely resemble serial programming. Without an intuitive framework by which to interpret them, the ordering rules can be confusing, however, and restrictions on vector code that don't apply to thread-parallel code must be kept in mind. In this talk, we'll introduce you to the common elements of most vector hardware, show what kind of C++ code can be automatically vectorized by a smart compiler, and talk about programmer-specified vectorization in OpenMP as well as proposals making their way through the C++ standards committee. You'll understand the rules of vectorization, so that you can begin to take advantage of the vector units already in your CPU.

A basic understanding of C++11 lambda expressions is helpful.

Speakers
avatar for Pablo Halpern

Pablo Halpern

Software Engineer, Intel Corp.
Pablo Halpern has been programming in C++ since 1989 and has been a member of the C++ Standards Committee since 2007. He is currently an enginneer at Intel Corp., where he works on high-performance computing. As the former chairman of the Parallel Programming Models Working Group... Read More →


Wednesday September 21, 2016 3:15pm - 4:15pm PDT
Kantner (Room 403) Meydenbauer Center

3:15pm PDT

Rainbow Six Siege: Quest for Performance
While 2014 CppCon talk "C++ in Huge AAA Games" focused on reality for a lot of games developed at Ubisoft Montreal, this talk with focus on what was done to ship Rainbow Six Siege at 60 frames per second. Delivering a game with 5 versus 5 multi-player with heavy procedural environment destruction at 60 FPS was a constant challenge. From memory usage to lock-free solutions, a lot of developed C++ solutions are reusable outside of games. Some interesting analysis tools were also developed to find issues, and their concepts could be reused by any C++ developer caring about performance.

Speakers
avatar for Nicolas Fleury

Nicolas Fleury

Technical Architect, Ubisoft Montreal
Nicolas has 15 years of experience in the video game industry, more years in the software industry in telecoms, in speech recognition and in computer assisted surgery. Technical Architect on Tom Clancy's: Rainbow Six Siege for 7 years, he also worked on games like Prince of Persia... Read More →


Wednesday September 21, 2016 3:15pm - 4:15pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

3:15pm PDT

Using weakly ordered C++ atomics correctly
Most programmers should usually avoid C++ atomics altogether and use mutexes instead. If that's not possible, perhaps because the code must be usable in interrupt handlers, I recommend that you consider limiting yourself to sequentially consistent atomics, which provide a more subtle, but still reasonably unsurprising programming model. This talk will target those who choose to ignore both of those pieces of advice, for either good or bad reasons.

I will start by trying to distinguish the good and bad reasons for using weakly ordered atomics, and then follow with guidelines for using them correctly.

I will discuss why it is often incorrect to think of atomics in terms of fence-based implementations, and about some common errors I've seen, including some really convincing looking, but still incorrect, code. I will also try to go through some of the common idioms for which weakly ordered atomics are actually safe. In my experience, the latter are also reasonably common, but not always easy to distinguish from the subtly erroneous examples.

Speakers
avatar for Hans Boehm

Hans Boehm

Google
Hans is a software engineer at Google, where he has been since March 2014. He now works mostly on concurrent programming issues, both generally, and focussed on Android. Hans is an ACM Fellow, and a past Chair of ACM SIGPLAN (2001-2003). Until late 2017 he chaired the ISO C++ Concurrency... Read More →



Wednesday September 21, 2016 3:15pm - 4:15pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

4:45pm PDT

C++ Costless Abstractions: the compiler view
One of the motto of C++ is « costless abstractions », a.k.a. you only pay for what you use. To achieve this goal, modern C++ puts a heavy burden on the compiler. But what does the compiler really does when it meets an exception? When it finds a nested lambda? When it encounters a structure that wraps a single scalar?

During this talk, we'll go trough a set of innocent C++ sample that involves several data types and algorithms from the standard library, and verify that the costless abstraction principle holds, especially when looking at the difference between several optimization level, eventually digging into specific compiler optimization to understand what happens under the hood.

This talk uses Clang++ as the reference compiler, and relies on its LLVM bitcode output to explain how the abstractions are lowered (or completely pruned) at the Intermediate Representation level.

Speakers
SG

Serge Guelton

QuarksLab


Wednesday September 21, 2016 4:45pm - 5:45pm PDT
Prince Theater (2nd Floor) Meydenbauer Center

4:45pm PDT

C++14 Reflections Without Macros, Markup nor External Tooling: metaprogramming tricks for POD types
C++ was lacking the reflections feature for a long time. But a new metaprogramming trick was discovered recently: we can get some information about POD structure by probing it's braced initializes. Combining that trick with variadic templates, constexpr functions, implicit conversion operators, SFINAE, decltype and integral constants we can count structure's fields and even deduce type of each field.

Now the best part: everything works without any additional markup nor macros typically needed to implement reflections in C++.

In this talk I'll explain most of the tricks in detail, starting from a very basic implementation that is only capable of detecting fields count and ending up with a fully functional prototype capable of dealing with nested PODs, const/volatile qualified pointers, pointers-to-pointers and enum members. Highly useful use-cases will be shown a the end of the talk. You may start experimenting right now using the implementation at https://github.com/apolukhin/magic_get.

Small motivating example:

#include <iostream>
#include "magic_get.hpp"

int main() {
    struct foo { // no `ostream& operator <<` defined for `foo`!
        double d;
        char c;
   };

   foo f{ 1.0, '!' };
   std::cout << f; // Outputs `{1.0, !}`
}

Speakers
avatar for Antony Polukhin

Antony Polukhin

Yandex
Hi, I'm Antony Polukhin, the author of Boost.TypeIndex and Boost.DLL libraries; maintainer of the Boost.LexicalCast, Boost.Any, Boost.Variant and Boost.Conversion libraries. I'm also the author of of the "Boost C++ Application Development Cookbook"


Wednesday September 21, 2016 4:45pm - 5:45pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

4:45pm PDT

Elegant Asynchronous Code
Asynchronous I/O is an essential technology for increasing concurrency without introducing more threads, which carry both overhead and risks. Unfortunately, leveraging async I/O can be disruptive to careful code architecture.

This talk focuses not on the mechanics of async I/O, but rather on a library that manages async I/O with code that looks and behaves like traditional sequential code. Boost.Fiber introduces "userland threads," permitting the application coder the benefits of both async I/O and clean layers of abstraction.

This talk presents an overview of the library, discusses integration with event-driven frameworks and illustrates several useful patterns.

Speakers
NG

Nat Goodspeed

Linden Lab
Nat Goodspeed first read about C++ shortly after implementing a medium-sized language interpreter in classic C. Almost every C++ feature led to forehead smacking accompanied by muttered remarks about how the language could have solved THIS problem... He has been fascinated (sometimes... Read More →


Wednesday September 21, 2016 4:45pm - 5:45pm PDT
Vanity (Room 404) Meydenbauer Center

4:45pm PDT

From Numerical Cosmology to Efficient Bit Abstractions for the Standard Library
Efficient bit abstractions for the standard library, or how to beat vector<bool> performances by three orders of magnitude.

Can you imagine a perfect world? A world of unicorns. A world of double rainbows. A world of candy mountains. A world in which vector<bool> would not even have existed. As the first three aspects are easy to imagine, I will mostly focus on the last one. For about 20 years now, vector<bool> has been regarded as a bad design decision. There is no problem with the functionality provided by a dynamic vector of bits, but specializing vector for boolean data types was not the best idea ever. In this talk, I will present a radically new approach, generalizing existing implementation practices and experimentations, to achieve both genericity and performances for bit manipulation. I will describe how we designed a minimalist set of abstractions to access and manipulate bits and to serve as a common basis for bit oriented data structures, algorithms and arbitrary precision arithmetic. This presentation echoes a standardization work that will hopefully make bit utilities available in a future revision of the C++ standard library.

Bit manipulation is used as a fundamental building block of a wide range of applications including arithmetic of big integers, cryptography, hash tables, compression, fast Fourier transforms and bioinformatics. We started this work while investigating... the expansion of the Universe. Cosmological simulations on supercomputers require fast data structures, and in our case bit manipulation was a bottleneck. A common problem with bit abstractions is that they need a double standard: an easy to use interface for users, and a full access to low level instructions and compiler intrinsics to make the most of modern architectures. I will review our approach and give examples on how to use our library. I will also explain how to use bit values, bit references, bit pointers and bit iterators to design algorithms that outperform bit vectors by factors varying between 100 an 3500. I will conclude this talk by discussing how the bit abstraction proposal may affect the future of the standard library and particularly how it will be interfaced with standard algorithms, standard containers, ranges and arbitrary precision arithmetic.

Speakers
avatar for Vincent Reverdy

Vincent Reverdy

Researcher in Astrophysics and Mathematics, Ecole Normale Supérieure
Vincent has been working as a post-doctoral researcher at the University of Illinois at Urbana-Champaign (USA) since he obtained his PhD at the Paris observatory (France) in november 2014. His main scientific interests are related to cosmology and general relativity. He his particularly... Read More →


Wednesday September 21, 2016 4:45pm - 5:45pm PDT
Frey (Room 406) Meydenbauer Center

4:45pm PDT

The Guideline Support Library: One Year Later
At CppCon 2015 we introduced the Guideline Support Library (GSL): a set of portable vocabulary types for use constructing safe and efficient C++ programs. This talk looks at how the library has evolved in the course of one year. The talk will provide a brief review of the current set of facilities in the library, where it is available, how to build and contribute. Then the talk will look at how the library changed in response to feedback and contributions from the user community, as well as from the ISO C++ Working Group as parts of the library move through the standardization process for inclusion in the C++ standard library. The talk will cover lessons learned about how to optimize key parts of the library - such as the span<T> type - in the compiler, and what had to change in the library implementation to support this. It will present some examples of these optimizations and discuss performance of span<T>. Finally, the talk will include a status report on notable places the library is being used and preview what might be next for the GSL.

Speakers
avatar for Neil MacIntosh

Neil MacIntosh

Principal Software Engineer, Microsoft
Neil is the lead for the C++ static analysis frameworks used widely within Microsoft, including PREfix, PREfast, and EspXtension, as well as the /analyze feature of the Microsoft C++ compiler. He is currently focused on making all these tools work better with portable C++14 code rather... Read More →


Wednesday September 21, 2016 4:45pm - 5:45pm PDT
Kantner (Room 403) Meydenbauer Center
  lecture

8:30pm PDT

Start teaching the Concepts TS and the ranges library now!
The Concepts TS is a formally published ISO Technical Specification, and receives serious augmentation through the Ranges library TS. Lots of people want to see them be used, they're not a feature that's in the International Standard, so there may be some caution. We'll have a chat about how concepts and ranges can make your (students') lives easier, and why you should start teaching (using) them immediately.

Please bring a laptop, as there will be a demo that you might like to play around with on your machine.
You will also need gcc 6.2 and this GitHub repository: https://github.com/CaseyCarter/cmcstl2

Speakers
avatar for Christopher Di Bella

Christopher Di Bella

Staff Software Engineer, Codeplay Software
Christopher Di Bella is a Staff Software Engineer for Codeplay’s ComputeCpp Runtime Technology. He is a strong proponent for generic programming in C++ and C++ education. Chris was previously a software developer for Nasdaq, and a tutor for UNSW Australia’s COMP6771 Advanced C... Read More →


Wednesday September 21, 2016 8:30pm - 9:30pm PDT
Kantner (Room 403) Meydenbauer Center
 
Thursday, September 22
 

9:00am PDT

A modern database interface for C++
C++ has historically had many options for database connectivity but has lacked a standard interface that other languages, such as Java, have had for a long time. This talk will present a standards grade interface along with experience with a reference implementation that includes support for at least 6 databases. A key aspect of the design is to show how modern C++ features can be used to achieve a high degree of both efficiency and ease-of-use. Specific features to be covered will include type conversion, connection pooling, I/O binding for scalars and arrays, row sets, direct/polymorphic interfaces, policy based design, the driver interface, and details on the implementation. Forward looking standards proposals, such as ranges and variants, will also be included in the discussion.

Speakers
avatar for Erik Smith

Erik Smith

Engineering Manager, TranscendInsights
Erik Smith is a member of the clinical analytics team at Transcend Insights in San Diego. Erik is a specialist in building high performance full stack applications. He is a co-founder of AppFluent, a maker of database caching technology and analytic monitoring software. He has a diverse... Read More →



Thursday September 22, 2016 9:00am - 10:00am PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

9:00am PDT

Deploying C++ modules to 100s of millions of lines of code
Compile times are a pain point for C++ programmers all over the world. Google is no exception.. We have a single unified codebase with hundreds of millions of lines of C++ code, all of it built from source. As the size of the codebase and the depth of interrelated interfaces exposed through textually included headers grew, the scaling of compiles became a critical issue.

Years ago we started working to build technology in the Clang compiler that could help scale builds more effectively than textual inclusion. This is the core of C++ Modules: moving away from the model of textual inclusion. We also started preparing our codebase to migrate to this technology en masse, and through a highly automated process. It's been a long time and a tremendous effort, but we'd like to share where we are as well as what comes next.

In this talk, we will outline the core C++ Modules technology in Clang. This is just raw technology at this stage, not an integrated part of the C++ programming language. That part is being worked on by a large group of people in the ISO C++ standards committee. But we want to share how Google is using this raw technology internally to make today's C++ compiles faster, what it took to get there, and how you too can take advantage of these features. We will cover everything from the details of migrating a codebase of this size to use a novel compilation model to the ramifications for both local and distributed build systems. We hope to give insight into the kinds of benefits that technology like C++ Modules can bring to a large scale C++ development environment.

Speakers
MK

Manuel Klimek

Software Engineer, Google
Manuel Klimek is a software engineer at Google since 2008 and a professional code monkey since 2003. After developing embedded Linux terminals for the payment industry and distributed storage technology at Google in C++, he decided that C++ productivity lags significantly behind other... Read More →


Thursday September 22, 2016 9:00am - 10:00am PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

9:00am PDT

Improving Performance Through Compiler Switches- Examples from Scientific Computing
Much attention has been given to what modern optimizing compilers can do with your code, but little is ever said as to how to make the compiler invoke these optimizations. Of course, the answer is compiler switches! But which ones are needed to generate the best code? How many switches does it take to get the best performance? How do different compilers compare when using the same set of switches? I explore all of these questions and more to shed light on the interplay between C++ compilers and modern hardware drawing on my work in high performance scientific computing.

Enabling modern optimizing compilers to exploit current-generation processor features is critical to success in this field. Yet, modernizing aging codebases to utilize these processor features is a daunting task that often results in non-portable code. Rather than relying on hand-tuned optimizations, I explore the ability of today's compilers to breathe new life into old code. In particular, I examine how industry-standard compilers like those from gcc, clang, and Intel perform when compiling operations common to scientific computing without any modifications to the source code. Specifically, I look at streaming data manipulations, reduction operations, compute-intensive loops, and selective array operations. By comparing the quality of the code generated and time to solution from these compilers with various optimization settings for several different C++ implementations, I am able to quantify the utility of each compiler switch in handling varying degrees of abstractions in C++ code. Finally, I measure the effects of these compiler settings on the up-and-coming industrial benchmark High Performance Conjugate Gradient that focuses more on the effects of the memory subsystem than current benchmarks like the traditional High Performance LinPACK suite.

Speakers
TH

Tim Haines

PhD Candidate, University of Wisconsin-Madison
I am a third-year PhD candidate working in computational astrophysics. My undergraduate work was in computer science, physics, and mathematics, and I have an M.S. in physics. Fundamentally, my interests lie in developing software systems to try to answer difficult scientific questions... Read More →


Thursday September 22, 2016 9:00am - 10:00am PDT
Vanity (Room 404) Meydenbauer Center
  lecture

10:30am PDT

Keynote: Developing Blockchain Software
This talk will explain what public blockchain systems like Bitcoin and Ripple are, the unique challenges of developing software for them, and how C++ helps to meet these challenges. 

Security issues are paramount. Blockchain systems are open source, have large attack surfaces, and can cause significant financial damage if they have exploitable defects. Performance and scalability are also major concerns. 

C++ provides a unique balance that helps meet these challenges. The language's design makes it possible to catch bugs at compile time, write modular code that can be tested, develop flexible data structures and manage resources. Yet, where performance is critical, it does not obscure what your code is making the computer actually do. 

The primary purpose of the talk is to explain what blockchains are, increase understanding of the unusual challenges developers of blockchain software experience, and to demonstrate why C++ is a good choice to address them. 

Speakers
avatar for David Schwartz

David Schwartz

Chief Cryptographer, Ripple
David Schwartz is the Chief Cryptographer of Ripple, a distributed payment network. Also known as "JoelKatz", he is a respected voice in the crypto-currency community. David has also developed secure messaging and cloud storage software for government and military applications.



Thursday September 22, 2016 10:30am - 12:00pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center

12:30pm PDT

Texture Compression
This talk focuses on the current state of the art in practical (general purpose) lossless data compression and GPU texture compression. On the lossless front, a new breed of codecs (such as LZHAM, Zstd, Brotli, Kraken) carefully optimized to strike a practical balance between very high compression ratios and high decompression performance have been released. This talk will show how these new codecs perform across a wide variety of inputs. There are also several new developments in the specialized GPU texture compression space, such as rate distortion optimization (RDO), transcoding, and multiformat ("universal") encoding methods. This talk will explain the details behind these technologies, and also show some of our latest work on "Basis", a new GPU texture compression library we're creating at Binomial.


Speakers
avatar for Rich Geldreich

Rich Geldreich

Graphics Engineer & Co-Founder, Binomial
Rich works at Binomial, were he's working on "Basis", a new transcoding-based texture compression system for GPU textures. He's also worked on several open source data lossless compression libraries, such as LZHAM and miniz.
avatar for Stephanie Hurlburt

Stephanie Hurlburt

Graphics Engineer & Co-Founder, Binomial
Stephanie is building Basis, a texture compressor, at Binomial. She loves all things VR/AR/MR, C++, optimization, graphics, and games. Previously, she worked with C++ and graphics programming at Oculus and Unity.


Thursday September 22, 2016 12:30pm - 1:30pm PDT
Prince Theater (2nd Floor) Meydenbauer Center

2:00pm PDT

Channels - An alternative to callbacks and futures
Currently in the C++ Networking TS and Concurrency TS, callbacks and futures are the means for communicating an asynchronous value. However, there are disadvantages with both. Callbacks are low overhead, but hard to compose. Futures are easy to compose, but have increased overhead. In this talk we will consider channels as a third alternatives that can have lower overhead than futures while still being easy to compose.

Speakers
avatar for John Bandela

John Bandela

SWE, Google LLC
I first started programming in C++ at age 14 in 1994 when I cajoled my parents into buying me Visual C++ 1.0 for my birthday. It took a while, but as I learned the language, I decided I really liked C++. I attended the University of Florida and obtained my undergraduate degree in... Read More →


Thursday September 22, 2016 2:00pm - 3:00pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

2:00pm PDT

No Sane Compiler Would Optimize Atomics
False.

Compilers do optimize atomics, memory accesses around atomics, and utilize architecture-specific knowledge. My hobby is to encourage compilers to do more of this, programmers to rely on it, and hardware vendors to give us new atomic toys to optimize with. Oh, and standardize yet more close-to-the-metal concurrency and parallelism tools.

But, you say, surely volatile always means volatile, there’s nothing wrong with my benign races, nothing could even go wrong with non-temporal accesses, and who needs 6 memory orderings anyways‽ I’m glad you asked, let me tell you about my hobby…

Speakers
avatar for JF Bastien

JF Bastien

Compiler Engineer, Apple
JF Bastien is a compiler engineer, currently focusing on performance and security to bring portable, fast and secure code to the Web. JF is a member of the C++ standards committee, where his mechanical engineering degree serves little purpose. He's also the chair of the WebAssembly... Read More →


Thursday September 22, 2016 2:00pm - 3:00pm PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

2:00pm PDT

What C++ Programmers Need to Know about Header
The generation of pseudo-random numbers has been an important computing application ever since the pioneering work of John von Neumann and others during the World War II era. It remains an important application for gaming, statistical sampling, and simulation, to name but a few areas of its continuing utility.

Obtaining a random number (technically, a variate) is widely believed to be a simple task. Alas, it usually isn't, and programmers often have little or no training to help them make important decisions that can have subtle effects on the correctness and reliability of their programs' results.

In this talk by the principal author of the C++ <random> facility, we will describe the header's conceptual underpinnings, demonstrate its most common correct usage pattern, exhibit and explain what's wrong with its most common usage anti-pattern, and discuss the merits of a number of possible toolkits based on the header's facilities.

Speakers
avatar for Walter E. Brown

Walter E. Brown

With broad experience in industry, academia, consulting, and research, Dr. Walter E. Brown has been a C++ programmer for over forty years, joining the C++ standards effort in 2000. Among numerous other contributions, he is responsible for introducing such now-standard C++ library... Read More →


Thursday September 22, 2016 2:00pm - 3:00pm PDT
White (Room 407) Meydenbauer Center
  lecture

3:15pm PDT

Algorithm Design For Values Distributed In Time
Algorithms and the Concepts that enable them (Range and Iterator) are designed to work over values distributed in space (VDiS). The algorithms in std and the rangev3 proposal and the parallel algorithm are all focused on efficiently utilizing every resource assigned to them to process values distributed in space. Whenever values are distributed in space, these are the tools to use.

Values distributed in time (VDiT) require different Concepts and Algorithms. This talk will explore some of these Algorithms and the requirements that they impose on the Concepts. The result is a library that composes algorithms the same way that the rangev3 proposal does and in a way that allows knowledge of one to transfer to the other.

Speakers
avatar for Kirk Shoop

Kirk Shoop

Principal Software Engineer, Microsoft
Rx Cpp, Asynchronous Algorithms, catching code errors at compile time.


Thursday September 22, 2016 3:15pm - 4:15pm PDT
White (Room 407) Meydenbauer Center
  lecture

3:15pm PDT

How to test static_assert?
static_assert gives us the ability to assert conditions at compile time and provide custom error messages in case the conditions are not met. Cool! But how can you be sure that your precious static_asserts actually fire when you need them? There is only one way to know for sure:

You need to test your static_assert!

That is easier said than done, though, as static_assert produces a hard, unrecoverable compile-time error. For instance, you cannot test one static_assert with another.

This talk will demonstrate several options for testing static_assert, ranging from the build system, over the compiler features to template meta programming. It will include real-life examples from sqlpp11.

Speakers
avatar for Roland Bock

Roland Bock

Principal Software Engineer, PPRO Financial Ltd
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 →


Thursday September 22, 2016 3:15pm - 4:15pm PDT
Frey (Room 406) Meydenbauer Center
  lecture

3:15pm PDT

I Just Wanted a Random Integer!
I just wanted to generate a random integer between 1 and 100 for my unit tests.

An hour later I was down the rabbit hole of the C++ <random> header wondering why it was so complicated, weren't rand() and modulo good enough and was <random> overkill, genius or both?

Several hours later I had watched STLs 2013 Going Native talk on <random> (go watch it!), read some blogs and had even more questions: does the mt19937 generator go on the heap? Just how cheap are uniform distributions to construct? Were there even better generators out there and were they easier to use? Oh and what is entropy? How do you put it in a pool and how can it be exhausted?

The story took a few unexpected twists and turns, but in the end I got my random integers, and answers to almost all my questions which I will share. Whether <random> is genius or overkill though, you will have to decide for yourself.

Speakers
CM

Cheinan Marks

Swarm64
As an engineer with a chemical engineering background, Cheinan is interested in practical code and wants to take the latest advances both in science and programming and use them in real life working code along with applying engineering principles to software development. Cheinan is... Read More →


Thursday September 22, 2016 3:15pm - 4:15pm PDT
Kantner (Room 403) Meydenbauer Center

3:15pm PDT

Making C++ and the STL Work in the Linux / Windows Kernels
This presentation will describe how we bootstrapped a C++11/C++14 environment from the ground up, to essentially provide the ability to execute “user-space” like applications inside the Linux and Windows kernel. We leveraged this C++ environment and the Standard Template Library (STL) to create the first open source, cross platform, cross architecture, hypervisor that can support both baremetal (i.e. type 1) and late launch (i.e. type 2) virtualization models. Topics include the benefits of using C++ over C when creating a hypervisor as well as how we handled compilation, module loading, global constructor / destructor support, and of course, full exception support. If you have ever wondered how C++ works under the hood, or are interested in learning more about C++, this presentation is for you.

Speakers
avatar for Rian Quinn

Rian Quinn

CTO, Assured Information Security, Inc.
Dr. Rian Quinn is a Senior Principal Investigator in the Trusted Information Systems Group at Assured Information Security, Inc. were he has focused on trusted computing and hypervisor related technologies for nearly 10 years. He holds a Ph.D. in Computer Engineering with specializations... Read More →


Thursday September 22, 2016 3:15pm - 4:15pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

3:15pm PDT

There and Back Again: An Incremental C++ Modules Design
The Clang project has been working on Modules in one form or another for many years. It started off with C and Objective-C many years ago. Today, we have a C++ compiler that can transparently use C++ Modules with existing C++ code, and we have deployed that at scale. However, this is very separate from the question of how to integrate a modular compilation model into the language itself. That is an issue that several groups working on C++ have been trying to tackle over the last few years.

Based on our experience deploying the core technology behind Modules, we have learned a tremendous amount about how they interact with existing code. This has informed the particular design we would like to see for C++ Modules, and it centers around incremental adoption. In essence, how do we take the C++ code we have today, and migrate it to directly leverage C++ Modules in its very syntax, while still interacting cleanly with C++ code that will always and forever be stuck in a legacy mode without Modules.

In this talk we will present our ideas on how C++ Modules should be designed in order to interoperate seamlessly with existing patterns, libraries, and codebases. However, these are still early days for C++ Modules. We are all still experimenting and learning about what the best design is likely to be. Here, we simply want to present a possible and still very early design direction for this feature.

Speakers
RS

Richard Smith

Clang hacker, Google
Richard is the code owner of the Clang C++ frontend, to which he has been contributing for over five years. He implemented most of the C++11, C++14, and C++17 features that Clang supports, and brought Clang's modules support up to production quality.Richard is also the Project Editor... Read More →


Thursday September 22, 2016 3:15pm - 4:15pm PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

4:45pm PDT

Mobile App Development for Multiple Platforms with Visual C++, 2016
Visual C++ supports mobile app development for Windows, Android, and iOS from a single code base, optionally with a thin platform-specific UI layer. The resulting binaries can be deployed to an emulator or to a real device and debugged on both, all from within Visual C++ . This presentation is a follow up to my session given at CppCon 2015, and as such the session will only briefly cover the basics of cross-platform mobile app development. Please view https://www.youtube.com/watch?v=2Y47g8xNE1o or https://channel9.msdn.com/events/CPP/CppCon-2015/CPPConD02V019 for this material in depth. In this follow up, we go over the new features added for cross-platform development since last year. Additionally, we continue where last year’s session ended, and will go deeper on how to write your applications to have a native look-and-feel UI on each of the different platforms.

Speakers
avatar for Marc Gregoire

Marc Gregoire

Software Architect, Nikon Metrology
Marc Gregoire is a software architect from Belgium. He worked 6 years as a consultant for Siemens and Nokia Siemens Networks on critical 2G and 3G software running on Solaris for telecom operators. This required working in international teams stretching from South America and the... Read More →


Thursday September 22, 2016 4:45pm - 5:45pm PDT
Kantner (Room 403) Meydenbauer Center
  lecture

4:45pm PDT

The Power of Reflection with Facebook's Thrift
At Facebook we use C++ extensively in our backend and core infrastructure. We've recently added static reflection support for C++ to Thrift, in expectation of a first class standardized solution.

This talk demonstrates the power of reflection as a productivity enhancer, an enabler for features and an aid in managing complexity. It shows some useful functionalities that can be easily achieved through reflection in a portable and elegant way, which weren't possible before without code repetition, complex DSLs or non-portable pre-processors.

We'll cover things like pretty printers, data converters, migration to typed APIs, serialization and compilation times.

REQUIREMENTS: intermediate to advanced knowledge of template meta-programming. This talk is not aimed at people who want to learn meta-programming.

Speakers
avatar for Marcelo Juchem

Marcelo Juchem

Software Engineer, Facebook
Marcelo is a Software Engineer working with core infrastructure at Facebook.


Thursday September 22, 2016 4:45pm - 5:45pm PDT
Prince Theater (2nd Floor) Meydenbauer Center
  lecture

4:45pm PDT

Using build2, C++ Build Toolchain
It all started with a CppCon 2014 lightning talk where I tried to convince the audience we needed a C++ package manager. Turned out, no convincing was necessary. Fast forward two years and we have a new build system, a package manager, and cppget.org, a repository of open source C++ packages. In this talk I would like to give a practical overview of what it's all about.

We start with a brief discussion of what exactly are we trying to achieve, how it is "better" than other solutions, and why we need yet another build system.

Then, we put on the "consumer" hat and see how to find packages that we are interested in and use the package manager to build/upgrade/downgrade them and their dependencies using multiple build configurations.

In the second half we look into more interesting features of the build system: out-of-source, persistent build configurations (don't you wish you could just edit them with a text editor), high-fidelity builds (what happens if I upgrade my compiler or change compile options), command-line configuration overrides (what if I want to quickly rebuild my project with clang++ instead of g++), cross-compilation (something is wrong if it's harder to cross-compile than to build natively on Windows), subprojects and amalgamation (what if I really don't like external dependencies).

Build systems also rarely handle just building. There is testing, installation (do we really have to run the whole process as sudo), and preparation of distributions (no, shipping your .gitignore files is not cool).

We finish with a brief discussion of cppget.org: what's its future, who should control it, and what should its policies be (acceptable licenses, name disputes, etc)?

Speakers
avatar for Boris Kolpackov

Boris Kolpackov

Chief Hacking Officer, Code Synthesis
Boris Kolpackov is a founder and CHO (Chief Hacking Officer) at Code Synthesis, a company focusing on the development of open-source tools and libraries for C++. For the past 10 years Boris has been working on solving interesting problems in the context of C++ using domain-specific... Read More →


Thursday September 22, 2016 4:45pm - 5:45pm PDT
Vanity (Room 404) Meydenbauer Center
  lecture

4:45pm PDT

Variadic expansion in examples
Templates - and variadic templates - are an important aspect of writing a successful library in C++; libraries that can deal with custom types the user creates greatly eases their use. Variadic templates specifically are still a new, relatively unknown and at the same time quite a buggy (in the sense of bugs in their implementations) tool, but nevertheless, they offer much easier ways of creating truly generic types and functions.

This talk will focus slightly less on variadic templates in general; the common pitfalls will be discussed, but more attention will be given to the tool of parameter pack expansion and all the contexts where it can be used, especially as a code generation tool.

The talk will start mostly from scratch, assuming the audience's general knowledge about templates. It'll introduce the idea of variadic templates and general syntax and typical techniques for their use. Next, it will head into the (mostly) unknown and buggy lands of the interesting uses of variadic packs, like unpacking a tuple into a function call using `std::integer_sequence`, the use of empty packs for a slightly easier way to work with `enable_if`. The final examples will explain the way of invoking an expression per every argument in a pack, and dispatch to appropriate version of code for each of the argument types based on runtime values, which will be used to more easily create variant visitors.

Speakers
avatar for Michał Dominiak

Michał Dominiak

System Software Engineer, Nvidia


Thursday September 22, 2016 4:45pm - 5:45pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture

9:15pm PDT

Making a tiny memory footprint IRC server in C++
Internet Relay Chat is a simple, text-based communications protocol. Join me for a discussion of how you can use C++ to minimize allocations, avoiding std::string, and support thousands of users on simple servers running on tiny virtual machines.

Speakers
avatar for Alf-Andre Walla

Alf-Andre Walla

Kernel Developer, IncludeOS


Thursday September 22, 2016 9:15pm - 10:00pm PDT
Vanity (Room 404) Meydenbauer Center
 
Friday, September 23
 

8:00am PDT

Using Enum Structs as Bitfields

We will discuss the challenges involved in an solution to the problem of using modern enums as bitfelds. Along the way we'll sneak in a gentle introduction to SFINAE.

Presentation by Jon Kalb, based on an article in Overload magazine by Anthony Williams


Speakers
avatar for Jon Kalb

Jon Kalb

Conference Chair, Jon Kalb, Consulting


Friday September 23, 2016 8:00am - 8:45am PDT
Frey (Room 406) Meydenbauer Center

9:00am PDT

A lock-free concurrency toolkit for deferred reclamation and optimistic speculation
This talk introduces the concept of a Concurrency Toolkit that contains the proposed lock-free algorithms on Hazard Pointers and Read-Copy_Update and analyzes their motivation, while showing where they can be useful and their performance differences.
Under optimistic concurrency, threads may use shared resources concurrently with other threads that may make such resources unavailable for further use. Care must be taken to reclaim such resources only after it is guaranteed that no threads are concurrently using them or will subsequently use them.

More specifically, concurrent dynamic data structures that employ optimistic concurrency allow threads to access dynamic objects concurrently with threads that may remove such objects. Without proper precautions, it is generally unsafe to reclaim the removed objects, as they may yet be accessed by threads that hold references to them. Solutions for the safe reclamation problem can also be used to prevent the ABA problem, a common problem under optimistic concurrency.

There are several methods for safe deferred reclamation. The main methods are garbage collection, reference counting, RCU (read-copy-update), and hazard pointers. Each method has its pros and cons and none of the methods provides the best features in all cases. Therefore, it is desirable to offer users the opportunity to choose the most suitable methods for their use cases.

This talk will show why we are considering their inclusion (with the exception of garbage collection) in future C++ Standards under SG14/SG1 into the Concurrency TS.

Speakers
PE

Paul E. McKenney

Software Engineer, Facebook
Paul E. McKenney has been coding for almost four decades, more than half of that on parallel hardware, where his work has earned him a reputation among some as a flaming heretic. Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present... Read More →
avatar for Maged Michael

Maged Michael

Engineer, Facebook
Maged Michael is a software engineer at Facebook. He is the inventor of hazard pointers, lock-free malloc and several algorithms for concurrent data structures. He received a Ph.D. in computer science from the University of Rochester. He is an ACM Distinguished Scientist. He is an... Read More →
avatar for Michael Wong

Michael Wong

DE, Codeplay
wongmichael.com/about


Friday September 23, 2016 9:00am - 10:00am PDT
Vanity (Room 404) Meydenbauer Center

9:00am PDT

C++ Modules: The State of The Union
I give a report on the progress we have made since last year on specification, standardization, implementation experience, deployment, and user experience with C++ modules. Looking forward, I will give a glimpse into the world of semantics-aware developer tools, including runtime reflection, made possible by C++ module implementation.

Speakers
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Principal Software Engineer, Microsoft
Gabriel Dos Reis is a Principal Software Engineer at Microsoft, where he works in the area of large scale software construction, tools, and techniques. He is also a researcher, and a longtime member of the C++ community, author and co-author of numerous extensions to support large... Read More →


Friday September 23, 2016 9:00am - 10:00am PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture
  • Level Beginner, Intermediate, Advanced, Expert
  • Tags modules

9:00am PDT

How bad is Meta-Programming still today?
When innovation-hungry programmers discovered by accident that C++
allows us to calculate and transform programs at compile time, an
humongous hype was triggered: gigantic research projects were launched
to develop self-optimizing software. Unfortunately, such software also
had gigantic compile times of up to several days on parallel
machines. And the syntax of template meta-programming can drive the
toughest geeks into insanity. Despite this disillusion, the compiler
support improved over the years and constexpr brought us a much
simpler syntax.

In this light we like to ask the questions: What can,
should, and must we compute at compile time? Which new opportunities
offer constexpr and their extension in C++14? What have to be done
in the classical manner still? We will discover the different techniques of
meta-programming with examples of simple examples, type information,
expression templates and meta-tuning. Without becoming unbearably
theoretical, we will show the equivalence of constexpr in C++11 and
C++14 and their Turing completeness.

Speakers
PG

Peter Gottschling

CEO, SimuNova
Peter Gottschling is founder of SimuNova, a company that works on developing the Matrix Template Library (MTL4) and offers C++ training. He is a member of the ISO C++ standards committee, vice-chair of Germany s programming language standards committee, and founder of the C++ User... Read More →


Friday September 23, 2016 9:00am - 10:00am PDT
Kantner (Room 403) Meydenbauer Center
  lecture

9:00am PDT

Implementing Lightweight Object Persistence with Modern C++
Modern C++ brings many exciting and powerful advances to both the core language and the standard C++ library. Among these are changes to the standard allocator requirements that now permit allocators to allocate and deallocate blocks of memory that are addressable by generalized (i.e., non-native) pointers, as well as requirements for allocator-aware containers to employ such pointers.

This talk will describe a slightly different way of thinking about memory allocation, decomposing the idea into four distinct structural concepts – addressing model, storage model, pointer interface, and allocation strategy. To illustrate this new mental framework, we'll examine the design of a standard-conformant allocator that uses shared memory as its storage model, and show how it can be used to construct data structures based on standard C++ containers directly in shared memory. We'll then explore how this particular allocator's address-independent storage model supports a form of lightweight object persistence (with some constraints). Along the way we'll compare and contrast the old C++03 allocator requirements with those of C++14, and we'll also see at least one way to implement a generalized pointer. Finally, if time permits, we'll touch on other storage models and possible applications.

Speakers
avatar for Bob Steagall

Bob Steagall

CppCon Poster Chair, KEWB Computing
I've been working in C++ since discovering the second edition of The C++ Programming Language in a college bookstore in 1992. The majority of my career has been spent in medical imaging, where I led teams building applications for functional MRI and CT-based cardiac visualization... Read More →


Friday September 23, 2016 9:00am - 10:00am PDT
Prince Theater (2nd Floor) Meydenbauer Center

9:00am PDT

Iterator Haiku
Iterator Haiku: How five iterator categories blossomed into seven, and Sentinels trimmed them back to five again. Recently proposed changes to the ranges TS distill its seven iterator categories back to five without sacrificing any expressive power. Removing operations that are extraneous in the Sentinel world eliminates a potential source of programming errors.

Speakers
CC

Casey Carter

Software Engineer II, Microsoft
Casey Carter is longtime user of C++ who recently ended his career in aerospace manufacturing to participate in C++ standardization. After attending a WG21 meeting, his enthusiasm for Concept library design and semantics somehow turned into authorship of the Ranges TS. He is currently... Read More →


Friday September 23, 2016 9:00am - 10:00am PDT
White (Room 407) Meydenbauer Center
  lecture

10:30am PDT

Lifetime Safety... By Default: Making Code Leak-Free by Construction

Lifetime safety means writing code that, by construction, is guaranteed to eliminate two things: (a) use of null/dangling pointers (including pointerlike things such as references, iterators, views, and ranges), and (b) leaks (including the rare 1% case where we’re tempted to admit the possibility of an ownership cycle or need to support lock-free concurrent data structures).

 

Last year, my CppCon 2015 talk “Writing Good C++14… By Default” focused on (a), null/dangling, because it's the more difficult and usually more serious problem. I gave an overview of a new approach of using static analysis rules to eliminate use of null and dangling in C++. That work continues and we’re in the process of writing down the formal rules for the approach that I showed last year.

 

This year, the focus will be on (b), leaks: The talk aims to begin with a set of simple rules, the “5-minute talk” to demonstrate that a handful of rules can be taught broadly to programmers of all levels, and results in code that is clean and free of leak bugs by construction.

 

But, since we’ll still have 85 minutes left, we can use the time to spelunk through a series of “Appendix” code examples, in which we'll demonstrate "why and how" to apply those rules to a series of increasingly complex/difficult situations, and that are aimed at increasingly advanced and “clever” (note: not always a good thing) programs and programmers. We’ll address questions such as: How should we represent Pimpl types? How should we represent trees – what should the child and parent pointer types be, and (when) should they be unique and when shared? How should we deal with “intra-module” or “encapsulated” cycles when you control all the objects in the cycle, such as all the nodes within a Graph? And what about “inter-module” or “compositional” cycles when you don’t know in advance about all the objects that could be in the cycle, such as when combining libraries written by different people in a way that may or may not respect proper layering (notoriously, using callbacks can violate layering)? The answers focus on cases where we have solid guidance, and then move toward some more experimental approaches for potentially addressing the ~1% of cases that aren’t yet well covered by unique_ptr, shared_ptr, and weak_ptr.

Speakers
avatar for Herb Sutter

Herb Sutter

Software architect, Microsoft
Herb is an author, designer of several Standard C++ features, and chair of the ISO C++ committee and the Standard C++ Foundation. His current interest is simplifying C++.


Friday September 23, 2016 10:30am - 12:00pm PDT
Bowie Hall (1st Floor Hall) Meydenbauer Center
  lecture
  • Level Beginner, Intermediate, Advanced, Expert