Home » Blog » Categories » Video & On-Demand

Video & On-Demand

CppCon 2017: Fuzz or lose...--Kostya Serebryany

By Adrien Hamelin | Jun 20, 2018 12:31 PM | Tags: community

Have you registered for CppCon 2018 in September? Early bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

Fuzz or lose...

by Kostya Serebryany

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Fuzzing is a family of testing techniques in which test inputs are generated semi-randomly. The memory unsafety of C++ has made fuzzing a popular tool among security researchers. Fuzzing also helps with stability, performance, and equivalence testing; and it’s a great addition to everyone’s CI.

Our team has launched OSS-Fuzz, the Google's continuous fuzzing service for open source software, and a similar service for our internal C++ developers. Over 1000 C++ APIs are being fuzzed automatically 24/7, and thousands of bugs have been found and fixed.

Now we want to share this experience with the wider C++ community and make fuzzing a part of everyone’s toolbox, alongside unit tests. We will demonstrate how you can fuzz your C++ library with minimal effort, discuss fuzzing of highly structured inputs, and speculate on potential fuzzing-related improvements to C++.

CppCon 2017: dynamic_cast From Scratch--Arthur O'Dwyer

By Adrien Hamelin | Jun 18, 2018 12:08 PM | Tags: community

Have you registered for CppCon 2018 in September? Early bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

dynamic_cast From Scratch

by Arthur O'Dwyer

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This session will introduce you to the C++ object model: the rules by which C++ class objects are translated into memory layouts. We'll quickly cover polymorphic class types and multiple and virtual inheritance. We'll discuss the anatomy of a virtual method call, the difference between `static_cast` and `reinterpret_cast`, and what's contained in a vtable besides function pointers. We'll see that the way `dynamic_cast` thinks about the class hierarchy is slightly different from the way we're used to drawing it; and that `dynamic_cast` is expensive enough that sometimes we can find cheaper ways to ask an object for its type! The climax will be a complete, bug-free, and fast implementation of C++'s built-in `dynamic_cast`, using our own hand-crafted artisanal run-time type information (RTTI).

Attendees will incidentally be exposed to several features of the modern C++ language, including type traits and the `final` qualifier.

This session will mostly be talking about the Itanium C++ ABI, which is the standard on Linux and OS X systems. Mapping these concepts to the MSVC ABI will be left as an exercise for the reader of the project's GitHub repo: https://github.com/Quuxplusone/from-s...

CopperSpice: Futures & Promises

By Ansel Sermersheim | Jun 16, 2018 01:47 PM | Tags: None

New video on the CopperSpice YouTube Channel:

Futures and Promises

by Barbara Geller and Ansel Sermersheim

About the video:

In this video we talk about the concepts of futures, promises, and async. We explore why these concepts are useful, what the applications are, and also discuss some of the shortcomings of the current standard implementation.

Please take a look and remember to subscribe!

Dublin C++ Group: Variadic templates and fold-expressions -- Denis Sukhonin

By Pawel Kurdybacha | Jun 16, 2018 01:43 PM | Tags: None

Talk from Dublin C++ User Group 11.06.2018.

Variadic templates and fold-expressions

by Denis Sukhonin

About the session:

Abstract: It all started with a single printf causing undefined behavior due to mismatch of the format string and arguments. To solve similar problems in a type-safe manner C++ introduced variadic template parameters and fold-expressions. Denis covers the basics and shows how a type-safe printf function can be implemented.

Slides: https://goo.gl/mmzdrH

 

CppCon 2017: Going Nowhere Faster--Chandler Carruth

By Adrien Hamelin | Jun 13, 2018 12:56 PM | Tags: performance

Have you registered for CppCon 2018 in September? Early bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

Going Nowhere Faster

by Chandler Carruth

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

You care about the performance of your C++ code. You have followed basic patterns to make your C++ code efficient. You profiled your application or server and used the appropriate algorithms to minimize how much work is done and the appropriate data structures to make it fast. You even have reliable benchmarks to cover the most critical and important parts of the system for performance. But you're profiling the benchmark and need to squeeze even more performance out of it... What next?

This talk dives into the performance and optimization concerns of the important, performance critical loops in your program. How do modern CPUs execute these loops, and what influences their performance? What can you do to make them faster? How can you leverage the C++ compiler to do this while keeping the code maintainable and clean? What optimization techniques do modern compilers make available to you? We'll cover all of this and more, with piles of code, examples, and even live demo.

While the talk will focus somewhat on x86 processors and the LLVM compiler, but everything will be broadly applicable and basic mappings for other processors and toolchains will be discussed throughout. However, be prepared for a lot of C++ code and assembly.

CppCon 2017: ThinLTO: Scalable and Incremental Link-Time Optimization--Teresa Johnson

By Adrien Hamelin | Jun 11, 2018 12:33 PM | Tags: community

Have you registered for CppCon 2018 in September? Early bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

ThinLTO: Scalable and Incremental Link-Time Optimization

by Teresa Johnson

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Whole program optimization enables higher performance in C++ applications, because of the expanded scope for analysis and optimization. However, the memory and time required to optimize the entire program together as a single unit traditionally has made whole program optimization infeasible for complex and large C++ applications, such as those being built at Google. Additionally, traditional whole program optimization frameworks have not supported fast incremental builds. ThinLTO (Thin Link Time Optimization) is a new compilation model that was recently deployed in the LLVM compiler toolchain to enable scalable whole program optimization for these huge C++ applications, and additionally enables the fast incremental builds required for use in day-to-day development.

In this talk we’ll describe why whole program optimization is beneficial for C++ applications, how the ThinLTO compilation model enables scalable and incremental builds, and how ThinLTO can be integrated with distributed build systems for even faster whole program builds. Additionally, we’ll describe implications for C++ developers.

CppCon 2017: The Nightmare of Move Semantics for Trivial Classes--Nicolai Josuttis

By Adrien Hamelin | Jun 8, 2018 12:25 PM | Tags: community

Have you registered for CppCon 2018 in September? Early bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

The Nightmare of Move Semantics for Trivial Classes

by Nicolai Josuttis

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Assume, we implement a very simple class having just multiple string members. Even ordinary application programmer prefer to make it simple and fast.

You think you know how to do it? Well beware! It can become a lot harder than you initially might assume.

So, let’s look at a trivial class with multiple string members and use live coding to see the effect using different implementation approaches (using constructors passing by value, by reference, by perfect forwarding, or doing more sophisticated tricks).

Sooner than later we will fall into the deep darkness of universal/forwarding references, enable_if, type traits, and concepts.

CppCast Episode 153: Vcpkg with Robert Schumacher

By robwirving | Jun 8, 2018 11:21 AM | Tags: None

Episode 153 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Robert Schumacher from Microsoft to discuss the vcpkg package manager and more.

CppCast Episode 153: Vcpkg with Robert Schumacher

by Rob Irving and Jason Turner

About the interviewee:

Robert Schumacher is a developer on the Microsoft Visual C++ Libraries team and the lead developer for vcpkg. He has previously worked on the MSVC implementation of the Modules TS and is the current maintainer of Cpprestsdk. Besides work, he occasionally indulges in functional programming and arguments about whether inheritance is fundamentally flawed.