Speakers

Emotional Code

Programmers, it turns out, are human beings. This means they not only feel emotions, they leave traces of those emotions behind in their code. Kate will show you why that is so, and what you can do about it.

A State of Compile Time Regular Expressions

In this talk I will present an advancement on the Compile Time Regular Expression (CTRE) Library. The library was designed with new C++20 features, and it uses novel techniques. This presentation sums up the recent work on the library.

One of the primary topics of this talk will be an explanation of the new Deterministic Finite Automaton (DFA) engine in the library and how it's built and optimised during compilation. I will explain the differences and limitations of the new engine in comparison to the previous Back Tracking engine.

I will address these differences with a benchmark and I will discuss the generated assembly. Even if you are not interested in regular expressions, you will learn new techniques in compile-time meta-programming and see new C++20 features in action.

Tools to Ease Cross-Platform C++ Development

Writing high-quality error-free C++ code itself is a challenging task, let alone when having to juggle multiple platforms at the same time! In this session, I will talk about many challenges in cross-platform C++ development and how tools can help: what options do I have if my production environment is different than my dev box? Can I be as productive when working with remote Linux machines? Is there any good C++ editor that works consistently on all platforms I work on? How can I efficiently build and debug CMake projects, or even get IntelliSense? How can I easily find and acquire open sourced libraries? Is there an easy way to write and run cross-platform tests? Come to see what Visual Studio 2017, Visual Studio Code, CMake, WSL, Vcpkg and more have to offer to make cross-platform C++ development much easier in this demo-heavy talk.

On the Aesthetics of Code

Améliorer votre C++ avec les algorithmes de la STL

Le C++ dit "Moderne" mets l'accent sur la généricité et l'expressivité du code.

Les algorithmes de la bibliothèque standard en sont un parfait exemple, capables d'accomplir toutes sortes d'opérations sur des collections, qu'importe leur type.

Dans cette session, nous rappellerons le concept des itérateurs et comment ils sont utilisés pour lier les conteneurs aux algorithmes, puis nous explorerons les algorithmes les plus commun offerts par la STL et comment les utiliser pour résoudre simplement bon nombres de problèmes liés aux collections en C++.

Enfin nous conclurons avec un aperçu du futur et comment C++20 rendra les algorithmes encore meilleurs.

Tacit DSL All the Things

Can't we just add a functional programming language to C++ as a DSL that integrates seamlessly? Would that be a good thing? Would I have to understand category theory to use it? Whether or not you are a fan of domain-specific languages it seems we are getting one in C++20's standard library. The ranges DSL brings with it some high-level concepts and with a little abuse many more concepts, from functional programming. At the same time, there seems to be interest in other DSLs bringing other functional concepts such as monadic extensions to optional or monadic composition of asynchronous tasks. But why in separate DSLs? This seems odd because unifying things is at the very heart of functional programming.

In this talk, I will make the argument that with 3 small extensions to the ranges DSL syntax we can make one DSL to rule them all lifting may existing C++ language and library features into a more functional or declarative paradigm as well as unifying many boost libraries. After refreshing the core concepts of the ranges DSL and presenting my proposed extentions we will take a whirlwind tour of how I think we should add functional programming paradigms to C++ in a unified manner. We will rethink sum types, fusion metaprogramming, event-based programming, monads, Haskell do notation, closure's transducers, rust's match, named/deduced parameters, state machines, "terser" lambda syntax, pointfree programming, generative programming, and declarative programming paradigms.

Adding a New clang-tidy Check by the Practice

The LLVM tool suite has changed the rules of C++ codeline evolution by allowing to manipulate the AST. As example, we can list all the popular clang-tidy checks like "modernize-replace-auto-ptr" which allows to replace old C++98 std::auto_ptr usages by C++11 std::unique_ptr.

However, adding a new check to clang-tidy could be difficult as the C++ AST is complex and the clang API rich without knowing where to start.

The purpose here will be to present how to create a simple rule and as an example, we will try to replace some standard algorithm by the new range ones.

