Loading…
This event has ended. View the official site or create your own event → Check it out
This event has ended. Create your own
View analytic

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

Saturday, September 17
 

9:00am

Concurrent Thinking in C++: Part I
"Concurrent Thinking in C++" is a two day training course taught by Anthony Williams of Just Software Solutions Ltd. This course is for students that have a good knowledge of C++, but no prior knowledge of concurrency or multithreading is assumed. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/concurrent-thinking-in-c/

Speakers
avatar for Anthony Williams

Anthony Williams

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


Saturday September 17, 2016 9:00am - 5:00pm
Frey (Room 406) Meydenbauer Center

9:00am

Crafting Embedded Software in C++: Part I
"Crafting Embedded Software in C++" is a two day training course taught by Dan Saks of Saks & Associates. This course is for students that have basic knowledge of the C++ language and standard library. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/crafting-embedded-software-in-c/

Speakers
DS

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 including The C/C++ Users Journal, The C++ Report, Software Development, and Embedded Systems Design. With Thomas Plum, he wrote C++ Programming Guidelines, which... Read More →


Saturday September 17, 2016 9:00am - 5:00pm
Haggard (Room 408) Meydenbauer Center

9:00am

Modernizing Your C++: Part I
"Modernizing Your C++" is a two day training course taught by Michael Caisse of Ciere Consulting. This course is for students that are comfortable with classic C++, but want to come up to speed with C++11/14. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/modernizing-your-c/

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com


Saturday September 17, 2016 9:00am - 5:00pm
Grimmie (Room 407) Meydenbauer Center

9:00am

Programming with Qt/Widgets: Part I
"Programming with Qt/Widgets" is a two day training course taught by Giuseppe D'Angelo of KDAB. This course is for students that have a good knowledge of C++, but no prior knowledge of Qt is assumed. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/programming-with-qtwidgets/

Speakers
GD

Giuseppe D'Angelo

Senior Software Engineer, KDAB
Giuseppe D’Angelo is a software Engineer at KDAB. Giuseppe is a long time contributor to Qt, having used Qt and C++ since 2000, and he is an Approver in the Qt Project. His contributions in Qt range from containers and regular expressions to GUI, Widgets, and OpenGL. A free software passionate and UNIX specialist, before joining KDAB, he organized conferences on open source around Italy, especially about Perl. He holds a BS in Computer... Read More →


Saturday September 17, 2016 9:00am - 5:00pm
Robinson (Room 409) Meydenbauer Center

9:00am

Using C++ for Low-Latency Systems: Part I
"Using C++ for Low-Latency Systems" is a two day training course taught by Patrice Roy of Sherbrooke University. This course is for students that have an intermediate knowledge of the C++ language; emphasis will be put on robust C++ code with predictable — and fast — runtime behavior. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/using-c-for-low-latency-systems/

Speakers
avatar for Patrice Roy

Patrice Roy

Professor, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 20 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 been involved more specifically in helping graduate students and professionals from the fields of real-time systems and game programming develop the skills they... Read More →


Saturday September 17, 2016 9:00am - 5:00pm
Kantner (Room 403) Meydenbauer Center
 
Sunday, September 18
 

9:00am

Concurrent Thinking in C++: Part II
"Concurrent Thinking in C++" is a two day training course taught by Anthony Williams of Just Software Solutions Ltd. This course is for students that have a good knowledge of C++, but no prior knowledge of concurrency or multithreading is assumed. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/concurrent-thinking-in-c/

Speakers
avatar for Anthony Williams

Anthony Williams

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


Sunday September 18, 2016 9:00am - 5:00pm
Frey (Room 406) Meydenbauer Center

9:00am

Crafting Embedded Software in C++: Part II
"Crafting Embedded Software in C++" is a two day training course taught by Dan Saks of Saks & Associates. This course is for students that have basic knowledge of the C++ language and standard library. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/crafting-embedded-software-in-c/

Speakers
DS

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 including The C/C++ Users Journal, The C++ Report, Software Development, and Embedded Systems Design. With Thomas Plum, he wrote C++ Programming Guidelines, which... Read More →


Sunday September 18, 2016 9:00am - 5:00pm
Haggard (Room 408) Meydenbauer Center

9:00am

Modernizing Your C++: Part II
"Modernizing Your C++" is a two day training course taught by Michael Caisse of Ciere Consulting. This course is for students that are comfortable with classic C++, but want to come up to speed with C++11/14. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/modernizing-your-c/

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com


Sunday September 18, 2016 9:00am - 5:00pm
Grimmie (Room 407) Meydenbauer Center

9:00am

Programming with Qt/Widgets: Part II
"Programming with Qt/Widgets" is a two day training course taught by Giuseppe D'Angelo of KDAB. This course is for students that have a good knowledge of C++, but no prior knowledge of Qt is assumed. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/programming-with-qtwidgets/

Speakers
GD

Giuseppe D'Angelo

Senior Software Engineer, KDAB
Giuseppe D’Angelo is a software Engineer at KDAB. Giuseppe is a long time contributor to Qt, having used Qt and C++ since 2000, and he is an Approver in the Qt Project. His contributions in Qt range from containers and regular expressions to GUI, Widgets, and OpenGL. A free software passionate and UNIX specialist, before joining KDAB, he organized conferences on open source around Italy, especially about Perl. He holds a BS in Computer... Read More →


Sunday September 18, 2016 9:00am - 5:00pm
Robinson (Room 409) Meydenbauer Center

9:00am

Using C++ for Low-Latency Systems: Part II
"Using C++ for Low-Latency Systems" is a two day training course taught by Patrice Roy ofSherbrooke University. This course is for students that have an intermediate knowledge of the C++ language; emphasis will be put on robust C++ code with predictable — and fast — runtime behavior. It is offered at the Meydenbauer from 9AM to 5PM on Saturday and Sunday, September 17th & 18th (immediately prior to the conference). Box lunch included. Course and instructor details are available at http://cppcon.org/using-c-for-low-latency-systems/

Speakers
avatar for Patrice Roy

Patrice Roy

Professor, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 20 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 been involved more specifically in helping graduate students and professionals from the fields of real-time systems and game programming develop the skills they... Read More →


Sunday September 18, 2016 9:00am - 5:00pm
Kantner (Room 403) Meydenbauer Center

8:00pm

Registration / Reception
Come for the registration and stay for the reception.

Get your badge, your registration package, and, if you ordered one, your shirt.

Stick around and get acquainted with new friends and reacquainted with old friends.

Sunday September 18, 2016 8:00pm - 10:00pm
Vanity (Room 404) Meydenbauer Center
 
Monday, September 19
 

8:00am

Registration
Welcome! Let's get the paperwork out of the way.

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

9:00am

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

MD, Morgan Stanley
C++: history, design, use, standardization, future; performance, reliability; software developer education; | distributed systems


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

11:00am

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

Senior Software Engineer, Microsoft Visual C++
James McNellis is a senior engineer on the Visual C++ team at Microsoft, where he works on C++ library design and is responsible for the Microsoft C Runtime (CRT) and C Standard Library implementation. He can be found on Twitter at @JamesMcNellis and can be found elsewhere online via http://www.jamesmcnellis.com.


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

11:00am

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 Charles Bay

Charles Bay

Senior Software Engineer, F5 Networks
Software developer with 25+ years experience in large-scale and distributed systems in performance-sensitive environments including real-time processing, performance visualization, embedded systems, time-sensitive processing of large data sets, hardware status-and-control, and instrument/process/sub-assembly monitoring.


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

11:00am

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 <regex>.


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

11:00am

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

Coding Manager, Creative Assembly
Coding Manager of Creative Assembly, makers of the Total War franchise, Alien:Isolation and the upcoming Halo Wars sequel, Guy has been writing games since the early 1980s. He is now also a contributor to SG14, the study group devoted to low latency, real time requirements, and performance/efficiency especially for Games, Financial/Banking, and Simulations. He speaks at schools, colleges and universities about programming and likes to help good... Read More →
avatar for Nicolas Guillemot

Nicolas Guillemot

MSc Student, University of Victoria
Hi, nice to meet you! My name is Nicolas, and my main interests are game development, real-time rendering, graphics hardware and graphics APIs. I tackle problems at the intersection of designing efficient computer algorithms and leveraging the strengths of hardware. My favorite thing about C++ is that it lets me write detailed systems-level code and high-level GUI code together in a single robust language.
SM

Sean Middleditch

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

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


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

11:00am

Using Types Effectively
C++ has a pretty good type system, and modern C++ gives us a greater ability than ever before to use that type system for good: to make APIs easier to use and harder to misuse, to make our datatypes more closely express our intent, and generally to make code safer, more obvious in function and perhaps even faster.

This is an interactive session - incorporating games played between presenter and audience, even - taking a look at choices available to us as datatype and API designers, and examining how a little knowledge about the algebra of algebraic datatypes can help. We'll see why std::optional and (hopefully soon) std::variant will quickly become an essential part of everyone's toolbox, and also explore how types can be used to express not just the structure of data, but also the behaviour of objects and functions.

Speakers
avatar for Ben Deane

Ben Deane

Principal Software Engineer, Blizzard Entertainment
Ben has been writing games for almost 20 years, and in C++ for most of that. He is currently a Principal Engineer at Blizzard Entertainment where he works on the Battle.net team. He's always looking for useful new techniques in C++, and he likes functional programming.


