Compile Time Regular Expressions with Deterministic Finite Automaton

Speaker: Hana Dusíková

Audience level: Advanced

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 independently sums up the work since my previous CppCon talk about the library. The primary topic 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.

...

Multithreading 101: Concurrency Primitives From Scratch

Speaker: Arvid Gerstmann

Audience level: Beginner | Intermediate | Advanced

With Moore’s law declared dead, multi-threading is becoming even more important. To extract the last bit of performance out of recent CPUs, developers need full and thorough understanding of the used concurrency primitives. In this talk, I’ll explain and build the most used threading primitives from scratch. 

The Dawn of a New Error

Speaker: Phil Nash

Audience level: Beginner | Intermediate | Advanced

As a community we've tried many different ways to express, propagate and handle error conditions in our code over the years. Each seem to have different trade-offs, with none being perfect in all cases.

Lambdas - the old, the new and the tricky

Speaker: Dawid Zalewski

Audience level: Beginner | Intermediate

Lambda expressions have been in the language since C++11. Over the years they evolved, gaining the hidden generic powers in C++14 or having some details, like the ability to capture a copy of the enclosing object, polished in C++17. C++20 brings a handful of additions to their extensive feature set, including explicit lambda templates with concepts, default-constructible stateless lambdas or the ability to use lambdas in unevaluated context (e.g. template parameter). Those changes not only simplify the use of lambda expressions but also open doors to applications that were not possible before.
In this talk, I will briefly go through the evolution of closures, describing the limitations of the previous specifications and covering the main caveats and traps that await(ed) their users. I will move onto the new features of lambda's in C++20, discussing how they remove those limitations and what new usage scenarios they enable. The talk will conclude with the outlook on what's still not possible with lambda's and how this might change in the future.

...

Clang based refactoring, or how to refactor millions of line of code without alienating your colleagues

Speaker: Fred Tingaud

Audience level: Beginner | Intermediate | Advanced

At first look, Clang-Tidy looks like a convenient static analysis tool. But it is actually the emerged part of an incredible iceberg that can change the way software developers work on big projects.
Using the extension API provided by clang tooling, you can design custom tools that will allow you to get rid of bad patterns or API mistakes in your code that were historically considered "too deep-rooted to fix". Through concrete examples we will see what these custom tools can do and how this could impact your everyday job as software maintainers.
But wielding such powerful tools can be hard! And working on big projects also means you are likely working in an ecosystem with a lot of other developers. What happens when each time these colleagues try to sync their repository they find out one of your refactorings completely changed the API they were calling in their local work? We will see the difficulties and pitfalls one can encounter when developing and using clang based refactoring tools and how to avoid or reduce them.

...

Concepts in C++20: A Evolution or a Revolution

Speaker: Rainer Grimm

Audience level: Beginner | Intermediate

The key idea of generic programming with templates is it to define functions and classes which
can be used with various types. Often it happens that you instantiate a template with the wrong
type. The result is typically a few pages of cryptic error messages. This sad story ends with
concepts. Concepts empower you to write requirements for your templates which can be
checked by the compiler. Concepts revolutionise the way, we think about and write generic
code. Here is why:

  • Requirements...

Teaching Analytic Geometry to C++

Speaker: Guy Davidson

Audience level: Beginner | Intermediate | Advanced

With the linear algebra proposal working its way through the committee, the co-authors are considering the first succession paper: adding analytic geometry to the standard library.

Asynchronous C++ programming

Speaker: Pavel Novikov

Audience level: Intermediate

Since C++11, the standard includes primitives for asynchronous tasks. Pavel will tell about capabilities that the standard library offers now and that are slated to be added in the future. He will also tell about concurrency::task from PPL as an illustration for possible implementation. He will also cover how using coroutines can make writing and understanding of code much easier (as Gor Nishanov describes it in his proposal, which was voted in C++20) with reference to aforementioned primitives.

...

Phantastic Code Smells And How To Find Them

Speaker: Arne Mertz

Audience level: Beginner | Intermediate

Code smells are subtle or not so subtle hints that there may be problems within our code. Some code smells are universal and independent of the language we use, others are C++ specific. Usually, a code smell represents violations of basic design principles or negligence of idioms and patterns that would make the code easier to grasp and maintain.

Debugging data corruptions in C++

Speaker: Mateusz Nowak

Audience level: Beginner | Intermediate

C++ is very powerful language allowing to efficiently access and process data. This comes at cost of missing built-in checks that may protect against data access errors, but would add extra overhead, thus requires programmer to be extra careful. Eventually, every software need to be verified against data access errors, and, sometimes, such errors need to be debugged.

Combining C++17 Features in Practice

Speaker: Nicolai Josuttis

Audience level: Beginner | Intermediate | Advanced

C++17 is a remarkable collection of many features both in the core language and the library.
But the real power comes by using them together. And after 2 years of experience, we know enough to give good examples and advice.

10 Techniques to Understand Existing Code

Speaker: Jonathan Boccara

Audience level: Beginner | Intermediate | Advanced

One of the reasons why a lot of us work in C++ is because there is a huge amount of existing projects written in C++.

C++20: The small things

Speaker: Timur Doumler

Audience level: Intermediate | Advanced

C++20 comes with some big new language features: modules, coroutines, concepts, spaceship, and many new libraries. But apart from all those, C++20 also offers many small language improvements, making C++ more powerful and expressive, but also safer and more consistent.

Value Propositon: Allocator-Aware Software

Speaker: John Lakos

Audience level: Intermediate | Advanced

The performance benefits of supplying local allocators are well-known and substantial [Lakos, CppCon’17]. Still, the real-world costs associated with orchestrating the integration of allocators throughout a code base, including training, supporting tools, enlarged interfaces (and contracts), and a heightened potential for inadvertent misuse cannot be ignored. Despite substantial upfront costs, when one considers collateral benefits for clients – such as rapid prototyping of alternative allocation strategies – the case for investing in a fully allocator-aware (AA) software infrastructure (SI) becomes even more compelling. Yet there remain many “concerns” based on hearsay or specious conjecture that is either overstated or incorrect.

In...

Oh No! More Modern CMake

Speaker: Deniz Bahadir

Audience level: Beginner | Intermediate | Advanced

By now the term "Modern CMake" should not be anything completely new to a C++ developer. Several sources about what Modern CMake is can be found on the Internet and the Meeting C++ conference itself had some pretty good talks about this topic in former years.

Partner Sponsors

Gold Sponsors

Silver Sponsors

Online Sponsor

Community Sponsor