This live coding session will present step by step how to:
- Integrate a new check to clang-tidy
- Manipulate the AST matchers
- Create a Fix-it
- Unittest it

C++ Modules: What You Should Know

Merci le Compilo!

On parle souvent du langage C++ comme d'un langage alliant performance et abstraction. Mais la « sauce secrète » n'est connue que du compilateur, et c'est autant lui qu'il faut remercier que le langage qu'il compile.

C++ a en effet cette particularité de devoir ses bonnes propriétés autant au standard qu'au bon vouloir des développeurs de compilateur, et aussi à la capacité du développeur à utiliser finement le compilateur pour qu'un même code atteigne des objectifs différents : portabilité ? facilité de debug ? empreinte mémoire ? sécurité ? performance ? vitesse de compilation ?

À nous de bien connaître le compilateur pour utiliser la bonne combinaison d'option suivant ce que l'ont veut faire de son code.

Using C++ as a C on steroids

Some people want to use the latest version C++ with all the bells and whistles. Some like it for only a few aspects, and would love to forget about the remaining parts. But is that possible? The answer is yes, and from freestanding C++ to a range of compiler flags, many a project do use C++ like this. Let's discover these choices and explore the consequence!

The Anatomy of an Exploit

Security vulnerabilities and secure coding is often talked about in the abstract by programmers, but rarely understood. In this talk we will walk through a simple exploit, how it’s developed and how it’s used. The goal is to try to get a feeling for the point of view of an "attacker", and to slowly start looking at exploitation as another programming tool. We will mainly be looking at C and x86_64 assembly, so bring snacks.

Élégance, style épuré et classe

Écrire une classe en C++ n’est pas un exercice aussi simple que ce que l’on pourrait espérer. Au-delà des questions d’architecture, une multitude de détails techniques peuvent être autant d’embûches pour le développeur un peu candide : constructeurs de copie, opérateurs d’affectation, comparaison, sémantique de déplacement…

Le parti pris de cette présentation ne sera pas d’entrer successivement dans toutes les particularités de ces opérations, mais plutôt de partir de l’approche inverse : essayer de catégoriser les différentes sortes de classes que l’on rencontre régulièrement, afin de voir pour chacune d’entre elles comment n’écrire que le minimum nécessaire. Notre objectif : obtenir un code robuste et maintenable, des classes élégantes et épurées.

How I learned to stop worrying and love MISRA

MISRA C++2008 is a collection of coding rules aimed at safety-critical software. It is used in many places, and is prominent in the automotive sector.

As a developer of a static analysis software, I have created tools that can automatically validate if some code is MISRA-compliant. And I hated it. Those rules seemed to go against everything that I knew and loved about C++. A few years ago, I learned that MISRA was working on an updated version of its standard, and instead of remaining on the side, grumpily criticizing the new release, I decided to join this group.

In this talk, I will tell of my journey, and how part of what I hated in MISRA was indeed due to some misunderstanding about what MISRA really is and really means.

Quickly Testing Legacy Code

You've inherited some legacy code: it's valuable, but it doesn't have tests, and it wasn't designed to be testable, so you need to start refactoring! But you can't refactor safely until the code has tests, and you can't add tests without refactoring. How can you ever break out of this loop?

I will present a new C++ library for applying Llewellyn Falco's "Approval Tests" approach to testing cross-platform C++ code - for both legacy and green-field systems, and a range of testing frameworks.

I will describe its use in some real-world situations, including how to quickly lock down the behaviour of legacy code. I will show how to quickly achieve good test coverage, even for very large sets of inputs. Finally, I will also describe some general techniques I learned along the way.

Identifying Monoids: Exploiting Compositional Structure in Code

Composition is the essence of code architecture, and monoids are a powerful and underappreciated compositional pattern that is lurking in code of all kinds. Identifying and exploiting monoids is perhaps the best way to improve our code's large-scale architecture, in the same way that recognizing algorithms and replacing raw loops is a great way to improve small-scale architecture.