Monday September 19, 2016 11:00am - 12:00pm
Bowie Hall (1st Floor Hall) Meydenbauer Center

2:00pm

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
White (Room 407) Meydenbauer Center

2:00pm

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
AM

Alisdair Meredith

Bloomberg LP
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 project that would become C++11, and also fixed the contents of the original library TR. | | He is currently working on the BDE project, BloombergLP's open... Read More →


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

2:00pm

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

Programmer
John McFarlane has used C++ for twenty years, specializing in simulation, AI and interactivity. He is a contributor to Study Groups 6 and 14 and is involved in standardizing fixed-point arithmetic.
avatar for Robert Ramey

Robert Ramey

Proprietor, 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.  He is the author and maintainer of the Boost... Read More →


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

2:00pm

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

Chief Software Architect, Tanium
Lisa Lippincott is Chief Software Architect at Tanium, a bay-area startup. Her claim to fame is writing one phrase appearing in the C++ standard. In her spare time, she studies mathematical logic with a category-theoretic approach.


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

2:00pm

Computer Architecture, C++, and High Performance
With the increase in the available computational power, the Nathan Myhrvold's Laws of Software continue to apply: New opportunities enable new applications with increased needs, which subsequently become constrained by the hardware that used to be "modern" at adoption time. C++ itself opens the access to high-quality optimizing compilers and a wide ecosystem of high-performance tooling and libraries. At the same time, simply turning on the highest optimization flags and hoping for the best is not going to automagically yield the highest performance -- i.e., the lowest execution time. The reasons are twofold: Algorithms' performance can differ in theory -- and that of their implementations can differ even more so in practice.

Modern CPU architecture has continued to yield increases in performance through the advances in microarchitecture, such as pipelining, multiple issue (superscalar) out-of-order execution, branch prediction, SIMD-within-a-register (SWAR) vector units, and chip multi-processor (CMP, also known as multi-core) architecture. All of these developments have provided us with the opportunities associated with a higher peak performance -- while at the same time raising new optimization challenges when actually trying to reach that peak.

In this talk we'll consider the properties of code which can make it either friendly -- or hostile -- to a modern microprocessor. We will offer advice on achieving higher performance, from the ways of analyzing it beyond algorithmic complexity, recognizing the aspects we can entrust to the compiler, to practical optimization of the existing code. Instead of stopping at the "you should measure it" advice (which is correct, but incomplete), the talk will be focused on providing practical, hands-on examples on _how_ to actually perform the measurements (presenting tools -- including perf and likwid -- simplifying the access to CPU performance monitoring counters) and how to reason about the resulting measurements (informed by the understanding of the modern CPU architecture, generated assembly code, as well as an in-depth look at how the CPU cycles are spent using modern microarchitectural simulation tools) to improve the performance of C++ applications.

Slides: https://speakerdeck.com/mattpd/computer-architecture-c-plus-plus-and-high-performance-cppcon-2016
Resources: https://github.com/MattPD/cpplinks

Speakers
avatar for Matt P. Dziubinski

Matt P. Dziubinski

Research & Development, Aalborg University
Matt P. Dziubinski is affiliated with the Department of Mathematical Sciences, Aalborg University, Denmark and a Junior Fellow at Center for Research in Econometric Analysis of Time Series (CREATES). His fascination with computers started in the late 1980s with an 8-bit Atari. His current research interests include Quantitative Finance and High Performance Scientific Computing, with a focus on applied cross-platform parallel computing... Read More →


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

2:00pm

A <chrono> Tutorial
This talk starts very simple: with seconds. It explains exactly what a second is: what is under the hood, what it can do, and most importantly how and why it fails at compile time. Failing at compile time, instead of at run time is the critical design philosophy that runs through chrono.

Slowly the talk adds complexity: other units of time duration, custom time durations, conversions among durations, points in time, etc. With each addition, another layer of the chrono onion is peeled away.

By the end of the talk, you will understand both the importance of the simplicity of chrono, and the power available to you if you avoid the typical mistakes beginners make when first learning chrono. Even experts will find at least one undiscovered gem in this talk to take back to their own code. And you may see ways to transfer some of the chrono design principles into your own designs.

People who attend this talk will be especially well prepared for my later talk about time zones.

This talk is a prequel to my CppCon 2015 talk: https://www.youtube.com/watch?v=tzyGjOm8AKo

Now available at: https://www.youtube.com/watch?v=P32hvk8b13M

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://github.com/HowardHinnant/date



Monday September 19, 2016 2:00pm - 3:00pm
Frey (Room 406) Meydenbauer Center

2:00pm

Template Normal Programming (part 1 of 2)
    What is "template normal programming"? It's template metaprogramming without so much of the "meta" part!  During this talk, I promise not to mention SFINAE, or recursion, or standard type traits. We'll focus on the common scenarios "I think this code could benefit from templates, but I don't understand how to organize it;" "I can't get anything to compile without errors;" and "My coworker wrote some template code and I don't understand any of it." 

    In Part I of the talk, we'll start with function templates and class templates, then explain variable templates (new in C++14) and template aliases (new in C++11). We'll do a deep dive into template type deduction; then talk about full and partial specialization; and finish up with an example that motivates the final feature of C++11 template syntax, explicit instantiation.

    In Part II of the talk, we'll begin by demystifying tag dispatch and traits classes; discuss situations in which you have to add disambiguating "template" or "typename" keywords (and why); and do a deep dive into the rules of what gets instantiated when and where. We'll revisit template type deduction just long enough to explain how it works for variadic templates; and explain two common template idioms — the Curiously Recurring Template Pattern and the Mixin Pattern.
    Time permitting, we'll finish by exploring the big new features of templates according to the C++17 Draft Standard:
    - template
    - type deduction for class template constructors
    - explicit deduction guides
Slides are here: Part 1, Part 2

Speakers
avatar for Arthur O'Dwyer

Arthur O'Dwyer

Software Engineer, Mixpanel
Arthur O'Dwyer worked for many years at Green Hills Software, making the world's most optimizing C and C++ compilers. Now he works at Mixpanel in San Francisco, where he organizes a monthly C++ meetup.


Monday September 19, 2016 2:00pm - 3:00pm
Vanity (Room 404) Meydenbauer Center

3:15pm

Designing C++ portable SIMD support
SIMD extensions have been a feature of choice for processor manufacturers for a couple of decades. Designed to exploit data parallelism in applications at the instruction level, these extensions still require a high level of expertise or the use of potentially fragile compiler support or vendor-specific libraries. While a large fraction of their theoretical accelerations can be obtained using such tools, exploiting such hardware becomes tedious as soon as application portability across hardware is required.

Accessing such capabilities directly from C++ code could be a major improvements in a lot of use cases. Different take on this has been proposed either by the community or as an actual standard proposal. Solutions include pragma based annotations, standard algorithms policies, full blown compiler support and libraries.
In this talk we will present one such solution - the Boost.SIMD library (currently being proposed as such) which takes a library approach to this issues.

We will go over the basic notion required to grasp SIMD programming in general. Then, we'll discuss the different existing approaches. We will describe Boost.SIMD API and API design to demonstrate how it solves issues raised by the actual idiomatic way of writting SIMD enabled code. Design issues like standard algorithm integration, memory handling and how to fill the gaps in SIMD instructions sets will be discussed. Finally, we show its performances with respect to a subset of well known benchmarks.

Speakers
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 in Orsay, France.


Monday September 19, 2016 3:15pm - 4:15pm
Robinson (Room 409) Meydenbauer Center

3:15pm

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
AM

Alisdair Meredith

Bloomberg LP
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 project that would become C++11, and also fixed the contents of the original library TR. | | He is currently working on the BDE project, BloombergLP's open... Read More →


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

3:15pm

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, getting interested in programming again, building a game engine, and stumbling across some generalized solutions to some old problems.


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

3:15pm

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

Visual C++ Development Manager, Microsoft Corporation
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

Program Manager, Microsoft
Visual Studio


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

3:15pm

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

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 known through his involvement in open source software projects, mainly as the author of several C++ libraries he has contributed to Boost, which are in use by... Read More →


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

3:15pm

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

Chief Software Architect, Tanium
Lisa Lippincott is Chief Software Architect at Tanium, a bay-area startup. Her claim to fame is writing one phrase appearing in the C++ standard. In her spare time, she studies mathematical logic with a category-theoretic approach.


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

3:15pm

Template Normal Programming (part 2 of 2)
    What is "template normal programming"? It's template metaprogramming without so much of the "meta" part!  During this talk, I promise not to mention SFINAE, or recursion, or standard type traits. We'll focus on the common scenarios "I think this code could benefit from templates, but I don't understand how to organize it;" "I can't get anything to compile without errors;" and "My coworker wrote some template code and I don't understand any of it." 

    In Part I of the talk, we'll start with function templates and class templates, then explain variable templates (new in C++14) and template aliases (new in C++11). We'll do a deep dive into template type deduction; then talk about full and partial specialization; and finish up with an example that motivates the final feature of C++11 template syntax, explicit instantiation.

    In Part II of the talk, we'll begin by demystifying tag dispatch and traits classes; discuss situations in which you have to add disambiguating "template" or "typename" keywords (and why); and do a deep dive into the rules of what gets instantiated when and where. We'll revisit template type deduction just long enough to explain how it works for variadic templates; and explain two common template idioms — the Curiously Recurring Template Pattern and the Mixin Pattern.
    Time permitting, we'll finish by exploring the big new features of templates according to the C++17 Draft Standard:
    - template
    - type deduction for class template constructors
    - explicit deduction guides
