Center Keynote
Speaker: Frances Buontempo
Audience level: [Beginner | Intermediate | Advanced]
TBA
Closing Keynote
Speaker: James McNellis
Audience level: [Beginner | Intermediate | Advanced]
TBA
From Introductory to Advanced C++ - Learning Guidelines
Speaker: Slobodan Dmitrovic
Audience level: [Beginner | Intermediate | Advanced]
From Introductory to Advanced C++ - Learning Guidelines
Instruction Level Parallelism and Software Performance
Speaker: Ivica Bogosavljevic
Audience level: [Intermediate | Advanced]
Instruction Level Parallelism (ILP) is the magic ingredient of a modern CPU that makes it run fast. But not all programs are equal, some have more ILP, others have less. In this talk we are going to investigate our codes from the viewpoint of ILP: which code has more ILP, which has less ILP, how does ILP affect software performance and what techniques we can use to speed up our software.
100 BC
Speaker: Marc Mutz
Audience level: [Beginner | Intermediate | Advanced]
This talk is about BC (Binary Compatibility) in C++ user libraries.
What does BC mean? What's the difference between BC and SC (Source Compatibility)? Why would one want to maintain BC? What is forward and backwards BC? And, most importantly, what are the things you suddenly cannot do anymore when you're under BC constraints?
After setting these corner stones, we will discuss patterns that help maintain BC and that have evolved over the last decades in the KDE and Qt projects.
Finally, after talking about the things you cannot do, we'll cheat and do some of them nonetheless.
Building Bridges: C++ Interop., Foreign Function Interfaces & ABI
Speaker: Gareth Williamson
Audience level: [Intermediate | Advanced]
Modern software development is a cross-language undertaking. Large projects increasingly mix-and-match to choose the right language for each part of the job. C++ remains the right tool in many cases and decades worth of existing code is written in it.
The Misra C++:2023 Guidelines
Speaker: Richard Kaiser
Audience level: [Beginner | Intermediate]
The Misra Guidelines define a subset of C++ in which the opportunity to make mistakes is removed or reduced.
Persistence squared: persisting persistent data structures
Speaker: Juan Pedro Bolívar Puente
Audience level: [Beginner | Intermediate | Advanced]
Persistent data structures are used to implement immutable containers, so that they are manipulated by producing new values, leaving the old ones intact. To do so efficiently, these new values do not contain a copy of the whole structure. Instead only the changed parts are created new, and the rest of the structure is shared internally between old and new values. We call this structural sharing , and is crucial feature to implement immutable data structures efficiently. It opens the door to radically simpler software architectures, specially for interactive applications or highly concurrent systems.
However, structural sharing is traditionally preserved in memory only. When serializing multiple values to disk, these are linearized—for example, by writing out sequences as JSON arrays—losing whatever sharing may exist between these values. A similar thing happens when transforming data structures (as with std::transform or a functional map() )
Here we present the new library immer::persist , that enables the serialization of pools of containers while preserving structural sharing. With it, we can also do in-memory transformation over large sets of data that considers and preserves structural sharing. This is novel technique, not present in any other implementation of persistent data structures. We will show when and how to use it, how it is implemented, and include some practical examples from our Digital Audio Workstation at BRONZE.
C++23 Tools You Would Actually Use
Speaker: Alex Dathskovsky
Audience level: [Intermediate]
Last year, we explored why C++20 is not just a “future standard,” but a powerful and practical tool you should already be using. If you haven’t adopted it yet, now’s the time.
Trees in C++
Speaker: Jens Weller
Audience level: [Beginner | Intermediate]
In recent weeks I've been thinking about various things in C++, one thing they have in common is data structures like trees. Which also let me down the rabbit hole of searching the web about trees in C++. So lets have a bit of fun and talk about trees in C++.
Type Traits without Compiler Intrinsics – The Promise of Static Reflection
Speaker: Andrei Zissu
Audience level: [Beginner | Intermediate]
Type traits are a powerful feature of C++ that allows programmers to query and manipulate the properties of types at compile time. They are widely used in generic programming and metaprogramming to enable static polymorphism, type-based dispatching, and compile-time optimization.
CMake for the Impatient
Speaker: Steve Love
Audience level: [Beginner | Intermediate]
CMake has emerged as a leading tool for managing C++ projects. Although it's not particularly new,
there's a perception that it's complicated, arcane, or just unfamiliar. As an experienced programmer
returning to C++ after an extended absence, I certainly found CMake unfamiliar, but a little
research showed me that it's not as hard as it looks. I also discovered that it's flexible and
powerful too. In this talk I want to share some of that experience and hope that you'll embrace
CMake.