cppcon / cppcon2018

Slides and other materials from CppCon 2018

CppCon 2018 Presentation Materials

https://github.com/CppCon/CppCon2018 is the canonical location for presentations and code from CppCon 2018.

For Speakers: Submitting Materials

Index of Materials

Keynotes

• Concepts - The Future of Generic Programming by Bjarne Stroustrup
• Thoughts on a more powerful and simpler C++ (5 of N) by Herb Sutter

Presentations

• A Little Order - Delving Into The STL Sorting Algorithms by Fred Tingaud
• A Semi Compile/Run-time Map with (Nearly) Zero Overhead Lookup by Fabian Renn-Giles [README] [more materials]
• An Allocator is a Handle to a Heap by Arthur O'Dwyer
• Applied Best Practices by Jason Turner
• Avoiding Disasters with Strongly Typed C++ by Arno Lepisk
• Better C++ using Machine Learning on Large Projects by Nicolas Fleury, Mathieu Nayrolles
• Better Tools in Your Clang Toolbox by Victor Ciura
• Build Systems: A Simple Solution to a Complicated Problem by Peter Bindels
• Building a C++ Reflection System in One Weekend Using Clang and LLVM by Arvid Gerstmann [README]
• Building Multi-Million Line C++ Projects Effortlessly with the Meson Build System by Jussi Pakkanen
• Class Template Argument Deduction for Everyone by Stephan T. Lavavej
• Compile Time Regular Expressions by Hana Dusíková [README]
• Concepts as She is Spoke by Arthur O'Dwyer
• C++ Cryptozoology - A Compendium of Cryptic Characters by Adi Shavit
• C++ Dependency Management from Package Consumption to Project Development by Boris Kolpackov
• C++ Everywhere with WebAssembly by Damien Buhl [README]
• C++ Modules by Nathan Sidwell
• Crafting Embedded Domain Specific Language (EDSL) in C++ by Gilang Hamidy [more materials]
• CUDA Kernels with C++ by Michael Gopshtein
• Dealing with Aliasing Using Contracts by Gábor Horváth
• Debug C++ Without Running by Anastasia Kazakova
• Declarative Style in C++ by Ben Deane
• Design for Performance by Fedor Pikus
• Don't package your libraries, write packagable libraries! by Robert Schumacher [.pptx] [.pdf]
• DynaMix: A New Take on Polymoprhism by Borislav Stanimirov [README]
• Effective replacement of dynamic polymorphism with std::variant by Mateusz Pusz
• Emulating the Nintendo 3DS - Generative and Declarative Programming in Action by Tony Wasserka
• Enough string_view to hang ourselves by Victor Ciura
• Fancy Pointers for Fun and Profit by Bob Steagall
• Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics by Bob Steagall
• Feather: A Modern C++ Web Development Framework by Yu Qi
• From Metaprogramming Tricks to Elegance by Vincent Reverdy
• Get Rich Quick! Using Boost.Beast WebSockets and Networking TS by Vinnie Falco [README]
• Git, CMake, Conan - How to ship and reuse our C++ projects by Mateusz Pusz
• How to Argue(ment) by Richard Powell
• Implementing the Cpp Core Guidelines Lifetime Safety Profile in Clang by Matthias Gehre, Gabor Horvath
• Inside Visual C++'s Parallel Algorithms by Billy O'Neal [.pptx] [.pdf] [README]
• Latest and Greatest in the Visual Studio Family for C++ Developers 2018 by Steve Carroll, Marian Luparu
• Liberating the Debugging Experience with the gdb Python API by Jeff Trull
• Make It Fixable: Preparing for Security Vulnerability Reports by Patricia Aas
• minidumps: gdb-compatible, software controlled core dumps by Matthew Fleming
• Modern C++ API Design, pt 1 by Titus Winters
• Modern C++ API Design, pt 2 by Titus Winters
• Modern C++ in Embedded Systems - The Saga Continues by Michael Caisse
• Multi-Precision Arithmetic for Cryptology in C++, at Run-Time and at Compile-Time by Niek J Bouman
• Named Arguements from Scratch by Richard Powell [README] [more materials]
• OOP is dead, long live Data-oriented design by Stoyan Nikolov
• Operator Overloading by Ben Deane
• Pessimistic Programming by Patrice Roy
• Rapid Prototyping of Graphics Shaders in Modern C++ by Valentin Galea
• Regular Types and Why Do I Care? by Victor Ciura
• Return Value Optimization - Harder Than It Looks by Arthur O'Dwyer
• Sane and Safe C++ Classes by Peter Sommerlad
• Save $$ Testing Code the Playback-Based Way by William Clements
• Scripting at the Speed of Thought: Using Lua in C++ with sol3 by JeanHeyd Meneide
• Simplicity - Not Just For Beginners by Kate Gregory [.pdf] [.pptx]
• Smart References There and Back Again by Erik Valkering
• Software Vulnerabilities in C and C++ by Patricia Aas
• Standard Library Compatibility Guidelines by Titus Winters
• State Machines Battlefield - Naive vs STL vs Boost by Kris Jusiak
• Surprises In Object Lifetime by Jason Turner
• Teaching Old Compilers New Tricks - Transpiling C++17 to C++11 by Tony Wasserka
• The Bits Between the Bits by Matt Godbolt
• The C++ Execution Model by Bryce Adelstein Lelbach
• The Embedded Device Under Your Desk: UEFI Applications With Modern C++ by Morris Hafner
• The Most Valuable Values by Juanpe Bolívar [README]
• The Networking TS in Practice: Testable, Composable Asynchronous I/O in C++ by Robert Leahy [README] [more materials]
• The Salami Method for Cross Platform Development by Adi Shavit
• These Aren't the COM Objects You're Looking For by Victor Ciura
• To Kill a Mocking Framework: Tools and Techniques for Testing Callbacks Using Standard C++ by Alastair Rankine
• Undefined Behavior is Not an Error by Barbara Geller, Ansel Sermersheim
• Unwinding the Stack - Exploring How C++ Exceptions Work on Windows by James McNellis
• What Do We Mean When We Say Nothing At All? by Kate Gregory [.pptx] [.pdf]
• What do you mean thread-safe? by Geoff Romer [.pptx] [.pdf]
• What to Expect from a Next-Generation C++ Build System by Boris Kolpackov
• Woes of Scope Guards and Unique Resource by Peter Sommerlad
• Writing Standard Library Compliant Data Structures and Algorithms by Marc Gregoire