Slides are here: Part 1Part 2

Speakers
avatar for Arthur O'Dwyer

Arthur O'Dwyer

Software Engineer, Mixpanel
Arthur O'Dwyer worked for many years at Green Hills Software, making the world's most optimizing C and C++ compilers. Now he works at Mixpanel in San Francisco, where he organizes a monthly C++ meetup.


Monday September 19, 2016 3:15pm - 4:15pm
Vanity (Room 404) Meydenbauer Center

4:45pm

#Include <os>: 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 C++ for 5 years. I'm working on a PhD in the area of cloud computing under the working title "Resource efficient Cloud Computing using minimal virtual machines" and... Read More →


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

4:45pm

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
avatar for Paul E. McKenney

Paul E. McKenney

Distinguished Engineer, IBM Linux Technology Center
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. Over the past decade, Paul has been an IBM Distinguished Engineer at the IBM Linux Technology Center. Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present highly entertaining performance, scalability, real-time response... Read More →


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

4:45pm

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 and has applied them in the design of real-time embedded space systems at NASA JPL and the HPC data-intensive applications at Sandia National Labs. 
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 performance critical applications. He has also collaborated with Sandia National Laboratory on large scale performance monitoring and simulation analysis.



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

4:45pm

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.

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

4:45pm

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 professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now conferences and is especially well known for his advanced functional programming in C++ talks. David’s... Read More →


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

4:45pm

The C++17 Parallel Algorithms Library and Beyond
One of the major library features in C++17 is a parallel algorithms library (formerly the Parallelism Technical Specification v1). The parallel algorithms library has both parallel versions of the existing algorithms in the standard library and a handful of new algorithms inspired by common patterns from parallel programming (such as std::reduce() and std::transform_reduce()).

We’ll talk about what’s in the parallel algorithms library, and how to utilize it in your code today. Also, we’ll discuss some exciting future developments relating to the parallel algorithms library which are targeted for the second version of the Parallelism Technical Specification – executors, and asynchronous parallel algorithms.

Speakers
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

Lawrence Berkeley National Laboratory
Bryce Adelstein Lelbach is a researcher at Lawrence Berkeley National Laboratory (LBNL), a US Department of Energy research facility. Working alongside a team of hardware engineers and scientists, he develops and analyzes new parallel programming models for exascale and post-Moore architectures. Bryce is one of the developers of the HPX C++ runtime system. He spent five years working on HPX while he was at Louisiana State University's Center... Read More →


Monday September 19, 2016 4:45pm - 5:45pm
Prince Theater (2nd Floor) Meydenbauer Center

8:30pm

Grill the Committee
What would you like to know about the C++ standard?

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

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Speakers
avatar for Hans Boehm

Hans Boehm

Google
Hans is the WG21 SG1 (Concurrency) Chair, and co-led the design of the C++ memory model and atomic operations. He now mostly works on concurrency-related issues in Android, and occasionally on teaching calculators to calculate correctly. In the past, he mostly focused on garbage collection. He is the original primary author of bdwgc, a conservative garbage collector for C and C++. http://hboehm.info
avatar for Chandler Carruth

Chandler Carruth

C++ Lead, 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 active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all... Read More →
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 pursuing interests in Ranges, world domination, and doughnuts at Microsoft Redmond.
MC

Marshall Clow

Principal Engineer, Qualcomm, Inc.
Marshall is a long-time LLVM and Boost participant. He is a principal engineer at Qualcomm, Inc. in San Diego, and the code owner for libc++, the LLVM standard library implementation. He is the author of the Boost.Algorithm library and maintains several other Boost libraries.
GD

Gabriel Dos Reis

Principal Software Engineer, Microsoft
avatar for Bjarne Stroustrup

Bjarne Stroustrup

MD, Morgan Stanley
C++: history, design, use, standardization, future; performance, reliability; software developer education; | distributed systems
avatar for Herb Sutter

Herb Sutter

Software architect, Microsoft
Author, chair of the ISO C++ committee, software architect at Microsoft.
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Monday September 19, 2016 8:30pm - 10:00pm
Prince Theater (2nd Floor) Meydenbauer Center
  • Level Beginner, Intermediate, Advanced, Expert
 
Tuesday, September 20
 

8:15am

SG14 meeting Wednesday:Towards better support in C++ for Games and Finance
Two significant areas where C++ violates "don't pay for what you don't use" are RTTI and exception handling. So much so that some groups turn it off for performance reasons.

Two industries that do so but still use C++ heavily are Games and Financial/Trading. They are among the highest employer of C++ programmers. So have you wondered how C++ can be improved for low-latency applications like Games and Financial/Trading. The emphasis is performance in low-latency, soft-real-time, simulation, graphics, simulation applications.

ISO C++ decided to start a Study Group 14 to officially analyze proposals to improve C++ in these important domains and it will occur on Wednesday as an official C++ Standard meeting. If you are in these domains and are interested in analyzing proposals, or just want to see how a C++ Standard meeting is run, please come to this Open Content talk to find out more about Wednesday's SG14 meeting.

Speakers
avatar for Nicolas Guillemot

Nicolas Guillemot

MSc Student, University of Victoria
Hi, nice to meet you! My name is Nicolas, and my main interests are game development, real-time rendering, graphics hardware and graphics APIs. I tackle problems at the intersection of designing efficient computer algorithms and leveraging the strengths of hardware. My favorite thing about C++ is that it lets me write detailed systems-level code and high-level GUI code together in a single robust language.
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Tuesday September 20, 2016 8:15am - 8:45am
Frey (Room 406) Meydenbauer Center

9:00am

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

Senior Software Engineer, Microsoft Visual C++
James McNellis is a senior engineer on the Visual C++ team at Microsoft, where he works on C++ library design and is responsible for the Microsoft C Runtime (CRT) and C Standard Library implementation. He can be found on Twitter at @JamesMcNellis and can be found elsewhere online via http://www.jamesmcnellis.com.


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

9:00am

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

C++ Lead, 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 active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all... Read More →


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

9:00am

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
Hi, nice to meet you! My name is Nicolas, and my main interests are game development, real-time rendering, graphics hardware and graphics APIs. I tackle problems at the intersection of designing efficient computer algorithms and leveraging the strengths of hardware. My favorite thing about C++ is that it lets me write detailed systems-level code and high-level GUI code together in a single robust language.


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

9:00am

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

Principal Software Engineer, Blizzard Entertainment
Ben has been writing games for almost 20 years, and in C++ for most of that. He is currently a Principal Engineer at Blizzard Entertainment where he works on the Battle.net team. He's always looking for useful new techniques in C++, and he likes functional programming.


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

9:00am

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

Professor, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 20 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 been involved more specifically in helping graduate students and professionals from the fields of real-time systems and game programming develop the skills they... Read More →


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

9:00am

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 with a perverse love for template meta-programming, Edouard likes to come up with uncompromising solutions to seemingly impossible problems. He lives in Paris... 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 in Orsay, France.


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

9:00am

GDB - a lot more than you realized
If you’re writing C++ for anything other than Windows, chances are that you occasionally break out GDB. This session presents some of the lesser known features of GDB that can change the way you debug. GDB has come a long way in the last few years and now does so much more than break, print, step and continue. Reversible debugging; Non-Stop Mode; Multi-process Debugging; and Dynamic Printf are but some of its best features, and its built-in Python scripting is particularly powerful. Join Undo co-founder and CEO, Greg Law, as he takes you through a series of demos to show some amazing tricks with GDB and some of its powerful new (and not-so-new) features that you may not have heard of.

Speakers
avatar for Greg Law

Greg Law

CEO, Undo Ltd
Greg is a software geek at heart, but likes to keep one foot in the software world and one foot in the business world. He finds it particularly rewarding to turn innovative software technology into “real” business development. Greg has over 20 years of experience in both academia and innovative start-up software companies. In 2005 he co-founded Undo Software, which he now runs.


Tuesday September 20, 2016 9:00am - 10:00am
Vanity (Room 404) Meydenbauer Center

10:30am

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
DS

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 including The C/C++ Users Journal, The C++ Report, Software Development, and Embedded Systems Design. With Thomas Plum, he wrote C++ Programming Guidelines, which... Read More →


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

12:30pm

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, basketball and, of course, fixing bugs in software.


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

12:30pm

C++ in Colleges Panel
Join a panel of college professors, recent and current undergraduates, and professionals with teaching and outreach experience as we discuss how to engage students in C++. Why is it important to teach C++ early, and is it an appropriate choice for a first programming language? Are colleges teaching C++ less than they used to? Are colleges teaching C++ well? How can the C++ community better engage students in open source and in industry?

Speakers
avatar for Michał Dominiak

Michał Dominiak

Software Engineer, Nokia Networks
Bachelor of Engineering in Computer Science, studied at Faculty of Electronics at Wrocław University of Technology. Loves metaprogramming and doing as much as possible during compile time, instead of wasting precious cycles at runtime.
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 in Orsay, France.
HK

