Loading…
CppCon 2016 has ended

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

tutorial [clear filter]
Monday, September 19
 

2:00pm PDT

A 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://git... Read More →



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

2:00pm PDT

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

C++ Trainer
Arthur O'Dwyer is the author of "Mastering the C++17 STL" (Packt 2017) and of professional training courses such as "Intro to C++," "Classic STL: Algorithms, Containers, Iterators," and "The STL From Scratch." (Ask me about training your new hires!) Arthur is occasionally active on... Read More →


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

3:15pm PDT

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

C++ Trainer
Arthur O'Dwyer is the author of "Mastering the C++17 STL" (Packt 2017) and of professional training courses such as "Intro to C++," "Classic STL: Algorithms, Containers, Iterators," and "The STL From Scratch." (Ask me about training your new hires!) Arthur is occasionally active on... Read More →


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

4:45pm PDT

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

CUDA C++ Core Libraries Lead, NVIDIA


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

9:00am PDT

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

CTO, Undo
Greg is co-founder and CEO at Undo. He is a programmer at heart, but likes to keep one foot in the software world and one in the business world. Greg finds it particularly rewarding to turn innovative software technology into real business development. Greg has over 20 years of experience... Read More →


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

9:00am PDT

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 Consulting
Michael Caisse has been crafting code in C++ for 30-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere which provides Software Contracting services, C++ training, and Project Recovery for failing multidisciplinary... Read More →


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

9:00am PDT

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

C++ Trainer/Consultant, Siemens
Klaus Iglberger is a freelancing C++ trainer and consultant and is currently on the payroll of Siemens in Nuremberg, Germany. He has finished his PhD in computer science in 2010 and since then is focused on large-scale C++ software design. He shares his experience in popular advanced... Read More →


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

4:45pm PDT

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
Cranelift. Wasmtime. Rust. WebAssembly. SIMD. Instruction Sets. Control Flow representations. Floating point determinism. NaNs. Did I say Cranelift?


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

9:00am PDT

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
Vittorio Romeo (B.Sc. Computer Science) has been a Software Engineer at Bloomberg for more than 3 years, working on mission-critical company C++ infrastructure and providing Modern C++ training to hundreds of fellow employees.He began programming around the age of 8 and quickly became... Read More →


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

3:15pm PDT

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

Owner, Jason Turner
Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http://cppbestpractices.com.I'm... Read More →


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

4:45pm PDT

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 PDT
Frey (Room 406) Meydenbauer Center