When we start looking for monoids, we find that they are everywhere, and it's not just about std::accumulate with addition! In this talk I want to develop an intuition for recognizing this ubiquitous design pattern. I will show some ways to think about code capabilities at a higher level, and how thinking in terms of monoids can help us with things like API design, incremental computation, evolving system state and distributing work. Along the way we'll also look at how C++ language and library features can support putting monoids to work in our code.

Introduction

Conclusion

SIMD in C++20 - EVE of a new Era

In those days and ages of GPGPU, Cloud Computing, and other bleeding-edge large-scale computing architectures, peoples often forget that 150% of their CPU comes with a layer of Instruction Level Parallelism: their SIMD computing unit. If writing code using SIMD systems was less of a nightmare then, yeah, people would use it. So, obviously, we had to write a library for it.

Writing SIMD wrapper libraries is not a new idea and a bunch exists already. What we want to showcase here is EVE : a C++20 library giving access in a uniform way across both ARM (neon) and x86 (from sse2 to avx-512)..

Its main advantages over similar libraries include:

• STL like algorithm support, including zip to operate on multiple ranges.
• ARM support (many libraries only support x86)
• A very comprehensive math library.It is liberally licensed and intended to be production quality.

This talk will include a collection of demos (like https://godbolt.org/z/n6Pds78s6) for different library features and benchmarks, as well as practical advice on using EVE in your projects.

Introduction

Conclusion

C++'s Superpower

Iterators and Ranges: Comparing C++ to D, Rust, and Others

C++20 Templates - The next level: Concepts and more

C++20 is probably the biggest change to the language ever since. In this session, we will look into some changes that templates received with C++20. The biggest change is the introduction of Concepts.

We don’t stop there. We will also talk about improvements to CTAD and NTTP. Of course, we will also look into how templated lambdas work in C++20.

By the end of the talk, attendees have learned about the newest C++20 template updates and how to apply them.

The C++ rvalue lifetime disaster

Rvalue references have been with us since C++11. They have originally been introduced to make moving objects more efficient: the object an rvalue reference references is assumed to go out of scope soon and thus may have its resources scavenged without harm. The C++ standard library, for example std::cref or std::ranges, makes use of yet another aspect of rvalue references: since they go out of scope soon, it is assumed unsafe to hold on to them beyond the scope of the current function, while lvalue references are considered safe. We, too, found this assumption to be very useful for smart memory management, in particular in generic code. Unfortunately, the C++ language itself violates this assumption in at least two places. First, rvalues bind to const&. This means that innocent-looking functions taking a parameter by const& and passing it through in some way silently convert rvalues to lvalue references, hiding any lifetime limitation of the rvalues. std::min/max are two such examples. Worse still, every accessor member function returning a const& to a member suffers from this problem. Second, temporary lifetime extension is meant to make binding a temporary to a reference safe by extending the lifetime of the temporary. But this only works as long as the temporary is still a prvalue. If the temporary has been passed through a function, even it has been correctly passed through by rvalue reference, lifetime extension will no longer be invoked and we get a dangling reference. These problems are not merely theoretical. We have had hard-to-find memory corruption in our code because of these problems. In this talk, I will describe the problems in detail, present our library-only approach to mitigate the problems, and finally, make an impossible-to-ever-get-into-the-standard proposal of how to put things right.

The concepts of concepts

In this talk, you'll learn all you need to know about one of the flagship features of C++20; concepts. First, I'll explain the concept behind concepts, why templates needed this extension. Then we'll discover the different ways concepts can be used with functions and with classes. What kind of concepts do we get with the standard library of C++20? That's also something we'll discuss, right before we will start the most interesting part of this session; how to write your own concepts? From the simplest we'll go towards more complex examples while describing all the different constraints we express with concepts. We'll finish with some real-life examples where concepts can document better and/or simplify our codebase.

Parameterized testing with GTest

At this talk, you will learn about how to keep your unit tests short, expressive and maintainable by using parameterized tests from the GTest library. First, we are going to cover why unit test code is as important as production code. Then, I'm going to show how we can make our tests less repetitive with different techniques. We are going to cover in detail, how to use parameterized tests and what are the pitfalls to avoid. Before concluding, I'll briefly cover what other libraries support the same feature.

Exceptional C++

When writing code we usually focus our attention on the happy paths - that’s where the interesting stuff happens. But there are also plenty of exciting things happening on the error handling flow, too. Although not universally loved/used, exceptions are a powerful mechanism of maneuvering execution on the unhappy path. Even if std::exception and related machinery are not your cup of tea, you might care about hardware faults or OS signals like access violations, page errors, ALU overflows. Let’s take a deep dive and explore what happens when an exception occurs, both at the application level and the OS level. We’ll explore the unwind process, the compiler generated code, the CRT hooks available and other exception internals. As we’re taking the scenic Windows route, we’re also going to encounter async exceptions (structured exceptions) on our quest for a better crash. We’ll poke into these mechanisms and see how we can leverage them in our application error handling. Did I mention threads? Routing exceptions between threads… oh my!

What Classes we Design and How

C++ class design has been error prone since the beginning, until Scott Meyers told us about the Rule-of-Three. But even that is not enforced by the language. In addition, C++11 changed the set of compiler-provided special member functions and the intrinsic rules have become more complicated. However, instead of starting from the rules for special member functions, we will look at what role a class type plays and how that maps on what special member functions to define and how, if any. Examples for class roles are Value, Relationship, Manager (scoped, unique, general), Mix-in. We will also look at the roles of member variable types that influence or imply the role of the class type. The role of a class will also take out many mysteries of move operations and will lead to clear guidance when and how to implement move: for suppressing copying, for managing unique ownership (Unique Manager) or for optimizing object copies (General Manager). We will rehearse the Rule of Zero, and learn more about the Rule of Five/Six, the Rule of DesDeMovA, and the Rule of Unique Three. This all will enable you to much more consciously and safely design your class types and combine types of member variables. You will have then the ability to select from a few reasonable combinations from the plethora of possibilities of special member function combinations: {public:,protected:,private:} x {destructor, default constructor, copy constructor, copy assignment, move constructor, assignment} x {noexcept(true),noexcept(false)} x { =default, =delete, {/body/}, not declared } (math as homework)

A Series of Unfortunate Bugs

Any C++ developer working in a large codebase is very likely to experience weird bugs. In this talk, I'll be sharing with you post-mortem of a set of weird bugs that occurred in deceptively simple code but were difficult to debug. Many of these bugs occurred at unfortunate moments - for instance, just before the day of the release or at the customer site. Almost all of them took nontrivial amount of time to debug them. But surprisingly it took only a few lines of code to fix them. The cause of these bugs range from static buffer overflow and stack corruption to undefined behaviours and many other exciting ways to break a C++ program. In this talk I’ll present the code snippets in which the bugs occurred, show you the fixes and share with you the pitfalls to avoid these bugs. Through these bugs, we focus on how to get better at debugging.

Zen and the art of Code Lifecycle Maintenance

Robert Pirsig’s 1974 bestselling classic, “Zen and the Art of Motorcycle Maintenance” was not about Zen - or Motorcycles - although both made an appearance. The subtitle gives you more of an idea: “An Inquiry into Values” - but it was only later that the main concepts in the book, along with the sequel, “Lila” came to form part of “A Metaphysics of Quality”.

Quality, it turns out, is very hard to define. Software Quality is no different. When someone talks about software quality, what do they really mean? How do we measure it? How can we improve it? How do we know when we have it? We have no shortage of incomplete candidates for these definitions. But over the years I’ve been working to establish what I think are the most important aspects of software quality, how they work together (and sometimes against each other) and how we need all of them (even if they sometimes come as a set). In Pirsig’s semi-autobiographical novel, we are taken on a motorcycle journey from the east to west coasts of the USA. Our journey will take us through the territories of tests, types and static and dynamic static analysis - all with no mention of east or west const.

The foundation of C++ atomics: The knowledge you need to correctly use C++ atomics

This talk covers all the knowledge you need about atomics to give you a good understanding of how they work under the hood and make sure your code is correct.

C++11 introduced std::atomic template class which supports six memory orderings, writing correct concurrent programs which use the atomic classes can be challenging. It requires understanding the complexity of how std::atomic works under the hood. The goal of this talk is to encourage programmers to use the atomic classes when appropriate and give them the knowledge to do so correctly.

This talk will help you confidently use atomics correctly by bringing knowledge of some of the main components that make parallelism possible in modern computer systems, the relationship between these components, and the individual contribution of each of these components in making atomic difficult to use correctly.

This talk will be aimed at programmers who are new to std::atomic as well as those who have been using these classes. I will show some aspects of atomics which may not be commonly known.

Topics Covered:

• A brief overview of atomics in C++.
• Multi-core processors.
• Operating system context switching.
• Memory Barriers.
• Memory Consistency and Cache Coherence.
• Static & Dynamic Instruction Scheduling.
• The C++ memory model
• Optimizations Allowed by the memory model.
• The Cost of Sequentially Consistent Atomics.
• Semantics of Data Races.
• Compiler and Hardware introduced Data Races.
• The compiler and hardware cooperation to respect the memory model.
• The relationships and tradeoffs among atomics and fences/barriers.
• How atomic map to their expected machine-instruction implementations on x86 architecture.

Cross-Platform Development with CMake

CMake is an open source, cross-platform, build system generator which supports portable C++ development. CMake has been downloaded over 9M times and is becoming the standard for building C++ applications. In this talk we'll present the main features of CMake and how it can help you write a better and more maintainable build system. We will also tackle how CMake can help with package management as well as testing infrastructure.

If you are already familiar with CMake, this talk will present new features we are implementing in CMake and how it can be useful for your every day development.

Constructors and destructors: A few things you might want to know

It seems that in C++ there is nothing easier than constructor and destructor. But some interesting things can make your life better if you keep them in mind when you write code.

In this talk we will discuss some of the tricks and pitfalls in coding, as well as broader topics, such as type design.

For example, what's the difference between a privately declared and a deleted constructor? (Spoiler: none.)

We will also discuss:

• 0/3/5 rules;
• constexpr constructors;
• explicit constructors and strong typing;
• copy/move and equivalence;
• destructors are now noexcept by default (and when destructors can still throw exceptions);
• virtual destructors and polymorphism;

and few other things.

Just Enough Assembly for Compiler Explorer

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-64 Assembly and the System V AMD64 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/.)