Hartmut Kaiser

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 known through his involvement in open source software projects, mainly as the author of several C++ libraries he has contributed to Boost, which are in use by... Read More →
avatar for Jackie Kay

Jackie Kay

Software Engineer, Marble Robotics
I write FOSS tools for the robotics community.
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

Lawrence Berkeley National Laboratory
Bryce Adelstein Lelbach is a researcher at Lawrence Berkeley National Laboratory (LBNL), a US Department of Energy research facility. Working alongside a team of hardware engineers and scientists, he develops and analyzes new parallel programming models for exascale and post-Moore architectures. Bryce is one of the developers of the HPX C++ runtime system. He spent five years working on HPX while he was at Louisiana State University's Center... Read More →
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 in C++ through open source, academic, and industry work, Patrick is enthusiastic about pushing the our understanding of C++ forward. To that end, Patrick teaches... Read More →
avatar for Vittorio Romeo

Vittorio Romeo

Software Engineer, Bloomberg LP
Vittorio Romeo is an Italian 21 year old Computer Science student at "Università degli Studi di Messina". He began programming at a very young age and is now a C++ enthusiast. While following the evolution of the C++ standard and embracing the newest features, he worked on several open-source projects, including modern general-purpose libraries and free cross-platform indie games. Vittorio is an active member of the C++ community: he... Read More →
avatar for Patrice Roy

Patrice Roy

Professor, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 20 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 been involved more specifically in helping graduate students and professionals from the fields of real-time systems and game programming develop the skills they... Read More →
avatar for Brett Searles

Brett Searles

Principal Architect, Attobotics
Work in hardware, embedded, graphics and web-based software space. Currently working on a Holographic Surgical Center to allow surgeons to perform simulated surgeries on real patient data. Also working with a major electronics distributor on a SAAS tool for their customers to easily interchange embedded environments.


Tuesday September 20, 2016 12:30pm - 1:30pm
Prince Theater (2nd Floor) Meydenbauer Center

2:00pm

Implementing a Modern C++ MQTT Client for Embedded Devices
Many IoT (Internet of Things) devices have adopted MQTT (Message Queueing Telemetry Transport) as an efficient protocol for communication. Few IoT devices have embraced modern C++ as a viable language for implementations. MQTT is a reliable publish-subscriber based messaging protocol that can be found in diverse ecosystems such as servers, cell phones, and light bulbs. Unfortunately, existing open source libraries leave much to be desired and many are a rich source of bad practices when compared to modern techniques. This session will explore maqiatto, CiereLab’s open source MQTT client library written for embedded systems in modern C++ . There will be a brief demonstration of the library followed by digging into the design and implementation while providing the resource “cost” of various solutions. As we explore the C++14 code base to illustrate useful idioms and techniques for your own code we will answer the questions, what does is take to put modern C++ on a small OS-less device or a cell phone? Are there features to avoid? Join us and see how libraries can be elegantly designed and implemented for big or small targets alike.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com


Tuesday September 20, 2016 2:00pm - 3:00pm
Frey (Room 406) Meydenbauer Center

2:00pm

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 Infrastructure Manager, 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, Library Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos... Read More →


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

2:00pm

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

Principal 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
Prince Theater (2nd Floor) Meydenbauer Center

2:00pm

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
Bowie Hall (1st Floor Hall) Meydenbauer Center

2:00pm

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

Staff Software Engineer, SYCL, 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

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


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

2:00pm

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 code in Fortran, C, and C++ for numerical simulations of the cosmic structure formation, Timur became committed to audio and music production software. Before joining... Read More →


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

3:15pm

Conan, a C and C++ package manager for developers
Conan is a FOSS (MIT license) and portable C and C++ package manager for developers:



  • Decentralized, git-like, the server is also released OSS, so it can be hosted in-house, and use conan totally behind the firewall, or just for your private packages. Using local caches, allows full offline usage, also for creating and testing packages.

  • Handles both binary packages and building them from source. Packages defined with simple yet powerful python recipes. Build system agnostic, so any build system can be wrapped while creating packages. Generators also allow to consume packages directly from many environments: CMake, Visual Studio, XCode, etc.

  • Growing and Involved community, contributing in Github repositories with code and feedback, and actively using conan.



This talk will give a brief technical introduction to conan, showing first how to consume existing packages, defining dependencies, using generators for different build systems (e.g. cmake), using package options (e.g. shared/static linkage) and settings (compiler, version, architecture, libstdc++/libc++/libstdc++11, build type, etc) to install or build the right packages. Also, different handling of paths for shared libraries in different OS will be summarized, and how conan approaches them.

Then, how to create packages will be introduced by example. How to retrieve source code from external sources (github, sourceforge, or any other origin), or integrating the recipe in the same source project, how to build the packages from sources, considering the different inputs (as compiler, architecture, etc. settings and options), how to package artifacts and how to define package information. A short discussion about how upstream dependencies affect your own package depending on linkage, visibility, versions, etc, will be done.

Speakers
avatar for Diego Rodriguez-Losada

Diego Rodriguez-Losada

SW Engineer, Freelance
Diego's passions are robotics and SW development. He has developed many years in C and C++ in the Industrial, Robotics and AI fields. He was also a University (tenure track) professor till 2012, when he quit academia to try to build a C/C++ dependency manager, co-founded startup biicode, since then mostly developing in Python. Now he is working as freelance and having fun with conan.io.


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

3:15pm

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

Senior Staff Engineer, 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 most likely be found in LWG. He received his B.S. and M.S in Applied Mathematics from the University of Tulsa and is currently working on a Ph.D. in Computer Science. If asked, he will tell stories from his research semester at NCSA when web browsers... Read More →


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

3:15pm

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

Senior Software Engineer, PAR Government Systems Corporation
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
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 available for contracting and onsite training.


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

3:15pm

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 Infrastructure Manager, 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, Library Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos... Read More →


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

3:15pm

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
Bowie Hall (1st Floor Hall) Meydenbauer Center

3:15pm

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

Senior Software Engineer, Microsoft Visual C++
James McNellis is a senior engineer on the Visual C++ team at Microsoft, where he works on C++ library design and is responsible for the Microsoft C Runtime (CRT) and C Standard Library implementation. He can be found on Twitter at @JamesMcNellis and can be found elsewhere online via http://www.jamesmcnellis.com.


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

3:45pm

Out of Memory? Business as usual: Examining applications that do not terminate on std::bad_alloc
System memory holds a special place in the hierarchy of program resources; its availability is the implied precondition for many innocuous lines of code, from std::string::substr() to passing std::function<> by value. The ability to always create another object is ingrained in the OOP mindset so much that it is often said that immediate termination is the cleanest way to handle memory allocation failures in most situations. Nevertheless, C++, when consistently applying RAII, makes it possible to treat memory allocation exactly as any other resource acquisition.

To what degree do actual applications take advantage of that possibility and what responses to allocation failures are there in the wild? This presentation will examine over 300 open source projects that incorporate explicit handling for std::bad_alloc, examine the causes (it’s not always “out of memory”), response strategies (it’s more than just rollback), and related practical considerations.

Speakers
avatar for Sergey Zubkov

Sergey Zubkov

Morgan Stanley
Sergey is a former biochemistry researcher and OS developer, who now works in finance and spends his free time editing cppreference.com


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

3:45pm

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

Diego Rodriguez-Losada

SW Engineer, Freelance
Diego's passions are robotics and SW development. He has developed many years in C and C++ in the Industrial, Robotics and AI fields. He was also a University (tenure track) professor till 2012, when he quit academia to try to build a C/C++ dependency manager, co-founded startup biicode, since then mostly developing in Python. Now he is working as freelance and having fun with conan.io.


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

3:45pm

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 developer efficiency engineer at Facebook. If he talks too much, disable him with a well-placed nerd snipe.


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

4:45pm

Writing applications in modern C++ and Qt
I started writing my own Content Managment System for Meeting C++ last year. One of the goals for this project is to seperate the Qt GUI code from the layer that handles the logic and data storage, written in modern C++ and boost. This presentation will focus on my usage of modern C++ to implement the CMS.

Today my CMS has a little bit more then 10k loc, uses boost extensively and has a Qt GUI as the user facing frontend. In this talk I will focus on how boost powers the application and where I had to find my own solutions. I knew that with boostache there is a library for text templates, which later also inspired me to write a generic layer to use JSON for import and data storage in my CMS. The resulting generic_json library is currently a prototype, but a very interesting idea: uniting several json libraries into one interface. This way my own code is not hard wired to a specific JSON library.

Speakers
avatar for Jens Weller

Jens Weller

C++ Evangelist, Meeting C++
Jens Weller is the organizer and founder of Meeting C++. Doing C++ since 1998, he is an active member of the C++ Community. From being a moderator at c-plusplus.de and organizer of his own C++ User Group since 2011 in Düsseldorf, his roots are in the C++ Community. Today his main work is running the Meeting C++ Platform (conference, website, social media and recruiting). His main role has become being a C++ evengalist, as this he speaks and... Read More →


Tuesday September 20, 2016 4:45pm - 5:45pm
Frey (Room 406) Meydenbauer Center