Lightning Talks and Lunch Sessions

• Big Infrastructure at a Small Scale by Matthew von Arx [README]
• [Boost].DI - Inject All The Things! by Kris Jusiak
• Emacs BoF by Jeff Trull
• Fixing Two-Phase Initialization by Andreas Weis
• How to create slides about CMake with CMake by Mateusz Pusz
• Qt Signals and the Coroutines TS by Jeff Trull
• rof_egnar by Peter Sommerlad
• Set it and Forget it by Matthew von Arx
• Study Group 14: CppCon Report by John McFarlane
• Study Group 14: The Story So Far by John McFarlane
• The Bad Big Wolf Meets Riding Hood Little Red by Borislav Stanimirov
• The Shape of a Program by James McNellis
• Trivially Relocatable by Arthur O'Dwyer

Posters

• A C++ tasking framework with compile-time dispatching and type-driven priority scheduling for HPC by David Haensel
• CodeChecker: A static analysis infrastructure built on the LLVM/Clang Static Analyzer tool chain by György Orbán, Tibor Brunner, Gábor Horváth, Réka Kovács
• CodeCompass: An Open Software Comprehension Framework by Zoltán Porkoláb, Tibor Brunner, Márton Csordás, Máté Cserép, Anett Fekete, Endre Fülöp, Gábor Horváth
• Cpp-Taskflow: Fast Parallel Programming with Task Dependency Graphs by Tsung-Wei Huang, Chun-Xun Lin, Guannan Guo, Martin D. F. Wong
• CTwik: Hot Reloading & Quick-Build System by Mohit Saini
• Efficiently and Comprehensively Reproducing C++ Bug Reports with Sciunit by Zhihao Yuan, Tanu Malik
• Feedback on practical use of c++17 std::filesystem::recursive_directory_iterator by Noel Tchidjo Moyo
• Fighting Non-determinism in C++ Compilers by Mandeep Singh Grang
• Fizz, a C++14 implementation of TLS 1.3 by Subodh Iyengar, Kyle Nekritz
• Funky Pools - Active Containers for Refactoring Legacy Code by Norman Birkett
• Hardware Memory Tagging makes C++ Memory-Safer by Kostya Serebryany
• Lifting machine code instructions to LLVM bitcode by Peter Goodman
• Modernizing HPC Software with C++11 by Ivo Kabadshow, Andreas Beckmann, David Haensel
• Retrofit C++17 to large Visual Studio codebases by Gabriel Diaconița
• The C++ Lands, its amazing creatures and weird beasts by Elena Sagalaeva, Vladimir Gorshunin
• Using C++ to improve productivity in platform with C API by Alexius Alvin, Gilang Hamidy

