CppCon 2021

Every other conference talk these days seems to be showing off some code on Compiler Explorer. But what does all that Assembly actually mean?

In this talk you'll learn the very basics of X86 Assembly and the X86_64 calling convention, just enough to understand the full Assembly listing of simple functions on Compiler Explorer. No previous experience with Assembly is necessary, but a basic understanding of C or C++ is useful.

After this talk you will:
- Be able to paste code from your own project into Compiler Explorer, and either understand the Assembly output or know how to simplify it until you do.
- Have a solid understanding of the fundamentals, so you know what to search for and understand it when you need to know more.

(Compiler Explorer is an increasingly popular tool which allows you to see exactly what the compiler does with your code. Check it out at https://godbolt.org/.)

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Martin Fowler once wrote that high-quality software is actually cheaper to produce than low-quality software. We agree with that sentiment, and we warmly welcomed the C++ Core Guidelines when they were introduced in 2015. Research and surveys conducted in the C++ Community consistently demonstrate the popularity of the Clang family of tools, as well as the growing demand for static analysis to be added to code editors.

In this talk, we’ll explore the current capabilities of existing C++ static analyzers and discuss some of the enforcements listed in the C++ Core Guidelines from a toolability aspect. We’ll also look into the recent “Simplify C++” trend in the language’s evolution, and to wrap things up we’ll take a look at how technology-specific analysis (like MISRA and AUTOSAR) is being adopted.

A variety of checks will be discussed, from catching a dangling pointer to conforming to the preferred code style and naming scheme. And I want to share a crazy idea I have about gamifying static analysis. Let’s play!

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

As much as we try to make it go away, the preprocessor is still here. It is used by many libraries and extensively throughout legacy code. And, in some cases, it is still the best tool to get the job done. In this talk, we will review the C and C++ preprocessor directives, where the abilities of the preprocessor differ between the two languages, and the modern C++ attempts to replace those directives. When this talk is completed, you should be more comfortable both debugging and modernizing preprocessor usage in your code.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Once you decide to start a big project or a company, it eventually comes down to unifying the build infrastructure. However, hundreds and thousands of compilation units are extremely difficult to maintain to achieve the highest possible performance. Contrary to the belief that you should always trust your compiler, recent micro-architectural breakthroughs from merging two arrays with special instructions to JSON parsing through SIMD showed that compilers are far from understanding every single piece of code you write. In this session we will talk about our experience on how to achieve the highest possible performance without much rewriting of your code, which trade-offs C++ compilers have, how to make the most of your micro-architecture, why unrelated changes may decrease the performance and how to debug them. In the end we will show which compiler options gave us the opportunity to gain 5-15% of performance, stabilized the benchmarks and decreased the build size for search engines, databases and high performance computing.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

In this talk, I will explore how to leverage language rules and static analysis principles to provide safety guarantees in C++ at compile time, without compromising on its performance and memory efficiency. Modern analysis tools have come a long way since their inception and are much more powerful than traditional Lint-style checks. They use several techniques from theorem solvers to simple heuristics mimicking developer’s reasoning and can find deep semantic errors in programs. Furthermore, modern analysis tools take advantage of information available in types and type extensions in the language to bridge the gap across function boundaries, without incurring performance penalties of running global analyses. This makes them an indispensable part of the “shift left” experience to drive program safety. Throughout the talk, I will share my experience in developing and running these tools on large production codebases over the last decade and how they evolved over time. All the checks in the demo will be available for free in the community edition of Visual Studio and as security actions in GitHub.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

WebAssembly has become a very popular target platform for C++ developers. Thanks to emscripten, porting native applications to WebAssembly is easy — as long as the application only uses the browser as a display and input device. However, emscripten does not provide type-safe wrappers to the standard JavaScript APIs such as the DOM manipulation API, let alone any other JavaScript API provided by existing web applications.

Our open source tool “typescripten” has been built on top of three powerful technologies to close this gap. It uses TypeScript interface definition files and the TypeScript compiler API to create type-safe C++ wrappers based on emscripten. TypeScript already has interface definition files for over 7000 JavaScript libraries that you can now use safely from C++.

We strive to design our C++ wrappers such that the C++ code using them looks similar to the equivalent TypeScript or JavaScript code. However, the peculiar semantics of prototype-based Javascript and Typescript are often difficult to translate into a type-based language such as C++. I will discuss the challenges we faced and choices we made when designing this framework.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

What to do when a program is slower than what we'd like? Where to start when trying to improve throughput, latency or responsiveness?

In this beginner friendly session we will introduce the two big families of profilers (sampling and instrumentation) and two tools my team uses almost every day when working on games: Optick and vTune.
Through a few concrete cases based on past experience we will study how to troubleshoot a performance problem using a profiler and how the code was improved.

We will illustrate a few classic cases such as inefficient algorithms, unsuitable data structures, I/O waits and bad concurrency.

If time allows we will also see how profilers such as vTune can be used to delve into micro-optimizations by looking at low level metrics such as cache misses and branch prediction.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Visual Studio 2022 is almost here, bringing new and deeper experiences for C++ developers targeting any platform. Since last year we’ve been working hard on implementing C++20 and making the IDE 64-bit, alongside a host of improvements to make your C++ development safer and more productive.

In this talk we’ll demonstrate many of these features, live: showing you how to use our new AddressSanitizer features to find bugs, target WSL 2 in seconds, express your build instructions with CMakePresets.json, consume specific versions of your dependencies with vcpkg, build and test your code with GitHub Actions, and more.

Come along to learn all about the latest in our tooling, and to get a peek into our plans for the future.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

GDB is bigger than you might think, and it's evolving fast. This is a depth-first walk through what's been added in versions 9 and 10. Depth-first meaning that no prior knowledge of these features is assumed, but even if you've used them before there should be plenty new for you. Few slides, lots of live demos. Some brand new things and some neat new additions to existing features. Topics include the new debuginfod facility; user-defined commands; enhancements to super-useful convenience variables such as $_siginfo, $_gdb_setting, $_gdb_setting_str; enhancements to TUI mode; how to add new TUI windows from GDB's Python scripting; advanced querying of types from GDB's Python scripting; and enhanced configuration of backtrace printing. You should learn at least two new tricks that will make improve you debugging effectiveness, and so make you a better programmer.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Finding and correcting defects in our code (aka bugs) is often a time-consuming, tedious, and challenging task. As the size and complexity of our code bases grows, it can feel like the corresponding difficulty in finding and understanding defects is growing exponentially. And yet, defects continue to arise, and we must continue to fix them.

This talk will look at what debugging is, the role of debugging in our development processes, and some of the many challenges associated with debugging. We'll look at the kinds of defects that debugging can address, and examine a number of strategies, tools, and tips for tracking them down. Finally, we'll provide some guidance for what to do after you've found the problem.

If you've ever faced a challenging bug, and wished for a more complete set of tools for finding it, then this session is for you. Attendees will leave this session with a basic set of debugging tips, tools, and tricks that they can immediately apply to their own daily work.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

In this session, you’ll learn how to take advantage of VS Code’s new debugging capabilities and discover easy ways to boost your C++ development productivity along the way.

We’ll get a simple embedded project up and running on a Raspberry Pi using the CMake Tools extension for Visual Studio Code. Then, we’ll dive deep into a debugging session, digging into both source code and assembly language. Next, we’ll debug GPU kernels in VS Code using NVIDIA’s Nsight Visual Studio Code Edition extension.

You’ll walk away from this talk with the knowledge and tools to take advantage of all VS Code’s debugger has to offer, along with bonus tips about optimizing productivity in C++ development regardless of which editor or IDE you’re using.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Code size of embedded application has been a concern for a very long time. While storage becomes cheaper and smaller, developers find creative ways to increase code size by adding features or unnecessary software engineering. Compilers have come a long way in optimizing applications for code size. While most compiler optimization work were focused on application performance, we have seen increase in the code size optimizations in recent years.

In this presentation I'll talk about classical as well as recent compiler optimizations for code size, a few of which I implemented in the LLVM compiler. Some optimizations (hot cold splitting, function entry instrumentation) require collecting data from the field while the application is running. I'll provide an overview of how those compiler techniques help reduce code size. I'll also talk about some tips and techniques (compiler flags to reduce code size, tuning of compiler options like inline threshold), that help reduce binary size. Having knowledge of the code generated by the compiler and the instruction set architecture can help engineers chose appropriate programming abstractions and idioms.

Key takeaways:
- Compiler optimization flags and tunings for code size optimizations
- Selecting code-size friendly data structures and algorithms from the C++ standard library
- Source code level optimization and annotation techniques to reduce binary size
- Compiler instrumentation techniques to get insights into the source code
- Software re-organization techniques to reduce working set during program startup

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Many Clang AST matcher use cases revolve around refactoring code. We utilized them in a new way, to ensure compliance in our codebase. In this presentation, we will explore Clang's LibASTMatcher library, go over the basics of setting up a project, and walk through our approach to creating matchers for simple to complex cases.

Developers who must comply with industry or product regulations will find this use case helpful. Join me as we take what we've learned and apply it.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Path-sensitive static analysis simulates the runtime behavior of the program code and uses the analysis state to evaluate which branches can be taken. It is an effective tool to find non-trivial bugs in code at compile time. While checks based on such analysis can take longer time to run, they have a sophisticated understanding of the code that helps them uncover semantic issues. First, I will discuss how can you turn these checks on and how to make sense of the warning messages they produce. Furthermore, I will do a deep dive on what makes path-sensitive analysis an effective tool to reason about code and how MSVC is leveraging this power to find bugs. In particular, I will explain how modern tools like constraint solvers can help increase the precision of the analysis. Throughout the talk, I will not only feature already released checks but also give a glimpse of the upcoming ones that we are actively working on. All the checks in the demo will be available for free in the community edition of Visual Studio and as security actions in GitHub.

Delayed broadcast

Path-sensitive static analysis simulates the runtime behavior of the program code and uses the analysis state to evaluate which branches can be taken. It is an effective tool to find non-trivial bugs in code at compile time. While checks based on such analysis can take longer time to run, they have a sophisticated understanding of the code that helps them uncover semantic issues. First, I will discuss how can you turn these checks on and how to make sense of the warning messages they produce. Furthermore, I will do a deep dive on what makes path-sensitive analysis an effective tool to reason about code and how MSVC is leveraging this power to find bugs. In particular, I will explain how modern tools like constraint solvers can help increase the precision of the analysis. Throughout the talk, I will not only feature already released checks but also give a glimpse of the upcoming ones that we are actively working on. All the checks in the demo will be available for free in the community edition of Visual Studio and as security actions in GitHub.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/