CppNorth 2024

C++17 and higher offer enough grammatical tools to support meta compilation.

A meta compiler is a paradigm of self similarity where at compile time one can lex, parse, and translate domain specific languages (embedded in string literals) to meta assembly code analogous to object code. This meta assembly can further be passed to a general purpose compile time engine creating constexpr functions for use at either compile time or run time.

This talk will demonstrate how this is possible, as well as the benefits in doing so.

Join us as we explore pivotal milestones in computer science, spotlighting visionary scientists and engineers whose work resonates in today's software landscape. From architecture to programming languages, GUI, web, and AI, we'll bridge historical breakthroughs to their enduring impact on modern software engineering. As we dive into Alan Turing's AI contributions, David Parnas's modular design principles, Grace Hopper's revolutionary compiler, Nasir Ahmed's image compression algorithm and more, we discuss how algorithms from the past continue to influence contemporary software practices and demonstrate how theoretical concepts from earlier eras manifest in today's complex distributed systems.

This talk transcends timelines, connecting past innovations to contemporary impacts. In light of the influential discoveries, we highlight how they impact what we build today in more ways than we can count and how this knowledge can inform our decision making process in our day to day jobs as we work on products that transform the world as we know it.

Whether creating new features or fixing bugs, what does Done mean in Software Engineering terms and what is its effect on delivering change in the real world ?
Being "Done" can mean just checking code into a repository but primitive approaches to delivering change and marking it as complete can lead to unwieldy code bases that are difficult to manage and foment technical debt.

Being done should ask questions on the completeness of the changes. Has code quality/technical debt been addressed ? How does tactical fixes versus strategic direction achieve different versions of being finished. what about the vital task of decommissioning of old code, refactoring solutions as better thinking emerges ?

In this presentation, we will explore these topics and build up a Software Engineering Completeness pyramid for change delivery - analogous to the survival needs pyramid - and illustrate differing levels of being change complete with the bottom level equating to unsustainable hacking of a codebase up through tiered levels of engineering practice with the apex representing Excellence in Engineering.

The revelation that "doneness" - properly defined - and executed is a force that drives superior software engineering and strikes to the heart of achieving improved outcomes. This clarity of thinking on the real cost of software ownership promotes flexible software, happy consumers and allows for clean communication to others of when you are actually and finally DONE.

Gaussian splatting has taken over the world like a storm! My super curious programming side couldn't stand a chance against the opportunity to recreate realistic 3D scenes. It looked so easy!So I jumped on the train to learn a lot about this new visualization technique. Using the latest standards, I simplified an implementation until it didn't feel like C++ anymore. It feels like we've evolved so much since 'classes' that we should take a moment to realize how easy it has become to use that little silicon chip to get our dopamine hit!
Expect modules, ranges, coroutines, mdspan, a little bit of compile time, a tiny bit of OpenGL but most importantly a lot of fun!

Having a substantial team design, develop, and operationally-maintain a near-real-time browser for the financial markets requires certain disciplines to be adhered to across the system's C++, JavaScript, and rendering subsystems. This talk will highlight some of those techniques within the development cycle. We will go into detail about how they are used practically when programming, as well as in enabling the team to collaborate well.

Message reception and dispatch is something common to many codebases. And deep down, we know that Boolean algebra underlies everything we do. But we seldom give it a second thought, or if we do, we probably dismiss it as trivial; something we learned in college and quickly outgrew.

This talk shows the unreasonable effectiveness of going back to basics and really understanding and unlocking the power of Boolean algebra in the design of a message handling library. We'll talk about separating message layout and semantics, how to match against messages for dispatch, and particularly how to compose and simplify constraints at compile time, in order to do the least at runtime. We'll also introduce Boolean implication and see a non-obvious application which is key to a generic approach. Finally we'll see how message matchers can be generically transformed using compile-time information, allowing complete flexibility of expression and maximum runtime performance.

Everybody wants to write safe, efficient, bug-free code, but C++ doesn't always make it easy!
In this talk, we'll look at some common safety problems that can occur in everyday C++ code and offer practical advice and suggestions for detecting and avoiding them.
While C++ isn't going to become "a safe language" any time soon, we can certainly make it safer for everyday use -- without harming performance. For practical, take-away tips on how you can do so, please join us in this talk!