4:45pm

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 Infrastructure Manager, 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, Library Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos... Read More →


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

4:45pm

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 automation, tools/plugins/scripts for content creators, automated testing, game/toolchain optimizations, and many other generalist engineering tasks. Jason has... Read More →


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

4:45pm

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 Gabor Horvath

Gabor Horvath

Software Engineer, Ericsson
Gabor finished his Masters and started a PhD recently. He is a contributing to research projects related to static analysis since 2012. He is a clang contributor, participated in Google Summer of Code twice and interned at Apple. He teaches C++ to undergrads at Eotvos Lorand University.


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

4:45pm

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 Engineering Scientist, Mentor Graphics
Fedor G Pikus is a Chief Engineering Scientist in the Design to Silicon division of Mentor Graphics Corp. 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 Mentor Graphics in 1998 when he made a switch from academic research in computational physics to software industry. His responsibilities as a Chief Scientist include planning long-term... Read More →


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

4:45pm

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 actually spell) and cats (although he doesn't own any).


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

4:45pm

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://github.com/HowardHinnant/date



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

6:15pm

Come learn about the cutting-edge C++ technology Tower uses!

Happy Hour with Tower's Developers


Tuesday September 20, 2016 6:15pm - 8:00pm
Tavern Hall 505 Bellevue Square, Bellevue, WA 98004

8:30pm

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com

Tuesday September 20, 2016 8:30pm - 10:00pm
Prince Theater (2nd Floor) Meydenbauer Center
 
Wednesday, September 21
 

8:30am

ISO SG14 Working Meeting
Limited Capacity seats available

ISO Study Group 14 “Game Development and Low Latency” working session. Conference attendance is not required to participate in the SG14 meeting, but a separate ticket is. Registration is here.

Moderators
avatar for Herb Sutter

Herb Sutter

Software architect, Microsoft
Author, chair of the ISO C++ committee, software architect at Microsoft.
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →

Wednesday September 21, 2016 8:30am - 5:30pm
Robinson (Room 409) Meydenbauer Center

9:00am

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 professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now conferences and is especially well known for his advanced functional programming in C++ talks. David’s... Read More →


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

9:00am

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 in C++ through open source, academic, and industry work, Patrick is enthusiastic about pushing the our understanding of C++ forward. To that end, Patrick teaches... Read More →


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

9:00am

Optimally Shooting Furry Balls out of Vulkanoes
Real-time 3D graphics rendering is commonly agreed upon as one of the more interesting haunting grounds for a programmer. Similarly, whether by way of presentations or canonical books, experts in the field talk about using C++ for rendering beautiful scenes. It is just that when looking at the “C++” bits they don’t quite seem…right. In effect, they frequently look like anything but what has come to be accepted as idiomatic, modern, good quality C++. And this was before the advent of a new generation of graphics APIs whose claim to fame is being “low-level”, and thus, in some sense, even more abstraction adverse. One must wonder, is this the only way to get pixels on our HiDPI screens to light up in pleasing patterns?
Having been on the receiving end of more than one “this uses modern C++, and no function-like macros, how can it possibly work for what we do?” tirades, the talk’s author thinks that a better way exists. Attendees will see that it is possible to write beautiful, clean, portable C++ that yields beautiful graphics by leveraging the recently released Vulkan API. Using bottoms-up design, a minimal yet sufficient set of generic abstractions emerges, freeing programmers from the burden of dealing with API idiosyncrasies. The best part? These abstractions will be derived live, by the audience and the presenter, and we will see that the essence of things is straightforward, and not some mysterious ineffable quantity only known to a handful of gurus.

Speakers
avatar for Alexandru Voicu

Alexandru Voicu

Until recently, I was a Senior Software Engineer at Imagination Technologies, where I did my best to drive GPUs towards painting the prettiest pixels imaginable in no more than 16.6 milliseconds per masterpiece. A large part of my work concerned itself with obtaining generic C++ abstractions that optimally map to modern APIs, such as Vulkan or DirectX 12. Before joining Imagination Technologies, I spent a fair amount of time breaking things in... Read More →



Wednesday September 21, 2016 9:00am - 10:00am
Kantner (Room 403) Meydenbauer Center

9:00am

Asynchronous IO with Boost.Asio
Reactive systems are found everywhere. The temptation to implement them with legions of waiting threads can be strong; however, the result is nearly always disappointing. The Boost.Asio library provides a framework to handle asynchronous resources with specific classes directed toward networking, serial port I/O, timers and more. In this session we will introduce Asio and some best practices while implementing a simple TCP client and server.

Asio has been submitted to the C++ Standards Committee for inclusion and can be found in the Boost library collection or as a stand-alone version. Come and learn a better way to implement reactive systems with the Asynchronous I/O library.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com


Wednesday September 21, 2016 9:00am - 10:00am
Vanity (Room 404) Meydenbauer Center

9:00am

The Blaze High Performance Math Library
In this presentation we introduce the Blaze C++ math library, a hot contender for the linear algebra performance throne. Blaze is an open-source, high-performance library for dense and sparse arithmetic. It combines elegance and ease of use with HPC-grade performance, making it one of the most intuitive and at the same time fastest C++ math libraries available.

We demonstrate its basic linear algebra functionality by means of several BLAS level 1 to 3 operations and explain why Blaze outperforms even well established linear algebra libraries. Additionally, we present some advanced features that enable users to adapt Blaze to special circumstances: custom data structures, custom operations, and the customizable error reporting mechanism.

Homepage:   https://bitbucket.org/blaze-lib/blaze
Benchmarks: https://bitbucket.org/blaze-lib/blaze/wiki/Benchmarks

Speakers
avatar for Klaus Iglberger

Klaus Iglberger

Senior Software Engineer, CD-adapco
Klaus Iglberger has finished his PhD in computer science in 2010. Back then, he contributed to several massively parallel simulation frameworks and was active researcher in the high performance computing community. From 2011 to 2012, he was the managing director of the central institute for scientific computing in Erlangen. Currently he is on the payroll at CD-adapco in Nuremberg, Germany, as a senior software engineer. Additionally, he is the... Read More →


Wednesday September 21, 2016 9:00am - 10:00am
White (Room 407) Meydenbauer Center

10:30am

Rich Code For Tiny Machines: A Simple Commodore 64 Game In C++17
The Commodore 64 was released in 1982 and is the best selling computer model of all time. At 34 years old, even the most simple embedded processor today outperforms it. Join me on an exploration of how C++17 techniques can be utilized to write expressive, high performance, high level code for simple computers. Together we will create a game for this aging system.

You'll leave the talk with a better understanding of what your compiler is capable of and be able to apply these ideas to create better code on modern systems

Speakers
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
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 available for contracting and onsite training.


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

12:30pm

clang-format Birds of a Feather
Are you working on integrating clang-format into your favorite editor or tool? Hacking new features? Or just a happy fan? Come find other people like yourself at this birds of a feather session all about clang-format.

Speakers
avatar for Mark Zeren

Mark Zeren

Staff Engineer, VMware
Mark is a staff engineer at VMware where he maintains several internal clang-format enhancements.


Wednesday September 21, 2016 12:30pm - 1:00pm
White (Room 407) Meydenbauer Center

12:30pm

C++ Community Building Birds of a Feather
Are you a C++ community leader? Would you like to be?

If you are or would like to be working to build a C++ community, either on-line or in meat space, we'd like to hear from you about your challenges and your successes.

We'll hear from sucessful community leaders, answer questions, and share resources and ideas. We'll discuss user groups, conferences, podcast, and online communities and forums.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!
avatar for Jens Weller

Jens Weller

C++ Evangelist, Meeting C++
Jens Weller is the organizer and founder of Meeting C++. Doing C++ since 1998, he is an active member of the C++ Community. From being a moderator at c-plusplus.de and organizer of his own C++ User Group since 2011 in Düsseldorf, his roots are in the C++ Community. Today his main work is running the Meeting C++ Platform (conference, website, social media and recruiting). His main role has become being a C++ evengalist, as this he speaks and... Read More →

Wednesday September 21, 2016 12:30pm - 1:30pm
Kantner (Room 403) Meydenbauer Center

12:30pm

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, incredibly user-friendly packages. | | Globalscape is an exciting place to work for C++ developers. We have won numerous "best places to work" awards, and... Read More →


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

12:30pm

Reflection, Status and Use Cases
David (and potentially other committee members) will give an update on
what's currently being discussed for reflection in C++

Everybody is invited to chime in on a discussion about use cases. For
instance, Roland is going to present his ideas for SQL statements being
used on databases, containers and streams.

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 that it was as difficult as some people claimed. Turns out they were totally wrong and totally right at the same time. | | Today, I am still learning and I hope... Read More →
avatar for David Sankel

David Sankel

Bloomberg
David Sankel is a professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now conferences and is especially well known for his advanced functional programming in C++ talks. David’s... Read More →


Wednesday September 21, 2016 12:30pm - 1:30pm
Vanity (Room 404) Meydenbauer Center

2:00pm

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.

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

2:00pm

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

Proprietor, 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.  He is the author and maintainer of the Boost... Read More →


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

2:00pm

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. Mark is the author of the tech blog "Modern Maintainable Code" that tries to educate folks about properties of maintainable code and effective program design. Mark has a background in teaching and has been giving tech talks for several years now, most of which can be found on his blog. Website... Read More →


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

2:00pm

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

C++ Lead, 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 active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all... Read More →


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

2:00pm

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
Work in hardware, embedded, graphics and web-based software space. Currently working on a Holographic Surgical Center to allow surgeons to perform simulated surgeries on real patient data. Also working with a major electronics distributor on a SAAS tool for their customers to easily interchange embedded environments.


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

2:00pm

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
MC

Marshall Clow

Principal Engineer, Qualcomm, Inc.
Marshall is a long-time LLVM and Boost participant. He is a principal engineer at Qualcomm, Inc. in San Diego, and the code owner for libc++, the LLVM standard library implementation. He is the author of the Boost.Algorithm library and maintains several other Boost libraries.


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

3:15pm

Achieving ultimate performance in financial data processing through compile time introspection: CME MDP3 example
C++ does not yet have complete introspection (reflection), but in many cases it may be easy to complete. We will present an example of what we think is is a general method whenever data specifications may be converted to C++ through a code generator. We have done this for processing financial market data very sensitive to latencies and obtained huge advantages of
* Economy of effort
* Performance
* Reliability
* Extensibility
over any other option we considered. We will show:
* How we converted the specification of market data from an important exchange, CME MDP3, into C++ types and a minimal set of variadic templates that give us full introspection capabilities
* The code and the techniques to implement generic introspecting software components, including these concrete examples:
* Converting any value that belongs to the specification into string
* Testing for whether the value is null in any of the three ways the specification allows encoding of null values
* Applying design patterns such as flyweights to traverse the data with zero or minimal performance cost
* Subscription mechanisms

We hope these code examples will show how straightforward and maintainable metaprogramming techniques can emulate introspection for truly significant quality gains.

Support code at github:
https://github.com/thecppzoo/cppcon2016/

Speakers
avatar for Eduardo Madrid

Eduardo Madrid

Software Developer, Crabel Capital Management
Eduardo Madrid has over 18 years of C++ experience and works as Software Developer at Crabel Capital Management. The material for this presentation is derivative of work made by him currently running in production at "Crabel" to process CME MDP3 financial data. "Crabel" is a Hedge Fund with activities including automated trading, it has been continuously successful for over two decades, and is among the largest trader of Futures



Wednesday September 21, 2016 3:15pm - 4:15pm
White (Room 407) Meydenbauer Center

3:15pm

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, including HHVM, folly, proxygen, wangle, and mcrouter. Previously he worked at F5 networks on load balancers and network monitoring tools.


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

3:15pm

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 at Intel, he coordinated the efforts of teams working on Cilk Plus, TBB, OpenMP, and other parallelism languages, frameworks, and tools targeted to C++, C, and Fortran... Read More →


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

3:15pm

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 13 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, he is one of the key Architects behind some collaboration initiatives at Ubisoft and was also Technical Architect on games like Prince of Persia. He presented at CppCon 2014 "C++ in Huge AAA Games".


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

3:15pm

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 the WG21 SG1 (Concurrency) Chair, and co-led the design of the C++ memory model and atomic operations. He now mostly works on concurrency-related issues in Android, and occasionally on teaching calculators to calculate correctly. In the past, he mostly focused on garbage collection. He is the original primary author of bdwgc, a conservative garbage collector for C and C++. http://hboehm.info



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

4:45pm

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
Prince Theater (2nd Floor) Meydenbauer Center

4:45pm

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
Bowie Hall (1st Floor Hall) Meydenbauer Center

4:45pm

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
avatar for Nat Goodspeed

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 infuriated) by C++ ever since. | | When he first encountered Boost libraries, a light shone from the heavens and choirs of angels sang "AAAAAAH..." The idea... Read More →


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

