<< Previous

Taming lambdas' uniqueness

Speaker: Dawid Zalewski

Audience level: [ Intermediate | Advanced ]

There's nothing more different than two lambda expressions. Not even [](){} is the same as [](){}, at least not from the compiler's point of view. By the rules of the C++ language, each lambda results in a unique type. This leads to problems, and not of the trivial kind. Making a couple of lambdas of the same type but with different capture values? Nope. Writing a function that takes lambdas with identical signatures as an argument? Not easy. Storing merely two lambdas in a vector? Impossible. And doing any of this while maintaining readability and efficiency? Better give it up already.


What I learned From Sockets

Speaker: Filipp Gelman

Audience level: [ Intermediate ]

This talk will discuss how socket concepts like select or poll can be used when composing all kinds of concurrent operations in C++.

Typical C++, But Why?

Speaker: Björn Fahller

Audience level: [ Beginner ]

The C++ type system is both very weak and very strong. In this presentation I will show you how using the strengths of the type system makes your code better. I will show you how types...

Variable Monitoring with Declarative Interfaces

Speaker: Nikolaj Fogh

Audience level: [ Beginner | Intermediate ]

In control software for industrial systems, many signals need to be monitored to ensure they satisfy certain conditions. When these signals number in the hundreds, ad-hoc solutions do not scale. Object-oriented solutions based on inheritance also tend to fall short. How do we create a framework that is intuitive and yet extensible to support the various monitoring tasks needed for different signals?
In the talk, I will show an example of a signal monitoring framework using a declarative API. Using a builder-pattern, monitoring can be set up using an almost natural language syntax, making it easy to read what is being monitored.


TDD for Microcontrollers: A practical test-first approach

Speaker: Daniel Penning

Audience level: [ Beginner | Intermediate | Advanced ]

With test-driven development, you first write a test and only then begin with the implementation.
Studies show that this approach reduces both the development time and the error rate.

Expressive Compile Time Parsers

Speaker: Alon Wolf

Audience level: [ Intermediate | Advanced ]

Modern C++ has many language features and that can be leveraged to design an expressive API or a domain-specific language. However, these features are limited by the syntax rules of C++. To overcome this limitation, we will discuss the use of compile-time parsers to write more expressive code with zero overhead.

Back 2 Basics - Tooling Intuition

Speaker: Kevin Carpenter

Audience level: [ Beginner ]

Over the years the tools we use to develop have improved significantly. It used to be the compiler that could barely tell us we were missing a semicolon, now it will tell us the exact location. The results from compilers have improved but are we doing all we can with them? Do you always understand what they are saying?

Applied Modern C++: the problem of messages versioning in API

Speaker: Olivia Quinet

Audience level: [ Beginner ]

When dealing with versioned exchanged API messages, it is often useful to upgrade/downgrade the version to answer the requests, e.g. the client is communicating with version 1.1 and the server is using version 1.2.1 internally. 

This talk presents an elegant solution in Modern C++ for this use case

Hazard Pointers and RCU in C++26

Speaker: Marek Krajewski

Audience level: [ Beginner | Intermediate ]

We all are being constantly warned that multithreading is HARD and that we need more high-level concepts for structured concurrency. Nonetheless most of us is still using basic tools of the trade - threads and locks, which are notoriously hard to be used correctly.

Optimizing Multithreaded Performance: Unveiling False Sharing and Harnessing Hardware Destructive Interference

Speaker: Shivam Kunwar

Audience level: [ Intermediate ]

In this session, we will explore the crucial aspects of multithreaded performance optimization - false sharing and hardware destructive interference. False sharing can significantly impact performance by causing unnecessary cache invalidations, while hardware destructive interference provides a solution by guiding optimal data structure alignment for improved cache efficiency. Join us to understand the causes and consequences of false sharing and delve into the concept of hardware destructive interference. Through real-world examples and performance benchmarks, you will learn practical strategies to mitigate false sharing and leverage hardware destructive interference to unlock maximum performance in your multithreaded applications.

Key Takeaways:

- Identify and mitigate false sharing issues that degrade multithreaded performance

- Understand the concept of hardware destructive interference and its impact on cache efficiency

- Learn techniques to align data structures based on hardware destructive interference for optimal performance in multithreaded applications

- Gain insights from real-world examples and performance benchmarks to apply the concepts effectively

This session is essential for software developers, system architects, and researchers seeking to maximize the performance of their multithreaded applications and overcome cache-related performance bottlenecks.

Rewiring your brain - with Test Driven Thinking

Speaker: Phil Nash

Audience level: [ Beginner | Intermediate ]

We all say we should write tests, or at least we should write more of them.

AI Assistants for C++ Develolpers

Speaker: Michael Price

Audience level: [ Beginner | Intermediate | Advanced ]

The rapid emergence of Artificial Intelligence (AI) assistants has been powered by advancements in large language models (LLMs). They have shocked many with their uncanny ability to “act human.” These tools are no longer sci-fi plot devices only found in books, television, movies, and video games. They are here, now, in the products you are likely to be using, both in your personal life and in your role as a software developer.

Performance matters: new tricks for old dogs

Speaker: Matt Bentley

Audience level: [ Beginner | Intermediate | Advanced ]

An overview of several new techniques, most of which are old ideas but with unique spins on them.

In-memory database with indices from scratch

Speaker: Hana Dusíková

Audience level: [ Beginner | Intermediate | Advanced ]

In this lecture I will show you how to use C++'s standard library to build a simple in-memory generic database with indices. The design of code is intended to be easy and extensible using C++ meta-programming and templates.

Playing Video Games One Frame at a Time

Speaker: Ólafur Waage

Audience level: [ Beginner | Intermediate ]

Video games are hard and as I age my reaction time has gone down. But I'm also a programmer and I can write tools that solve this for me.

Next >>