Performance is not (only) about micro-optimizations!

One of the main reasons people chose C++ is because it lets you write performant applications. It is used in time-critical software, games, finance, embedded platforms, which all need performance.

But what exactly are we talking about when we ask for performance? In this talk we will try to answer this question and show you that micro-optimizations and hardware knowledge are not the only way to make big savings.Before diving into the basics of optimization, we will talk about the common pitfalls in performance analysis and measurement.

You will be provided with tools and methods so that you can start squeezing performance out of your applications.

Safer multithreading programming with C++

Threads are commonly used nowadays. Programmers slowly moved from fear of multithreading to overuse of it. Sadly, even with modern tools and frameworks, implementations of multithreaded applications are commonly bearing a log of data races and deadlocks that make debugging a nightmare. This presentation is about how to detect, correct and write correct multithreading code, using modern features of C++.

Why you should move your legacy code to smart pointers.

When working on legacy code, one often face the tricky question "when to move legacy code to modern features of C++". Changing "working" production to use smart pointer is usually seen as risky and have low return over investment.

This talk aims to explain why the right moment to move you legacy code to smart pointers is now.

Target audience are people trapped in legacy code and looking got methods and example to convince themselves and co-workers to move to smart-pointers.

The Performance Price of Virtual Functions

Virtual function mechanism is one of the core concepts of C++, however, it does come with a performance price. But how high is that price?