4:45pm

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

Astrophysicist, University of Illinois at Urbana-Champaign
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 interested in the study of relativistic effects at cosmological scales using high performance simulations run on supercomputers. Because these simulations rely on... Read More →


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

4:45pm

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 than nonstandard annotations. He also maintains Microsoft's implementation of the Guideline Support Library (GSL).


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

4:45pm

C++ on the Web: Let's have some serious fun.
Want to get started compiling C++ code for the Web? Come to this session to learn how. We'll look at the tools, C++ libraries, and C++ OpenGL and SDL APIs, available to C++ programmers today, and walk through building and running a C++ application in Web browsers using WebAssembly, the new cross-browser standard for compiled code on the Web.

We'll also do an deep-dive tour through the entire system, starting from C++ code, through the compilation process to the WebAssembly binary format, and then to native code. We'll look at how to make C++ code interface with Web APIs and JavaScript, how both standalone C++ and hybrid applications are built, how WebAssembly delivers the kinds of performance characteristics C++ code expects while keeping users safe, and how C++ developers can make the most of WebAssembly's optimizations for fast download and startup times to deliver great experiences on the Web.

Let's play some games, have some fun, and do some serious C++ on the Web!

Speakers
avatar for Dan Gohman

Dan Gohman

Mozilla
WebAssembly. asm.js. Emscripten. Itanium C++ ABI V2. SIMD. Undef. AliasAnalysis. Instruction Sets. Control Flow representations. Floating point determinism. Vulkan. NaNs. Did I say WebAssembly?


Wednesday September 21, 2016 4:45pm - 5:45pm
White (Room 407) Meydenbauer Center

8:30pm

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

Software Developer
Chris is a full time software developer at a financial company in Sydney, a casual tutor for a C++ course at UNSW Australia, and an avid C++ programmer.


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

8:30pm

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com

Wednesday September 21, 2016 8:30pm - 10:00pm
Prince Theater (2nd Floor) Meydenbauer Center

8:30pm

Biggest Security Fails
This lively panel will cover some of the biggest security fails. We’ll discuss some of the fails common to C++ and other compiled languages, and some ideas for avoiding problems in your own code.

Moderators
avatar for Crystal Bong

Crystal Bong

Product Manager, F5 Networks

Speakers
avatar for Jeff Costlow

Jeff Costlow

As a software security specialist and engineer, Jeff has designed and implemented secure software and has successfully led engineering teams specializing in host and network security. With a deep understanding of a secure development lifecycle and many years of successful program design and execution, Jeff’s work has positively impacted the software engineering market across the areas of design-time threat modeling, peer based software review... Read More →
avatar for David Holmes

David Holmes

Worldwide Security Evangelist, F5 Networks
David Holmes is the world-wide security evangelist for F5 Networks. He writes and speaks about hackers, cryptography, fraud, malware and many other InfoSec topics. He has spoken at over 30 conferences on all six developed continents, including RSA Europe in Amsterdam, InfoSec in London and Gartner Data Center in Las Vegas. | | David writes a bi-weekly column at SecurityWeek, and has had the good fortune to write for DarkReading, SC Magazine... Read More →
avatar for Jeff Warren

Jeff Warren

Senior Manager, Product Development, F5 Networks
I always appreciate a good ski/snowboard story. I hunt bugs. I tend to find bugs in C,C++, and other interpreted languages. Typically the bugs are not an abuse of the language but a developer not being perfectly precise with the intended business logic. They can also be from more insidious issues such as https://en.wikipedia.org/wiki/Conway%27s_law


Wednesday September 21, 2016 8:30pm - 10:00pm
Vanity (Room 404) Meydenbauer Center
 
Thursday, September 22
 

9:00am

C++ at the South Pole : Turning Particle-Astro-Physicist-Hackers into Software Engineers
Want to increase software literacy in your organization? In this talk I'll present programs I've developed over the last year to teach C++ software engineering principles to graduate students and postdocs on the IceCube South Pole Neutrino Observatory. I believe similar programs could be beneficial to all types of organizations, from scientific collaborations to professional software shops.

IceCube is a kilometer-scale high energy neutrino observatory located deep in the Antarctic ice at the geographic South Pole. IceCube studies physics in energy regimes ranging from the most energetic processes in the visible universe (several orders of magnitude greater than the collision energies at the Large Hadron Collider), to dark matter detection at the 100 GeV scale. It is a relatively large collaboration, consisting of roughly 300 physicists and engineers from 48 institutions from a dozen different countries. IceCube has been collecting data for over 11 years (going into our 6th season with the fully completed detector) and is expected to run for at least another decade.

Many large scientific projects, which often run for decades, rely on code developed by hackers, who's focus and passion is rarely software engineering. Their primary passion, understandably, is the field for which they found themselves writing code. To make matters worse, the amount of work and focus required to secure a career in their chosen field often leaves little time and energy to devote to honing the skills needed to develop production quality code. Many students and postdocs often have, at best, a cursory understanding of the programming language(s) that comprise the experiment's codebase.

C++ has become the primary programming language for High Energy Physics (HEP) and will likely continue to be for decades to come. Consider, for example, that ROOT, GEANT, and Pythia to name a few critical HEP libraries are written in C++. Over the last year on IceCube, I've developed several comprehensive internal training programs in an attempt to bridge the gap between the scientist-hacker and the professional C++ software engineer. In this session I'd like to present the challenges I've encountered over the last year and my plans for extending these programs to the High Energy Physics community through the HEP Software Foundation.

Thursday September 22, 2016 9:00am - 10:00am
Frey (Room 406) Meydenbauer Center

