CppNorth, The Canadian C++ Conference 2025

TBA

Get ready for a crazy fun & informative talk! Boost your C++ code's performance by utilizing the full power of your computer’s built-in cache. In this talk, we'll delve into the basics of caches, spatial and temporal cache locality, and practical techniques for optimizing cache access. We'll also explore cache prefetching, branch prediction, and false sharing, providing examples modelled on real-world production code and performance benchmarks to drive home each point. By the end of this talk, you'll be equipped with the knowledge and tools to better optimize your code for cross-platform performance gains.

This talk explores five widely taught C++ coding guidelines and the subtle but profound way that the special member functions interact with class invariants, all with the ultimate goal of learning how to write better code.

A pipeline is a chain of processing elements such as functions, threads etc., arranged so that the output of each element is the input of the next. We often encounter this pattern in practice. C++ also allows us to write in this way, e.g. using the `std::ranges` library with its characteristic overloaded pipe `operator |`. But modern C++ enables much more and this will be discussed in this talk. First, we'll show how to implement a custom pipeline framework that employs `std::expected`, available since C++23. Secondly, we will show pipelines in the serial version, where the functions communicate the results of their calculations, as well as in the parallel version, in which at least one thread operates on each link. In the last case we will need synchronized queues – and here we will also show how `std::expected` can be used again to create a flexible interface. Everyone is welcome!

In today’s fast-paced tech landscape, innovation thrives where diversity and creativity intersect. This talk explores the unique synergy between code and culture, revealing how diverse perspectives amplify problem-solving, foster creativity, and drive groundbreaking advancements. We'll dive into real-world examples and research that demonstrate how inclusive teams leverage varied experiences, viewpoints, and skills to craft solutions that resonate globally. Attendees will gain insights into how cultivating a culture of diversity not only enhances team dynamics but also fuels sustainable & impactful innovation. Join me to uncover how diversity in tech isn’t just a value—it’s a vital component of building the future.

Dynamic memory allocations are ever-present in most programs. A simple look at the RAM usage of the browser you are currently using to read this abstract will likely tell you something.
But what of the runtime performance cost? How much (or little) should you be concerned about it and keep it in mind while implementing new features or designing software?

In this talk, we will present a set of about 10 guidelines to keep in mind when dealing with dynamic memory allocation and mitigate its potential performance impact on execution speed. From quite simple to somewhat advanced, everyone should be able to walk away from this talk having learnt something.

Recognizing objects in real-world situations, especially on mobile devices with limited resources or in areas with poor internet connectivity, can be a significant challenge. This talk presents a C++ application for real-time landmine detection, focusing on the Android deployment and its ability to perform on-device detection.

The application, built with the Qt framework written in C++, is designed for both offline (on-device) and online (cloud-connected) operation, balancing performance, accuracy, and connectivity constraints. The Android deployment utilizes the Qt JNI (Java Native Interface) to interact with an ONNX Runtime-based inference engine running in a Java environment, as well as accessing native Android APIs for tasks requiring on-device processing, such as file I/O, thumbnail generation, and network connectivity checks. We will discuss the challenges and solutions involved, including data marshalling between C++ and Java (image format conversion and bounding box result processing), and accessing native Android functionalities from C++. The presentation will include simplified code examples that illustrate these critical integration points.

By the end of the talk, attendees will gain a practical understanding of how to communicate between C++ and Java using JNI, integrate pre-trained deep learning models into their C++ applications, evaluate the trade-offs between on-device and cloud-based processing, and address performance considerations for real-time object detection on Android.

C++ is a powerful language, but with great power comes… plenty of pitfalls. Memory management quirks (even when using smart pointers), subtle undefined behaviors, and bug-prone code can silently introduce dangerous behaviors—only to surface at the worst possible moment in production. While static code analysis can catch some of these issues, it requires proper usage and adherence to warnings, and even then, it won’t catch everything. Many of these traps can lead to hard-to-debug issues, safety problems, and security vulnerabilities.
In this talk, we’ll explore some of the most notorious C++ pitfalls and sharp edges, discussing strategies to avoid them and write safer, more resilient code. We’ll walk through both design best practices and C++ coding guidelines to help you navigate the language’s trickier corners with confidence.

Many individual contributors professionals are choosing to create their careers off-road. Instead of climbing the standard career ladder to and through management, they are choosing to navigate tech careers one project and one team at a time. Such professionals often show their leadership without titles, relying instead on creativity, curiosity, and empathy toward their colleagues.

This panel featuring a group of four engineers who have mapped out their careers as individual contributors is designed as a conversation with our audience, a way to encourage others to understand what is possible. Each panelist has learned to stretch beyond assignments while sharing the day-to-day load on their teams. The panel will also include a manager who leads by trusting his people and providing structure when it is requested. One of the panelists spent some hours interviewing other managers, so they can speak with authority about how they balance a team with strongly self-led individuals.

We believe this discussion can help both managers and individual contributors find balance between team needs and individual growth; to navigate the cultures within their organizations; and understand the value that is derived from professional freedom with intent.

While we all work together now, each of us has worked at other companies and in other circumstances where we thrived mainly because we were able to balance autonomy with a deep sense of collaboration and adventure.