In this talk we are going to dissect virtual functions to understand when they are slow and why they are slow. We will investigate how well virtual functions use the CPU's underlying resources and how good is the compiler at optimizing virtual functions. We will also present several techniques to help you speed up your program using virtual functions.

Correctly Calculating min, max, and More

The C++ standard library long ago selected operator ＜ as its ordering primitive, and even spells it in several different ways (e.g., std::less). This talk will explain why operator ＜ (and its aliases) must be used with care, in even such seemingly simple algorithms as max and min.

We will also discuss the use of operator ＜ in several other order-related algorithms, showing how easy it is to make mistakes when using the operator ＜ primitive directly, no matter how it’s spelled.

(Of course, we will also present a straightforward technique to avoid such mistakes.)

Live-Testing bugs in legacy code with test data builders and the mikado method

"Remember to add tests before you fix any bugs!" That’s very nice in theory, but a lot more tricky in practice.

We know we need to add tests, but it’s more easily said than done. In legacy codebases, just setting up the objects for the test is most often an unjustifiable nightmarish 2 weeks work. Mocks are a common workaround, but mocking legacy codebases usually makes them more difficult to change, not less!

In this live coding presentation, we will combine the mikado method with test data builders to build a baby-step plan to add the first test to a legacy codebase. We'll draw a graph of nested test data builders so that we can instantiate test data, without mocks.