9:00am

The MAME (Multi-Arcade Machine Emulator) story: From C to Modern C++
In 1997, the MAME project was started as a DOS application written in C. Initially it could emulate a single arcade game, but today we have over 30,000 games. During the years, the code base grew but until 2009, there were no big steps. Then we started using C++. 

This case study will show how moving from C and plain C++ to modern C++ benefited both developers and end users, how we got better compatibility and portability, and better code. We will also discuss libraries that we feel are missing from the standard and the libraries that we are sharing with the community.


Speakers
avatar for Miodrag Milanović

Miodrag Milanović

Software Architect, Levi9
Born in 1978. Bachelor of Computer Science, work as wide-range developer in local company, for some years as C++ development for various international customers. From 2012 coordinator of MAME emulation project, pushing hard in modernization of two decade old code.


Thursday September 22, 2016 9:00am - 10:00am
White (Room 407) Meydenbauer Center

9:00am

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 background in the development of C++ applications involving database interfaces and in the implementation of database engines.



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

9:00am

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 programming languages and set out to change this. He led the effort to grow Clang (http://clang.llvm.org) into a world class tooling platform for AST-based C... Read More →


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

9:00am

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 combining modern parallel programming techniques in C++ with heterogeneous and massively parallel hardware. As such, I have a keen interest in the application of... Read More →


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

9:00am

Implementing `static` control flow in C++14
There has always been great interest in imperative compile-time control flow: as an example, consider all the existing `static_if` proposals and the recently accepted `constexpr_if` construct for C++17.

What if you were told that it is actually possible to implement imperative control flow in C++14?

In this tutorial, the implementation and design of a compile-time `static_if` branching construct and of a compile-time `static_for` iteration construct will be shown and analyzed. These constructs will then be compared to traditional solutions and upcoming C++17 features, examining advantages and drawbacks.

Speakers
avatar for Vittorio Romeo

Vittorio Romeo

Software Engineer, Bloomberg LP
Vittorio Romeo is an Italian 21 year old Computer Science student at "Università degli Studi di Messina". He began programming at a very young age and is now a C++ enthusiast. While following the evolution of the C++ standard and embracing the newest features, he worked on several open-source projects, including modern general-purpose libraries and free cross-platform indie games. Vittorio is an active member of the C++ community: he... Read More →


Thursday September 22, 2016 9:00am - 10:00am
Kantner (Room 403) Meydenbauer Center

10:30am

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
Bowie Hall (1st Floor Hall) Meydenbauer Center

12:30pm

Robotics Birds of a Feather Session

Description: This is an informal gathering for conference attendees in the robotics and automation industry to meet and discuss the current state of C++ in this domain. Topics include popular tools, achieving real-time performance, high-level algorithms for perception and autonomy, and low-level systems integration.

Moderators: Jackie Kay and Rita Ciaravino


Moderators
avatar for Jackie Kay

Jackie Kay

Software Engineer, Marble Robotics
I write FOSS tools for the robotics community.

Thursday September 22, 2016 12:30pm - 1:00pm
Kantner (Room 403) Meydenbauer Center

12:30pm

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

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

Software Engineer, 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
Prince Theater (2nd Floor) Meydenbauer Center

2:00pm

AAAARGH!? Adopting Almost Always Auto Reinforces Good Habits!?
Prominent members of the C++ community are advocating the "almost-always-auto" idiom, but there are understandable concerns from many about its implications. This case study will demonstrate how it may be applied in different situations, suggest ways to avoid performance penalties, introduce algorithms to minimize the "almost" part, and discuss the overall impact.

Speakers
avatar for Andy Bond

Andy Bond

Lead Software Engineer, Blizzard Entertainment
I've been programming professionally at Blizzard for over 16 years and am currently a Lead Software Engineer for Heroes of the Storm. While my day-to-day focus is on providing the best gameplay experience for our players, in my spare time I enjoy tinkering with the latest C++ features to discover better ways to implement whatever our designers dream up next.


Thursday September 22, 2016 2:00pm - 3:00pm
Bowie Hall (1st Floor Hall) Meydenbauer Center

2:00pm

Constant Fun
This presentation discusses why it is useful to move some of the processing to compile time and shows some applications of doing so. In particular it shows how to create associative containers created at compile time and what is needed from the types involved to make it possible. The presentation also does some analysis to estimate the costs in terms for compile-time and object file size.

Specifically, the presentation discusses:
- implications of static and dynamic initialization – the C++ language rules for implementing constexpr functions and classes supporting constexpr objects.
- differences in error handling with constant expressions.
- sorting sequences at compile time and the needed infrastructure – creating constant associative containers with compile-time and run-time look-up.


Speakers
DK

Dietmar Kühl

Software Developer, Bloomberg LP
Dietmar Kühl is a senior software developer at Bloomberg L.P. working on the data distrubtion environment used both internally and by enterprise installations at clients. In the past, he has done mainly consulting for software projects in the finance area. He is a regular attendee of the ANSI/ISO C++ standards committee, frequent presenter at the ACCU conference, and a moderator of the newsgroup comp.lang.c++.moderated.


Thursday September 22, 2016 2:00pm - 3:00pm
Kantner (Room 403) Meydenbauer Center

2:00pm

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

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 Computer and Information Science. During my undergraduate time, I created and submitted Boost.Tokenizer. I went on to medical school and neurosurgery residency, but... Read More →


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

2:00pm

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

Jest-in-Time Compiler, template
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 worked on startup incubators, business jets, flight simulators, CPUs, dynamic binary translation, systems, and compilers.


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

2:00pm

What C++ Programmers Need to Know about Header <random>
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 thirty-five years, joining the C++ standards effort in 2000. Among numerous other contributions, he is responsible for introducing such now-standard C++ library features as cbegin/cend, common_type, gcd, and void_t, as well as headers < random > and < ratio >. He has also significantly impacted such core language... Read More →


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

2:00pm

Better mutual exclusion on the filesystem using Boost.AFIO (asynchronous file and filesystem)
This is the third and likely final part of a surprisingly popular "from first principles" series of beginner's workshops based on developing the v2 post-peer-review rewrite of proposed Boost.AFIO, a C++ library wrapping the advanced features of the filesystem intended for eventual ISO C++ standardisation. If you're the kind of library developer who likes building unusual low level concurrent algorithms using the very latest C++ 14-17 (proposed) features and testing them for time and space complexities, this is definitely your kind of talk.

At CppCon 2015 we studied the concurrency fundamentals of the filing system, and how it can have the acquire/release semantics of memory atomics but also differs in many ways from memory. At ACCU 2016, using those fundamentals we built from first principles a novel distributed mutual exclusion implementation boost::afio::algorithm::atomic_append which doesn't suffer from the "scalability holes" found in the OS kernel provided facilities boost::afio::algorithm::byte_ranges and boost::afio::algorithm::lock_files. At this third workshop we shall continue the "from first principles" theme by building a fourth and probably last distributed mutual exclusion algorithm for the AFIO algorithms library boost::afio::algorithm, with this one making use of shared memory maps for superior performance when only a single machine is doing the locking.

Is it possible to portably detect the arrival of a networked drive user (SMB, NFS) and safely disable using shared memory maps such that we can automatically race free downgrade our implementation to a networked drive compatible technique?

It turns out that the answer is yes. It has superb performance and scalability, but also comes with many interesting preconditions, tradeoffs and caveats, the most important being that this is an anti-social mutual exclusion algorithm.

Slides: This is a live link to the slides in progress. Expect them to change up right up until the workshop is given.

These are the slides and video for the ACCU 2016 workshop on the atomic append locking algorithm, and the slides and video for the CppCon 2015 workshop on the concurrency fundamentals of the file system. Both were surprisingly well attended, indeed the former was the most attended talk of its track for some reason where it received 18 green votes, zero yellow and zero red votes.

Speakers
avatar for Niall Douglas

Niall Douglas

Consultant, ned Productions Ltd
Niall Douglas is a lead author of WiP Boost.AFIO v2, Boost.Outcome, Boost.KernelTest and Boost-lite. He has been the lead Google Summer of Code administrator for Boost since 2014. He is an Affiliate Researcher with the Waterloo Research Institute for Complexity and Innovation at the University of Waterloo, Canada, and holds postgraduate qualifications in Business Information Systems and Educational and Social Research as well as a second... Read More →


Thursday September 22, 2016 2:00pm - 3:00pm
Frey (Room 406) Meydenbauer Center

3:15pm

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
White (Room 407) Meydenbauer Center

3:15pm

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 that it was as difficult as some people claimed. Turns out they were totally wrong and totally right at the same time. | | Today, I am still learning and I hope... Read More →


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

3:15pm

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

Spiral Genetics
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 a senior developer at Spiral Genetics, Inc. in Seattle.


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

3:15pm

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

Principal Investigator, 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 in Information Assurance and Computer Architectures from Binghamton University. He is a lead developer and co-founder of the Bareflank Hypervisor, and is an... Read More →


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

3:15pm

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 of the ISO C++ committee, in which he is an active participant. He proposed or contributed to more than half of the language features added in C++14 and C++17.


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

3:15pm

Practical Performance Practices
In the past 6 years ChaiScript's performance has been improved by nearly 100x. This was not accomplished by adding a virtual machine or performing dynamic recompilation. Instead, these increases have been accomplished by moving to more simple, cleaner, idiomatic C++ and by following some simple rules. We will outline these concepts with examples for how they both simplified code while improving performance.

Speakers
avatar for Jason Turner

Jason Turner

Developer, Trainer, Speaker
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 available for contracting and onsite training.


Thursday September 22, 2016 3:15pm - 4:15pm
Bowie Hall (1st Floor Hall) Meydenbauer Center

4:45pm

Control Freak++: Writing an Embedded RTPS Library in C++14
Software for embedded systems means writing code for a microprocessor with specs straight out of the 80s. But that doesn’t mean that embedded developers should be afraid of using the best tools that modern languages have to offer. This talk will explore embedded development through the source code of a modern C++ implementation of the RTPS (Real-Time Publish/Subscribe) wire protocol. Our targeting ARM STM32 microcontrollers (but generalizable to many platforms). We will put zero-cost abstractions to the test as we attempt to fit a system conforming to a 200-page OMG specification document onto an MCU with 384 KB of RAM and 2048 KB of flash. At a higher level, we will discuss the philosophy of using high-level abstractions in a low-level environment, and seek to settle the score with old-school C microcontroller hackers.

Speakers
avatar for Jackie Kay

Jackie Kay

Software Engineer, Marble Robotics
I write FOSS tools for the robotics community.


Thursday September 22, 2016 4:45pm - 5:45pm
White (Room 407) Meydenbauer Center

4:45pm

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 has worked as a software engineer consultant for 6 years 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 USA to EMEA and Asia. Now, Marc is working for Nikon Metrology on 3D scanning software. His main expertise is C/C++, and specifically Microsoft VC++ and the MFC framework. Next to C/C... Read More →


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

4:45pm

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
Prince Theater (2nd Floor) Meydenbauer Center

4:45pm

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 languages (DSL), C++ parsing, source-to-source | translation, and code generation. His notable projects to date | include ODB (ORM for C++), XSD... Read More →


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

4:45pm

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

Software Engineer, Nokia Networks
Bachelor of Engineering in Computer Science, studied at Faculty of Electronics at Wrocław University of Technology. Loves metaprogramming and doing as much as possible during compile time, instead of wasting precious cycles at runtime.


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

4:45pm

BDE Libraries, An Orientation
The BDE libraries, https://github.com/bloomberg/bde, provide a wide range of
useful functionality and also showcase the design and testing principles long
advocated by John Lakos (see Lakos '96, CppCpon 201[456]):
  • Fine-grained, hierarchical reusable (physical) components 
  • Focused component purposes based on well-defined class categories. 
  • Use of library facilities to implement effective Defensive Programming. 
  • Ubiquitous support for a user-supplied memory--allocation mechanisms. 
  • Design by (appropriately narrow) contracts. 
After an outline of the functionality provided (e.g., date/time classes,
logging), this talk recaps the above Lakosian ideas, and shows, through BDE
documentation and code examples, how the ideas above influence the use of BDE
libraries in applications.

Speakers
avatar for Steven Breitstein

Steven Breitstein

Engineer, Bloomberg LP
Professional Experience | Bloomberg, 10 years | Bell Labs, 20 years | Education | Graduate: M.I.T. | Undergraduate: City College of New York


Thursday September 22, 2016 4:45pm - 5:45pm
Frey (Room 406) Meydenbauer Center

8:30pm

CppCon 2017 Kick-off Meeting
The planning committee for next year's conference starts now. Join us if you'd like provide suggestions or otherwise pitch in.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Thursday September 22, 2016 8:30pm - 10:00pm
Frey (Room 406) Meydenbauer Center

8:30pm

Lightning Talks
The adventure continues-- come for bite size talks you'll want more of!

Moderators
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre. :: ciere.com

Thursday September 22, 2016 8:30pm - 10:00pm
Kantner (Room 403) Meydenbauer Center

8:30pm

Compression Panel
Join our panelists for a discussions of compression algorithms.

Moderators
avatar for Nicolas Guillemot

Nicolas Guillemot

MSc Student, University of Victoria
Hi, nice to meet you! My name is Nicolas, and my main interests are game development, real-time rendering, graphics hardware and graphics APIs. I tackle problems at the intersection of designing efficient computer algorithms and leveraging the strengths of hardware. My favorite thing about C++ is that it lets me write detailed systems-level code and high-level GUI code together in a single robust language.

Speakers
avatar for Guy Davidson

Guy Davidson

Coding Manager, Creative Assembly
Coding Manager of Creative Assembly, makers of the Total War franchise, Alien:Isolation and the upcoming Halo Wars sequel, Guy has been writing games since the early 1980s. He is now also a contributor to SG14, the study group devoted to low latency, real time requirements, and performance/efficiency especially for Games, Financial/Banking, and Simulations. He speaks at schools, colleges and universities about programming and likes to help good... Read More →
avatar for Rich Geldreich

Rich Geldreich

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

Software Engineer, 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 8:30pm - 10:00pm
Prince Theater (2nd Floor) Meydenbauer Center

9:15pm

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
Vanity (Room 404) Meydenbauer Center
 
Friday, September 23
 

8:00am

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, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!


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

9:00am

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
avatar for Paul E. McKenney

Paul E. McKenney

Distinguished Engineer, IBM Linux Technology Center
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. Over the past decade, Paul has been an IBM Distinguished Engineer at the IBM Linux Technology Center. Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present highly entertaining performance, scalability, real-time response... Read More →
avatar for Maged Michael

Maged Michael

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. His work is included in several IBM products where he was a Research Staff Member at the IBM T.J. Watson Research Center. He received a Ph.D. in computer science from the University of Rochester. He is an ACM Distinguished Scientist and an ACM Distinguished Speaker. He is an elected... Read More →
avatar for Michael Wong

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


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

9:00am

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
GD

Gabriel Dos Reis

Principal Software Engineer, Microsoft


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

9:00am

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 Group in Dresden. He earned his Ph.D. in computer science at Technische Universitat Dresden in 2002.


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

9:00am

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

I've been working in C++ for the last 24 years. 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. After a brief journey through the world of DNS, I'm now trying my hand at analytics.


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

9:00am

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 pursuing interests in Ranges, world domination, and doughnuts at Microsoft Redmond.


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

10:30am

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
Author, chair of the ISO C++ committee, software architect at Microsoft.


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

12:30pm

CppCon 2017 Planning Committee Work Session
This session is a follow-on to the kick-off meeting and is a chance for the planning committee to set up goals and milestones.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, CppCon
Jon Kalb is a freelance C++ instructor and chairs CppCon, C++ Now, and the Boost Steering Committee. He has been programming in C++ for over 25 years and has written C++ for Amazon, Apple, Dow Chemical, Intuit, Lotus, Microsoft, Netscape, Sun, and Yahoo!

Friday September 23, 2016 12:30pm - 1:30pm
Room 303 Meydenbauer Center

2:00pm

Implementing The C++ Standard Library
Want to meet your standard library maintainer? Now's your chance! Join us for a panel discussion of the C++ standard library with the people who implement it! C++ standard library maintainers and members of the C++ Committee's Library Working Group will talk about the philosophy behind the specification and implementation of the C++ standard library. We'll talk about all the new library features coming in C++17 (and beyond).

Moderators
avatar for Bryce Adelstein Lelbach

Bryce Adelstein Lelbach

Lawrence Berkeley National Laboratory
Bryce Adelstein Lelbach is a researcher at Lawrence Berkeley National Laboratory (LBNL), a US Department of Energy research facility. Working alongside a team of hardware engineers and scientists, he develops and analyzes new parallel programming models for exascale and post-Moore architectures. Bryce is one of the developers of the HPX C++ runtime system. He spent five years working on HPX while he was at Louisiana State University's Center... Read More →

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 thirty-five years, joining the C++ standards effort in 2000. Among numerous other contributions, he is responsible for introducing such now-standard C++ library features as cbegin/cend, common_type, gcd, and void_t, as well as headers < random > and < ratio >. He has also significantly impacted such core language... Read More →
MC

Marshall Clow

Principal Engineer, Qualcomm, Inc.
Marshall is a long-time LLVM and Boost participant. He is a principal engineer at Qualcomm, Inc. in San Diego, and the code owner for libc++, the LLVM standard library implementation. He is the author of the Boost.Algorithm library and maintains several other Boost libraries.
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://github.com/HowardHinnant/date
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 actually spell) and cats (although he doesn't own any).
AM

Alisdair Meredith

Bloomberg LP
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 project that would become C++11, and also fixed the contents of the original library TR. | | He is currently working on the BDE project, BloombergLP's open... Read More →
avatar for Anthony Williams

Anthony Williams

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

Michael Wong

VP of R&D/Director, Codeplay Software/ISOCPP
Michael Wong is VP of R&D at Codeplay; a current Director and VP of ISOCPP.org, and a senior member of the C++ Standards Committee with 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups and is the co-author of a number C++/OpenMP/Transactional Memory features including generalized attributes, user-defined literals, inheriting constructors, weakly ordered... Read More →


Friday September 23, 2016 2:00pm - 3:30pm
Bowie Hall (1st Floor Hall) Meydenbauer Center
  • Level Beginner, Intermediate, Advanced, Expert