cppcon2018's Issues

Wrong document for "CUDA Kernels with C++"

The "PDF" document in the repo actually is the GitHub web view of the PDF document

Missing Slides: Jonathan Boccara "105 algorithms in less than an hour"

https://www.youtube.com/watch?v=2olsGf6JIkU

Missing slides: Gordon Brown “A Modern C++ Programming Model for GPUs using Khronos SYCL”

Missing Slides: H. Wright “Large-Scale Changes at Google: Lessons Learned From 5 Yrs of Mass Migrations”

Presentation link: https://www.youtube.com/watch?v=TrC6ROeV4GI

Missing Slides: Chandler Carruth "Spectre: Secrets, Side-Channels, Sandboxes, and Security"

CppCon 2018: Chandler Carruth "Spectre: Secrets, Side-Channels, Sandboxes, and Security"
https://youtu.be/_f7O3IfIR2k

git reports error when checking out in Git Windows

Git 2.38.1: https://git-scm.com/download/win

$ git clone https://github.com/CppCon/CppCon2018.git
Cloning into 'CppCon2018'...
remote: Enumerating objects: 933, done.
remote: Total 933 (delta 0), reused 0 (delta 0), pack-reused 933
Receiving objects: 100% (933/933), 335.19 MiB | 12.97 MiB/s, done.
Resolving deltas: 100% (398/398), done.
error: unable to create file Posters/codechecker_a_static_analysis_infrastructure_built_on_the_llvmclang_static_analyzer_tool_chain/codechecker_a_static_analysis_infrastructure_built_on_the_llvmclang_static_analyzer_tool_chain__gyorgy_orban_tibor_brunner_gabor_horvath_reka_kovacs__cppcon_2018.pdf: Filename too long
Updating files: 100% (258/258), done.
fatal: unable to checkout working tree
warning: Clone succeeded, but checkout failed.

MissingSlides: Walter E. Brown “C++ Function Templates: How Do They Really Work?”

CppCon 2018: Walter E. Brown “C++ Function Templates: How Do They Really Work?”
https://www.youtube.com/watch?v=NIDEjY5ywqU

Missing slides: Jon Cohen “Ensuring Exception Safety Through Testing"

Presentation link: https://www.youtube.com/watch?v=XPzHNSUnTc4

Missing slides for Nir Friedman's “Understanding Optimizers: Helping the Compiler Help You”

Missing Slides: Alan Talbot “Moving Faster: Everyday efficiency in modern C++”

I can find the presentation on YouTube, yet I cannot find the slides in this repo.

lifetime-talk of 2018 and take on structured bindings

hey, I love your talks, but one thing had me confused:
In the CppCon2018 talk about object lifetimes, the slides claim that auto [s, i] = get_Holder(); was essentially equivalent to

auto e = get_Holder();
auto& s = e.s;
auto& i = e.i;

But that would mean s is a reference, which is not how I understand auto [s, i] to behave. Indeed, std::is_reference_v<decltype(s)> says it's not a reference:

[...]

struct Holder { S s; int i; };
Holder get_Holder() { return {}; }

[...]

S get_S() {
    auto [s, i] = get_Holder(); /// structured bindings
    
    auto e = get_Holder();
    auto& _s = e.s;
    auto& _i = e.i;
    
    std::cout << std::is_reference_v<decltype(s)> << std::is_reference_v<decltype(_s)> <<"\n";
    return s;
}

Output:

01

So, I seem to not get something here. Do you have a guess on what's up?

Cheers & thanks for your time, man