Ever found a codebase full of function pointers and thought, there must be a better way? You found that better way, introduced std::function and now have a horrific performance regression? Performance problems are perfectly normal, and std::function_ref is here to help.std::function_ref is a vocabulary type that does not throw, does not allocate, improves compile-times and reduces memory footprint, all with a single abstraction.
In this session, we will go through how C++26’s std::function_ref provides these benefits, what it is and when you should use it.

C++ Named Modules are not about build optimization, although that was an important design consideration. Modules are about controlling visibility and access to names and definitions at a fine-grained level.

This talk will show how to use the various features of modules and the kinds of module units to provide access to the features of your library while hiding the details you don't want clients to depend on. The talk will also cover some of the limitations and how clients may still end up depending on your details in ways that constrain your ability to maintain ABI compatibility.

Optimization is often considered a second pass in software development, where initially it is tempting to write your business logic out and later think about optimizing it. It has its pros and cons, but the aim of this talk is to provide you with the knowledge that will let you write optimized and fast C++ code as you go, rather than in a second pass. At worst, your optimization passes would become shorter. At best, you would be able to write out fast code in the first go, improving your ability to write efficient systems.

The talk will cover various fundamental principles and concepts useful to form a mental model of how long any given computation or operation may take, and what factors you can think of to make trade-offs while writing code. We will cover this through code examples, microbenchmarks, and looking at assembly code in godbolt. We will also discuss some principles to guide your thought process as you design your systems in an efficiency-first manner, with code examples.

After this talk, attendees would be able to intuitively guess what is a reasonable amount of time for a certain operation from a theoretical perspective. Is 10ms a reasonable time for my web server to respond with a HELLO message? Is 100us enough to compute a machine learning model's output?

This talk is about type erasure in C++ (I have to be specific because the term has a completely different meaning in other languages). The aim of this talk is to explain how type erasure works, and do it in a very simple and clear way.
Type erasure is probably the closest C++ comes to “and then magic happens.” It’s a technique used to write a program (in a strictly typed language, no less) that doesn’t mention the types it works with. It is the pinnacle of abstraction in C++, and, like most abstractions, it’s much easier to show what that looks like than to define it: most concise definitions of type erasure are circular. So we will begin the talk by demonstrating what the code looks like after the magic happens.
Then comes the biggest letdown of all time: I’ll show the basic technique that type erasure relies on. It’s very simple, it’s very familiar, it predates C++, and every implementation of type erasure uses it.
After that, we learn three basic ways to implement type erasure. There are several great type erasure libraries out there, you should use them if you just want to get stuff done. I’m going to strip them down to the bare minimum to show the essence of each implementation as clearly as possible. Along the way, we will learn how vtables are implemented.
Finally, we will measure and compare the performance of the different implementations of type erasure. Type erasure is easy to implement; fast type erasure is not really any harder to implement, but it relies on some subtle details I’m going to demonstrate (including how to make std::function 50% faster).
Whether you want to write your own implementation or use an existing library, by the end of this talk the type erasure will no longer be shrouded in a mystic aura for you.

In the realm of C++ development, threading and memory management play a crucial role in crafting highly parallel and optimized programs. However, the absence of a memory model in C++98 posed challenges. Thankfully, with the advent of C++11, significant changes were introduced, including the introduction of a memory model, which brought forth a plethora of new and exciting tools for developers to leverage. This talk aims to delve into the realm of the C++ memory model, showcasing the arsenal of tools at our disposal. Attendees will gain insights into how CPUs and compilers optimize code and understand the criticality of adhering to the memory model correctly. Practical guidelines on utilizing these tools effectively will also be explored. Throughout the talk, we will illustrate practical examples and share best practices for utilizing the diverse set of tools now available to us. From atomic operations to memory barriers, we will explore the range of techniques that allow us to develop robust and thread-safe code.
This talk will also illustrate the newer tools from newer C++ standards like JThread and so this talk will show how memory model is used and how it advanced since C++11