In more details:

• Test Data Builders simplify and factorize test data initialization
• The Mikado Method is a technique to split a large refactoring in a graph of baby-steps
• These baby steps remain deployable at any time and don’t block other development
• When we combine these 2 techniques together, we get an incremental plan to create test data builders
• At every step, test data is easier to initialize, the overall testability improves, helping everyone to add more tests
• Driven by usage, critical code parts naturally get testable first
• By making reuse and extend the easiest option, these techniques are viral, and snowball
• Relying on a visual mikado graph, these techniques are collaborative by design

Back at work, you'll be able to practice this session yourself with the open-source kata. After that, you should be able to inject these contagious testing techniques into your team!

In depth Mikado Method: open discussion

Come discuss about the Mikado Method with Philippe from Murex.

Sandbox Games: Using WebAssembly and C++ to make a simple game

WebAssembly is an interesting environment, especially for C++ programmers. With tools like Emscripten becoming better and better and game development libraries starting to add support for WebAssembly it is worth taking a look into this world.

We will go over what WebAssembly is, how a development environment might look like and then make a simple game that will run in the browser using C++. While making the game we will hit a few hurdles that are unique to WebAssembly and see how they can be overcome.

After this talk, you should have a good overview of WebAssembly and it can be used. This talk targets intermediate to advanced C++ programmers and no experience of game development is required.

ctbench: compile time benchmarking for Clang

As C++ metaprogramming paradigm grows richer revision after revision, C++ metaprograms get more complex, more powerful, and therefore compile times increase over time. Common knowledge about the impact of metaprogramming mechanisms like SFINAE, concepts, or if constexpr on compile times are now parts of the C++ culture, but actual analysis of their behavior remains few and far between.

Compile time analysis should become as trivial as runtime analysis.

ctbench was made with that purpose in mind and proposes a way of gathering, analysing, and comparing granular compile time data using Clang's time-trace feature. It provides a C++/CMake developer-friendly API to declare parametric compile-time benchmarks and comparisons through flexible plotting backends.

Our Adventure building a massively scalable C++ remote compiler cloud

Our journey implementing a massively scalable web application for tipi.build, in a mixed environment with many cloud vendors, REST APIs and multi-cloud capabilities.

C++ web frameworks, REST server autogeneration, template metaprogramming and the learnings of building and running a rock solid cloud application with C++ and containers swarms.

Undo hands on workshop

Join this hands-on workshop to learn how to do travel time debugging and understand code you're not familiar with.