CppNorth 2024

We all get older every day. But when are you old? Do the natural changes of aging make it harder to be a good programmer? Do you have to stop or can you keep going? What can you do to make both aging and programming more pleasant for yourself? How can you help the older people you know, and set up systems that will help you when you need it? When it comes to ensuring a pleasant and long old age, it's not too late -- and it's also never too soon.

Building extensible software is a goal and a often a metric of good software design. It is becoming more and more common for users to also contribute to the development of the software that they use--especially in the domains of computer graphics and gaming. Terms like 'modding' software have been around since at least the early 90s when the popular game Doom allowed for users to create their own content and modify the behavior of the program. Behind these programs there thus must be a mechanism for allowing users to 'hook' into the main program. In this talk, I will be showing several software developer kits including Autodesk Maya 3D (C++), Unity3D (C#), Unreal Engine (C++), and QT Modeler(C), and present a case study of how they are designed. At the end of the design discussion I will present how to get started building your own plugin system, and what considerations must be taken in mind (e.g. does the application or plugin manage resources, what should be exposed in the API, how do you embed a scripting language, and how should you distribute your plugins). Attendees will leave the presentation with practical knowledge on how to build software that can be extended by their user base.

We are all born with the innate ability to count and to learn languages. Sadly, the same cannot be said for programming. What's more, neither linguistic nor math prowess seem to translate into coding skills. Similarly, just because you are an expert in C++ concurrency doesn't mean you won't have a hard time deciphering a textbook Haskell program. So what is it that makes us adept at reading, writing and reasoning about code? Crucially, can the journey on the path to become a better programmer be facilitated?

In this talk we will try to answer this question by exploring the cognitive processes involved in reading, producing and reasoning about code. We will discuss the role of short- and long-term memory, and introduce terms such as cognitive load, beacons and chunks. Enriched with live experiments and illustrated with examples in C++, we will see how these concepts interplay with our programming abilities. Finally, we will discuss how we can use this knowledge to write better code, grow as programmers, facilitate collaboration between developers of different levels, or improve the onboarding of new team members.

Static initialization is utilized to ensure that values are constructed before main(), making them available for use immediately and allowing important prerequisites to be established. However, the initialization of these values is more complex than it first appears. Statically linked or dynamically loaded libraries also need their own dependencies, global variables, and lifetime management making the picture more complex when we use other people’s code this way.

In this session, we will explore how applications and libraries handle initialization and discuss methods for building safe initialization mechanisms in our libraries. Whether you develop and distribute code as a library or SDK, or you are simply curious about how application initialization happens, this session is for you.

See how I meandered through writing a version of *ranges::to* because I was impatient for the GCC 14 version. It had to be easy, right? After all, it is just copying pipeline elements to a container. Ha! Ha! No.

This trek encounters *concepts*, *if constexpr*, and containers that are copyable and others that are not. Eventually, an encounter with a **** approach, which I can only reveal during the talk, solved the copy problem for most containers. But then there are sets and queues. Finally, wrangling with `range_adaptor_closure` to work as the pipeline's endpoint was, well, interesting.

Why is ranges::to important? It is easier to use than other methods of invoking pipelines.

The talk is code intensive to illustrate all the steps to demonstrate the development process and the solution.

Good code must be both testable by its developers and usable in application test drivers and integration tests. We will explore and recommend approaches for designing APIs that result in both easily testable code and convenient interfaces for test drivers and integration tests. We will discuss specific techniques, simplified versions of examples from popular libraries such as BDE, and how to write generalized mocks.

Lightning Talks

C++ is a language of many features and new keep being added over time. Rarely does any individual addition have a significant impact on how we write code, but when put together they can enable game-changing expressiveness. In this session we look at how the wombo combo of variadic templates, class template argument deduction (CTAD), and non-type template parameters (NTTP) enables writing code in a declarative manner never seen before, the practicality of which is shown on a real world problem from the domain of thermodynamic simulation.

Keynote: Eric Wastl
Title & Abstract: To be Announced (soon)

Learning a new programming language can be a heinous task, especially when faced with biases and myths surrounding the language. In this speech, we will discuss how to overcome biases and break down the barriers to learning a new programming language using technical terms and examples. In the context of programming languages, we will focus on the case of C++ and discuss its features and applications, as well as the perceived biases around the language. We will explore the benefits of using C++ and how it can be used to build high-performance applications and also relate our experiences in learning C++ from Africa that is geographically isolated from other developers and the challenges of mixing and matching of spoken languages. The speech will provide practical tips for learners seeking guidance from experienced programmers. We will also discuss the role of mindset and motivation in the learning process and provide strategies for developing a growth mindset. Attendees will leave this speech with a better understanding of the biases that can impede learning, and the steps they can take to overcome these biases and become successful learners of a C++ programming language. The speech is designed to inspire and encourage beginners to embrace the challenge of learning a C++ programming language and unlock their potential as programmers.

In this engaging talk, I will be discovering my journey into tech as a teenager, and share some advice for starting your career as a fellow teenager.

A key programming principle that encapsulates significant aspects of Object-Oriented Programming, is to hide your implementation details. This guidance aligns with principles such as encapsulation, decoupling, and programming for interfaces rather than concrete types.

Yet, keeping your implementation details hidden is no easy feat. In this talk, we'll discuss the challenges, highlight tricky situations, and share tips on how to steer clear of them.

Applying the practices presented in this talk, participants will be well-equipped to navigate potential pitfalls, foster best practices, and ultimately write C++ code that is more elegant, robust and maintainable.

Keynote: April Wensel
Title & Abstract: To be Announced (soon)

Lea is a researcher working on an autonomous ship project. She needs to write complex dynamical equations to model the ship movement, but she keeps making errors that cause bugs and jeopardize the project.

She decides to use template metaprogramming and constexpr to build a compile-time library that can catch these errors and simplify the equation writing.

In this talk, you will learn how Lea explores features of C++, such as strong types, metaprogramming and tuple algorithms, to create a library that can automatically map types to indices.

This mapping enables her to write nonlinear equation systems with meaningful names. It makes it even possible to build up libraries of individual systems that can be combined at compile-time.

You will also see how Lea faces the challenges of design and implementation in the realm of metaprogramming. Will she succeed in her quest? Will the ship sail safely? And will it be worth the effort? Come and find out.

Optimization remarks are logs of Clang's optimization passes, describing optimization attempts and failures - which might be mitigated. Sometimes. Deciphering them might seem a matter for compiler authors, but we can kick-start this effort together.
About 50% of the talk would be dedicated to practical examples of missed optimizations and mitigations - with emphasis on alias analysis and escape-analysis. We will also discuss other compilers and even other languages.

This sequel to Composition Intuition will be a masterclass about everything you wanted to know (and potentially what you didn't even know you wanted to know) when it comes to function composition and combinators. We will cover the different "composition strategies" used in languages like C++, Python, Haskell, APL, J, KAP, Jelly, Uiua, Clojure and more. Furthermore, we will in more detail cover the most common combinators and the patterns in which they are most useful.

Closing Keynote: Tony Van Eerd
Title & Abstract: To Be Announced (Soon)