Loading…
Attending this event?
View analytic

Sign up or log in to bookmark your favorites and sync them to your phone or calendar.

Saturday, September 22
 

09:00

Advanced and Modern C++ Programming: The Tricky Parts
"Advanced and Modern C++ Programming: The Tricky Parts" is a two-day training course with programming examples taught by Nicolai Josuttis. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Lunch is included.

Students are expected to have a basic knowledge of C++ including C++11. Students are not required to bring any laptop. We will go through exercises together with the laptop of the presenter. Course and instructor details are available at https://cppcon.org/tricky-parts/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Nicolai Josuttis

Nicolai Josuttis

IT Communication
Nicolai Josuttis (http://www.josuttis.com) is an independent system architect, technical manager, author, and consultant. He designs mid-sized and large software systems for the telecommunications, traffic, finance, and manufacturing industries. He is well known in the programming community because he not only speaks and... Read More →


Saturday September 22, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Concurrency with Modern C++
"Concurrency with Modern C++" is a two-day training course with programming examples taught by Rainer Grimm. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Lunch is included.

Participants should have a basic knowledge of the C++ language and the fundamentals of multithreading.

Course and instructor details are available at https://cppcon.org/concurrency-with-modern-cpp/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
RG

Rainer Grimm

Independent Trainer, Modernes C++


Saturday September 22, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Interface Design for Modern C++
"Interface Design for Modern C++" is a two-day training course with programming examples taught by Bob Steagall. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Lunch is included.

Participants should have advanced beginner to intermediate knowledge of C++14 and the standard library, including a good understanding of copy semantics, move semantics, inheritance, virtual functions, exceptions, lambdas, and some experience with templates. Experience with multi-threading is a plus, but not required.

Course and instructor details are available at https://cppcon.org/interface-design-for-modern-cpp/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Bob Steagall

Bob Steagall

CppCon Poster Chair, KEWB Computing
I've been working in C++ for the last 25 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 detour through the world of DNS and analytics, I'm now working... Read More →


Saturday September 22, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Modern C++ Template Programming
“Modern C++ Template Programming” is a two-day training course with programming exercises taught by Steve Dewhurst. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Attendees should be experienced software developers with basic knowledge of C++ templates. Lunch is included. Course and instructor details are available here.

Speakers
avatar for Stephen Dewhurst

Stephen Dewhurst

President, Semantics Consulting, Inc.
Steve Dewhurst is the co-founder and president of Semantics Consulting, Inc. Steve is the author of numerous technical articles on C++ programming techniques and compiler design, is the author of the critically acclaimed books C++ Common Knowledge and C++ Gotchas, and is the co-author... Read More →


Saturday September 22, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Modernizing Your C++
"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 22 & 23 (immediately prior to the conference). Box lunch included. Course and instructor details are available here.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 28-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... Read More →


Saturday September 22, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Thinking Small
“Thinking Small” is a two-day training course with programming examples taught by Patrice Roy. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Lunch is included.

Attendees should be familiar with C++11 (lambdas, constexpr). Bring a laptop with a C++17 compiler. There will be in-class excercises and live discussion of various techniques and tricks. Course and instructor details are available at https://cppcon.org/thinking-small/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Patrice Roy

Patrice Roy

Professeur, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 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... Read More →


Saturday September 22, 2018 09:00 - 17:00
TBA Meydenbauer Center
 
Sunday, September 23
 

09:00

Advanced and Modern C++ Programming: The Tricky Parts
"Advanced and Modern C++ Programming: The Tricky Parts" is a two-day training course with programming examples taught by Nicolai Josuttis. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Lunch is included.

Students are expected to have a basic knowledge of C++ including C++11. Students are not required to bring any laptop. We will go through exercises together with the laptop of the presenter. Course and instructor details are available at https://cppcon.org/tricky-parts/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Nicolai Josuttis

Nicolai Josuttis

IT Communication
Nicolai Josuttis (http://www.josuttis.com) is an independent system architect, technical manager, author, and consultant. He designs mid-sized and large software systems for the telecommunications, traffic, finance, and manufacturing industries. He is well known in the programming community because he not only speaks and... Read More →


Sunday September 23, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Concurrency with Modern C++
"Concurrency with Modern C++" is a two-day training course with programming examples taught by Rainer Grimm. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Lunch is included.

Participants should have a basic knowledge of the C++ language and the fundamentals of multithreading.

Course and instructor details are available at https://cppcon.org/concurrency-with-modern-cpp/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
RG

Rainer Grimm

Independent Trainer, Modernes C++


Sunday September 23, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Engage, Entertain, Educate: Technical Speaking that Works
"Engage, Entertain, Educate: Technical Speaking that Works" is a one-day
workshop lead by Andrei Alexandrescu, Kate Gregory, and Scott Meyers. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Sunday, September 22nd. Lunch is included.

Because each participant will be given time to give short presentations, size is strictly limited.

# Course Description

Successful technical talks require more than just mastery of the topic at
hand. They also demand a strong stage presence, a memorable delivery,
effective audience management, clear presentation materials, comfort with the environment (e.g., mics, stages, screens), and an ability to cope with the unexpected. This workshop, led by three of the most storied speakers in C++, lets you strut your stuff in several short presentations. After each, you’ll receive specific feedback on how your stuff-strutting can be improved.

For speakers at CppCon, the utility of the workshop should be obvious, but anyone giving (or aspiring to give) good technical presentations will benefit from this session.

Further information is available at https://cppcon.org/engage-entertain-educate/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Andrei Alexandrescu

Andrei Alexandrescu

Vice President, D Language Foundation
Andrei Alexandrescu is a researcher, software engineer, and author. He wrote three best-selling books on programming (Modern C++ Design, C++ Coding Standards, and The D Programming Language) and numerous articles and papers on wide-ranging topics from programming to language design... Read More →
avatar for Kate Gregory

Kate Gregory

Partner, Gregory Consulting
Kate Gregory has been using C++ since before Microsoft had a C++ compiler. She writes, mentors, codes, and leads projects, in both C++ and .NET, especially for Windows. Kate is a Microsoft Regional Director, a Visual C++ MVP, has written over a dozen books, and speaks at conferences... Read More →


Sunday September 23, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Interface Design for Modern C++
"Interface Design for Modern C++" is a two-day training course with programming examples taught by Bob Steagall. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Lunch is included.

Participants should have advanced beginner to intermediate knowledge of C++14 and the standard library, including a good understanding of copy semantics, move semantics, inheritance, virtual functions, exceptions, lambdas, and some experience with templates. Experience with multi-threading is a plus, but not required.

Course and instructor details are available at https://cppcon.org/interface-design-for-modern-cpp/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Bob Steagall

Bob Steagall

CppCon Poster Chair, KEWB Computing
I've been working in C++ for the last 25 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 detour through the world of DNS and analytics, I'm now working... Read More →


Sunday September 23, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Modern C++ Template Programming
“Modern C++ Template Programming” is a two-day training course with programming exercises taught by Steve Dewhurst. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Attendees should be experienced software developers with basic knowledge of C++ templates. Lunch is included. Course and instructor details are available here.

Speakers
avatar for Stephen Dewhurst

Stephen Dewhurst

President, Semantics Consulting, Inc.
Steve Dewhurst is the co-founder and president of Semantics Consulting, Inc. Steve is the author of numerous technical articles on C++ programming techniques and compiler design, is the author of the critically acclaimed books C++ Common Knowledge and C++ Gotchas, and is the co-author... Read More →


Sunday September 23, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Modernizing Your C++
"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 22 & 23 (immediately prior to the conference). Box lunch included. Course and instructor details are available here.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 28-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... Read More →


Sunday September 23, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Thinking Small
“Thinking Small” is a two-day training course with programming examples taught by Patrice Roy. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 22nd and 23rd (immediately prior to the conference). Lunch is included.

Attendees should be familiar with C++11 (lambdas, constexpr). Bring a laptop with a C++17 compiler. There will be in-class excercises and live discussion of various techniques and tricks. Course and instructor details are available at https://cppcon.org/thinking-small/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Patrice Roy

Patrice Roy

Professeur, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 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... Read More →


Sunday September 23, 2018 09:00 - 17:00
TBA Meydenbauer Center

17:30

Tee Shirt Night Dinner
Tee Shirt Night is our way to helping you get to know other conference attendees even before the conference has officially started. It works best if you brought a C++ (or CppCon) shirt with you. But even if you didn't you can join the fun.

Here is how:
  1. Put on your C++ or CppCon shirt (or don't, if you didn't bring one).
  2. Go to one of the resturants TBA.
  3. Look for others wearing a C++ or CppCon shirt.
  4. Ask to join their group.
  5. Enjoy getting to know other attendees before the conference starts!
  6. Get a promo deal from the restuarant!

Here are the resturants and the promo deals they are offering to any party with someone wearing a C++ or CppCon shirt:
  • TBA

Have fun, but save room for cake at the Registration Reception.


Sunday September 23, 2018 17:30 - 20:30
TBA Meydenbauer Center

20:00

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 23, 2018 20:00 - 22:00
TBA Meydenbauer Center
 
Monday, September 24
 

08:00

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

Monday September 24, 2018 08:00 - 09:00
TBA Meydenbauer Center

09:00

Keynote: TBA
Monday September 24, 2018 09:00 - 10:30
TBA Meydenbauer Center

11:00

C++ Dependency Management: from Package Consumption to Project Development
TL;DR: Want to see what Cargo for C++ looks like? Then this talk is for you.

Existing C++ package managers focus primarily on consumption: there is a repository of released packages that we can download, build, and install. But what happens between releases of these packages? In other words, how are they developed, tested, and delivered? Currently, the answer is "painfully" (and rarely by mere mortals).

Meantime, as languages competing with C++ have shown (see Rust's Cargo, Go's dep/vgo), the state of the art has moved on and a "consumption manager" alone is no longer sufficient: we need support for managing dependencies of a project over its entire development lifecycle -- a tool commonly referred to as a project dependency manager.

In this talk I would like to show the C++ dependency management workflow focused on development as supported by the build2 toolchain. Specifically, we will create from scratch a cross-platform C++ project, add/manage a few dependencies (that can come both from a central package repository as well as individual git repositories), setup CI for all the major platform/compiler combinations, go through a couple of releases, and, finally, publish our package to a central repository and see how our users can reproduce the exact set of dependencies we used in our builds (the lockfile functionality).

And this won't be an entirely toy example either: in the process we will touch on quite a few real-world challenges, including continuous versioning between releases, how to depend on unreleased revisions in version control repositories, dependency auto-synchronization through build system integration, as well as how the upcoming C++ Modules will likely affect packaging.

Speakers
avatar for Boris Kolpackov

Boris Kolpackov

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


Monday September 24, 2018 11:00 - 12:00
C

11:00

The C++ Execution Model
At the heart of the C++ programming language is the multi-threaded abstract machine and its execution model, the platform-agnostic formal model that generically describes how to run a C++ program. In this talk, you will learn the rules that govern how your C++ code is executed and see how those rules impact the C++ code you write every day.

We'll explore the C++ execution and memory model, and discuss fundamental questions such as:

* What are threads in C++ and how do they interact?
* What is memory in C++?
* In what order are things in my C++ program executed?
* How are C++ expressions and statements executed?
* What are the semantics of calling a function in C++?
* What does "happens before" mean?

If you're interested in gaining a deeper understanding of how your C++ code is executed and how concurrency works in C++, you should attend this talk.

Speakers
BA

Bryce Adelstein Lelbach

Bryce Adelstein Lelbach is a software engineer on the CUDA driver team at NVIDIA. Bryce is passionate about parallel programming. He maintains Thrust, the CUDA C++ core library. He is also one of the initial developers of the HPX C++ runtime system. He spent five years working on... Read More →


Monday September 24, 2018 11:00 - 12:00
F

11:00

Enough string_view to Hang Ourselves
Wouldn’t it be nice if we had a standard C++ type to represent strings ? Oh, wait... we do: std::string. Wouldn’t it be nice if we could use that standard type throughout our whole application/project ? Well… we can’t ! Unless we’re writing a console app or a service. But, if we’re writing an app with GUI or interacting with modern OS APIs, chances are that we’ll need to deal with at least one other non-standard C++ string type. Depending on the platform and project, it may be CString from MFC or ATL, Platform::String from WinRT, QString from Qt, wxString from wxWidgets, etc. Oh, let’s not forget our old friend `const char*`, better yet `const wchar_t*` for the C family of APIs…
So we ended up with two string types in our codebase. OK, that’s manageable: we stick with std::string for all platform independent code and convert back-and-forth to the other XString when interacting with system APIs or GUI code. We’ll make some unnecessary copies when crossing this bridge and we’ll end up with some funny looking functions juggling two types of strings; but that’s glue code, anyway… right?
It’s a good plan... until our project grows and we accumulate lots of string utilities and algorithms. Do we restrict those algorithmic goodies to std::string ? Do we fallback on the common denominator `const char*` and lose the type/memory safety of our C++ type ? Is C++17 std::string_view the answer to all our string problems ?
We’ll try to explore our options, together: best practices, gotchas, things to avoid, with a case study on a 15 year old Windows application: Advanced Installer (www.advancedinstaller.com) - an actively developed C++ project, modernized to C++17, thanks to clang-tidy and “Clang Power Tools” (www.clangpowertools.com).

Speakers
avatar for Victor Ciura

Victor Ciura

Software Developer, CAPHYON
Victor Ciura is a Senior Software Engineer at CAPHYON and Technical Lead on the Advanced Installer team (http://www.advancedinstaller.com). | For over a decade, he designed and implemented several core components and libraries of Advanced Installer such as: IIS, Repackager, OS... Read More →


Monday September 24, 2018 11:00 - 12:00
B

11:00

Fun for All: Teaching C++
At some point in your career, you will need to teach someone something about C++. You might not be a lecturer or a trainer, but you could be helping a colleague with a problem that they're solving, presenting at a lunch-time session, or even at a conference! Perhaps you're someone who is helping to write your company's style guide or "Intro to Our Repo" manual. Correctly teaching C++ is a tough endeavour. C++ is often taught incorrectly at the university level, via online resources, and in books. Many resources are still outdated or refuse to change with the paradigm shift that the C++ community has been undergoing over the past two decades.

We should seek to convey correct information and provide resources that are factual. We should make learning C++ an enjoyable experience, and that stems from the way in which we teach it.

This talk digs into how we can achieve some of this, but it by no means provides all the answers, and may lead to more questions.

Speakers
avatar for Christopher Di Bella

Christopher Di Bella

Staff Software Engineer, ComputeCpp Runtime, Codeplay Software
Christopher Di Bella is a Staff Software Engineer for Codeplay’s ComputeCpp Runtime Technology. He is a strong proponent for having the Concepts TS and the Ranges TS in C++20. Chris spends his days working on ComputeCpp, Codeplay’s implementation of SYCL; the Khronos implementation... Read More →


Monday September 24, 2018 11:00 - 12:00
E

11:00

Concepts and Contracts: When, What, and How
Challenge: Write a library function template that takes exactly one positive, integral parameter.

There are many different ways to implement this function template in standard C++. The future additions of Concepts and Contracts will provide even more, possibly simpler, implementations as well. We will review the current status of both of these important new features, conduct a brief overview of what they can do, and then examine how they can work together towards an interface specification nirvana.

Speakers
avatar for Michael Price

Michael Price

Senior Software Engineer, Synopsys, Inc.
Michael Price has developed and taught C++ for more than a decade and has been an active participant in WG21 since 2014, allocating most of his committee-time to EWG and the Reflection Study Group. He professes interest in making C++ "safer" to use through language and library design... Read More →


Monday September 24, 2018 11:00 - 12:00
A

11:00

Text Formatting For a Future Range-Based Standard Library
Text formatting has been a favorite problem of C++ library authors for a long time. The standard C++ iostreams have been criticized for being difficult to use due to their statefulness and slow due to runtime polymorphism. Despite its age, printf is still popular because of simplicity and speed. The Boost library offers two more alternatives, Boost.Format and Boost.LexicalCast. And finally, the P0645 standard proposal sponsored by Facebook is currently finding its way through the C++ committee.

All these approaches are still firmly based on standard containers and iterators. But the Standard Library is changing radically with the advent of ranges, range adaptors and functional style programming in C++. Generating optimized code with metaprogramming is becoming standard fare.

In this talk, I want to convince you that the combination of ranges with a bit of metaprogramming makes for a very elegant solution to the text formatting problem. We introduce a form of ranges with internal iteration, which are generating their elements one by one rather than exposing external iterators. We can use these generator ranges to represent the values to be formatted, conceptually turning them into lazily evaluated strings. These can be used just like regular strings are used today: in function returns; as standard algorithm input; embedded into other, equally lazily evaluated strings; and so on, before they are finally expanded for display. By choosing the right interfaces, we can optimize this expansion at compile-time, making it no less pretty to write, but more efficient to expand than any text formatting approaches that rely on format strings that must be parsed at runtime.

I believe that this approach is the natural extension of a range-based future standard library to text formatting.

Speakers
avatar for Arno Schoedl

Arno Schoedl

CTO, think-cell
Arno is the CTO of think-cell Software GmbH. He is responsible for the design, architecture and development of all their software products, and the evolution of the company's open source C++ library. Before founding think-cell, Arno worked at Microsoft Research and McKinsey. Arno... Read More →


Monday September 24, 2018 11:00 - 12:00
D

12:30

Open Content Sessions: TBA
Monday September 24, 2018 12:30 - 13:30
TBA Meydenbauer Center

14:00

Modern C++ Design (part 1 of 2)
The old rules for C++API design are due for an update - we have made ad hoc changes to design principles in the standard library, but haven’t really written down the new ideas. Parameter passing and API design for free functions/member functions is due for a general update, particularly as a result of rvalue-references and reference qualification. How do we pass non-owning references? How do we sink a T? How do we express “maybe move” APIs? When do we want reference-qualified overload sets? What does an rvalue-reference qualified non-overloaded method mean? How do we express call once semantics?

For types, our consistency in producing Regular types has weakened in recent C++ releases with types like unique_ptr (move-only) and string_view (reference semantics). These classes of design that have shown themselves to be valuable, but certainly surprising at first. As we should not continue to extend the set of type designs arbitrarily, this is a good time to look at type design in the modern C++ era and narrow down the set of designs that are generally favored. This talk will focus on modern C++ design from small (choice of passing by value or reference) to large (Regular types, reference types, move-only types, etc). We will also introduce a taxonomy of type properties as a means to discuss known-good type design families.

We will also dive into the discussion of whether Regular design covers all good design, or whether there is more to the story.

Speakers
avatar for Titus Winters

Titus Winters

C++ Codebase Cultivator, Google
Titus Winters has spent the past 6 years working on Google's core C++ libraries. He's particularly interested in issues of large scale software engineer and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Along... Read More →


Monday September 24, 2018 14:00 - 15:00
B

14:00

C++ Function Templates: How Do They Really Work?
This talk will focus on C++ function templates and such allied topics as compiler-synthesized function template declarations/signatures, overload resolution and partial ordering of these declarations, and compiler instantiation of function template definitions.

We’ll also look at function template specialization, explaining why to avoid explicit ones, and recommending what to do instead.

Finally, time permitting, we’ll offer advice for customizing function templates in the standard library, especially in light of recent WG21 developments re customization points.

Speakers
avatar for Walter E. Brown

Walter E. Brown

retired, none
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... Read More →


Monday September 24, 2018 14:00 - 15:00
F

14:00

Contract Programming in C++(20) (part 1 of 2)
This is a two part session about writing and using contracts
to specify code in C++.

Contract Programming in C++ (first session)
Contract Programming in C++20 (second session)

The first session will define the fundamental princple that
all software is build on: contracts as an exchange of promises
between API authors and consumers. This first session will look
at how deep these promises go, down into the language specification
and design, and how we can effectively write and test our contracts
using C++ from the original C++98 standard up through more modern
dialects. Finally, the properties of good and bad contracts will be
studied, with an emphasis on how they impact API design.

The second session will quickly recap the first session, before
jumping into the details of new proposals for C++20 that allow
contracts to be more clearly expressed in the language. New
features include contracts that can be tested and queried at
compile-time through the type system (Concepts), and support for
writing and testing contracts on object values at runtime, with
direct support for contracts in new attributes. Finally, the
advice regarding good and bad contracts will be revisited in
light of the new language support.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

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


Monday September 24, 2018 14:00 - 15:00
A

14:00

Crafting Embedded Domain-Specific Language (EDSL) In C++ using Metaprogramming, Operator Overloading, and Lambda Expressions
Ever thinking of creating your own specific-purpose programming language? Or maybe improving programming experience by adding a language feature in existing language? This talk presents about Embedded Domain-Specific Language (EDSL) from basic concepts and technique to build it using C++.

EDSL is a powerful technique in integrating a custom libraries or frameworks in users’ codes. EDSL can improve user’s experience in using libraries by reducing boilerplate codes and providing more readable and straightforward codes. Some success stories are: Boost.Spirit, Boost.Proto.

Although Boost.Proto provides tool to build EDSL in C++, this talk presents building EDSL from the ground up utilizing operator overloading, template metaprogramming, and macro. We use operator overloading and template metaprogramming to build a simple expression tree for our EDSL.

This talk provides an example of developing an “asynchronous block” within C++ codes to be used in Tizen native application development. The “asynchronous block” has similar purpose with C++11 std::async but targeting a different API and mimicking the structure of try-catch block.

Speakers
avatar for Gilang Hamidy

Gilang Hamidy

Ex Engineers, Currently Studying
Gilang Hamidy was an Engineer from Samsung Research Indonesia. He was in charge to lead Tizen native application development to support Tizen launch in Indonesia from 2016 to 2017. He initiated Tizen Fundamental Classes (TFC) as a framework libraries to support developing Tizen native... Read More →


Monday September 24, 2018 14:00 - 15:00
G

14:00

Secure Coding Best Practices: Your First Line Is The Last Line Of Defense (part 1 of 2)
Computer systems are under siege 24 hours a day, day in and day out. The critical security infrastructure designed to protect those systems, won't:

* Perimeter security won't protect you.
* Network analytics won't protect you.
* Virus scanners won't protect you.
* Even the users who should know better than to click on that too-good-to-be-true offer won't protect you.

The other side has the best security hardware and software systems other people's money can buy and they have all the time in the world to find creative ways to defeat them. Meltdown and Spectre are prime examples of security vulnerabilities that have lurked dormant for decades. Or have they? If your systems are in any way connected to the outside world, the other side will get inside the wire on you. Know that going in.

Whether you write applications, libraries or work in kernel code, the line of code you write today may very well be the vulnerability someone else finds tomorrow. By nature every code base contains hundreds of attack surfaces and it only takes one serious vulnerability to compromise your system.

While Modern C++ is designed to be secure, the ways we use it often aren't.


In part one of this talk we'll see:

* How hackers think and how they identify weaknesses in our systems.
* How to identify hidden attack surfaces, attack vectors and vulnerabilities in critical systems.
* Where the most common vulnerabilities in Modern and classic C++ are and how to avoid them.
* Why avoiding parts of the language doesn't help.
* Where we can trade off security for performance.

At the end of part one, we'll do a walkthrough of a classic buffer overflow exploit to see how it works and what we've added to the operating systems and compilers to protect against them. Then we'll use it live to run a privilege escalation exploit and gain admin access on a system.


In part two, we'll see:

* Why common guidelines and static analysis tools often fail to find vulnerabilities.
* How to use Threat Modeling to analyze complex systems and build security into our systems at design time.
* How to use Trust Boundaries to protect critical infrastructure.
* Why open source and third-party libraries are fast becoming hidden liabilities in our software and how to protect ourselves against their vulnerabilities.
* What the best practices for protecting our code from attack are.

At the end of part two, we'll do a walkthrough of an exploit that can be successful today in spite of the safe guards built into our operating systems and compilers. Then, as before, we'll use it live to penetrate a system.


The critical security infrastructure designed to protect your systems is largely out of your control. The one thing you can control is the next line of code you write. This talk is for anyone that uses C++ or Modern C++ for kernel, applications or libraries that run in the real-world and that face real-world attacks.

In today's world, that's all of us.

Speakers
avatar for Matthew Butler

Matthew Butler

Matthew Butler started out as a hacker and has spent the last three decades as a systems architect and software engineer developing systems for network security, law enforcement and the military. He primarily works in signals intelligence using C, C++ and Modern C++ to build systems... Read More →


Monday September 24, 2018 14:00 - 15:00
C

14:00

Modern C++ Testing with Catch2
Catch has gained popularity over the last seven years as a modern, C++-native, test framework. Simple to use, easy to get started with, yet still powerful.
Until recently, though, it has been constrained by pre-C++11 compatibility.
Catch2 rebases on C++11 and takes advantage of this to simplify further, as well as offer new capabilities.
This talk takes a look at what's new in Catch and Catch2 and how to effectively test-drive modern C++ codebases.

Familiarity with the original Catch is not assumed, but if you already use it, or have seen previous talks, in this material we'll focus more on some of the newer features.

Speakers
avatar for Phil Nash

Phil Nash

Developer Advocate, JetBrains
Phil is the author of the test frameworks, Catch - for C++ and Objective-C, and Swordfish for Swift. As Developer Advocate at JetBrains he's involved with CLion, AppCode and ReSharper C++. More generally he's an advocate for good testing practices, TDD and using the type system and... Read More →


Monday September 24, 2018 14:00 - 15:00
D

14:00

How to Write Well-Behaved Value Wrappers
There are many useful generic types which wrap a number of values up into one object, e.g. std::optional or std::tuple. These types are conceptually very simple, but designing and implementing them to be as optimal and consistent as possible is deceptively difficult. This talk will outline key considerations, show why they matter by examining the assembly generated from compilers, and describe a number of solutions for problems which arise. Finally, a number of C++ standards papers which could ease the implementation burden for these types will be discussed.

Topics covered will include implicit/explicit constructors, conditional deletion of special member functions, propagation of special member triviality, noexcept correctness, private inheritance, and comparison operators.

Speakers
avatar for Simon Brand

Simon Brand

Senior Software Engineer, GPGPU Toolchains, Codeplay Software
Simon is a GPGPU toolchain developer at Codeplay Software in Edinburgh. He turns into a metaprogramming fiend every full moon, when he can be found bringing compilers to their knees with template errors and debating undefined behaviour on the C++ Slack channel. He co-organises the... Read More →


Monday September 24, 2018 14:00 - 15:00
E

15:15

An Allocator is a Handle to a Heap
C++17 introduced the std::pmr framework. In this framework, a std::pmr::polymorphic_allocator<T> holds a pointer to a std::pmr::memory_resource. The memory resource is in charge of managing and organizing the heap itself, and the allocator object is just a thin "handle" pointing to the memory resource.

This is not just a convenient implementation strategy for std::pmr! Rather, this elucidates the true meaning of the Allocator concept which has existed, unchanged, since C++98. An Allocator *is* a (value-semantic) handle to an (object-semantic) MemoryResource. Even std::allocator can — and should — be viewed as a handle to a global singleton "heap", and not as a heap itself.

From this core insight we derive many corollaries, such as the need for allocator types to be lightweight and efficiently copyable, the fundamental impossibility of implementing an "in-place" std::vector via stupid allocator tricks, and the philosophical underpinnings of "rebinding."

Time permitting, we'll
- discuss what we can expect from a "moved-from" allocator object
- relate the notion of "handle" to neighboring notions such as "façade" and "adaptor"
- suggest similarities between "allocator/heap" and "executor/execution-context"

Speakers

Monday September 24, 2018 15:15 - 16:15
E

15:15

Modern C++ Design (part 2 of 2)
The old rules for C++API design are due for an update - we have made ad hoc changes to design principles in the standard library, but haven’t really written down the new ideas. Parameter passing and API design for free functions/member functions is due for a general update, particularly as a result of rvalue-references and reference qualification. How do we pass non-owning references? How do we sink a T? How do we express “maybe move” APIs? When do we want reference-qualified overload sets? What does an rvalue-reference qualified non-overloaded method mean? How do we express call once semantics?

For types, our consistency in producing Regular types has weakened in recent C++ releases with types like unique_ptr (move-only) and string_view (reference semantics). These classes of design that have shown themselves to be valuable, but certainly surprising at first. As we should not continue to extend the set of type designs arbitrarily, this is a good time to look at type design in the modern C++ era and narrow down the set of designs that are generally favored. This talk will focus on modern C++ design from small (choice of passing by value or reference) to large (Regular types, reference types, move-only types, etc). We will also introduce a taxonomy of type properties as a means to discuss known-good type design families.

We will also dive into the discussion of whether Regular design covers all good design, or whether there is more to the story.

Speakers
avatar for Titus Winters

Titus Winters

C++ Codebase Cultivator, Google
Titus Winters has spent the past 6 years working on Google's core C++ libraries. He's particularly interested in issues of large scale software engineer and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Along... Read More →


Monday September 24, 2018 15:15 - 16:15
B

15:15

Contract Programming in C++(20) (part 2 of 2)
This is a two part session about writing and using contracts
to specify code in C++.

Contract Programming in C++ (first session)
Contract Programming in C++20 (second session)

The first session will define the fundamental princple that
all software is build on: contracts as an exchange of promises
between API authors and consumers. This first session will look
at how deep these promises go, down into the language specification
and design, and how we can effectively write and test our contracts
using C++ from the original C++98 standard up through more modern
dialects. Finally, the properties of good and bad contracts will be
studied, with an emphasis on how they impact API design.

The second session will quickly recap the first session, before
jumping into the details of new proposals for C++20 that allow
contracts to be more clearly expressed in the language. New
features include contracts that can be tested and queried at
compile-time through the type system (Concepts), and support for
writing and testing contracts on object values at runtime, with
direct support for contracts in new attributes. Finally, the
advice regarding good and bad contracts will be revisited in
light of the new language support.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

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


Monday September 24, 2018 15:15 - 16:15
A

15:15

The Nightmare of Initialization in C++
After introducing uniform initialization with C++11, there are at least 5 ways in C++ to initialize an object.
Each have them has different rules, different effects, and different usage depending on the context and goals.
The situation is so confusing that today nobody can tell anymore which type of initialization to teach to beginners.
That's nothing but a disaster.

This talk will discuss the different forms of initialization, compare them to know when to use which, discuss what changed with C++14 and C++17 and what still has to change, and finally what to teach now to beginners.
I promise a source of trouble and discussion.

Speakers
avatar for Nicolai Josuttis

Nicolai Josuttis

IT Communication
Nicolai Josuttis (http://www.josuttis.com) is an independent system architect, technical manager, author, and consultant. He designs mid-sized and large software systems for the telecommunications, traffic, finance, and manufacturing industries. He is well known in the programming community because he not only speaks and... Read More →


Monday September 24, 2018 15:15 - 16:15
F

15:15

Secure Coding Best Practices: Your First Line Is The Last Line Of Defense (part 2 of 2)
Computer systems are under siege 24 hours a day, day in and day out. The critical security infrastructure designed to protect those systems, won't:

* Perimeter security won't protect you.
* Network analytics won't protect you.
* Virus scanners won't protect you.
* Even the users who should know better than to click on that too-good-to-be-true offer won't protect you.

The other side has the best security hardware and software systems other people's money can buy and they have all the time in the world to find creative ways to defeat them. Meltdown and Spectre are prime examples of security vulnerabilities that have lurked dormant for decades. Or have they? If your systems are in any way connected to the outside world, the other side will get inside the wire on you. Know that going in.

Whether you write applications, libraries or work in kernel code, the line of code you write today may very well be the vulnerability someone else finds tomorrow. By nature every code base contains hundreds of attack surfaces and it only takes one serious vulnerability to compromise your system.

While Modern C++ is designed to be secure, the ways we use it often aren't.


In part one of this talk we'll see:

* How hackers think and how they identify weaknesses in our systems.
* How to identify hidden attack surfaces, attack vectors and vulnerabilities in critical systems.
* Where the most common vulnerabilities in Modern and classic C++ are and how to avoid them.
* Why avoiding parts of the language doesn't help.
* Where we can trade off security for performance.

At the end of part one, we'll do a walkthrough of a classic buffer overflow exploit to see how it works and what we've added to the operating systems and compilers to protect against them. Then we'll use it live to run a privilege escalation exploit and gain admin access on a system.


In part two, we'll see:

* Why common guidelines and static analysis tools often fail to find vulnerabilities.
* How to use Threat Modeling to analyze complex systems and built security into our systems at design time.
* How to use Trust Boundaries to protect critical infrastructure.
* Why open source and third-party libraries are fast becoming hidden liabilities in our software and how to protect ourselves against their vulnerabilities.
* What the best practices for protecting our code from attack are.

At the end of part two, we'll do a walkthrough of an exploit that can be successful today in spite of the safe guards built into our operating systems and compilers. Then, as before, we'll use it live to penetrate a system.


The critical security infrastructure designed to protect your systems is largely out of your control. The one thing you can control is the next line of code you write. This talk is for anyone that uses C++ or Modern C++ for kernel, applications or libraries that run in the real-world and that face real-world attacks.

In today's world, that's all of us.

Speakers
avatar for Matthew Butler

Matthew Butler

Matthew Butler started out as a hacker and has spent the last three decades as a systems architect and software engineer developing systems for network security, law enforcement and the military. He primarily works in signals intelligence using C, C++ and Modern C++ to build systems... Read More →


Monday September 24, 2018 15:15 - 16:15
C

15:15

How C++ Debuggers Work
Debuggers are one of the most important tools in the belt of any developer, but they are often seen as a magic black box. This is compounded by the lack of available literature, especially when compared to other toolchain components like compilers. This talk aims to demystify debuggers by showing how the utilities you use every day actually work.

Topics which will be covered include debug information and object file formats, breakpoints, stepping, register and memory manipulation, stack unwinding, multi-threaded applications, and expression evaluation. x86 Linux platforms will be used for demonstrative purposes, but the general concepts are platform independent.

Speakers
avatar for Simon Brand

Simon Brand

Senior Software Engineer, GPGPU Toolchains, Codeplay Software
Simon is a GPGPU toolchain developer at Codeplay Software in Edinburgh. He turns into a metaprogramming fiend every full moon, when he can be found bringing compilers to their knees with template errors and debating undefined behaviour on the C++ Slack channel. He co-organises the... Read More →


Monday September 24, 2018 15:15 - 16:15
D

16:45

Git, CMake, Conan - How to ship and reuse our C++ projects
Git and CMake are already established standards in our community. However, it is uncommon to see them being used in an efficient way. As a result, many C++ projects have big problems with either importing other dependencies or making themselves easy to import by others. It gets even worse when we need to build many different configurations of our package on one machine.

That presentation lists and addresses the problems of build system and packaging that we have with large, multi-platform, C++ projects that often have many external and internal dependencies. The talk will present how proper use of CMake and Conan package manager can address those use cases. It will also describe current issues with the cooperation of those tools.

If you've attended or seen my talk at C++Now 2018, that time you can expect much more information on Conan and package creation using that tool. I will also describe how the integration of CMake and Conan changed over the last few months.

Speakers
avatar for Mateusz Pusz

Mateusz Pusz

Chief Software Engineer, Epam Systems
Software architect, chief developer, and security champion with more than 14 years of experience in designing, writing and maintaining C++ code for fun and living. C++ consultant, trainer, and evangelist focused on Modern C++. His main areas of interest and expertise are code performance... Read More →


Monday September 24, 2018 16:45 - 17:45
D

16:45

A Modern C++ Programming Model for GPUs using Khronos SYCL
Computer system architecture trends are constantly evolving to provide higher performance and computing power, to support an increasing demand for high-performance computing domains including AI, machine learning, image processing and automotive driving aids. The most recent being the move towards heterogeneity, where a system has more than one kind of processor working together in parallel. These kinds of systems are everywhere, from desktop machines and high-performance computing servers to mobile and embedded devices.

OpenCL is an open standard from the Khronos group which provides a low-level C API for compiling and offloading code to be executed on another heterogeneous architecture and moving data to and from the device. A more recent standard form the Khronos group; SYCL is a single source heterogeneous programming model which provides the performance portability of OpenCL with a high-level modern C++ programming interface.

SYCL allows users to write standard C++ code which is then executed on a range of heterogeneous architectures including CPUs, GPUs, DSPs, FPGAs and other accelerators. On top of this SYCL also provides a high-level abstraction which allows users to describe their computations as a task graph with data dependencies, while the SYCL runtime performs data dependency analysis and scheduling. SYCL also supports a host device which will execute on the host CPU with the same execution and memory model guarantees as OpenCL for debugging purposes, and a fallback mechanism which allows an application to recover from failure.

This talk will present the SYCL programming model. It will cover how to find an appropriate heterogeneous device to execute work on, how to defined data dependencies and construct task graphs using accessors and how to write C++ code which will execute on the device. It will cover other features of the interface including the host device, the fallback and templating device code. It will then present various ecosystem projects which are built on top of SYCL including Eigen / TensorFlow, Parallel STL and SYCBLAS.

Speakers
avatar for Michael Wong

Michael Wong

VP Research & Development, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. | He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C... Read More →


Monday September 24, 2018 16:45 - 17:45
A

16:45

Emulating the Nintendo 3DS: Generative & Declarative Programming in Action
Data de-serialization is a surprisingly common task in game console emulation (kernel interfaces, driver communication, and file IO), and to address it we usually use repetitive boilerplate code that is often nothing but error-prone and unmaintainable. How can modern C++ help?

We take a look at the interprocess communication subsystem of the Nintendo 3DS and see how generative programming tools (variadic templates, function reflection, metaprogramming) and a declarative approach give us wins in performance, maintainability, and correctness.

The takeaway of this session is a glimpse at generators, declarative interfaces, and how to use them to solve serialization-like problems with minimal effort and maximum reusability.

Speakers
avatar for Tony Wasserka

Tony Wasserka

Freelance Software Developer
Low-level anything: Tony is a long-term C++ enthusiast who has worked on the console emulator projects Dolphin (GameCube/Wii), PPSSPP (PSP), and Citra (3DS) since 2010. More recently, he has worked on Vulkan graphics drivers for PowerVR graphics processors. His main interest is exploring... Read More →


Monday September 24, 2018 16:45 - 17:45
E

16:45

Unwinding the Stack: Exploring How C++ Exceptions Work on Windows
If you’re writing modern C++ code, then it’s likely that you are using exceptions—whether you’re throwing them yourself or just using library code that might throw (e.g., std::vector). Have you ever stopped to think about how exceptions work under the hood? What actually happens at runtime when you throw an exception? How is the right catch statement found?

In this session, we’ll explore how C++ exceptions actually work in the Visual C++ implementation on Windows. This session will discuss:

* A very, very brief overview of how exceptions work in the C++ language
* The code and data structures the Visual C++ compiler generates to facilitate proper stack unwinding
* Exactly what happens when an exception is thrown, how the right catch statement is found, and how the stack is unwound
* Structured Exception Handling (SEH), the Windows OS feature atop which C++ exceptions are built
* How the Visual C++ runtime library interacts with the OS during stack unwinding
* Interoperation with non-C++ exceptions, like hardware exceptions
* How termination handling works when no matching catch statement is found or when a noexcept boundary is reached
* How things differ on different architectures (x86 is very different from x64 and ARM!)

This information can be very useful when debugging tricky problems—especially during postmortem debugging when you’re trying to figure out what went wrong before a program crashed—and we’ll highlight particular pieces of information that are most useful.

Speakers
avatar for James McNellis

James McNellis

Senior Software Engineer, Microsoft Corporation
James is a senior engineer on the Windows Debugger team at Microsoft, where he works on the Time Travel Debugging (TTD) reverse debugging toolkit. Prior to joining the Debuggers team in 2016, he was a member of the Visual C++ team, where he was responsible for the Microsoft C Runtime... Read More →


Monday September 24, 2018 16:45 - 17:45
C

16:45

Class template argument deduction in C++17
Class Template Argument Deduction (CTAD) is a very useful C++ language feature that was added in C++17. This talk is a comprehensive and practice-oriented introduction to this new technique.

In this talk I'll present how CATD and automatic deduction guides let you write cleaner and shorter code, show how to interact with it when using the C++ standard library and when designing your own classes, explain when and how user-defined deduction guides should be used, and cover the language rules behind all of this.

We will also discuss the various pitfalls that lie in wait: wrong and surprising template arguments being deduced, your constructor not being selected even if you think it should be, and automatic CTAD sometimes leading to unsafe and broken code – and how to circumnavigate those pitfalls.

Speakers
avatar for Timur Doumler

Timur Doumler

JetBrains
Timur Doumler works at JetBrains, where he develops the C++ frontend for CLion, the cross-platform C++ IDE. In the past he has spent much time working in the audio tech industry and has written code for the JUCE framework. Timur is an active member of the ISO C++ committee and passionate... Read More →


Monday September 24, 2018 16:45 - 17:45
G

16:45

Expect the Expected
Writing code that is resilient upon errors has always been a pain point in all languages. Exceptions are the politically correct means to signal errors in C++, but many applications still resort to error codes for reasons related to ease of understanding, ease of handling errors locally, and efficiency of generated code.

This talk shows how a variety of theoretical and practical artifacts can be combined together to address error codes and exceptions in one wholesome, simple package. The generic type expected<T> can be used for both local (error-code-style) and centralized (exception-style) manners, drawing from the strengths of each.

Speakers
avatar for Andrei Alexandrescu

Andrei Alexandrescu

Vice President, D Language Foundation
Andrei Alexandrescu is a researcher, software engineer, and author. He wrote three best-selling books on programming (Modern C++ Design, C++ Coding Standards, and The D Programming Language) and numerous articles and papers on wide-ranging topics from programming to language design... Read More →


Monday September 24, 2018 16:45 - 17:45
B
  • Level Intermediate, Advanced, Expert
  • Tags C++20

16:45

Surprises in Object Lifetime
One of the main defining features of C++ is that of well defined object lifetime. We know that when a scope exits any local variables will be properly cleaned up. This is something that we rely upon and use regularly for the management of resources (ie RAII).

However, there are some corners of the language that challenge our understanding of object lifetime. I have been teaching classes on understanding object lifetime for over a year now and some of these places continue to surprise my students and have even surprised me.

We will explore these corners of C++ and ask if they cause enough concern that the language features should not be used, or if they are still worth the price? We will also ponder if these can be considered mistakes in the language or just side effects of a useful feature. We will also explore when and how the compiler and analyzers can warn on these issues.

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... Read More →


Monday September 24, 2018 16:45 - 17:45
F

20:30

Open Content Sessions: TBA
Monday September 24, 2018 20:30 - 22:00
TBA Meydenbauer Center
 
Tuesday, September 25
 

08:00

Open Content Sessions: TBA
Tuesday September 25, 2018 08:00 - 08:45
TBA Meydenbauer Center

09:00

What Do We Mean When We Say Nothing At All?
They say silence can speak volumes. In a C++ application there are many places where not using a keyword or a piece of punctuation is a deliberate decision that carries a lot of information. Consider not marking a member function const, or virtual, or consider not indicating that a parameter is passed by reference. While in some cases this may be an oversight, a reliance on defaults that might or might not be appropriate, in others its a deliberate decision based on careful thought and design. How is a reader to know which is the case?

In this talk I will show some of the many places where nothingness carries meaning, and talk about approaches to increase the information others can get from your nothingness.

Speakers
avatar for Kate Gregory

Kate Gregory

Partner, Gregory Consulting
Kate Gregory has been using C++ since before Microsoft had a C++ compiler. She writes, mentors, codes, and leads projects, in both C++ and .NET, especially for Windows. Kate is a Microsoft Regional Director, a Visual C++ MVP, has written over a dozen books, and speaks at conferences... Read More →


Tuesday September 25, 2018 09:00 - 10:00
G

09:00

Regular Expressions Done in Compile Time
I will present a library that utilizes a feature of C++20 to build regular expressions from compile-time strings. This is a novel approach that doesn't have ordinary disadvantages of other regular expression implementations like having to use a linked library or a run-time cost of parsing and interpreting an internal finite machine.

You will see implementation details of the library and problems I have run into during its writing. In the last part of the talk, I will compare other implementations of regular expression engines and show compiled code in Compiler Explorer.

Speakers
avatar for Hana Dusíková

Hana Dusíková

Senior Researcher, Avast
Hana is working as a senior researcher in Avast Software. Her responsibility is exploring new ideas and optimizing existing ones. She also propagates modern C++ techniques and libraries in internal techtalks and gives talks at local C++ meetups. | | She studied computer science... Read More →


Tuesday September 25, 2018 09:00 - 10:00
C

09:00

Source Instrumentation for Monitoring C++ in Production
It is essential to discuss how modern C++ code can be effectively instrumented, in order to effectively monitor it after deployment. This talk will focus on portable source instrumentation techniques such as logging, tracing and metrics. Straightforward, but well designed code additions can drastically ease the troubleshooting of functional issues, and identification of performance bottlenecks, in production.

Of course when dealing with C++ performance is often critical, and so minimizing the cost of any instrumentation is also critical. Key to this is understanding the trade-off between the detail of information collected, and the overheads of exposing that information. It is also important to understand how best to benefit from advances in contemporary monitoring infrastructure, popularised by "cloud" environments.

This talk will open with a brief summary of monitoring goals, infrastructure, benefits, and existing practise. It will then detail practicalities of building a set of C++ source instrumentation primitives, based on proven principles employed in demanding production software.

Speakers
avatar for Steven Simpson

Steven Simpson

Senior Software Engineer, Graphcore
Hardware verification engineer, turned software engineer, turned infrastructure engineer. Most recently involved with developing monitoring systems for supercomputers at a well known university, but with over ten years experience spanning a wide range of software engineering problems... Read More →


Tuesday September 25, 2018 09:00 - 10:00
F

09:00

DynaMix: A New Take on Polymorphism
Software with very complex business logic, such as games, CAD systems, and enterprise systems, often needs to compose and modify objects at runtime - for example to add or override a method in an existing object. Standard C++ has rigid types which are defined at compile time and make this hard. On the other hand languages with dynamic types like lua, Python, and JavaScript make this very easy. Therefore, to keep the code readable and maintainable, and accomplish complex business logic requirements, many projects use such languages alongside C++. Some drawbacks of this approach include the added complexity in a language binding layer, the performance loss from using an interpreted language, and the inevitable code duplication for many small utility functionalities.

DynaMix is a library which attempts to remove, or at least greatly reduce, the need for a separate scripting language by allowing the users to compose and modify polymorphic objects at runtime in C++. This talk will elaborate on this problem and introduce the library and its key features to potential users or people who might benefit form the approach with an annotated example and a small demo.

Speakers
avatar for Borislav Stanimirov

Borislav Stanimirov

Borislav has been a C++ programmer for 15 years. In the past 11 he has been programming video games. He has worked on C++ software for all kinds of platforms: desktops, mobile devices, servers, and embedded. His main interests are software architecture and design, and programming... Read More →


Tuesday September 25, 2018 09:00 - 10:00
E

09:00

Avoiding Disasters with Strongly Typed C++
C++ is often described as a type-safe language — the compiler will not allow the programmer to mix types freely. But do we really use C++ in a type-safe manner? When a programmer uses the same type to represent different quantities, one could argue that the compiler's type-checks are bypassed and errors due to mix-ups not only become possible, but frequent! In this session a solution to this problem will be presented — strong types.

Strong types are a type-safe alternative to typedefs — but where typedefs only provide documentation and ease of writing, their strong counterparts are actually enforced by the compiler. We will explore how they work, and how using them can improve code quality. We will look at how one can implement a strong typedef by oneself, but also look at some of the readily available implementations which are available.

Finally we will look at how we can handle some special cases, e.g. where we need to allow two different strong types to interact with each other in well defined ways. These could be types representing two different linked quantities like positions and offsets; or scaled versions of the same quantity like different units of length.

Speakers
AL

Arno Lepisk

Software engineer, HiQ


Tuesday September 25, 2018 09:00 - 10:00
B

09:00

Fancy Pointers for Fun and Profit
In modern C++ it is possible to implement user-defined types that closely mimic the behavior of ordinary pointers; these types are often referred to as fancy (or synthetic) pointers. With such types at one's disposal, it becomes feasible to build standard-conforming allocators that support relocatable memory in a way that is compatible with the standard containers. This, in turn, enables the use of the standard containers in applications like shared-memory databases, self-contained private heaps, and lightweight object persistence.

This talk will describe a small set of components that implement synthetic pointers. We'll begin by looking briefly at a couple of motivating problems, and then review how the standard defines "pointer-like types". We'll then discuss how closely a user-defined type can emulate ordinary pointers and sketch out a strategy for implementing such a type using the concepts of addressing model, storage model, and pointer interface.

We'll jump into the deep end by implementing two different addressing models, offset addressing and based 2D addressing, which act as policy types for a synthetic pointer class template. We'll then review simple storage models that support raw memory allocation for both addressing models before examining the synthetic pointer class in detail. We'll discuss how the synthetic pointer class interacts with the addressing models to implement pointer operations and emulate an ordinary pointer's interface.

Finally, the talk will provide an example of how these concepts can be applied - namely, containers in a self-contained private heap.

Speakers
avatar for Bob Steagall

Bob Steagall

CppCon Poster Chair, KEWB Computing
I've been working in C++ for the last 25 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 detour through the world of DNS and analytics, I'm now working... Read More →


Tuesday September 25, 2018 09:00 - 10:00
D

09:00

Regular Types and Why Do I Care ?
“Regular” is not exactly a new concept (pun intended). If we reflect back on STL and its design principles, as best described by Alexander Stepanov in his 1998 “Fundamentals of Generic Programming” paper or his lecture on this topic, from 2002, we see that regular types naturally appear as necessary foundational concepts in programming.
Why do we need to bother with such taxonomies ? Well, the STL now informally assumes such properties about the types it deals with and imposes such conceptual requirements for its data structures and algorithms to work properly. The new Concepts Lite proposal (hopefully part of C++20) is based on precisely defined foundational concepts such as Semiregular, Regular, EqualityComparable, DefaultConstructible, LessThanComparable (strict weak ordering), etc. Formal specification of concepts is an ongoing effort in the ISO C++ Committee and these STL library concepts requirements are being refined as part of Ranges TS proposal (<experimental/ranges/concepts>).
Recent STL additions such as string_view, tuple, reference_wrapper, as well as new incoming types for C++20 like std::span raise new questions regarding values types, reference types and non-owning “borrow” types.
Designing and implementing regular types is crucial in everyday programing, not just library design. Properly constraining types and function prototypes will result in intuitive usage; conversely, breaking subtle contracts for functions and algorithms will result in unexpected behavior for the caller.
This talk will explore the relation between Regular types (and other concepts) and STL containers & algorithms with examples, common pitfalls and guidance.

Speakers
avatar for Victor Ciura

Victor Ciura

Software Developer, CAPHYON
Victor Ciura is a Senior Software Engineer at CAPHYON and Technical Lead on the Advanced Installer team (http://www.advancedinstaller.com). | For over a decade, he designed and implemented several core components and libraries of Advanced Installer such as: IIS, Repackager, OS... Read More →


Tuesday September 25, 2018 09:00 - 10:00
A

10:30

Plenary: TBA
Tuesday September 25, 2018 10:30 - 12:00
TBA Meydenbauer Center

12:30

Open Content Sessions: TBA
Tuesday September 25, 2018 12:30 - 13:30
TBA Meydenbauer Center

12:30

CppCon Program Committee
If you are on the CppCon Program Committee or if you have considered joining, this session is for you. This will be our first opportunity to meet as a group, face to face.

We'll discuss the CppCon PC Reviewer's Guide and share ideas about how to inprove the submission review process for all involved, including submitters.

Our goal is to have a common understanding what session ratings mean and what our role is in the program development process.


Moderators
BA

Bryce Adelstein Lelbach

Bryce Adelstein Lelbach is a software engineer on the CUDA driver team at NVIDIA. Bryce is passionate about parallel programming. He maintains Thrust, the CUDA C++ core library. He is also one of the initial developers of the HPX C++ runtime system. He spent five years working on... Read More →

Tuesday September 25, 2018 12:30 - 13:30
TBA Meydenbauer Center

14:00

The Exciting New Future of Safe Reclamation for High Performance
Plans are underway to introduce a new chapter in the C++ standard on concurrency, both literally (in the Specification Chapters) and conceptually. One of the topic in this new chapter is Safe Reclamation, which includes sections on:
- Atomic specialization for shared_ptr
- RCU
- Hazard Pointers
- Cell

There are several forms of Safe Reclamation that are now making their way through the C++ Standard Committee. The reference counting-based shared_ptr was introduced in C++11, and then Atomic Shared Pointer in Concurrency TS1. There are now proposals for Hazard Pointers, RCU, and Cell (an abstraction from Google that can build on top of all the other methods) have all advanced out of Study Group 1 (concurrency). Even better, all three proposals have accrued significant usage experience in production.

Of course, both committee discussions and usage experience have resulted in fundamental changes to the proposals over the last two years. This talk will give an overview and the latest status of the proposals, then expand on the new aspects of hazard pointers and RCU. Some of these experiences are pointing to a bright future beyond lock-free programming towards fast and scalable essential concurrent data structures in demanding production environments.

In this talk, we will dissect each of these important components and compare and contrast their qualitative features and performance profiles. We will cover the features that will be included in C++20, and those on track for inclusion in Concurrency TS2. We will discuss the important changes from the C++ standardization process and how they may impact your usage. We will demonstrate examples of use of these technique.

Beyond the current proposals, there are possible interface additions based on user experience in production. We will present newly added features to the hazard pointer method that expand its applicability to general concurrent data structures. The new interface is based on novel algorithmic additions to the method that use reference counting judiciously, with zero reader overhead and minimal writer overheads. We will show the usage of these interface expansions in common data structures, with code examples from the hazard pointer implementation in the Folly open-source library.

Speakers
avatar for Paul McKenney

Paul McKenney

Distinguished Engineer, IBM Linux Technology Center, Beaverton
Paul E. McKenney is a Distinguished Engineer with the IBM Linux Technology Center, where he maintains the RCU implementation within the Linux kernel. He has been coding for four decades, more than half of that on parallel hardware. His prior lives include the DYNIX/ptx kernel at Sequent... Read More →
MM

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... Read More →
avatar for Michael Wong

Michael Wong

VP Research & Development, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. | He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C... Read More →


Tuesday September 25, 2018 14:00 - 15:00
G

14:00

Making New Friends
A friend of a class is a function or class that is not a member of that class, but nonetheless has access to all members of that class. The conventional wisdom is that granting friendship is something you do should sparingly. This lecture introduces a distinctive use for friend function declarations in class templates that's not about granting access to non-public members. Rather, it's about using a template as a
factory for "making" new friends. Along the way, this session explains various subtleties about operator overloading, overload resolution,
template instantiation, and name lookup for friend functions.

Speakers
avatar for Dan Saks

Dan Saks

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


Tuesday September 25, 2018 14:00 - 15:00
A

14:00

Operator Overloading: History, Principles and Practice
Your code would benefit from greater use of operators. Really.

Operator overloading is such an unloved part of C++. It's not new, it's not
glamorous, it's frequently maligned for "syntax abuse", and often avoided due to
performance or implementation concerns. But operators deserve more
consideration! If you're designing types and interfaces, operators have the
potential to offer concision, clarity, and flexibility, and foster intuition in
a way that functions can't.

In this talk we'll look at past, current and likely future practices, from the
humble old operator+ on arithmetic types to new uses like operator/ to
concatenate paths, and beyond. We'll cover concrete guidelines for principled
operator usage and the implementation concerns involved.

Speakers
avatar for Ben Deane

Ben Deane

Ben was in the game industry for 23 years, at companies like EA and Blizzard. He's always looking for useful new techniques in C++, and he | geeks out on algorithms, APIs, types and functional programming.


Tuesday September 25, 2018 14:00 - 15:00
E

14:00

What Could Possibly Go Wrong?: A Tale of Expectations and Exceptions
In software things can go wrong. Sometimes we might expect them to go wrong. Sometimes it’s a surprise. In most cases we want to build in some way of handling these disappointments.

In some cases we can use exceptions. But there are many cases where the overhead of exceptions is more than we want or can afford - and some are so constrained that exceptions are not even possible. Alternatives now include std::optional, or the proposed std::expected - but these come with a lot of code overhead

What we really want is a way to concisely produce and handle disappointments in our code in a performant manner. This talk will evaluate a few approaches to solving this, including monads, syntactic sugar for error handling, and we'll even look at an intriguing possibility that promises to unify these worlds.

Speakers
avatar for Simon Brand

Simon Brand

Senior Software Engineer, GPGPU Toolchains, Codeplay Software
Simon is a GPGPU toolchain developer at Codeplay Software in Edinburgh. He turns into a metaprogramming fiend every full moon, when he can be found bringing compilers to their knees with template errors and debating undefined behaviour on the C++ Slack channel. He co-organises the... Read More →
avatar for Phil Nash

Phil Nash

Developer Advocate, JetBrains
Phil is the author of the test frameworks, Catch - for C++ and Objective-C, and Swordfish for Swift. As Developer Advocate at JetBrains he's involved with CLion, AppCode and ReSharper C++. More generally he's an advocate for good testing practices, TDD and using the type system and... Read More →


Tuesday September 25, 2018 14:00 - 15:00
D

14:00

Woes of Scope Guards and Unique Resource - 5+ years in the making
C++ major benefit is its deterministic lifetime model of variables and values. This lead to the RAII (resource-acquisition is initialization) idiom that is essential for resource safety and less leakage. Some standard library classes already implement RAII for specific cases, such as heap-allocated pointers, mutex locking or file-I/O.

While some "mis"-uses of unique_ptr are recommended as a general RAII wrapper, those uses sometimes fail to be general enough. This lead Andrew Sandoval to specify a unique resource wrapper for the standard libary in 2013 (N3677). This talk tells the story how the author helped shepherding that mechanism through at least 12 revisions to make it into the standard library, which might be achieved while CPPCon runs, or not yet (hopes are high).

Implementing a RAII wrapper seems trivial, just implement a constructor and destructor, but doing so in generic ways is hard and tricky. Even with simple DIY solutions, interesting effects lurk and can lead to surprises also when using the generic solutions potentially provided by C++20.


Speakers
avatar for Peter Sommerlad

Peter Sommerlad

Professor, HSR Rapperswil
Prof. Peter Sommerlad is director of IFS Institute for Software at FHO HSR Rapperswil where he inspired the C++ IDE Cevelop. Peter is co-author of the books POSA Vol.1 and Security Patterns. His goal is to make software simpler by Decremental Development: Refactoring software down... Read More →


Tuesday September 25, 2018 14:00 - 15:00
B

14:00

Pessimistic Programming
We often write programs in such a way as to make them run fast. We want good average speed, high throughput, and we tend to be happy when benchmarks show that our peak running speed is better than expected.

However, it's sometimes useful to write programs where we want to make the worst-case scenario faster, or make it run at predictable speed, or even reduce variations in execution speed. Instead of concentrating our efforts on making the best or the average speed better, we sometimes need to make the worst case speed "less bad".

C++ is a wonderful language for such situations. C++ gives us a lot of control over what's going on, and we can use this control to our advantage.

The aim of this talk is to discuss techniques to make the execution speed of programs more predictable, and to guide the compiler towards generating code where worst-case execution speed respects some constraints. It will probably most interesting to intermediate audiences who are curious about how to address such issues, or who wonder why it is sometimes important to be pessimistic and worry about those times when program execution takes the slow path.

Speakers
avatar for Patrice Roy

Patrice Roy

Professeur, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 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... Read More →


Tuesday September 25, 2018 14:00 - 15:00
C

14:00

More gdb and other Linux debugging wizardry
Greg will demonstrate some neat new GDB features and other advanced debugging tools on Linux.

Debugging dominates software development, and yet all too often we rely on printf or at best a little bit of gdb with a bit of 'next' and 'print'. This talk will demonstrate some of the power of newer versions of GDB (Reverse debug, dynamic printf, amazing scriptability possibilities through Python), as well as some of the other Linux debugging tools at your disposal: ftrace, strace, ltrace, valgrind, rr, asan, and lots of very useful stuff in /proc.

This presentation works either as a stand-alone talk or as a follow on to Greg's popular 'GDB Power User' talk at cppcon 2016."

Speakers
avatar for Greg Law

Greg Law

CEO, Undo Ltd
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 25, 2018 14:00 - 15:00
F

15:15

A Semi Compile/Run-time Map with (Nearly) Zero Overhead Lookup
An associative map container is one of the most useful data-structures in any modern program. Given a key, it can look-up the corresponding value incurring some runtime overhead. Often, however, this overhead is not strictly necessary as the key originated (either directly or indirectly) from a value which was known to the compiler at compile-time - such as a literal. In this talk, I will present a semi compile-/run-time map which can overcome this overhead by using C++’s constexpr features.

Yet another constexpr hash map talk, I hear you say? This one is different! Most constexpr maps presented at previous conferences are either constexpr-only, i.e. the values cannot be changed at runtime, or, require that all possible keys of the map are defined in one place making it unsuitable for library code. In contrast, the map presented in this talk, only calculates the storage of the key’s associated value at compile-time, but loading/storing the value and adding key/value pairs still occurs at run-time.

It will be shown how such a map can be used to implement a super efficient cache. In its most simplest form, looking up the storage of a primitive type for a given compile-time key has the same overhead as accessing a global variable. It will be shown that the underlying principle is surprisingly easy (3 lines of code) and the difficulty actually lies in associating any compile-time identifier to a unique C++ type - especially string literals. I will show how this can be achieved using constexpr if and constexpr lambda expressions - both C++17 features.

Speakers
FR

Fabian Renn-Giles

Fielding DSP


Tuesday September 25, 2018 15:15 - 15:45
E

15:15

Touring the "C++ Tip of the Week" Series
Since 2012, Google's C++ Library Team has published an essay/guidance series called the "C++ Tip of the Week." Internally, this is used as a sort of secondary to the C++ Style Guide - while the style guide is roughly treated with the force of law, the TotW series is only "very strong guidance." With the release of Abseil at last year's CppCon, we've begun re-publishing the relevant TotW entries on http://abseil.io/tips/.

We think this can serve a good purpose in the public C++ ecosystem. The Core Guidelines cover basically everything, and do a good job, but are often only a shallow summary of the topic at hand. Any given TotW, on the other hand, covers a relatively narrow topic in greater detail.

This talk will give a general overview of the series: it's major themes and most commonly cited entries. As such, this talk will hit on things like: understanding copy vs. move, how to use `emplace`, enums and producing readable APIs, how to construct a unique_ptr clearly, and how to structure your unittests.

Speakers
avatar for Jon Cohen

Jon Cohen

SWE, Google
Jon Cohen is an engineer at Google, maintaining our core common C++ libraries. He spends most of his days directing Google's robot army to rewrite its own source code to be more readable and efficient, and has so far managed to do so without accidentally creating Skynet.
avatar for Matt Kulukundis

Matt Kulukundis

Senior Software Engineer, Google
Matt is a senior software engineer on the C++ libraries team at Google.  Prior to Google he has worked on compilers, machine learning, and underwater robotics.  In his free time, he scuba dives in warm places.


Tuesday September 25, 2018 15:15 - 15:45
C

15:15

Overloading: The Bane of All Higher-Order Functions
Support for functional programming has been consistently growing in C++. Lambdas, new algorithms, variant visitation and std::apply are just a few of the many additions which make use of the paradigm more natural, expressive and powerful. Unfortunately, passing overloaded functions or function templates to higher-order functions is not as simple as it sounds, which forces users to adopt various unsatisfactory workarounds. This talk will discuss a few solutions, show how C++ still has a way to go in providing language support, and examine some existing standards proposals which could help.

Techniques discussed will include wrapping up overload sets in lambdas; maintaining noexcept specifications, return types, and brevity; global function objects; and avoiding subtle One Definition Rule (ODR) violations.


Speakers
avatar for Simon Brand

Simon Brand

Senior Software Engineer, GPGPU Toolchains, Codeplay Software
Simon is a GPGPU toolchain developer at Codeplay Software in Edinburgh. He turns into a metaprogramming fiend every full moon, when he can be found bringing compilers to their knees with template errors and debating undefined behaviour on the C++ Slack channel. He co-organises the... Read More →


Tuesday September 25, 2018 15:15 - 15:45
A

15:15

RVO is Harder than it Looks: the story of -Wreturn-std-move
Join Arthur O'Dwyer on a deep dive into Return Value Optimization and related topics.

Even C++03 allowed the compiler to "elide" copy construction in certain cases. We'll start with an explanation of the calling convention on a typical machine, showing where the mysterious "return slot" lives, and why it makes sense that C++03 allowed copy elision in certain special cases (but not others). Then we'll show how C++11 (and a subsequent defect report) upped the game by quietly turning the remaining copies into moves, so that the commonly received wisdom these days is that `return std::move(x)` is never necessary and often a pessimization.

...Or is it? We'll show some real-world examples where `return x` quietly copies a large object instead of moving it. We'll explain the little-known notion of a "converting constructor", contrast it with "conversion operator", and show the precise way in which C++17 drops the ball on these examples. Finally, Arthur implemented a Clang compiler warning to detect and suggest fixes for problematic return statements; he'll walk through the relatively painless process of creating that diagnostic, and perhaps inspire you to contribute to Clang yourself!

Speakers

Tuesday September 25, 2018 15:15 - 15:45
B

15:15

Make It Fixable: Preparing for Security Vulnerability Reports
From experience we have learned that almost any surface we expose could have weaknesses. We have to have a plan on how to deal with issues as they arise, and an architecture that allows us to correct and protect in products that are already in use. When security is lifted up to the discretion of the user, however, we often fail to inform their decision properly. The usability of security and the architecture of fixability are closely connected, and both need continued refinement and focus. This talk will describe architectural and organizational features that make it easier to make corrective measures. They are down-to-earth everyday scenarios, illustrated by real world software projects and security incidents. Some of the stories are well known, some are anonymized to protect the innocent. Finally we will show examples of how difficult it is to design the user experience of security.

Speakers
PA

Patricia Aas

Programmer, TurtleSec
Patricia has been programming C++ professionally for 13 years, she started out working on the Opera desktop browser and has looped back to browser making in the recent years, now working on the Vivaldi browser with many ex-opera colleagues. While away from the browser world she did... Read More →


Tuesday September 25, 2018 15:15 - 15:45
D

15:15

Funqual: user-defined statically-checked call tree constraints in C++
Static analysis tools can aid programmers by reporting potential programming mis-
takes prior to the execution of a program. Funqual is a static analysis tool that reads
C++17 code ”in the wild” and checks that the function call graph follows a set of
rules which can be defined by the user. This sort of analysis can help the program-
mer to avoid errors such as accidentally calling blocking functions in time-sensitive
contexts or accidentally allocating memory in heap-sensitive environments. To ac-
complish this, we create a type system whereby functions can be given user-defined
type qualifiers and where users can define their own restrictions on the call tree based
on these type qualifiers. We demonstrate that this tool, when used with hand-crafted
rules, can catch certain types of errors which commonly occur in the wild. We claim
that this tool can be used in a production setting to catch certain kinds of errors in
code before that code is even run.

Speakers
AN

Andrew Nelson

Andrew is passionate about creating tools and methodologies that enable everyone to write high quality software. He is currently a masters student at Cal Poly SLO where his area of research involves program static analysis. Andrew spends a lot of time teaching Computer Science to... Read More →


Tuesday September 25, 2018 15:15 - 15:45
F

15:50

yomm2 - Fast Orthogonal Open (Multi) Methods
Have you ever felt your life would be simpler if you could just add virtual functions to a class hierarchy whenever you needed to (e.g., to persist an object or render it in JSON), but refrained because you did not own the classes and it would violate the principle of separation of concerns? Have you toiled on a Visitor class once again? Did you struggle to get double dispatch right because you needed to implement binary operations for polymorphic classes?
Open methods solve all these problems, while requiring you to write much less code -- and they deliver superior performance.

Open methods are virtual functions that are defined outside of a class. Given a method declaration and a set of specializations, the most specific version is selected depending on the dynamic type of one or more arguments. Open methods make it possible to add polymorphic behavior to existing hierarchies of classes, without needing to modify them. They provide a superior alternative to the Visitor pattern and a solution to the problem of cross-cutting concerns. Since more than one argument can participate in the selection of the specialization, open methods also solve the binary (or multiple) dispatch problem.

Circa 2007, Pirkelbauer, Stroustrup and Solodkyy wrote several papers about open multi-methods methods for C++, but the idea has failed to gain acceptance so far. My yomm2 library provides an implementation that is both fast (close to virtual functions), elegant and non intrusive.

yomm2 is available on GitHub (https://github.com/jll63/yomm2).

I wrote a series of articles on an earlier version of a library (yomm11), see https://www.codeproject.com/Articles/635264/Open-Multi-Methods-for-Cplusplus-Part-The-Case. Note, however, that yomm2 is a complete rewrite and improves significantly on the initial library. In particular, this version does not require changing existing classes to deliver good performance; methods are called via ordinary functions (overloading is now supported); specializations need not be in the method declaration's namespace.

Speakers
avatar for Jean-Louis Leroy

Jean-Louis Leroy

Senior Software Engineer, Bloomberg LP
I am the author of yomm2, a library that implements open multi-methods. See https://github.com/jll63/yomm2


Tuesday September 25, 2018 15:50 - 16:20
D

15:50

Making printf-style Logging a Little Easier With C++17
Many people do development on systems that use printf-style logging. In order to do so, traditionally they have to do without the big benefit of C++ streams; namely, that objects know how to print themselves.

It is particularly tricky to keep format specifiers in sync with different types of integers, especially as people try to future-proof their code. Besides the integral types (from bool to long long) there are also the typedefs provided such as size_t, uint8_t, int16_t, etc., which have their own special macros. And then there are the signed versions of most of those types. It is very error-prone to keep these in sync, and bugs due to incompatible output range from embarrassing to costly.

To deal with this, we will develop an efficient, non-allocating string-like extensible class template which abstracts away the input type so the caller need not know or care what type of integer is being passed in. The class template will use many modern C++ features and techniques, including some from C++17, such as type traits, type lists, constexpr, deduction guides, variadic templates, const r-value references (!), etc.

While this class template is certainly useable out of the box, the more interesting part is in presenting the various design decisions and efficiency ramifications that went into developing it.

Speakers
NL

Nevin Liber

Senior Software Engineer, Ocient
He started programming in C++ over three decades ago, when a friend called and asked him what he knew about C++, which inspired him to learn all he could about the language. And he's still learning about it! Besides making a career out of it, he has been on the C++ Standards Committee... Read More →


Tuesday September 25, 2018 15:50 - 16:20
F
  • Level Beginner, Intermediate
  • Tags I/O, printf

15:50

Memory Tagging and how it improves C++ memory safety
Memory safety in C++ remains largely unresolved. A technique usually called "memory tagging" may dramatically improve the situation if implemented in hardware with reasonable overhead.

In this talk we will describe two existing implementations of memory tagging. One is SPARC ADI, a full hardware implementation. The other is HWASAN, a partially hardware-assisted compiler-based tool for AArch64. We describe the basic idea, evaluate the two implementations, and explain how they improve memory safety. We'll pay extra attention to memory tagging as a security mitigation.

If you know what AddressSanitizer (ASAN) is, think of Memory Tagging as of "Low-overhead ASAN on steroids in hardware".

This talk is based on the paper Memory Tagging and how it improves C/C++ memory safety (https://arxiv.org/pdf/1802.09517.pdf).

Speakers
avatar for Kostya Serebryany

Kostya Serebryany

Software Engineer, Google
Konstantin (Kostya) Serebryany is a Software Engineer at Google. His team develops and deploys dynamic testing tools, such as AddressSanitizer and ThreadSanitizer. Prior to joining Google in 2007, Konstantin spent 4 years at Elbrus/MCST working for Sun compiler lab and then 3 years... Read More →


Tuesday September 25, 2018 15:50 - 16:20
C

15:50

Teaching Old Compilers New Tricks: Transpiling C++17 to C++11
With all the new features C++14 and C++17 offer, it can be frustrating to be stuck with an old compiler that doesn't support them yet. Instead of forgoing structured bindings, fold expressions, and other additions, what if we could use them even on pre-2014 compilers?

Enter clang-from-the-future, a transpiler that reads C++17 programs and outputs standard C++11 source code. When used as a preprocessing step, it allows any compiler with C++11 support to compile a subset of C++14/17 programs. To enable this, CTFT rewrites new language features based on the program's abstract syntax tree and provides drop-in implementations for standard library additions.

In this talk, I will show how specifically this is achieved, how well it works in practice, and what's left to be done in the future.

Speakers
avatar for Tony Wasserka

Tony Wasserka

Freelance Software Developer
Low-level anything: Tony is a long-term C++ enthusiast who has worked on the console emulator projects Dolphin (GameCube/Wii), PPSSPP (PSP), and Citra (3DS) since 2010. More recently, he has worked on Vulkan graphics drivers for PowerVR graphics processors. His main interest is exploring... Read More →


Tuesday September 25, 2018 15:50 - 16:20
A

15:50

Smart References: There and Back Again
Smart references (aka "operator dot overloading") and Unified Call Syntax, it would be great if C++ supported both of them out of the box. Despite community requests, dating back from the 90s, the many proposals to add them to the language have been rejected. Therefore, we will have to wait until the arrival of a proposal that does succeed.

Or should we? Not if you use my smartref library, a modern header-only zero-overhead library for creating smart references. Last year at CppCon2017, I was awarded the jury's first prize for my poster about the library, because of its high quality and innovation in the presented approach. Now, one year later, I've gained many new insights, and would like to share them with all of you.

In this talk, I will show you some compelling examples of problems my library can solve in a very elegant way. Secondly, I will walk you through the design of the library, and show how tricky adding support for the most trivial operations turns out to be. Finally, I will show some unexpected possibilities of the library that I didn't initially foresee. For example, the Unified Call Syntax, which allows you to call free functions, using a member function syntax. Come to my talk, and be inspired by the new building blocks we can already create using existing C++.

Speakers
EV

Erik Valkering

Software Engineer, Plaxis BV
Erik Valkering has always been very interested in programming. Already at the age of 11, he was introduced to QuickBasic via a friend of his. During high school, he tried varying languages, like Visual Basic, Pascal, and Assembly, but eventually fell in love with C++. After high school... Read More →


Tuesday September 25, 2018 15:50 - 16:20
E

15:50

Why and How to Roll Your Own std::function Implementation
In recent years the increased usage of std::function has transformed the way many C++ programs are written. However, if your application is processing realtime data, or doing some other performance critical task, then the possibility of std::function allocating some memory from the heap may not be tolerable. It's also possible that the systems you are targeting simply lack a std::function implementation, preventing its adoption in applications for legacy operating systems, toolchains for embedded devices, and inside open source library code. Rolling your own implementation of std::function can provide a solution to both of these concerns simultaneously, allowing you to modernize your code and provide guarantees about the runtime performance of manipulating function objects.

This presentation outlines why and how a std::function replacement was added to the JUCE open source, cross platform, software development framework and discusses some differences between our implementation and others. We will also cover how we can move beyond the standard interface by extending the small buffer optimization to make manipulating callable objects more suitable for performance critical and realtime contexts, finishing with some examples of how this applies to processing live audio data.

Speakers
avatar for Tom Poole

Tom Poole

Senior Software Developer, ROLI
Tom Poole (PhD) is a senior software engineer at ROLI Ltd. and a maintainer of the JUCE open source, cross platform, C++ framework (https://juce.com). Before joining ROLI, he completed his PhD at Imperial College London, developing massively parallel Quantum Monte Carlo algorithms... Read More →


Tuesday September 25, 2018 15:50 - 16:20
B

16:45

Frozen data structures in C++14
This talk introduces frozen, an open source, header-only library that provides alternatives to std::map, std::set, std::unordered_map and std::unordered_set, with the extra constraint of making these data structures not mutable.
In exchange, their constructor is marked as constexpr, which makes it possible to initialize the containers at compile time, avoiding binary intialization cost and, as a side effect, static initialization order fiasco. As the whole interface is constexpr, they can even be used for meta-programming :-)

The talk details how a priori knowledge of the container size and values is taken advantage of to make unordered containers collision free, providing faster lookups than the standard containers. The design of an almost branch-free version of the search in the ordered containers will also be presented.

As a follow-up, we will also discuss the implementation of ``std::search`` for strings in the context of frozen, when the needle is known at compile time, leading to a reflexion on dynamic vs. static tradeoff for a class of algorithm.

The frozen library is being used at Tesla to store static configuration with low memory footprint and fast initialization, at QuarksLab to statically encode enumeration <> string representation in the LIEF library, but also to sucessfully store thousands of html entities to html code. It is avilable online at https://github.com/serge-sans-paille/frozen .


Speakers
SG

Serge Guelton

Software Engineer, Quarkslab
Serge « sans paille » Guelton is a compiler engineer at QuarksLab where he builds an LLVM-based code obfuscator. He's also the maintainer of the Pythran compiler that turns scientific Python kernels into efficient C++ code.


Tuesday September 25, 2018 16:45 - 17:45
D

16:45

Lightweight 2D graphics with io2d
In this presentation you will learn how to use the io2d 2D graphics library, which is available on vcpkg for Windows, OS X, iOS and Linux. The implementation contains several examples, including an Asteroids clone. We'll demonstrate the examples and their code in depth, show you how to write your own renderer, talk about the opportunities for casual graphics and teaching, and suggest some future directions.

Speakers
avatar for Guy Davidson

Guy Davidson

Principal Coding Manager, Creative Assembly
Principal 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 also a voting member of the ISO C++ committee, and a contributor to SG14, the study group devoted... Read More →
MM

Michael McLaughlin

Michael McLaughlin is a C++ contractor, and has been developing the BSI 2D drawing library for nearly five years. He will amend this biography.


Tuesday September 25, 2018 16:45 - 17:45
F

16:45

Named Arguments in C++ from Scratch
Given a function: void foo(int a, int b);

Wouldn't it be great to be able to write? foo("b" = 3, "a" = 2);

This will be a live coding session where we start from the basic idea of what we want to do and build up a small library similar that accomplishes this goal. We will outline some simply but powerful programming techniques and give a brief outline on how to use Hana, a powerful library for metaprogramming.

Speakers
avatar for Richard Powell

Richard Powell

Audio Software Engineer, Apple, Inc
I started using C++ 10 years ago to write a psychoacoustic audio encoder/decoder and have continued to explore how to make software that unlocks the potential of hardware to bring amazing applications to life. I graduated from UC Berkeley with a BS in Electrical Engineering and Computer... Read More →


Tuesday September 25, 2018 16:45 - 17:45
A

16:45

Undefined Behavior is Not an Error
We will provide an introduction to the terminology connected with Undefined Behavior in C++. We will explore the differences between run time errors and undefined behavior. Our talk will focus on Undefined Behavior from the perspective of a developer rather than a compiler designer. As developers we may need to assume that all Undefined Behavior is treated as if the code was not present. Many talks focus on what current day compilers actually do. Our talk will talk about what an "evil compiler" is permitted to do.

We will talk about how to look in the C++ standard to learn what constitutes undefined behavior.

Several examples will be provided to illustrate these ideas.

Familiarity with C++, no prior knowledge of compilers or undefined behavior is required.

Speakers
avatar for Barbara Geller

Barbara Geller

Co-Founder, CopperSpice
I am an independent consultant with over twenty-five years of experience as a programmer and software developer. I have worked with numerous smaller companies developing in-house applications. I have also designed and developed Windows applications for several vertical markets including... Read More →
avatar for Ansel Sermersheim

Ansel Sermersheim

Co-founder, CopperSpice
I have been working as a programmer for nearly twenty years. My degree is in Computer Science from Cal Poly San Luis  Obispo. I have transitioned to independent consulting and I am currently working on a project for RealtyShares in San Francisco. | | Co-founder of CopperSpice... Read More →


Tuesday September 25, 2018 16:45 - 17:45
C

16:45

Progress with C++ Modules
The C++ Modules-TS is progressing through standardization as
experience is gained through implementations, and I am implementing it
in the GNU G++ compiler. I will cover:

* background of the modules-TS
* changes since the TS was first published
* build integration possibilities
* implementation details
* predictions about releases, maybe

Speakers
avatar for Nathan Sidwell

Nathan Sidwell

Software Engineer, Facebook
Nathan is a developer of the GNU Compiler Collection, particularly the C++ Front End. His current major project is implementing the modules TS.


Tuesday September 25, 2018 16:45 - 17:45
B

16:45

The Networking TS in Practice: Testable, Composable Asynchronous I/O in C++
As the ISO Standard C++ Networking TS nears inclusion in C++20, Boost Asio, its foundation, has been available for some time; but in-depth coverage of how to use it is sparse. Asio’s own documentation, while thorough and detailed, is far from prescriptive, and offers few footholds for the beginner seeking to use and extend Asio in components of a larger software architecture. How can a library use Asio, or the TS, adding value and simplicity for users without hiding its power or sacrificing performance?

This talk provides all the context and prescriptive guidance required to get started building software components based on Asio and the Networking TS, ripe for reuse and composition. It covers in detail the guarantees Asio offers, and the patterns Asio uses: Why they are important, how to use and extend them, and how to present them to users of your components. It further demonstrates patterns and practices for constructing testable Asio- and Networking TS-based components.

The talk concludes with an overview of how the Networking TS is evolving on its way to inclusion in the Standard, becoming more general and integrating with other Standard Library features, particularly the Parallelism TS and its executors, so that come C++20 your libraries will be ready to pivot from Asio to the Standard painlessly.

Speakers
avatar for Robert Leahy

Robert Leahy

Software Engineer, Maystreet LLC
A graduate of the University of Victoria where he specialized in graphics, gaming, and digital geometry processing he spent 4.5 years in full stack web development before switching to develop infrastructure software for high frequency trading in early 2016 where he's focused on improving... Read More →


Tuesday September 25, 2018 16:45 - 17:45
E

18:00

Boost Community Dinner
The Boost Community invites anyone interest to join. Registration is here: https://cppcon2018.eventbrite.com/

Tuesday September 25, 2018 18:00 - 20:30
TBA Meydenbauer Center

20:30

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 28-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... Read More →

Tuesday September 25, 2018 20:30 - 22:00
TBA Meydenbauer Center

20:30

Open Content Sessions: TBA
Tuesday September 25, 2018 20:30 - 22:00
TBA Meydenbauer Center
 
Wednesday, September 26
 

08:00

Open Content Sessions: TBA
Wednesday September 26, 2018 08:00 - 08:45
TBA Meydenbauer Center

08:30

ISO SG14 Working Meeting

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
HS

Herb Sutter

Microsoft
avatar for Michael Wong

Michael Wong

VP Research & Development, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. | He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C... Read More →

Wednesday September 26, 2018 08:30 - 10:00
Courtyard Seattle Bellevue/Downtown, Ballroom A 11010 NE 8th St, Bellevue, WA 98004

09:00

Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics
UTF-8 is taking on an increasingly important role in text processing. Many applications require the conversion of UTF-8 to UTF-16 or UTF-32, but typical conversion algorithms are sub-optimal. This talk will describe a fast, correct, DFA-based approach to UTF-8 conversion that requires only three simple lookup tables and a small amount of straightforward C++ code.

We'll begin with a quick review UTF-8 and its relation to UTF-16 and UTF-32, as well as the concept of code units and code points. Next, we'll look at the layout of bits within a UTF-8 byte sequence, and from that, show a simple algorithm for converting from UTF-8 to UTF-32. Along the way will be a definition of overlong and invalid byte sequences. Following that will be a discussion of how to construct a DFA to perform the same operations as the simple algorithm. We'll then look at code for the DFA traversal underlying the basic conversion algorithm, and how to gain an additional performance boost by using SSE intrinsics.

Finally, we'll compare the performance of this approach to several commonly-available implementations on Windows and Linux, and show how it's possible to do significantly faster conversions.

Speakers
avatar for Bob Steagall

Bob Steagall

CppCon Poster Chair, KEWB Computing
I've been working in C++ for the last 25 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 detour through the world of DNS and analytics, I'm now working... Read More →


Wednesday September 26, 2018 09:00 - 10:00
B

09:00

State Machines Battlefield - Naive vs STL vs Boost
In this session, we will conduct a battle against different ways of implementing state machines in modern C++, each of which has different trade-offs and characteristics. We will use a connection [1] example to measure and compare varied aspects of each solution such as compilation time, run-time performance, memory usage, executable size, and readability.

In the first round, the Naive solutions will fight against Standard Template Library (STL) solutions. The Naive will be represented by the if/else and switch/enum, both of which could be classed as the 'old school' way of implementing state machines with implicit states defined by booleans and/or enums. On the other side, we will have STL, featured by C++17 - std::variant [2] and the newest addition to C++20 - coroutines [3]. These two can be used to demonstrate a new way of implementing state machines by leveraging modern C++ language features.

The winner will go on to take on the Boost libraries represented by Boost.Statechart [4] and Boost.MetaStateMachine (MSM) [5]. Both libraries are compliant with Unified Modeling Language (UML) standard [6] and have many additional features such as logging and/or serialization. Whilst Statechart is more run-time, the MSM represents a fully compile-time approach with minimal run-time overhead.

While our winners are recovering, we will introduce the final contender - [Boost].StateMachineLanguage (SML) library [7] - a C++14 version of Boost.MSM of which I'm the author and claimes to have much faster compilation times then its precursor. We will follow by some 'godbolting' (comparing a generated assembly) [8] of different dispatching techniques (branch, switch, jump table, fold expressions [9]) available in the library to illustrate the main power of the SML - the ability to change the feature set and behavior at compile-time.

After that, we will return to the final round, where the winner will battle against [Boost].SML.

At the end of this epic battle, the audience will walk out with a clear understanding of possible state machine implementations, thir trade-offs, and with guidelines of what solutions suit what problems.

Let's get ready to rumble at CppCon 2018!

[1]: http://boost-experimental.github.io/sml/embo-2018/images/connection.png
[2]: http://en.cppreference.com/w/cpp/utility/variant
[3]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4736.pdf
[4]: http://www.boost.org/doc/libs/release/doc/html/boost_statechart.html
[5]: http://www.boost.org/doc/libs/release/doc/html/boost_msm.html
[6]: https://www.omg.org/spec/UML/2.5.1/PDF
[7]: https://github.com/boost-experimental/sml(Boost.SML is not an official Boost library)
[8]: https://godbolt.org/g/HVavPU
[9]: http://en.cppreference.com/w/cpp/language/fold

Speakers
avatar for Kris Jusiak

Kris Jusiak

Senior Software Engineer, Quantlab Financial, LLC
Kris is a Software Engineer with interest in modern C++ development, especially during compilation time where performance and quality matters. He has experience in industries such as telecommunications, games, and finance as well as being an open source enthusiast and author of the... Read More →


Wednesday September 26, 2018 09:00 - 10:00
F

09:00

These Aren't the COM Objects You're Looking For
Windows COM is 25 years old. Yet it is relevant today more than ever, because Microsoft has bet its entire modern WinRT API on it (starting with Windows 8/10). But, if you’re familiar with the “old” COM with its idioms and SDK helper classes, you’re in for a treat. With the advent of modern C++ 17, using COM objects and new Windows APIs in your applications feels like a completely new experience.
In this session, we’ll explore how using modern C++ features such as variadic templates, lambdas, fold expressions, auto, structured bindings, tuple, string_views, type traits, smart pointers (and others) can radically transform the shape of your COM code. By eliminating a lot of boilerplate, your code will be much more readable and maintainable. Classic COM idioms around activation and QueryInterface() can feel totally different with modern C++ helpers. A beautiful example of modern COM usage is C++/WinRT (now part of Windows SDK). This is a standard C++ language projection for the new Windows Runtime API.
COM memory management, data marshalling, string handling can all feel quite mechanical in nature and very error prone, so a little help from modern C++ facilities would be more than welcomed. Error handling and debugging can be cumbersome for COM like APIs; we’ll explore some tricks to improve this experience, as well.
The techniques presented are not COM specific (although many examples will be) and we can easily apply them to modernizing similar older libraries or construct convenience modern C++ wrappers to facilitate their usage in client code.

Speakers
avatar for Victor Ciura

Victor Ciura

Software Developer, CAPHYON
Victor Ciura is a Senior Software Engineer at CAPHYON and Technical Lead on the Advanced Installer team (http://www.advancedinstaller.com). | For over a decade, he designed and implemented several core components and libraries of Advanced Installer such as: IIS, Repackager, OS... Read More →


Wednesday September 26, 2018 09:00 - 10:00
A

09:00

Software Vulnerabilities in C and C++
What does a vulnerability using signed integer overflow look like? Or a stack buffer overflow? How does code like this look and how can we change the way we program to reduce our risk? The first half of this talk will show examples of many different vulnerabilities and describe how these are combined to make the first steps of an exploit. Then we will discuss what kind of programming practices we can employ to reduce the chances of these kinds of bugs creeping into our code.

Speakers
PA

Patricia Aas

Programmer, TurtleSec
Patricia has been programming C++ professionally for 13 years, she started out working on the Opera desktop browser and has looped back to browser making in the recent years, now working on the Vivaldi browser with many ex-opera colleagues. While away from the browser world she did... Read More →


Wednesday September 26, 2018 09:00 - 10:00
E

09:00

Ensuring Exception Safety Through Testing
Are your APIs exception safe? How do you know? What about legacy interfaces written ten years ago? What about the code you will write next week? Are your dependencies exception safe?

Best practices for writing exception-safe code have long been established, but tests for exception safety remain rare even though the seminal work on the topic was written nearly twenty years ago. We will discuss the fundamentals of exception safety and how you can ensure the exception safety of your APIs using new features in Googletest. This will include examples of how we used these features to find bugs in Abseil, bugs in standard libraries, and even bugs in the standard itself! By the end of this talk you will have the tools to ensure that your codebase is exception-safe both now and into the future.

Speakers
avatar for Jon Cohen

Jon Cohen

SWE, Google
Jon Cohen is an engineer at Google, maintaining our core common C++ libraries. He spends most of his days directing Google's robot army to rewrite its own source code to be more readable and efficient, and has so far managed to do so without accidentally creating Skynet.


Wednesday September 26, 2018 09:00 - 10:00
D

09:00

Sane and Safe C++ Classes
C++ is a complex language and with the introduction of move semantics, noexcept and constexpr in C++11 and later, defining or declaring the right combination of magic keywords in the right place is daunting for the uninitiated. The talk will provide guidelines for how to circumvent expert territory and if needed, how to step there without shooting yourself in the foot or tripping a mine.

Many C++ guidelines try to limit the use of language features so that resulting code has higher chances to be correct and safe. This talk will give an overview of the kind of classes you can create in such a controlled setting and provides a map to where is expert territory that requires deliberate care about your classes.

For example, there is the Rule of Zero telling that you should let the compiler figure out what to provide. It carries far for the application level programmer, but still might not be sufficient. Should you then rely on the Rule of Five or Six? What would be the consequences? When should you actually deviate from the Rule of Zero and how?

Another area are classes representing values. Value classes better not have virtual member functions. But should you use final or not? Do you really need class hierarchies?

You will learn what kinds of classes are safe to design and how to spell their special member functions.

Speakers
avatar for Peter Sommerlad

Peter Sommerlad

Professor, HSR Rapperswil
Prof. Peter Sommerlad is director of IFS Institute for Software at FHO HSR Rapperswil where he inspired the C++ IDE Cevelop. Peter is co-author of the books POSA Vol.1 and Security Patterns. His goal is to make software simpler by Decremental Development: Refactoring software down... Read More →


Wednesday September 26, 2018 09:00 - 10:00
C

10:30

Keynote TBA
Wednesday September 26, 2018 10:30 - 12:00
TBA Meydenbauer Center

12:30

Open Content Sessions: TBA
Wednesday September 26, 2018 12:30 - 13:30
TBA Meydenbauer Center

13:00

ISO SG14 Working Meeting

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
HS

Herb Sutter

Microsoft
avatar for Michael Wong

Michael Wong

VP Research & Development, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. | He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C... Read More →

Wednesday September 26, 2018 13:00 - 15:00
Courtyard Seattle Bellevue/Downtown, Ballroom A 11010 NE 8th St, Bellevue, WA 98004

14:00

What to Expect from a Next-Generation C++ Build System
Few will argue that a standard build system would greatly benefit the C++ community. And the change is in the air: the upcoming C++ Modules are bound to shake things up, the need to support multiple build systems is putting pressure on our packaging efforts, and languages like Rust and Go clearly show things work much better if the build system and package manager are well integrated. Perhaps then this is the C++ community's "git moment": an opportunity to get a next-generation build system that everyone is finally happy to use.

In this talk I will demonstrate key features the next-generation C++ build system should have in order to achieve that elusive happy-to-use property. It is based on our experience developing the build2 toolchain, an integrated build system and package/project dependency managers (and which already supports C++ Modules).

We start with a brief discussion of overall design choices: native or project generator/meta build system, black box or a concept of build, declarative or scripted (or perhaps a hybrid), uniform or platform-specific, in which language can/should it be implemented, and, finally, what about IDE/tools integration?

Next, we go over what any current-generation build system should already support: build configuration management, cross-compilation, additional operations (test, install/uninstall, dist), out of source builds, and wildcard patterns.

Then on to the next-generation: high-fidelity hermetic builds, precise change detection, portable, parallel testing, project importing/composability, and support for C++ Modules which should pave the way to reliable, generally-available distribution compilation.

Speakers
avatar for Boris Kolpackov

Boris Kolpackov

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


Wednesday September 26, 2018 14:00 - 15:00
C

14:00

How to Argue(ment): What Type Should I Use for My Function's Arguments
How many different ways are there to pass an argument? Why do we have so many? Which way should you be using? What does it mean when you use the wrong one?

A function declaration is like the thesis statement in an essay. It should communicate both for the caller and the callee it's purpose, semantics, and side-effects. We often think this communication is in the form of comments, but a function's arguments also convey this information.

This talk will catalog many the different ways to pass arguments. We will then explore which ones are redundant or nonsensical, and give meaning to the ones that remain. We will end with recommendations what types to use to express your intent, and empower you with fundamentals to write clearer function definitions.

Speakers
avatar for Richard Powell

Richard Powell

Audio Software Engineer, Apple, Inc
I started using C++ 10 years ago to write a psychoacoustic audio encoder/decoder and have continued to explore how to make software that unlocks the potential of hardware to bring amazing applications to life. I graduated from UC Berkeley with a BS in Electrical Engineering and Computer... Read More →


Wednesday September 26, 2018 14:00 - 15:00
A

14:00

Compile-time programming in C++20 and beyond
Compile-time programming has been getting a lot of attention recently. Indeed, from Herb Sutter's well-known Metaclasses proposal to the newly created Reflection TS, a lot of effort is being put into solving the general problem of programmatic code generation and program introspection. More recently, the C++ Standards Committee has also been evaluating and adopting proposals that vastly expand the realm of constructs available at compile-time, in constexpr functions: new-expressions, try-catch blocks, virtual functions, some standard containers, and more.

For most people, it is unclear how all these features, whether exploratory or voted into the Draft International Standard, relate together. Without being active in the Committee, it can be difficult to see the big picture, the unifying vision driving all these changes. Fortunately, there is one, and this is what this talk is about.

We will go over these features and explain how they might interact with each other by boiling them down to their essential parts. We will present how different use cases for compile-time programming will be solved in C++20, and how even more use cases can be unlocked in the future. Attendees will leave this talk with an understanding of the improvements to constexpr planned for C++20, of what's needed to unlock more advanced use cases and an unifying vision for how to get there.

Speakers
avatar for Louis Dionne

Louis Dionne

C++ Standard Library Engineer, Apple
Louis is a math and computer science enthusiast with interest in C++ (meta)programming, functional programming, domain specific languages and related subjects. He is a member of the C++ Standards Committee and of the Boost community, where he authored the Boost.Hana metaprogramming... Read More →


Wednesday September 26, 2018 14:00 - 15:00
B

14:00

Understanding Optimizers: Helping the Compiler Help You
Optimizing compilers can seem rather fickle: sometimes they do something very sophisticated that surprises us, other times they fail to perform an optimization we assumed they would. By understanding the limits on their knowledge, and the constraints in their output, we can much more reliably predict when certain kinds of optimizations can occur. This, in turn, allows our designs to be informed by being friendly to the optimizer.

This talk will discuss concepts fundamental to understanding optimization such as the role of static types, basic blocks, and correctness of emitted code. It will also go through many examples: where inlining does and doesn't occur and why, const propagation, branch pruning, utilizing inferred information/values, the roles of const and value vs reference semantics, etc. Recent, specific improvements in inter-procedural optimizations starting with gcc 7 will be mentioned. It will also show how to help the compiler: writing code in different ways which encourages different optimization strategies.

Speakers
avatar for Nir Friedman

Nir Friedman

Quantitative Developer, Tower Research Capital
After completing a PhD in physics, Nir started working doing C++ in low latency and high frequency trading. He's interested in the challenges of writing robust code at scale, and highly configurable code that minimizes performance trade-offs.


Wednesday September 26, 2018 14:00 - 15:00
D

14:00

End of Error - Boost.SafeNumerics
Most computer languages, including C++, cannot guarantee that an integer expression will not produce a incorrect arithmetic result.

This fact is documented in numerous books, articles and conference presentations such as CPPCon. These presentations give good explanations of the problem and it's causes. But they are short on specific practical strategies to address the problem. The Boost.SafeNumerics library addresses this problem through C++ techniques such as operator overloading, template meta-programming. This library can be used to write C or C++ code guaranteed not to produce erroneous arithmetic results. In many cases, this guarantee can be made without adding any run-time overhead.

This presentation will

* illustrate some common problems such as integer overflows and type conversions.
* illustrate how the library can be used to address these problems.
* describe in general terms what the library does and how it works.
* describe the library API in some detail.
* present a case study applying the library to embedded motor controller written in C.

Speakers
avatar for Robert Ramey

Robert Ramey

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


Wednesday September 26, 2018 14:00 - 15:00
E

14:00

Latest and Greatest in the Visual Studio Family for C++ Developers 2018
This talk will be modeled on our previously successful talks at CppCon. We'll give the community an update on how we are doing in terms of conformance where we'll be announcing the final conformance state for MSVC for the final 2017 update. We'll be showing many many demos of new features (not in previous versions of this talk) that target cross platform developers in C++. This will include making it easier to bring your code to Visual Studio, significant improvements to ease of use for developers using CMake, improvements to unit testing experiences, a lot of new Linux targeting improvements, an update on our performance work, and new debugger features for C++ developers. Developers will learn new tricks they can apply immediately on leaving the session as well as get a sense of what is coming in future updates. The main message is that Visual Studio and Visual Studio Code will make every C++ developer (not just Windows developers) more productive.

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 Marian Luparu

Marian Luparu

C++ Program Manager Lead, Microsoft
Ask me about Visual Studio :)


Wednesday September 26, 2018 14:00 - 15:00
F

15:15

Don't package your libraries, write packagable libraries!
Amid an avalanche of packaging solutions, who's side should you take? Trick question; you can support all of them! Discover the fundamental principles that make your library easy for _others_ to package so you don't have to! As a bonus, your builds will be faster, simpler, and more maintainable.

This talk covers the lessons learned from packaging over 700 libraries in vcpkg, from the simplest single-header to the massive framework of Qt. We'll dissect the open source package maintainer's perspective and walk through the top library mistakes, supported by real-world examples from the vcpkg catalog.


Wednesday September 26, 2018 15:15 - 15:45
F

15:15

A Little Order: Delving into the STL sorting algorithms
Benchmarking STL sorting algorithms can lead to surprises. For example, std::partial_sort takes considerably more time to sort half a vector than std::sort to sort it completely...
Starting from this counter-intuitive result, we'll engage on a journey where we'll look at the standard, read implementations of the STL and benchmark code to understand how std::sort, std::nth_element and std::partial_sort are implemented and why. In the process, we'll see some of the challenges STL implementers encountered and how they chose to overcome them.
This session is targetted at STL users who are curious to know how their tool are working.

Speakers
avatar for Frederic TINGAUD

Frederic TINGAUD

Principal Software Engineer, Murex
Fred Tingaud is the creator of quick-bench.com. | He is also a Principal Software Engineer at Murex where he works on UI and front-end APIs. | His interests range from code efficiency and readability to UI ergonomics.


Wednesday September 26, 2018 15:15 - 15:45
D

15:15

The Embedded Device Under Your Desk: UEFI Applications With Modern C++
Inside of every PC, there is an environment capable of running arbitrary software without an operating system: The Unified Extensible Firmware Interface, or UEFI. Introduced to replace BIOS as a high-level interface between hardware and the kernel, it features many advanced features such as networking right after pressing the power button of your mainboard with a relatively simple C API.
In this session, we explore how we can apply modern C++ idioms to a bare metal environment like UEFI. Armed with a working modern C++ compiler, we'll wrap the C API with some metaprogramming tricks. This grants us better type safety and a cleaner API with no runtime overhead. Along the way we'll introduce a clean exceptionless error-handling method, and finally write a small demo application.
Finally, we look at the some of the proposals for the next C++ standard and how it helps us writing more concise yet efficient code that is sill conformant.

Speakers
avatar for Morris Hafner

Morris Hafner

Software Engineer, Codeplay Software
Morris is a Computer Science undergrad interested in computer graphics, the evolution of C++ and everything low level. | He tries to (ab)use the language and its tooling to prevent mistakes in software while keeping the code as general as possible. | On the GPU, he likes to play... Read More →


Wednesday September 26, 2018 15:15 - 15:45
C

15:15

Refactoring Legacy Codebases with LibTooling
If you are excited by the tools available from the Clang/LLVM project but are unsure how to bring them into your company's codebase or culture, this is the talk for you.

We'll cover how to make code standards-conformant and keep it that way, how to safely apply automated changes to codebases with few unit tests, and how to write custom tools to migrate away from those old container classes.

Speakers
JB

James Bennett

Software Engineer, Esri


Wednesday September 26, 2018 15:15 - 15:45
B

15:15

To Kill a Mocking Framework: Tools and Techniques for Testing Callbacks Using Standard C++
Callbacks are a commonly used technique for delivering data and passing control from one component to another. Their many uses include handling asynchronous events, providing customizations, and (with polymorphic lambdas) enable functional-style programming in C++. Testing components which invoke polymorphic callbacks can be a challenge, and this leads some developers to either avoid testing altogether, or to rely on mocking frameworks such as Google Mock.

Mocking frameworks sometimes rely on a Domain Specific Language or other syntax for expressing expectations on the mocked objects. My intention for this talk is to outline some ways in which standard C++ features and idioms can be used to test components with callbacks, as an alternative to such frameworks. In particular, I'll show how employing core features - lambdas, std::function, and RAII - allows us to build mocks which clearly express the desired behavior from the code under test, whilst being expressive and hard to misuse.

Speakers
avatar for Alastair Rankine

Alastair Rankine

VP, Automated Market Making, Morgan Stanley


Wednesday September 26, 2018 15:15 - 15:45
E

15:15

What's new in Visual Studio Code for C++ development
Free, open-source, and runs everywhere. If you’re looking for a fast and lightweight code editor, Visual Studio Code has you covered. Come to see what the latest Visual Studio Code editor has to offer for C++ development across Windows, macOS, and Linux - editing, building, and debugging C++ programs in one simple editor has never been easier.

Speakers
avatar for Rong Lu

Rong Lu

Principal Program Manager, Microsoft
Rong Lu is a Program Manager in the Visual C++ team at Microsoft. She has been working on the Visual Studio team for the past 10 years since she graduated with her master degree in computer science. She is currently working on Visual Studio tools for game development, Visual C++ tools... Read More →


Wednesday September 26, 2018 15:15 - 15:45
A

15:30

ISO SG14 Working Meeting

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
HS

Herb Sutter

Microsoft
avatar for Michael Wong

Michael Wong

VP Research & Development, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. | He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C... Read More →

Wednesday September 26, 2018 15:30 - 17:45
Courtyard Seattle Bellevue/Downtown, Ballroom A 11010 NE 8th St, Bellevue, WA 98004

15:50

Compiling Multi-Million Line C++ Code Bases Effortlessly with the Meson Build System
The Meson build system is a fresh build system designed from the ground up to solve the build problems of today. It is currently seeing growing adoption across many domains and is already being used to build large chunks of most modern Linux distributions. One of the main reasons for this is Meson's heavy focus on usability, meaning that build definitions are both powerful and easy to understand.

In this talk we shall look into the design and use of Meson from the ground up going up all the way to projects with millions of lines of code and complex build setups such as code generators and cross compilation. We shall especially examine the problem of dependencies and how Meson solves this age old problem with a composable design that supports both system provided and self built dependencies from the same build definition. Finally we will examine the multi-language support of Meson for easily combining C++ with other languages such as Java, C#, D and Python.

Speakers
JP

Jussi Pakkanen

Consultant
Jussi Pakkanen is the creator and project lead of the Meson build system. He is currently working as a consultant. He has experience in many different fields of computing ranging from slot machines to mail sorting, computer security, Linux desktop development and gaming. His free... Read More →


Wednesday September 26, 2018 15:50 - 16:20
C

15:50

Easy::Jit: A Just-in-Time compilation library for C++
Compiled languages like C++ generally don't have access to Just-in-Time facilities, which limits the range of possible optimizations.
The Easy::Jit library introduces an hybrid approach that combines classical ahead of time compilation with user-specified dynamic recompilation of some functions, using runtime information to improve compiled code.

Easy::Jit still remains a high level library, aiming to provide a simple way to benefit from Just-in-Time compilation for non-compiler experts. The main abstractions from the library mimics other standard C++ constructs (as std::bind) to ease its adoption.

The library is composed of two main parts, the library interface and a compiler plugin. The library interface relies on metaprogramming to generate the appropiate low-level API calls. It also wraps the returned raw function pointers in a high-level object that performs type checking on the parameters of the call.
The compiler plugin is in charge of identifying whose bitcode implementation must be exposed at runtime and inject calls to the API that associate function pointers with the bitcode implementations.

Speakers
avatar for Juan Manuel Martinez Caamaño

Juan Manuel Martinez Caamaño

Engineer, Quarkslab
Likes LLVM and just-in-time compilation.


Wednesday September 26, 2018 15:50 - 16:20
B

15:50

Multi-Precision Arithmetic for Cryptology in C++, at Run-Time and at Compile-Time
In the talk, I will present a new C++17 library for multi-precision arithmetic for integers in the order of 100--500 bits. Many cryptographic schemes and applications, like elliptic-curve encryption schemes and secure multiparty computation frameworks require multiprecision arithmetic with integers whose bit-lengths lie in that range.

The library is written in “optimizing-compiler-friendly” C++, with an emphasis on the use of fixed-size arrays and particular function-argument-passing styles (including the avoidance of naked pointers) to allow the limbs to be allocated on the stack or even in registers. Depending on the particular functionality, we get close to, or significantly beat the performance of existing libraries for multiprecision arithmetic that employ hand-optimized assembly code.

Beyond the favorable runtime performance, our library is, to the best of the author’s knowledge, the first library that offers big-integer computations during compile-time. For example, when implementing finite-field arithmetic with a fixed modulus, this feature enables the automatic precomputation (at compile time) of the special modulus- dependent constants required for Barrett and Montgomery reduction. Another application is to parse (at compile-time) a base-10-encoded big-integer literal.

In this talk, I will focus on several Modern C++ language features that I've used to write the library and design its API (e.g., std::array, variadic templates, std::integer_sequence, constexpr, user-defined literals, using-declarations and decltype, and combinations thereof) and explain some "tricks" that I've discovered while writing the library, for example, a technique to enforce the compile-time evaluation of a constexpr-function. Also, I plan to give a small demo of the API, show some benchmarks, and will demonstrate that the integer types offered by the library compose well with STL containers or other libraries (like Eigen for matrix/linear algebra operations).

The library is on Github (Apache 2 licensed)
https://github.com/niekbouman/ctbignum

Speakers
NJ

Niek J. Bouman

Researcher Secure Multiparty Computation, University of Technology Eindhoven
2017 - now Postdoc TU/e SODA (Scalable Oblivious Data Mining) project, Eindhoven University of Technology, the Netherlands 2016-2017 Senior Researcher Fraud Detection @ ABN AMRO Bank, Amsterdam, the Netherlands 2014-2016 Postdoc at Swiss Federal Institute of Technology (EPFL), Lausanne... Read More →


Wednesday September 26, 2018 15:50 - 16:20
D

15:50

Save $$ Testing Code the Playback-Based Way
Your actively growing library or component is inadequately tested. Great quality maintenance is nearly impossible, because you cannot run all of your clients' software for regressions.

Enter Playback-based Testing! A second cousin of Time Travel Debugging. Example will be shown, in action, "recording" the calls made by client software for later "playback" (qualification). Followed by code walkthrough.

The idea is to accumulate recordings from different clients to form test suite.This is automated integration testing. 

The benefit/cost can be spectacular, as library scales. (A cost is adapting or doubling the API layer). A real world - amazing - anecdote will be given.. 
 
Playback-based Testing source code/docs will be made available.

Speakers
avatar for William Clements

William Clements

Sr. Principal Engineer, Autodesk/Revit
Coding design software for almost 40 years on East coast. Accomplishments include feats of "infrastructure" -- graphics, data archiving performance, UI scripting. Built throughput multi-threading code powering a premier CAD app.......Interested in how to secure IP in large software... Read More →


Wednesday September 26, 2018 15:50 - 16:20
A

15:50

Datum: A Trivially Constructible, Bitwise Copyable Compact Value-semantic Variant Type
Datum is a value-semantic variant type used at Bloomberg. It has trivial construction, destruction, copy-construction and copy-assignment semantics. It encodes values of many frequently used types, such as doubles, integers, Booleans, and pointers inside a double value on a 32 bit platform without requiring any memory allocations. Values of more complex types like strings and arrays are allocated on the heap and a pointer to the memory is stored inside the Datum.

Due to Datum's compact representation, it reduces the memory footprint of applications. Datum's trivial initialization and copy semantics ensure that there is a negligible cost to default-constructing and moving around a large number of such objects, thus reducing the overall CPU usage of applications. In this talk, we will look into the implementation of Datum and benchmarks comparing Datum with a few other variant types.

Speakers
RW

Rishi Wani

Rishi is a senior software engineer at Bloomberg. He has been programming in C++ since 2002.


Wednesday September 26, 2018 15:50 - 16:20
F

15:50

Value Semantics: Fast, Safe, and Correct by Default
We hear a lot about value semantics whenever there's discussion of C++, and value semantics are often credited as one of the "Big Ideas" of C++; but what does this phrase mean? And how can you use the principles of value semantics and regularity to make your code faster and more correct?

We'll touch on using the existing value semantic standard library types, as well as creating your own types that follow these principles. You will learn useful optimization habits which create faster code without giving up the benefits of value semantics. I'll show you how to think in a value semantic way, so that your code is simple, fast, and correct!

Speakers
NM

Nicole Mazzuca

Software Engineering Intern, Microsoft
Nicole Mazzuca is a C++ and Rust programmer who is very interested in object models - she is helping to write the Rust object model, and as such has studied other object models heavily, especially C++'s.


Wednesday September 26, 2018 15:50 - 16:20
E

16:45

Memory Latency Troubles You? Nano-coroutines to the Rescue! (Using Coroutines TS, of Course)
Are you doing memory lookups in a huge table?
Does your embarrassingly random access to your lookup tables lead to memory stalls?

Fear no more!

We will explore techniques
that allow us to do useful work while the prefetcher is busily
working on bringing the
requested cache lines from main memory, by utilizing nano-coroutines.

And the best part, nano-coroutines can be easily implemented using
Coroutines TS that is already available in MSVC and Clang compilers.
With a little bit of library support we can utilize the coroutines to extract intra-thread
parallelism and quadruple the speed up your lookups.

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.


Wednesday September 26, 2018 16:45 - 17:45
B

16:45

105 STL Algorithms in Less Than an Hour
We are all aware that we should know the STL algorithms. Including them in our designs allows us to make our code more expressive and more robust. And sometimes, in a spectacular way.

But do you know your STL algorithms?

In this presentation, you’ll see the 105 algorithms that the STL currently has, including those added in C++11 and C++17. But more than just a listing, the point of this presentation is to highlight the different groups of algorithms, the patterns they form in the STL, and how the algorithms relate together. And all this in an entertaining way.

This kind of big picture is the best way I know to actually remember them all, and constitute a toolbox chock-full of ways to make our code more expressive and more robust.

Speakers
avatar for Jonathan Boccara

Jonathan Boccara

Jonathan Boccara is a Principal Engineering Lead at Murex where he works on large codebases in C++. | His primary focus is searching how to make code more expressive. He has dedicated his blog, Fluent C++, to writing expressive code in C++. | He also gives internal trainings on C... Read More →


Wednesday September 26, 2018 16:45 - 17:45
A
  • Level Beginner, Intermediate, Advanced, Expert
  • Tags STL, algorithms

16:45

C++ in Elvenland

On Linux systems, compiled C++ code is generally bundled in the ELF binary
format. This talk walks through several details of the format that can help a
C++ developper to better understand the whole compilation chain, from classical
text and data sections through symbol tables down to init_array, eh_frame.

The talk walks though all the sections of a binary compiled from a simple C++
code and explain the links between c++ concepts like constant global variables,
exceptions, global constructors, ODR, symbol visibility, thread local variables
and related binary artefacts.

All these aspects will be demonstrated on a live demo using the output of the
venerable objdump and readelf commands.

Speakers
SG

Serge Guelton

Software Engineer, Quarkslab
Serge « sans paille » Guelton is a compiler engineer at QuarksLab where he builds an LLVM-based code obfuscator. He's also the maintainer of the Pythran compiler that turns scientific Python kernels into efficient C++ code.


Wednesday September 26, 2018 16:45 - 17:45
D

16:45

Modern C++ in Embedded Systems - The Saga Continues
For nearly 35 years I have been working with small processors and there has always been deep divides between practitioners of languages. When writing assembly we ridiculed those using C and when I spent years microcoding we scoffed at everyone. However, nearly all groups continue to wag their heads at the shameful C++ programmers attempting to twist their tools toward the small.

Recent language developments have made C++ the obvious choice for many embedded projects; nevertheless, the toxic environment extends past reddit roasts into poor vendor support of tools and nearly obstructionist chip manufacturers.

At C++Now I introduced a bare-metal project started in 2018 for a Ciere client as a case study. The goal was to extract useful lessons ranging from tooling acrobatics to idioms, language features, and libraries for producing high quality embedded results. Like an Athenian youth navigating Minos’ labyrinth we were thwarted at every bend and could merely report on the first half of the quest. In this session we will complete the saga with a discussion of the recent language features that enable goals of size, speed, and expressiveness, the libraries employed, and debugging techniques to stave off the minotaur.

While the examples will be based on a concrete project, the extracted lessons-learned should be applicable to many embedded projects (bare-metal and small-OS). Attendees will walk away with motivations to use C++ in embedded projects, hints and tips to making tools work, and a sampling of language features and idioms that improve the quality of a final product.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse has been crafting code in C++ for 28-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... Read More →


Wednesday September 26, 2018 16:45 - 17:45
E

16:45

Accelerating Applications on a GPU with CUDA C++
CUDA is a parallel computing platform for a generic computing on Nvidia GPUs. We will focus on CUDA C/C++ programming, covering in detail various types of GPU memory (Shared/Global/Texture/ConstShared/Pinned), optimization of the work distribution between CUDA “threads”, precompiled CUDA code VS Runtime Compilation.
Often the CUDA code is written in C style, missing the opportunity to use safer and more readable C++ constructs. In the spirit of the conference a special focus will be given to the use of modern C++ features in the CUDA applications inside the device (“kernel”) code, host code, and more importantly – which of the C++ paradigms can cross the bridge between the two worlds.

Speakers
avatar for Michael Gopshtein

Michael Gopshtein

Framework TL, Eyeway Vision
Michael is a software engineer with more that 15 years of C++ experience. He worked on various performance-bound projects, like load generation on servers, network sniffing and packet analysis. In the recent years Michael is focused on Augmented Reality challenges in Eyeway Vision... Read More →


Wednesday September 26, 2018 16:45 - 17:45
F
  • Level Beginner, Intermediate
  • Tags CUDA, GPUs

16:45

Parsing C++
C++ is a notoriously hard language to parse. Its grammar is highly context-dependent and ambiguous, and ambiguity resolution requires a lookahead of arbitrary length. How do C++ parsers actually deal with this?

This talk sheds some light on the grammar of C++ and the inner workings of a C++ parser. I will give insight into the tricks and heuristic guesses that parsers employ in order to resolve C++ code efficiently. We will also see code snippets with surprising, ambiguous C++ statements and brain teasers that even experts (and the major compilers) tend to struggle with.

The talk is aimed at general C++ programmers rather than parser experts.

Speakers
avatar for Timur Doumler

Timur Doumler

JetBrains
Timur Doumler works at JetBrains, where he develops the C++ frontend for CLion, the cross-platform C++ IDE. In the past he has spent much time working in the audio tech industry and has written code for the JUCE framework. Timur is an active member of the ISO C++ committee and passionate... Read More →
avatar for Dmitry Kozhevnikov

Dmitry Kozhevnikov

Software Developer, JetBrains
Dmitry works on C++ support in the CLion IDE by JetBrains, covering various aspects like the in-house C++ engine, inspections and refactoring engine, and clang integration.


Wednesday September 26, 2018 16:45 - 17:45
C

16:45

Using Compile-time Code Generation to build an LLVM IR Pattern Matcher
Although expression templates have been around for many years and are a great example of compile-time code generation, they have typically been limited to relatively short expressions who's grammar can be expressed as a tree. What do you do when you want to express something more like an assembly-language program, with loops (cycles) in it? This was the problem that I encountered when trying to identify certain loop patterns in an LLVM compiler back end. The LLVM infrastructure provides a pattern matching library, but it has some limitations -- most notably the inability to express cycles in the code it matches.

Taking the idea of expression templates and kicking it up a notch, I created a library that allows an input pattern to be expressed directly in C++ using a syntax that resembles assembly language then generate, at compile time, an actual pattern-matching subroutine customized for that pattern. In the process, I deepened my knowledge of constexpr expressions, and built an interesting infrastructure that I will now share with you.

This talk is for the advanced C++ programmer. An understanding of templates, type traits, and basic metaprogramming is assumed. No prior knowledge of LLVM or compilers is required, though compiler back-end implementers will find this talk especially interesting.

Speakers
avatar for Pablo Halpern

Pablo Halpern

Mr, Intel
Pablo Halpern has been programming in C++ since 1989 and has been a member of the C++ Standards Committee since 2007. His work with allocators began at Bloomberg LP, where he developed an appreciation for the simple and powerful allocator model in use there. In 2005, he started writing... Read More →


Wednesday September 26, 2018 16:45 - 17:45
G

20:30

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 28-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... Read More →

Wednesday September 26, 2018 20:30 - 22:00
TBA Meydenbauer Center

20:30

Open Content Sessions: TBA
Wednesday September 26, 2018 20:30 - 22:00
TBA Meydenbauer Center
 
Thursday, September 27
 

09:00

Build Systems: a Simple Solution to a Complicated Problem
New developers starting out with C++ nearly universally hit a brick wall - it's very hard to start programming and get something working. Unlike other languages such as Java, NodeJS, Rust and Python, where a standard package manager and build system take care of these problems for you, C++ has all the ability and variation under the sun to create nearly anything - if you've understood how to make the tools do what you want them to.

Things don't need to be so complicated. Nearly always, the things you're making aren't as complicated as the tools allow you to express. There is a good reason why C++ build systems are so complicated though, but it's not one that requires them to be. In this talk we'll explore the design space for build tools (with a focus on C++) and discover a simpler way of building software.

Speakers
avatar for Peter Bindels

Peter Bindels

Principal Software Engineer, TomTom
Peter is a C++ developer known for writing HippoMocks and cpp-dependencies, and less well known for encouraging C++ both for beginners and for uncommon target areas (OS development, embedded, server-side). He likes to rethink the basics of what we take for granted to see if new ideas... Read More →


Thursday September 27, 2018 09:00 - 10:00
F

09:00

Inside Visual C++' Parallel Algorithms
Learn what makes parallel algorithms tick by stepping through them with one of Visual C++'s parallel algorithms' authors. Abstract design and structure of parallelizing STL algorithms will be discussed, and made concrete by stepping through Visual C++' specific implementations. Digging into a real implementation should provide better understanding of parallel algorithms' performance characteristics, or make it easier to implement your own parallel algorithms, regardless of platform.

Speakers
BO

Billy O'Neal

Billy a maintainer of the standard C++ libraries at Microsoft. He improves performance in the library for existing features, and is the author of several C++17 library features in Visual C++, including string_view, boyer_moore searchers, parallel algorithms, and parts of filesyst... Read More →


Thursday September 27, 2018 09:00 - 10:00
C

09:00

Using Template Magic to Automatically Generate Hybrid CPU/GPU-Code
In this talk you’ll learn how you can write code that will either compile into a CPU based loop or into a special kind of function called “kernel" to be executed on a GPU. You’ll get an introduction into the memory- and threading-models of recent GPUs and are provided with examples for (mostly) simple helper templates to manage them. You can test and debug your code on CPU and scale out later. In the end, you’ll be able to parallelise operations on vectors without having to think much about the architecture. Template magic will take of that for you.
Note: there are several ways to leverage the compute power of GPUs for your applications. There are pragma-based approaches like OpenACC or recent versions of OpenMP. Or you can take more control and use approaches like Nvidia’s CUDA, AMD’s similar HIP or the latest versions of OpenCL. All of the latter are based on subsets of the C++-14 standard with extensions to manage the execution of code (at least) on GPUs. This session will cover a CUDA-C++ based approach, but the techniques shown should be applicable to other models as well.

Speakers
EW

Elmar Westphal

Scientific Programmer, Forschungszentrum Juelich


Thursday September 27, 2018 09:00 - 10:00
E

09:00

Concepts As She Is Spoke
The last time the keyword `concept` appeared in the C++ Standard's working draft was July 2009, two years before the release of C++11. Now, in September 2018, two years before the expected release of C++20, the working draft once again contains something called "Concepts" — something very different from what was there before, and — so far — much more conservative than the Concepts TS (formerly known as "Concepts Lite").
What should the forward-looking C++ programmer do and know about Concepts in C++2a? Arthur will attempt to puzzle it all out. What is a "Concept" and why should we care? What is the current syntax for defining and using concepts? What compilers support C++2a concepts syntax today, and how do I enable it? How does it affect name-mangling? What are "atomic constraints," "disjunctive clauses," and "subsumption"? What good are value concepts and template concepts? What is the difference between a "requires clause" and a "Requires element"? What is this "terse syntax" we've been hearing about, and why is it controversial? What is "Giraffe_case" and should I use it? Can I use the "requires" keyword without Concepts?
This material will be presented from an outsider's perspective, which means you can expect Arthur to say at least a few wrong things; and the shelf life of this material will be short, as C++2a Concepts are very much in flux right now. Still, if you want to get caught up on (or in) the Concepts discussion, this might be the place for you.

Speakers

Thursday September 27, 2018 09:00 - 10:00
B

09:00

Better Tools in Your Clang Toolbox: Extending clang-tidy With Your Custom Checks
Clang-tidy is the go to assistant for most C++ programmers looking to improve their code. If you set out to modernize your aging code base and find hidden bugs along the way, clang-tidy is your friend. Last year, we brought all the clang-tidy magic to Visual Studio C++ developers with a Visual Studio extension called “Clang Power Tools”. After successful usage within our team, we decided to open-source the project and make Clang Power Tools available for free in the Visual Studio Marketplace. This helped tens of thousands of developers leverage its powers to improve their projects, regardless of their compiler of choice for building their applications.

Clang-tidy comes packed with over 250 built-in checks for best practice, potential risks and static analysis. Most of them are extremely valuable in real world code, but we found several cases where we needed to run specific checks for our project.

This session will focus on extending clang-tidy with custom checks. If you ever wanted a tidy check specific to a particular need of your codebase, you will now get a crash course in writing your own check from scratch. This talk will also share some of the things we learned while developing these tools and using them at scale on our projects and within the codebases of our community users.

http://clangpowertools.com
https://github.com/Caphyon/clang-power-tools

Speakers
avatar for Victor Ciura

Victor Ciura

Software Developer, CAPHYON
Victor Ciura is a Senior Software Engineer at CAPHYON and Technical Lead on the Advanced Installer team (http://www.advancedinstaller.com). | For over a decade, he designed and implemented several core components and libraries of Advanced Installer such as: IIS, Repackager, OS... Read More →


Thursday September 27, 2018 09:00 - 10:00
A

09:00

OOP Is Dead, Long Live Data-oriented Design
For decades C++ developers have built software around OOP concepts that ultimately failed us - we didn’t see the promises of code reuse, maintenance or simplicity fulfilled, and performance suffers significantly. Data-oriented design can be a better paradigm in fields where C++ is most important - game development, high-performance computing, and real-time systems.

The talk will briefly introduce data-oriented design and focus on practical real-world examples of applying DoD where previously OOP constructs were widely employed.

Examples will be shown from modern web browsers. They are overwhelmingly written in C++ with OOP - that’s why most of them are slow memory hogs. In the talk I’ll draw parallels between the design of systems in Chrome and their counterparts in the HTML renderer Hummingbird. As we’ll see, Hummingbird is multiple times faster because it ditches OOP for good in all performance-critical areas.

We will see how real-world C++ OOP systems can be re-designed in a C++ data-oriented way for better performance, scalability, maintainability and testability.

Speakers
avatar for Stoyan Nikolov

Stoyan Nikolov

Chief Software Architect, Coherent Labs AD
Stoyan Nikolov is the Chief Software Architect and Co-Founder of Coherent Labs. He designed the architecture of all products of the company. Stoyan has more than 10 years experience in games. Currently he heads the development of Hummingbird - the fastest HTML rendering engine in... Read More →


Thursday September 27, 2018 09:00 - 10:00
D

10:30

Plenary: TBA
Thursday September 27, 2018 10:30 - 12:00
TBA Meydenbauer Center

12:30

Open Content Sessions: TBA
Thursday September 27, 2018 12:30 - 13:30
TBA Meydenbauer Center

14:00

What do you mean "thread-safe"?
How can we communicate with other developers about the safety of our C++ code against the hazards of concurrency? Terms like "thread-safe" don't always have a clear meaning, and more precise terms like "data race" and "race condition" often operate at the wrong level of abstraction. In order to communicate effectively about these issues, we need straightforward ways to talk about the safety requirements that APIs impose, and what goes wrong if you violate them.

In this talk, I will present the simple yet precise vocabulary we use for talking about these issues at Google: an "API race" happens when two operations access the same object concurrently, in violation of its contract. For most C++ types, that contract can be classified as "thread-safe" or "thread-compatible" depending on what combinations of operations can cause an API race (the remainder are called "thread-unsafe"), and that two-word classification usually tells you everything you need to know to avoid API races on the object. This is significant because if you can avoid API races, you can avoid not only all data races but also many race conditions.

Speakers
GR

Geoffrey Romer

C++ Library Team, Google
I've been involved in C++ standardization for a couple of years. I've written a few papers, particularly on improvements to std::function, and I have another on the way about making it easier for people to hash their types. | | I'm a member of the C++ Library Team at Google, which... Read More →


Thursday September 27, 2018 14:00 - 15:00
E

14:00

From Metaprogramming Tricks to Elegance: Custom Overload Sets and Inline SFINAE for Truly Generic Interfaces
Wouldn't it be nice to be able to tell the compiler "pick the first piece of code in this list which compiles", "pick the first type which has these properties" or simply be able to ask "does this code compile?". In this talk we will build a set of tools to make this happen using some of the new C++17 features.

SFINAE (Substitution Failure Is Not An Error) has been used for years to do this and to help the writing of generic code. It often required to play with a lot of templates to force the compiler to choose the right overload or specialization, often leading to a lot of boilerplate code. The upcoming concepts, already usable in some compilers as an experimental feature, will simplify a lot of these use cases. However, sometimes, it would be very nice to be able to write "inline" SFINAE directly in application code without having to worry too much with templates. This talk is intended to both metaprogrammers (to write these tools) and developers who want to write very generic code (to use these tools) using C++17.

In this talk, we will build these tools step by step, layer by layer. This will allow to see how some C++17 features like void_t, template deduction guides, invoke and constexpr if can be used. First we will design some additional type traits to play with qualifiers and to retrieve information about callable types. Second, we will design classes to be able to create custom overload sets or overload sequences from functions with different names. Then on the top of it, we will use metaprogramming techniques to design tools to let the user ask questions to the compiler or to pick the first code that compiles from a list. Finally, we will explore some of the very nice applications of these tools, allowing to make interfaces even more generic than before with an elegant and simple syntax.

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... Read More →


Thursday September 27, 2018 14:00 - 15:00
A

14:00

Building a C++ Reflection System in One Weekend Using Clang and LLVM
Designing and building the runtime reflection system from tomorrow, today!

With the introduction of libraries like LLVM and libclang, building
custom tools for C++ is more approachable than it has ever been before.
With Clang we have a fantastic tool to analyze and augment the C++
AST without writing our own compiler or parser.

In this talk we'll go over the design and implementation of a
runtime reflection system, demonstrating the use of Clang and the
LLVM framework to craft custom C++ tools for your own needs.
We'll be able to query the members of a class, inspect their types and
size, as well as qualifiers and user-definable flags. To show-case a
real-world usage of the solution, we'll add a way to easily serialize
any class to or from a byte stream, by making use of the reflection
information. The implementation is available under a permissive
open-source license on Github (https://github.com/leandros/metareflect).

Speakers
avatar for Arvid Gerstmann

Arvid Gerstmann

CTO
Arvid Gerstmann is a passionate programmer and computer enthusiast, with a focus on writing high-performance C++ systems. His area of expertise includes writing compilers, standard libraries and game engines.


Thursday September 27, 2018 14:00 - 15:00
D

14:00

Design for Performance: Practical Experience
This presentation is a "lessons learned" summary of some 20 years of experience designing, developing, and maintaining a large-scale commercial software system for the users who are primarily interested in performance. Competitive benchmarks are the dominant factor in our users' decisions whose tool to buy.

A high-quality implementation, a skillful optimization, can win the day in such environment. But only the day. The design determines the long-term survival. Parts of the system have grown ten-fold in size and complexity, but still fundamentally use the original architecture and show no sign of strain. Others had to be radically redesigned or even rewritten from scratch. The designs of the former type tend to share certain characteristic properties, which we came to recognize. These are design patterns of high-performance software, at least in our experience. The design of the latter type, unfortunately, exhibit an infinite variety of poor decisions, although some mistakes (anti-patterns?) are repeated over and over.

In this presentation, I will show the most important patterns and practices of design for performance that I have learned. Some will be obvious, especially after you hear them. Others may be controversial (for example, sometimes you should optimize prematurely if you want to be able to optimize at all). I may even present some of the anti-patterns, but only for laughs and to make the listeners feel better about their own design mistakes.

Speakers
avatar for Fedor Pikus

Fedor Pikus

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


Thursday September 27, 2018 14:00 - 15:00
C

14:00

Early Modern C++: How to Handle a C++03 Codebase in $CURRENT_YEAR
C++11 came up 7 years ago, yet not all projects have made the upgrade today.
But that shouldn't stop you from adopting Modern C++, which idioms are quite older than C++11.
Using those patterns will not only ease the pain of working with an older revision of the standard, it will also help you migrate to a more recent compiler.

Join me in this talk for a quick tour of what the Modern C++ philosophy is, how you can apply it to your C++03 codebase while preparing for the future.
Following my experience of working most of the 2010s decade with a large C++03 codebase, I will explain how to emulate C++11 (and later) features and also provide a couple tips and mistakes to avoid when moving to a more recent standard, including how to convince your boss to sponsor it.

Speakers
avatar for Mathieu Ropert

Mathieu Ropert

Experienced Programmer, Paradox Development Studio
French C++ expert working on (somewhat) historical video games. Decided to upgrade his compiler once and has been blogging about build systems ever since. Past speaker at CppCon, Meeting C++ and ACCU. Used to run the Paris C++ User Group. Currently lives in Sweden.


Thursday September 27, 2018 14:00 - 15:00
B

14:00

Signed integers are two's complement
There is One True Representation for signed integers, and that representation is two’s complement. There are, however, rumors of a fantasy world—before C++20—where ones' complement, signed magnitude and "pure binary representations" dwell. That world boasts Extraordinary Values, Padding Bits, and just like our world it hosts swaths of Undefined Behavior.

Join me in exploring this magnificent fantasy world, and discover its antics. Together we'll marvel at how the other representations were forever banished from real-world C++, doomed to cast mere shadows onto our reality.

Speakers
avatar for JF Bastien

JF Bastien

Compiler engineer, Apple
JF is a compiler engineer. He leads C++ development at Apple.


Thursday September 27, 2018 14:00 - 15:00
F

15:15

Let's Intercept OpenGL Function Calls...for Logging!
Debugging in graphical applications is done primarily by visual inspection. Either the correct visual effect appears on the screen, or it does not. When a visual effect does not appear correctly, programmers have to carefully step through code, often guessing and making small changes before rebuilding their entire codebase. In this talk, we are going to understand how to instrument OpenGL programs using code injection techniques to log and record information and ultimately understand why each pixel appears as it does on the screen. We will then discuss how we can build tools on top of the recorded data to help assist in debugging graphics applications. Attendees will leave the session with the ability to make a small logger capable of recording OpenGL function calls and be able to further extend it for their needs.

Speakers
avatar for Mike Shah

Mike Shah

Lecturer


Thursday September 27, 2018 15:15 - 15:45
D

15:15

C++ Everywhere with WebAssembly
The elegance how a C++17 application can bind to HTML5 will be shown, while running a C++17 data-model on WebAssembly ABI in the server and the browser.

While we will look at the useful libraries, tips and techniques C++17 offers in this context. We will weigh the gains and the pains of meta-programming techniques like folding expressions and constexpr-if applied to HTML5 user experience.

The effective impact on maintainability, performance & lightness of web applications will be measured in comparison to typical web development techniques.

Speakers
avatar for Damien Buhl

Damien Buhl

Software Developer, Boost.Fusion
Damien is a 28 years old Software developer with a strong focus on C++ & Javascript. | | Leading development & product releases with tight schedules in an 100 years old IoT and Building Automation company in beautiful Basel, Switzerland. | | Enthusiast Open Source contributor... Read More →


Thursday September 27, 2018 15:15 - 15:45
E

15:15

Effective replacement of dynamic polymorphism with std::variant
This short talk presents how easy it is to replace some cases of dynamic polymorphism with std::variant. During the lecture, we will analyze and compare 2 implementations of the same simple Finite State Machine. It turns up that variant-based code is not only much faster but also it gives us the opportunity to define our interfaces and program flow much better. The talk will end up with the discussion of pros and cons of each approach and will try to give guidelines on when to use them.

Speakers
avatar for Mateusz Pusz

Mateusz Pusz

Chief Software Engineer, Epam Systems
Software architect, chief developer, and security champion with more than 14 years of experience in designing, writing and maintaining C++ code for fun and living. C++ consultant, trainer, and evangelist focused on Modern C++. His main areas of interest and expertise are code performance... Read More →


Thursday September 27, 2018 15:15 - 15:45
A

15:15

Better C++ using Machine Learning on Large Projects
Preventing defects to reach consumers is one of the most important task of any application developer. Using machine learning, we automatically prevent defects from reaching the central code repository by intercepting them at commit-time. In this talk, we present an approach to detect, and resolve, defects in large C++ projects. Our approach, when evaluated on past contributions, was able to prevent ~65% of the defects and propose resolution for 50% of them. In addition, this project allowed us to improve our C++ practices by discovering new guidelines that are applicable for our application domain, in our case AAA game development.

Speakers
NF

Nicolas Fleury

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

Mathieu Nayrolles

Technical Architect, Ubisoft
Mathieu has 7 years of experience in software quality and productivity. He's a Technical Architect dedicated to Research & Development on software quality and productivity. He started several collaboration with other companies such as Mozilla and presented at various international... Read More →


Thursday September 27, 2018 15:15 - 15:45
F

15:15

ConcurrencyCheck - Static Analyzer for Concurrency Issues in Modern C++
Ever wondered if there is an easier way to find a race or deadlock in multi-threaded code?

This talk presents the ideas and design behind ConcurrencyCheck, a static analysis tool that finds data races, deadlocks, uses of stale data, and other mistakes in concurrent C++ code. ConcurrencyCheck is the replacement for the LocalEspC analysis tool in Visual Studio, and complements the annotation-based approach with a built-in understanding of standard library types and standard idioms such as RAII. While ConcurrencyCheck currently works with the MSVC compiler, the approach is generally applicable and could be ported to other compilers and static analysis frameworks.

Speakers
avatar for Anna Gringauze

Anna Gringauze

Senior Software Engineerining Manager, Microsoft
Static analysis, windsurfing, formal verification, cats, security, sailing, lengths of formal proofs, music


Thursday September 27, 2018 15:15 - 15:45
B

15:15

Co- and Contra-: Adding a Little Variance
C++ had support for covariance almost since the dawn of time, that is: since 1998. This support, however, is limited, and covariance is only limited for types that are fully understood by the compiler, without any way to influence that knowledge. While sometimes useful, it remains a - somewhat - forgotten tool, especially since the dawn of the new era of C++11, where raw owning pointers are frowned upon.

This talk tries to present a case for co- and contravariance: what they are, why they are useful, and how other languages do them. It'll also discuss them in the context of C++: what tools we already have, what tools we can build today without the interference with our compilers, and what a possible future of the feature could look like.

Speakers
avatar for Michał Dominiak

Michał Dominiak

Engineer, Software Developer, Nokia Networks
Bachelor of Engineering in Computer Science from Wrocław University of Technology. Professional and enthusiast programmer. Interested in the foundational problems of computing, from the lowest levels of CPU architectures, through operating systems and programming language design... Read More →


Thursday September 27, 2018 15:15 - 15:45
C
  • Level Beginner, Intermediate, Advanced
  • Tags type system

15:50

Phylanx – A Distributed Asynchronous Array Processing Toolkit
Today, machine learning is being applied in almost all fields of science and industry. We present a new open source project ‘Phylanx’ that opens up opportunities to tap into distributed machine learning on problems where performance is a driving concern. Currently, machine learning applications are usually constrained in their ability to access high performance resources due to the lack of access to efficient parallel runtime systems. We use HPX, the C++ Standard Library for Parallelism and Concurrency, which enables linear algebra algorithms to be optimized for the target platform through cost functions that select data tiling and resource parameters. Phylanx combines highly efficient execution provided by a modular C++ backend with a highly productive Python based front end that many domain scientists are familiar with.

Phylanx offers compelling advances in three areas. First, it delivers scalable machine learning capabilities through its high-performance HPX-based implementations of core distributed parallel algorithms for machine learning frameworks. HPX's efficient support for executing asynchronous dynamic distributed task graphs is a unique technology that makes this possible. Second, it provides exceptional development productivity through support of high-level Python programming interfaces and semantics such that machine learning frameworks and applications easily run in a Phylanx environment, independent of where Phylanx is installed. The portability of HPX to different platforms and its ability to achieve high performance execution is again key. Third, Phylanx provides an avenue to realize high performance machine learning solutions on cloud resources, thereby making it possible to realize "domain science gateways" as a service. Here users build their domain solutions with rich client interface and edge computing tools, with automatic access to Phylanx-optimized algorithms.
This talk will demonstrate modern C++ techniques adopted to the design and implementation of Phylanx as well as demonstrate some exemplar use cases of this new and exciting technology.

Speakers
HK

Hartmut Kaiser

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


Thursday September 27, 2018 15:50 - 16:20
B

15:50

Interactive C++ Compilation (REPL) Done in a Tiny and Embeddable Way
Ever wanted to modify some value or execute some statement while your C++ program is running just to test something out - not trivial or possible with a debugger? Scripting languages have a REPL (Read-Eval-Print-Loop). The closest thing C++ has is cling (developed by researchers at CERN) but it is built on top of LLVM and is very cumbersome to set up and integrate.

In this presentation we will go through the inner-workings of a project showcasing an innovative approach to doing runtime C++ compilation in a platform and compiler agnostic way which can be easily embedded. We will see how to use it, how it works and how to modify and integrate it into any application and workflow.

Speakers
avatar for Viktor Kirilov

Viktor Kirilov

With 4 years of professional experience with C++ in the games and VFX industries, Viktor currently spends his time writing open source software (since 01.01.2016). He is the author of doctest - "The fastest feature-rich C++11 single-header testing framework". | | His interests are the making of games and game engines, high performance code, data oriented design, blockchains, optimizing workflows and incorporating good practices in the software development process such... Read More →


Thursday September 27, 2018 15:50 - 16:20
C

15:50

Dealing with aliasing using contracts
Telling the compiler when aliasing can or cannot happen is an important problem to solve. Lots of the crucial compiler optimizations such as load and store elimination, and less crucial such as vectorization rely on alias analysis. I will showcase some examples where alias analysis is playing an important role to get decent performance. Unfortunately, there is no standard way in C++ to give hints to the compiler about aliasing. There is the C restrict keyword which is supported by some compilers but it has its own shortcomings. In this talk, I will show some of the past approaches to move restrict keyword to C++ and propose a new solution which is based on contracts. I will also show some basic tricks how to use type based alias analysis and value types to help the compiler reason about aliasing until the related new features being accepted into the language.

Speakers
avatar for Gabor Horvath

Gabor Horvath

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


Thursday September 27, 2018 15:50 - 16:20
F
  • Level Intermediate, Advanced, Expert
  • Tags C++20

15:50

Engineering Software: integral types
In spite of more than 40 years of programming practice, we still make even the most basic errors of API design and coding: integer overflow, error-prone floating point arithmetic, unconstrained/flawed templated interfaces.
A few such examples from Boost, the C++17 standard and a discussion on generic and metaprogramming issues will illustrate why we need to focus more on quality and less on quantity.
When the most basic building blocks offer few or no guarantees on the validity of their results, the task of writing correct programs becomes a lot more difficult. At the same time, the standard library is not providing some essential primitives that would make writing correct code easier and with better performance characteristics.
The presentation will also include a surprise guest from the functional programming languages family.

Speakers
avatar for Andrei Zlate-Podani

Andrei Zlate-Podani

Team Lead, Avast
Andrei Zlate-Podani has been writing software professionally for 18 years, of which he spent more than a decade writing device drivers. | His software currently runs on more than 160 million computers worldwide and most bugs that ship in the release version will affect a significant... Read More →


Thursday September 27, 2018 15:50 - 16:20
E

15:50

Everything with Clang. Tooling by Qt Creator.
For a long time, Qt Creator had its custom C++ code model and all tooling revolving around it. Few years ago the historical decision to base the code model on Clang was made and now we are making more and more use of Clang.

In this session we will look at how Clang can be used in the IDE and which challenges come along with integrating Clang infrastructure. We will also discuss which Clang-based features are already supported by Qt Creator and what is coming next.

Speakers
avatar for Ivan Donchevskii

Ivan Donchevskii

Software Engineer, The Qt Company
Ivan is a Qt Creator developer. His main focus is ClangCodeModel plugin and other tooling based on Clang.


Thursday September 27, 2018 15:50 - 16:20
A
  • Level Beginner, Intermediate, Advanced, Expert
  • Tags IDE, Qt, tooling

15:50

Liberating the Debugging Experience with the GDB Python API
While C++ has continued to evolve to ever higher levels of complexity, debuggers like gdb have largely stayed within their historic, C-oriented feature sets. One compensating advancement is gdb's Python API, which gives programmatic access to most of gdb's features. Using this API, developers can create tools that improve the debugging experience for modern C++ and for their specific codebases.

gdb's Python API provides facilities to create new commands, add and remove breakpoints, improve the printed display of types, manipulate stack traces, get information on variables, and access most features of gdb. Combined with the vast array of libraries available in Python, remarkably powerful tools can be built.

The speaker will begin by demonstrating the creation of custom commands and parameters, then move on to the use of the pretty printing and stack frame filtering APIs. He will then show some tools built by combining gdb features with external Python libraries, such as an improved single-step command using libClang, graphical visualization of algorithm execution, and custom debugging accelerators for specific problem areas.

Speakers
JT

Jeff Trull

Jeff is a former microprocessor designer and current C++ consultant. He is something of a conference junkie. His interests include numerics - especially for modeling linear systems - performance analysis, and tooling of all kinds.


Thursday September 27, 2018 15:50 - 16:20
D

16:45

Compute More in Less Time Using C++ Simd Wrapper Libraries
Leveraging SIMD (Single Instruction Multiple Data) instructions are an important part of fully utilizing modern processors. However, utilizing SIMD hardware features in C++ can be difficult as it requires an understanding of how the underlying instructions work. Furthermore, there are not yet standardized ways to express C++ in ways which can guarantee such instructions are used to increase performance effectively.

This talk aims to demystify how SIMD instructions can benefit the performance of applications and libraries, as well as demonstrate how a C++ SIMD wrapper library can greatly ease programmers in writing efficient, cross-platform SIMD code. While one particular library will be used to demonstrate elegant SIMD programming, the concepts shown are applicable to practically every C++ SIMD library currently available (e.g. boost.simd, tsimd, VC, dimsum, etc.), as well as the proposed SIMD extensions to the C++ standard library.

Lastly, this talk will also seek to unify the greater topic of data parallelism in C++ by connecting the SIMD parallelism concepts demonstrated to other expressions of parallelism, such as SPMD/SIMT parallelism used in GPU computing.

Speakers
avatar for Jefferson Amstutz

Jefferson Amstutz

Software Engineer, Intel


Thursday September 27, 2018 16:45 - 17:45
C

16:45

Writing Standard Library Compliant Data Structures and Algorithms
The C++ Standard Library provides a lot of data structures, such as sequential containers (vector, array, deque, list, and forward_list), ordered associative containers (set, map, multiset, and multimap), unordered associative containers (unordered_set, ...), and container adaptors (stack, queue, and priority_queue). It also provides a wealth of algorithms for sorting, searching, computing, and so on.

Even so, it cannot provide every possible data structure or algorithm that you might need. So, sometimes, you might find the need to write your own data structure or algorithm. Since you are writing them yourself, you could give them any interface that suits you. However, wouldn't it be better to make them compliant with the Standard Library? That way, when you write your own algorithm, you will be able to use that algorithm independently of the type of the container that contains the data for your algorithm. Similarly, if you write a Standard Library compliant data structure, then you will be able to use Standard Library algorithms on the data in your own data structure.

It's clear, there are a lot of advantages in making your data structures and algorithms compliant with the Standard Library. We'll first develop a simple algorithm with our own interface. Then we'll look into what changes we have to make to transform the interface to be Standard Library compliant. Finally, we'll demonstrate our adapted algorithm by running it on data in a variety of Standard Library containers.

In the last part of the presentation we'll crank it up a notch. We'll start by writing our own data structure, initially without thinking too much about the Standard Library. Then we'll look at an overview of the different sets of requirements that the Standard Library imposes for the different types of containers (sequential, associative, and unordered associative). Finally, we'll adapt our data structure step-by-step to transform it into a Standard Library compliant data structure. This of course includes writing a suitable iterator. Finally, we'll demonstrate the transformed data structure by running Standard Library algorithms on the data in it.

If you want to write truly generic and flexible data structures and algorithms, then this session is for you.

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... Read More →


Thursday September 27, 2018 16:45 - 17:45
D

16:45

Development strategies: You've written a library - now what?
When you write a library, you want people to use it. (Otherwise, why write it as a library?). But to attract and keep users, you need to provide more than "a bunch of code". In this talk, I'll discuss some of those things.

I'll talk about:
* Code quality and portability
* Testing
* Documentation
* Static and dynamic analysis
* Fuzzing
* Managing change in your library

as well as tools that you can use for providing these things. Examples will be taken from Boost and libc++, the C++ standard library implementation for LLVM.

Speakers
avatar for Marshall Clow

Marshall Clow

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


Thursday September 27, 2018 16:45 - 17:45
F

16:45

Rapid Prototyping of Graphics Shaders in Modern C++
Traditionally it's been hard or downright impossible to have C++ on a GPU: Graphics Shaders are mainly done in GLSL/HLSL (C-like languages) and Compute Shaders only recently run it via CUDA/LLVM complex toolchains. This is not always desirable or available - mobile phones for ex. Turns out code can compile both as valid C++ and shader language with a bit of library writing effort. All you mostly need is equivalent 2D/3D/4D vector and matrix types.

What's the catch then? Swizzling! The shader vector allows addressing of its components both as [0], [1], [2] etc but also as .x, .y, .xyz, .zyx, .xxx and all possible combinations. The talk details how this can be achieved in modern C++, clean and in a generic way, without preprocessor tricks, and overcome language obstacles like template argument deduction with implicit conversions. After all the effort it's possible to prototype complex procedural effects at an interactive rate with full CPU-side debugging. Of course, a dedicated GPU will very quickly outpace this but loses the debugging, and some devices might not always produce correct results due to driver bugs.

As takeaway and showcase of what can be achieved with the C++ techniques presented I'll introduce Signed Distance Field functions modeling and some shaders that use it: Procedural Generated Planet, Volumetric Clouds simulation and some fun experiments: a Vinyl Turntable and an Egg On Bicycle!

Speakers
avatar for Valentin Galea

Valentin Galea

Lead Core Tech Programmer, Splash Damage
Valentin Galea is a professional video game developer based in London, UK. He currently works at Splash Damage for projects such as the award-winning "Gears of War" franchise on Windows 10 and Xbox One. C++ enthusiast and evangelist, focused on systems, graphics and engine programming... Read More →


Thursday September 27, 2018 16:45 - 17:45
A

16:45

Class Template Argument Deduction for Everyone
Class Template Argument Deduction (CTAD) is a C++17 Core Language feature that reduces code verbosity. C++17's Standard Library also supports CTAD, so after upgrading your toolset, you can take advantage of this new feature when using STL types like std::array, std::greater, std::pair, and std::vector. Class templates in other libraries and your own code will partially benefit from CTAD automatically, but sometimes they'll need a bit of new code (deduction guides) to fully benefit. Fortunately, both using CTAD and providing deduction guides is pretty easy, despite template metaprogramming's fearsome reputation!

This presentation will contain three parts: using CTAD in everyday code, providing deduction guides in library code, and understanding corner cases. For everyday code, we'll explore how CTAD makes using the STL easier, eliminating annoying angle brackets filled with redundant info. All programmers, from beginners to experts, will benefit from typing and reading less code. Next, for library code, we'll see how to distinguish situations where CTAD automatically works versus those where deduction guides are needed, and how to write those guides. Finally, we'll examine some corner cases that illustrate how CTAD works in complicated scenarios, including issues recently resolved in the Standard.

Speakers
avatar for Stephan T. Lavavej

Stephan T. Lavavej

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


Thursday September 27, 2018 16:45 - 17:45
B

16:45

Concepts in 60: Everything you need to know and nothing you don't
The Concepts TS -- the ISO-published Technical Specification for
constrained templates -- was merged into the C++20 Working Paper in
2016. This is a big deal for C++. We've been missing this kind of
language feature for nearly 30 years. Well... now that we have it,
it's probably a good idea to know what it's for and how to use it.

This talk covers basic topics of generic programming using concepts.
I will talk about using concepts to write constrained templates,
overloading constrained functions (why, when, and how), and how to
define good concepts (which is a bit trickier than you might imagine).

I will also discuss some of the changes to the syntax and semantics
of language features in the Concepts TS when it was merged into
the Working Paper for C++20.

Speakers
AS

Andrew Sutton

University of Akron
Andrew Sutton is an Assistant Professor at the University of Akron wherehe teaches, hacks on compilers and other interesting problems, and writes theoccasional research papers. Dr. Sutton is a member of the C++ Standards Committee,the editor of the Concepts Technical Specification... Read More →


Thursday September 27, 2018 16:45 - 17:45
E

16:45

Initialization, Shutdown, and constexpr
It's easy to create an access a global object in C++, but doing so correctly and safely is unfortunately a bit tricky. But why?

This talk will take a close look at the various rules that govern when an object is safe to access, including storage duration, object lifetime, initialization, and program termination. We'll look at some safe idioms for creating global singletons that are justified by these rules. And we'll look at the relevant, helpful features added in various revisions of C++, such as constexpr constructors, and how they make the situation better.

Speakers
GF

Gregory Falcon

Staff Software Engineer, Google
Greg Falcon is a Staff Software Engineer at Google, working on the Abseil C++ library.


Thursday September 27, 2018 16:45 - 17:45
G

18:30

Meet the Speakers Dinner
This is your opportunity to have a relaxing conversation with conference presenters. Registration is here: https://cppcon2018.eventbrite.com/

Thursday September 27, 2018 18:30 - 20:30
TBA Meydenbauer Center

20:30

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

Moderators
BA

Bryce Adelstein Lelbach

Bryce Adelstein Lelbach is a software engineer on the CUDA driver team at NVIDIA. Bryce is passionate about parallel programming. He maintains Thrust, the CUDA C++ core library. He is also one of the initial developers of the HPX C++ runtime system. He spent five years working on... Read More →

Thursday September 27, 2018 20:30 - 22:00
TBA Meydenbauer Center

20:30

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 28-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... Read More →

Thursday September 27, 2018 20:30 - 22:00
TBA Meydenbauer Center

20:30

Open Content Sessions: TBA
Thursday September 27, 2018 20:30 - 22:00
TBA Meydenbauer Center
 
Friday, September 28
 

08:00

Open Content Sessions: TBA
Friday September 28, 2018 08:00 - 08:45
TBA Meydenbauer Center

09:00

Bringing C++ 17 Parallel Algorithms to a standard library near you
There are two proposed parts of this talk -
Part 1 - Integration:

Intel have offered to contribute an implementation of the C++17 parallel algorithms to libstdc++ (GCC)
and libc++ (Clang). This talk will cover -
* brief introduction to C++17 parallel algorithms and execution policies
* overview of Intel's implementation
* considerations and changes necessary to integrate a substantial 3rd party contribution like this
into a standard library implementation.
* support for different execution back ends, tailored to the target platform

Part 2 - Mapping parallel algorithms to the proposed Executors design:

There is strong support for Executors to be part of the next version of C++. Support for parallel algorithms targeting
the proposed Executors design will be an important part of that work. The Intel parallel algorithms implementation
currently being integrated into libstdc++ and libc++ provides basic support for pluggable execution environments.
This talk would cover integrating the current Executors design as a concrete execution target for the parallel
algorithms implementation, with a focus on how you would use the proposed Executors API as a target for common
parallel algorithm implementations.

Speakers
TR

Thomas Rodgers

Sr Software Engineer - Platform Languages Runtime, RedHat, Inc
Thomas has been programming in C++ since 1989 and a member of the C++ Standards Committee since 2013. Thomas has worked in the financial industry since 1996 and currently works for DRW Trading Group in Chicago.


Friday September 28, 2018 09:00 - 10:00
A

09:00

Interfaces matter: High Performance and Heap Allocated Containers
The allocation, use, and passing of memory has always had a performance cost and this has had a major impact on the evolution of the standard library and ultimately the language itself. We are rediscovering forgotten lessons from C and it is helping reshape what modern C++ looks like.

For a long time C++ has tried to work at a higher level with memory, hoping to move beyond the simple constructs C provided. The standard library promised a universe where containers are general purpose and implement the optimum algorithms, freeing engineers to focus on higher levels of design.

Delivering this vision has proved difficult. Creating a string class that performs well has been an ongoing challenge for library implementers, and as they have moved through multiple designs, the lessons learned have shaped the language itself and are instructive to anyone writing high performance code.

We will take a look at the historical attempts to address performance in the standard library and the shift away now taking place from one size fits all and non-owning interfaces, and look at the rediscovered lessons to working with memory effectively.

Speakers
JW

John Woolverton

Engineer, Bloomberg


Friday September 28, 2018 09:00 - 10:00
B

09:00

Applied Best Practices
What happens when we start a project from scratch and try to apply all of the best practices? How well do constexpr, noexcept, [[nodiscard]] and other features interact with each other? Is it possible to apply all of the best practices at once, or will they conflict with each other? We will explore current best practices and examine their impact on compile time, runtime and testing. We'll also see some of the unexpected affects that result when best practices are applied to a new project.

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... Read More →


Friday September 28, 2018 09:00 - 10:00
F

09:00

C++ Modules and Large-Scale Development
Much has been said about how the upcoming module feature in C++ will improve compilation speeds and reduce reliance on the C++ preprocessor. However, program architecture will see the biggest impact. This talk explains how modules will change how you develop, organize, and deploy your code. We will also cover the stable migration of a large code base to be consumable both as modules and as normal headers.

Speakers
avatar for John Lakos

John Lakos

SI Enginning 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’s Evolution Working Group. Previously, Dr... Read More →


Friday September 28, 2018 09:00 - 10:00
E

09:00

Debug C++ Without Running
Macros, templates, compile-time evaluation and code generation, reflection and metaclasses – C++ tends to hide the final code passed to the compiler under the tons of various names and aliases. Add here the preprocessor that shadows the actual running curve of your program with dozens of alternatives mixed in a non-trivial way. While this allows to avoid boilerplate code and reduce copy-paste and other errors, such an approach demands better tooling support to make the debugging process easier.

To find an error in such a code, one has to continuously read-fix-run it and compare the results with some etalon, or to debug in order to find actual substitutions. But should you really wait until your code is run or even compiled to debug it? Or how to deal with the situations when the code can’t be run on the local machine? A text editor with code completion won’t help, while a smart IDE that “gets” your code can do a better job.

In this talk we’ll see interesting approaches to solving cases like macro and typedef ‘debug’, understanding types when auto/decltype hide them, dealing with different code branches depending on the preprocessor’s pass-through, and other ideas. Some suggestions are already implemented as ready-to-use features in CLion and ReSharper C++, tools for C++ from JetBrains (that means I can show it in action), others are planned for the future. The aim of this talk is to share the workflows supported by the tools that can help C++ developers create better modern C++ code.

Speakers
avatar for Anastasiia Kazakova

Anastasiia Kazakova

PMM, JetBrains
As a C and C++ software developer, Anastasia Kazakova created real-time *nix-based systems and pushed them to production for 8 years. She has a passion for networking algorithms and embedded programming and believes in good tooling. With all her love for C++, she is now the Product... Read More →


Friday September 28, 2018 09:00 - 10:00
D

09:00

Feather: A Modern C++ Web Development Framework
We will discuss how to implement a rapid web development framework in Modern C++, paying attention to ease-of-use and comparing favorable with frameworks of other lanuages.
 
The Feather framework is composed of four cool libraries working together. These libraries are:

*) cinatra, a flexible and powerful http/websocket library providing web services. It supports a functional interface and Aspect-Oriented Programming (AOP) for web applications.

*) ormpp, an Object-relational mapping (ORM) library that provides a single interface for database access. It currently supports MySQL, PostgresSQL, and SQLite and can be extended to support other databases.

*) iguana, a serialization library based on compile-time reflection (presented at CppCon 2017 - https://www.youtube.com/watch?v=WlhoWjrR41A&t=1s). We use this for encoding/decoding to JSON and/or a data table.

*) render, a HTML template rendering library.

We’ll cover how these libraries work together to implement that Feather framework and how to use Feather to develop a web application rapidly.

Speakers
avatar for Yu Qi

Yu Qi

Technical Director, purecpp.org
Yu is a C++ programmer with 10 years experience who lives in Zhuhai, Guangdong province, China. He loves modern C++ and has founded an open source community ( http://www.purecpp.org/ ) to promote C++11/14 in China. His focus is distributed systems and he is the author of rest_rpc... Read More →


Friday September 28, 2018 09:00 - 10:00
C
  • Level Beginner, Intermediate, Advanced
  • Tags C++17, HTML, web

10:30

Concurrency Challenges of Interrupt Service Routines
With the advent of IoT and industry 4.0 there has been a lot of hype
lately around bare metal and low level embedded software development.
Many make a distinction between C++ developers with and without
embedded experience, but what is really the difference when developing
in this domain and why is C still widely considered the pragmatic
choice. One of the crucial factors which is not well understood
outside of this domain are Interrupt Sercive Routines (ISRs). In order
to create a better understanding, this talk is a deep dive from no
previous experience all the way to an expert level understanding of
this feature. In this talk we will cover topics like jitter, latency,
priority inversion, starvation as well as the fundamental problems
ISRs cause in many mainstream C++ design patterns and even core
language features. I will also argue that ISRs change the basic
interface with regard to library abstractions and we will explore what
the alternate basic interface should look like.

Speakers
avatar for Odin Holmes

Odin Holmes

chaos monkey, Auto-Intern GmbH


Friday September 28, 2018 10:30 - 11:30
F

10:30

The Bits Between the Bits: How We Get to main()
When you run your C++ code, have you ever considered how the linker, loader, operating system, C and C++ runtime all work so hard to get everything set up for you to start running your code in main()?

In this Linux-focused talk, Matt will talk about how the linker stitches together your code and how that fits in with dynamic linking. He'll touch on debugging issues with the loader, and how ODR violations can manifest themselves. Then he'll take a look at what's going on behind the scenes to get the C runtime up, and then the C++ runtime, along with all the global object constructors - showing more reasons why you shouldn't be using them!

By the end of the talk you should have an understanding of how a bundle of object files are brought together by the linker, along with the relevant runtimes, and then loaded and executed by the operating system.

Speakers
avatar for Matt Godbolt

Matt Godbolt

Senior Software Engineer, Coinbase
Matt Godbolt is the creator of the Compiler Explorer website. He is passionate about writing efficient code. He has previously worked at a trading firm, on mobile apps at Google, run his own C++ tools company and spent more than a decade making console games. When he's not hacking... Read More →


Friday September 28, 2018 10:30 - 11:30
D

10:30

Better Code: Human Interface
Abstract: This talk explains the relationship between good code and a good human interface (graphical or otherwise). Human interface semantics are tightly coupled with code semantics and improving how we reason about code can have a direct on positive impact on the human interface behavior of the system. Part of my “Better Code” series of talks, the goal is “Don’t Lie.”

Speakers
avatar for Sean Parent

Sean Parent

Principal Scientist, Adobe
Sean Parent is a principal scientist and software architect for Adobe’s digital imaging group. Sean has been at Adobe since 1993 when he joined as a senior engineer working on Photoshop and later managed Adobe’s Software Technology Lab. In 2009 Sean spent a year at Google working... Read More →


Friday September 28, 2018 10:30 - 11:30
C

10:30

Moving Faster: Everyday efficiency in modern C++
There seems to be a widely held belief among programmers today that efficiency no longer matters in most situations because processors are so fast and numerous and memory is so large. But from a user’s perspective computers are often slower today than they were 30 years ago despite the enormous increase in measured performance of the hardware. How can this be? If this is true, what are we doing wrong and what can we do about it? Is efficiency an everyday concern for working programmers, or is it only needed for special cases written by specialists?

In this talk we will explore these questions and consider the proposition that, contrary to popular belief, performance almost always matters and pervasive attention to efficiency is essential to ensure good performance. We will examine the efficiency tools modern C++ has to offer and discuss techniques for writing efficient code in an elegant, expressive and natural way. Topics will include tuning vs. optimizing, value semantics vs. reference semantics, unions and variants, move semantics, forwarding, container choice, in-place construction, and container node handling.

Speakers
avatar for Alan Talbot

Alan Talbot

Manager - Software Engineering, LTK Engineering Services
Alan Talbot started programming in 1972, in BASIC on a DEC PDP-8. He began his professional programming career in 1979 and started using C++ in 1989. For 20 years he was a pioneer in music typography software, then spent 8 years writing digital mapping software, and has spent the... Read More →


Friday September 28, 2018 10:30 - 11:30
A

10:30

Scripting at the Speed of Thought: Lua and C++ with sol3
A big part of accelerating development and promoting collaboration often translates to deferring a lot of the typical programmer work to a scripting language, to allow for those with more design-oriented ideas and experience to handle overall design. What happens, then, when you have to bind a scripting language like Lua into C++ to allow for this workflow?

This session is going to be all about how you enable non-developers and developers alike to rapidly increase their development productivity by turning routines and algorithms into data that can be shipped alongside your product in Lua. We will talk primarily how you can use the library sol2 to abstract away the muck of working with the Lua C API and instead focus on using and describing both Lua and C++ with each other in a simple manner. We will demonstrate some of the more interesting properties of sol such as Overloading Support, Container Support, Usertypes -- C++ classes made available with automatic support for unique/shared pointers -- and Tables.

By the time this session is over, you will have a firm grasp over what a good Lua Binding can offer you, and how you can accelerate your C++ development with it.

Speakers
avatar for JeanHeyd Meneide

JeanHeyd Meneide

Student, Columbia Unviersity
JeanHeyd "ThePhD" is a student at Columbia University in New York. Most of his programming is for fun and as a hobby, even if his largest open-source contribution -- sol2 -- is used across many industries. He is currently working towards earning his own nickname, climbing the academic... Read More →


Friday September 28, 2018 10:30 - 11:30
B

10:30

Large-Scale Changes at Google: Lessons Learned From Five Years of Mass Migrations
Google has one of the largest single C++ codebases on the planet, yet is able to continually update both core libraries and the code which uses them. In this talk, I'll share many of the lessons we've learned across more than five years of doing these kinds of migrations, including:
* Why should you migrate in the first place?
* How hard can it really be?
* What happens when a change can't be done atomically?

I'll also talk about the myriad ways that such a process can go wrong, using various migrations we've done internal to Google to illustrate. In doing so, I'll also point out how you can structure your infrastructure and tooling to enable a successful large-scale change process within your organization.

Speakers
HW

Hyrum Wright

Software Engineer, Google
Hyrum Wright hates C++ less than the rest of the programming languages he's worked with, and works on C++ library infrastructure at Google. He writes programs to rewrite other programs, and will eventually put himself out of a job. In a former life, he was an author of Apache Subversion... Read More →


Friday September 28, 2018 10:30 - 11:30
E

12:00

CppCon 2018 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
BA

Bryce Adelstein Lelbach

Bryce Adelstein Lelbach is a software engineer on the CUDA driver team at NVIDIA. Bryce is passionate about parallel programming. He maintains Thrust, the CUDA C++ core library. He is also one of the initial developers of the HPX C++ runtime system. He spent five years working on... Read More →

Friday September 28, 2018 12:00 - 13:00
TBA Meydenbauer Center

12:00

Open Content Sessions: TBA
Friday September 28, 2018 12:00 - 13:00
TBA Meydenbauer Center

13:30

Easy to Use, Hard to Misuse: Declarative Style in C++
We say that interfaces should be easy to use and hard to misuse. But how do we get there? In this talk I will demonstrate how using declarative techniques in APIs, functions, and plain old “regular” code can help.

We’ll look at what is meant by “declarative style” in C++; explore why declarative interfaces are desirable and how to construct them; and take an in-depth look at which features of C++ help us write in a declarative style.

I want to deconstruct C++ a bit, examine what we’re doing and what makes the good parts good, and from that reconstruct some best practices. Many of us are already writing code following piecemeal modern advice such as “no raw loops”, or “almost always auto”, or C++ core guideline recommendations. In many cases, this advice translates to writing more declarative code; being deliberate about exploring and using declarative techniques gives us insight we can apply more widely.

Speakers
avatar for Ben Deane

Ben Deane

Ben was in the game industry for 23 years, at companies like EA and Blizzard. He's always looking for useful new techniques in C++, and he | geeks out on algorithms, APIs, types and functional programming.


Friday September 28, 2018 13:30 - 14:30
F

13:30

Standard Library Compatibility Guidelines
Over the past few years, the C++ Standard committee has discussed what types of things user code can do with the standard library that are guaranteed to be supported between language versions, and what usages are out of bounds. Starting with proposals in Toronto in 2017 (http://wg21.link/p0684r0) and continuing in 2018 (http://wg21.link/p0921), the committee has been moving toward producing a user-facing Standing Document (SD) describing roughly what is and is not supported. These are the rights that the committee reserves in order to make changes to the standard library in the future.

This talk will discuss the details of those proposals and that SD, and what it means for you. What uses of the standard library are guaranteed? What uses are sketchy, but you'll maybe get away with? What uses will make it difficult or impossible for you to upgrade to future language versions?

Speakers
avatar for Titus Winters

Titus Winters

C++ Codebase Cultivator, Google
Titus Winters has spent the past 6 years working on Google's core C++ libraries. He's particularly interested in issues of large scale software engineer and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Along... Read More →


Friday September 28, 2018 13:30 - 14:30
D

13:30

The Salami Method for Cross Platform Development
Designing, writing and maintaining systems targeting multiple platforms is hard! The same system might simultaneously target desktops, browsers, cloud services and multiple different mobile devices. Each target with it's own requirements, tool-chains, APIs, SDKs and limitations.
Mixing platform specific code with core functionality often leads to spaghetti code resulting in a refactoring and maintenance nightmare that is non-portable, un-testable with ample nooks and crannies for bugs to hide in.

In this talk I'll present a system architecture that I call The Salami Method. The Salami Method finely distinguishes between the different aspects and layers required for exposing platform-independent C++ on different “specific” platforms. At its extreme it strives to create a single, thin, transparent layer for each such aspect so that each layer is more easily built, tested, debugged, managed and maintained.

I will introduce the Salami Method and show a practical example of using it build a single C++ OpenCV app targeting both the desktop and the web with the same codebase.

Speakers
avatar for Adi Shavit

Adi Shavit

Architect, Consultant, Mr
Adi Shavit is an entrepreneur, speaker, independent consultant, experienced software architect and a computer vision, image processing, and machine learning expert with an emphasis on real-time applications. He specializes in building cross-platform, high-performance software combined... Read More →


Friday September 28, 2018 13:30 - 14:30
A

13:30

Clangd: architecture of a scalable C++ language server
Clangd is an open-source implementation of the Language Server Protocol (LSP) server for C++. It is based on Clang and developed as part of LLVM project. Thanks to LSP, Clangd is available for plenty of popular text editors. Join this session if you want to learn more about implementation of C++ editor tools and how we build project-wide features in Clangd that scale to the huge Google codebase.

Clangd provides the features you would expect from semantically aware editor tools: semantic code completion, go-to-definition, rename, signature help and code formatting. Moreover, we aim to build global features into Clangd, like cross references and, the new feature that we have been working on recently, global code completion. “Global” means that completion will suggest results beyond what a compiler sees in the current file, providing results from other files in the project and inserting missing #includes.

In this talk, we will give an introduction to Clangd and show some of the features it supports. Then we will cover the architecture of Clangd and focus on our implementation of the global completion to give a perspective of how our team builds project-global features into Clangd that can scale to huge codebases, i.e. to all of C++ source code at Google.

Speakers
IB

Ilya Biryukov

Software Engineer, Google


Friday September 28, 2018 13:30 - 14:30
E

13:30

The Most Valuable Values
The modern C++ community puts a strong emphasis on value semantics. We know how to build types and algorithms thinking in terms of values,
their properties and relationships. However, when it gets to the big picture—the architecture—we end up growing ad-hoc webs of mutable objects that perform poorly and are hard to understand, debug and maintain.

In this talk, we'll learn what value semantics are about in a fundamental way. We'll then use values where they matter most: the architectural foundations of our system! As an example, we'll present the Unidirectional Data Flow Architecture, that is changing how people build interactive software. We'll show some patterns, examples and tools that make it easy to implement, and efficient to execute.

We will also present Lager, a library that implements such architecture and augments value-based programs with time-travel capabilities!
Links:

Speakers
avatar for Juan Pedro Bolivar Puente

Juan Pedro Bolivar Puente

Consultant, Independent (Sinusoidal Engineering)
Juanpe is a Berlin based freelance software engineer, with a focus on interactive software, modern C++, functional programming and open source strategy. Before he worked for Ableton and he has been involved in various music technology projects. He has also developed for the GNU project... Read More →


Friday September 28, 2018 13:30 - 14:30
B

13:30

Interactive Websites: Using Boost.Beast WebSockets and Networking TS

The WebSocket protocol powers the interactive web by enabling two-way messaging between the browser and the web server. The Boost.Beast library implements this protocol on top of the industry standard Boost.Asio library which models the Networking Technical Specification proposed for the ISO C++ Standard.

This presentation introduces Networking TS concepts and algorithms, how to read their requirements, and how to use them in your programs. We will build from scratch a multi-user chat server in C++11 using Beast, and the corresponding browser-based chat client in HTML and JavaScript.  No prior knowledge or understanding of Beast or Asio is required, the talk is suited for everyone.

Access the source code and slides for this talk at https://github.com/vinniefalco/CppCon2018


Speakers
avatar for Vinnie Falco

Vinnie Falco

President, The C++ Alliance
I'm the author of BearShare, DSPFilters, and most importantly Boost.Beast - a C++ header only library that offers implementations for HTTP and WebSockets, located here: https://github.com/boostorg/beast/


Friday September 28, 2018 13:30 - 14:30
C

14:45

Plenary: TBA
Friday September 28, 2018 14:45 - 16:30
TBA Meydenbauer Center

16:45

Closing Panel: Spectre
This panel will consist of three experts from across the industry who have been working on and responding to Spectre, a new class of information leak vulnerability in modern CPUs and software. It will cover any and all questions the audience has about this new class of vulnerabilities, how they work, what it means for you, and what you can do about them.

Moderators
avatar for Matt Godbolt

Matt Godbolt

Senior Software Engineer, Coinbase
Matt Godbolt is the creator of the Compiler Explorer website. He is passionate about writing efficient code. He has previously worked at a trading firm, on mobile apps at Google, run his own C++ tools company and spent more than a decade making console games. When he's not hacking... Read More →

Speakers
avatar for Chandler Carruth

Chandler Carruth

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

Jon Masters

Computer Architect, Red Hat
Jon Masters is Chief ARM Architect at Red Hat. Masters has been a Linux developer for more than 18 years, since beginning university at the age of 13. He is the author of a number of books on the Linux operating system, including "Building Embedded Linux Systems," and the upcoming... Read More →


Friday September 28, 2018 16:45 - 18:00
TBA Meydenbauer Center

18:30

Open Content Sessions: TBA
Friday September 28, 2018 18:30 - 20:30
TBA Meydenbauer Center
 
Saturday, September 29
 

09:00

Accelerated TDD: For More Productive C++
“Accelerated TDD: For More Productive C++” is available as either a one-day or two-day training course with programming exercises taught by Phil Nash. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

Prerequisites: Be comfortable with the basics of C++ - Being an expert not required; A laptop with a reasonably modern OS; A compiler capable of running C++11 (ideally gcc, clang or VC++) – don’t worry if it’s not what you use in your day job; A development environment you’re comfortable with. Phil can provide short term CLion licenses if you’d like (please let him know beforehand if possible); An open mind and motivation to find better ways of doing things.

Course and instructor details are available at https://cppcon.org/accelerated-tdd/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Phil Nash

Phil Nash

Developer Advocate, JetBrains
Phil is the author of the test frameworks, Catch - for C++ and Objective-C, and Swordfish for Swift. As Developer Advocate at JetBrains he's involved with CLion, AppCode and ReSharper C++. More generally he's an advocate for good testing practices, TDD and using the type system and... Read More →


Saturday September 29, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

C++ Best Practices
“C++ Best Practices” is a two-day training course with programming exercises taught by Jason Turner. It is offered at the Sheraton Bellevue Hotel from 9AM to 5PM on Saturday and Sunday, September 30th and October 1st (immediately after the conference). Participants should have a beginner to intermediate knowledge of C++. Lunch is included. Course and instructor details are available here.

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... Read More →


Saturday September 29, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Debugging and Profiling C++ Code on Linux
“Debugging and Profiling C++ Code on Linux” is a two-day training course with programming exercises taught by David Faure of The KDAB Group. It is offered at the Meydenbauer Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Participants should have basic knowledge of the C++ language. No prior knowledge of any presented tools is assumed. Lunch is included. Course and instructor details are available here.

Speakers
avatar for David Faure

David Faure

KDAB
Qt, Linux, Debugging, Profiling


Saturday September 29, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Essential C++ Design
“Essential C++ Design” is a two-day training course with programming exercises taught by Klaus Iglberger. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

Course participants should have a solid base knowledge of C++ and at least one to two years of experience with the language.

Course and instructor details are available at https://cppcon.org/essential-cpp-design/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers

Saturday September 29, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Generic Programming 2.0 with Concepts and Ranges
“Generic Programming 2.0 with Concepts and Ranges” is a two-day training course with programming exercises taught by Christopher Di Bella. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

This course assumes familiarity with C++14 core features, templates and generic programming, first year university mathematics for computer science and git. You will need to have docker installed and configured before the class.

Course and instructor details are available at https://cppcon.org/generic-programming-2.0-with-concepts-and-ranges/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Christopher Di Bella

Christopher Di Bella

Staff Software Engineer, ComputeCpp Runtime, Codeplay Software
Christopher Di Bella is a Staff Software Engineer for Codeplay’s ComputeCpp Runtime Technology. He is a strong proponent for having the Concepts TS and the Ranges TS in C++20. Chris spends his days working on ComputeCpp, Codeplay’s implementation of SYCL; the Khronos implementation... Read More →


Saturday September 29, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Leveraging Modern C++ for Embedded Systems
“Leveraging Modern C++ for Embedded Systems” is a two-day training course with programming exercises taught by Dan and Ben Saks. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

Participants should have basic knowledge of the C++ language and standard library. This course includes programming exercises. The exercises run on a simulator provided by the instructor. Each exercise compiles and links with the simulator in C++ and executes as a command-line application. Please bring a computer with a C++11 or C++14 development environment that can build command-line applications.

Course and instructor details are available at https://cppcon.org/leveraging-modern-cpp-for-embedded-systems/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Dan Saks

Dan Saks

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

Ben Saks

Chief Engineer, Saks & Associates


Saturday September 29, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Parallel Programming with Modern C++: from CPU to GPU
“Parallel Programming with Modern C++: from CPU to GPU” is a two-day training course with programming exercises taught by Gordon Brown and Michael Wong. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

This course requires working knowledge of C++11 and git.

Course and instructor details are available at https://cppcon.org/parallel-programming-with-modern-cpp/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Michael Wong

Michael Wong

VP Research & Development, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. | He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C... Read More →


Saturday September 29, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

The Standard Library from Scratch
“The Standard Library from Scratch” is a two-day training course with programming exercises taught by Arthur O’Dwyer. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately following the conference). Lunch is included.

Students are expected to have a good working knowledge of C++11. A working knowledge of classes, virtual functions, templates, exception-handling, C++11 lambdas, and move semantics will be assumed. Knowledge of C++14 or template metaprogramming is not required. The class will include short exercises presented via the online compiler at wandbox.org. Please bring a computer with a Web browser and/or a C++14 compiler installed.

Course and instructor details are available at https://cppcon.org/the-standard-library-from-scratch.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers

Saturday September 29, 2018 09:00 - 17:00
TBA Meydenbauer Center
 
Sunday, September 30
 

09:00

Accelerated TDD: For More Productive C++
“Accelerated TDD: For More Productive C++” is available as either a one-day or two-day training course with programming exercises taught by Phil Nash. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

Prerequisites: Be comfortable with the basics of C++ - Being an expert not required; A laptop with a reasonably modern OS; A compiler capable of running C++11 (ideally gcc, clang or VC++) – don’t worry if it’s not what you use in your day job; A development environment you’re comfortable with. Phil can provide short term CLion licenses if you’d like (please let him know beforehand if possible); An open mind and motivation to find better ways of doing things.

Course and instructor details are available at https://cppcon.org/accelerated-tdd/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Phil Nash

Phil Nash

Developer Advocate, JetBrains
Phil is the author of the test frameworks, Catch - for C++ and Objective-C, and Swordfish for Swift. As Developer Advocate at JetBrains he's involved with CLion, AppCode and ReSharper C++. More generally he's an advocate for good testing practices, TDD and using the type system and... Read More →


Sunday September 30, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

C++ Best Practices
“C++ Best Practices” is a two-day training course with programming exercises taught by Jason Turner. It is offered at the Sheraton Bellevue Hotel from 9AM to 5PM on Saturday and Sunday, September 30th and October 1st (immediately after the conference). Participants should have a beginner to intermediate knowledge of C++. Lunch is included. Course and instructor details are available here.

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... Read More →


Sunday September 30, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Debugging and Profiling C++ Code on Linux
“Debugging and Profiling C++ Code on Linux” is a two-day training course with programming exercises taught by David Faure of The KDAB Group. It is offered at the Meydenbauer Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Participants should have basic knowledge of the C++ language. No prior knowledge of any presented tools is assumed. Lunch is included. Course and instructor details are available here.

Speakers
avatar for David Faure

David Faure

KDAB
Qt, Linux, Debugging, Profiling


Sunday September 30, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Essential C++ Design
“Essential C++ Design” is a two-day training course with programming exercises taught by Klaus Iglberger. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

Course participants should have a solid base knowledge of C++ and at least one to two years of experience with the language.

Course and instructor details are available at https://cppcon.org/essential-cpp-design/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers

Sunday September 30, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Generic Programming 2.0 with Concepts and Ranges
“Generic Programming 2.0 with Concepts and Ranges” is a two-day training course with programming exercises taught by Christopher Di Bella. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

This course assumes familiarity with C++14 core features, templates and generic programming, first year university mathematics for computer science and git. You will need to have docker installed and configured before the class.

Course and instructor details are available at https://cppcon.org/generic-programming-2.0-with-concepts-and-ranges/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Christopher Di Bella

Christopher Di Bella

Staff Software Engineer, ComputeCpp Runtime, Codeplay Software
Christopher Di Bella is a Staff Software Engineer for Codeplay’s ComputeCpp Runtime Technology. He is a strong proponent for having the Concepts TS and the Ranges TS in C++20. Chris spends his days working on ComputeCpp, Codeplay’s implementation of SYCL; the Khronos implementation... Read More →


Sunday September 30, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Leveraging Modern C++ for Embedded Systems
“Leveraging Modern C++ for Embedded Systems” is a two-day training course with programming exercises taught by Dan and Ben Saks. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

Participants should have basic knowledge of the C++ language and standard library. This course includes programming exercises. The exercises run on a simulator provided by the instructor. Each exercise compiles and links with the simulator in C++ and executes as a command-line application. Please bring a computer with a C++11 or C++14 development environment that can build command-line applications.

Course and instructor details are available at https://cppcon.org/leveraging-modern-cpp-for-embedded-systems/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Dan Saks

Dan Saks

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

Ben Saks

Chief Engineer, Saks & Associates


Sunday September 30, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

Parallel Programming with Modern C++: from CPU to GPU
“Parallel Programming with Modern C++: from CPU to GPU” is a two-day training course with programming exercises taught by Gordon Brown and Michael Wong. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately after the conference). Lunch is included.

This course requires working knowledge of C++11 and git.

Course and instructor details are available at https://cppcon.org/parallel-programming-with-modern-cpp/.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers
avatar for Michael Wong

Michael Wong

VP Research & Development, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. | He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C... Read More →


Sunday September 30, 2018 09:00 - 17:00
TBA Meydenbauer Center

09:00

The Standard Library from Scratch
“The Standard Library from Scratch” is a two-day training course with programming exercises taught by Arthur O’Dwyer. It is offered at the Meydenbauer Conference Center from 9AM to 5PM on Saturday and Sunday, September 29th and 30th (immediately following the conference). Lunch is included.

Students are expected to have a good working knowledge of C++11. A working knowledge of classes, virtual functions, templates, exception-handling, C++11 lambdas, and move semantics will be assumed. Knowledge of C++14 or template metaprogramming is not required. The class will include short exercises presented via the online compiler at wandbox.org. Please bring a computer with a Web browser and/or a C++14 compiler installed.

Course and instructor details are available at https://cppcon.org/the-standard-library-from-scratch.

For individuals whose organization requires it, a certificate of completion is available for this event. For information contact registrar@cppcon.org.

Speakers

Sunday September 30, 2018 09:00 - 17:00
TBA Meydenbauer Center