Monday 10:00

C++ Concepts Workshop

Constraining C++ Templates in C++20 and Before - Old Vic

1-day workshop on C++ concepts

C++ Concepts is one of the most significant and long-awaited features of C++20. They improve template interfaces by explicitly stating the compile-time contract between the user and the architect of the code, which limits the number of compilation errors and makes them much more user-friendly when they occur. The workshop will describe this C++20 feature, its similarities, and differences to Concepts TS (provided with gcc-7), and will present ways to benefit from a significant part of the functionality in current production C++ projects that can use only "legacy" C++11 features.

Preconditions to take part in the workshop:
1. Recent working experience with C++ templates
2. A laptop with a web browser and access to the Internet

C++20 (and C++23) in Practice Day 1

All the cool stuff and how to deal with the traps - Empire

We knew that C++20 is huge. We introduced several new key features and library that will change the way we use C++ dramatically (maybe even more dramatically that C++11 did). Of course, not everything is self-explanatory and there are hidden traps.

Now, 3 years later, the big picture becomes clear and the consequences for programming become more and more mature. At the same time, C++20 is still changing by applying significant fixes against C++20 and standardizing supplementary changes with C++23.

Time to look carefully at C++20 (with an eye on C++23) to see how all the new features of C++20 (concepts, ranges, views, operator<=>, coroutines, modules, and compile-time computing support) should be used in practice. It is key to understand all the concepts and their consequences to benefit best.

This 2-day workshop goes through all the major new C++20 features (covering both language and library) and provides many examples, unique background information, and advice for the use of C++20 in practice. It will cover topics for for application programmers as well as for library developers. The focus is on how these features impact day-to-day programming, what effect combining f...

Tuesday 10:00

Resilient C++ - Mitigate C++ Vulnerabilities

Safer C++ through guidelines, idioms and libraries - Matthew

C++ programmers suffer from its super power of backward compatibility that manifests known deficiencies in language and standard library design, as well as C++'s complexity. Fortunately, there exist collections of C++ vulnerabilities with their mi...

Writing safe and secure code suffers from the language's vulnerabilities. Knowing C++ vulnerabilities and potential mitigations is a first step to write better code. Fortunately there exist guidelines and collections of potential programming pitfalls to draw from. Those might recommend to not use a language feature or use it in a specific way. While this might not absolutely be possible, each violation of such guidelines should be well thought of. Also using dedicated libraries help with sidestepping some problems, such as the woes of implicit conversions of built-int types.

The workshop will

  • provide a mental model for C++ type design and use

  • demonstrate libraries that help circumventing language pitfalls

  • give examples of C++ vulnerabilities with mitigation hints

  • highlight some MISRA-C++ guidelines applicable beyond the safety realm

  • show some idioms and coding guidelines making your code less vulnerable

  • indicate where to look for further learning, such as ISO WG23, MISRA-C++, CERT, and Core Guidelines

  • notes when to think about violating a guideline consciously and how to convince that you didn't open up...

Modern C++ Idioms

Old Vic

1-day long workshop on Modern C++ idioms covering subjects like RAII, copy-and-swap, Smart Pointer, type traits, tag dispatch, policy-based design, EBO, Type Erasure, SOO, Copy-on-write, CRTP, CPO, and more.

C++ is no longer C with classes, and it never was just an Object-Oriented language. C++ is a general-purpose programming language. It has imperative, object-oriented, and generic programming features while also providing facilities for low-level memory manipulation. If used correctly, it provides hard-to-beat performance. Such usage requires a good knowledge of C++ templates and Modern C++ Idioms, which are much different from commonly known design patterns popularized by the GoF book and invented to handle common use cases in pure OO languages like Java or C#.

What you will learn:
During the workshop, we will refresh and broaden our knowledge about C++ templates and will learn Modern C++ Idioms like Niebloid, CRTP, Type Erasure, EBO, and many more. Crafting those skills will allow us to build powerful tools that are useful in the everyday work of every C++ developer.

Experience required:
In order to be able to follow the workshop, you should be current with C++ and have some recent experience with writing simple C++ templates.

A laptop with a web browser and access to the Internet

Software Engineering in the D Programming Language

A Tour of DLang for your Competitive Advantage - Castle View

The following hands-on training provides a tour of the essential parts of the mature and multi-paradigm programming language D. In this workshop attendees will learn about the programming language paradigms supported in D, core idioms, and the ess...

Longer Description

Presented below is an outline of the following topics that will be covered.

  1. Course introduction - Introduction to instructor, learning objectives, and how to succeed.

    1. Resources on how to learn and strategies for retaining information will be implemented by attendees.

  2. D Tour - A quick tour of the language and the big ideas

    1. Core ideas of the D programming language (better defaults, multi-paradigms, opt-out memory safety)

    2. Core Language Features

      1. arrays/slices

      2. functions (and Uniform Function Call Syntax (UFCS)

      3. structs, classes and interfaces

      4. templates

      5. ranges

    3. Activity:

      1. Building

  3. DLang Batteries Included - Phobos Standard Library

    1. Data Structures and Containers

    2. Iterators/Ranges

    3. Algorithm

    4. Activity:

      1. Using D’s profiler

  4. DLang Object Oriented Programming - Project

    1. In this section we see DLang in action building a ray tracer

      1. Students will learn about...

Python as a Perfect Companion Language


In system software engineering it is often required to implement auxiliary software for various supporting tasks: processing logging and telemetry output, prototype future system components or manage complex integration tests. In all these tasks P...

In the areas of software engineering where Python is not a primary production programming language of choice, many tasks emerge requiring quick development of a supplementary software. Collecting and processing data from logs and metrics, prototyping or faking of not yet existent system parts or orchestrating large integration test execution - for tasks of that kind the power of the Python programming language and its module library can be of great aid.
The workshop targets an audience familiar with programming concepts but without prior Python experience and aims at providing a starting point to learn how to use the language for solving auxiliary tasks.
The class will cover the following topics:
• Basic syntax: built-in types, control structures, functions and basics of OOP
• Text and binary data processing
• Interaction with shell. Process management
• Interoperability with C and C++ code
• Python unit-testing environment. Application for the orchestration of the automated tests for the non-python applications.
• Introduction into concurrency and networking
Some advanced language features involved in modules, covered in the workshop, will be reviewed. Common practice...

Early Careers Day

A mini-conference for junior developers - Wallace

This is an all-day pre-conference tutorial. But unlike other tutorials, the Early Career Day is exclusively for software developers in their first years of work, whether as a placement student or a graduate level employee. In the company of others...

The day is chaired by Dr Gail Ollis, an ACCU conference regular who remembers what it was like to attend her first ACCU conference. After a long career in commercial software development Gail turned to academia and is now a lecturer and researcher in software development. Think of this session as a short course in honing your craft as a software developer, with an experienced lecturer as your course leader and the best presenters as your tutors.

The content will include a mix of personal and technical skills, including:

* Presentation Skills
* Software Processes and Architecture
* Coding practices
* Code review
* Testing
* Debugging
* Deployment

The day includes your very own lightning talk session so you can, if you choose, practice sharing your thoughts at a conference. You are warmly invited to take this great opportunity to practice with a small, friendly, supportive audience, but participation is absolutely voluntary.

C++20 (and C++23) in Practice Day 2

All the cool stuff and how to deal with the traps - Empire

We knew that C++20 is huge. We introduced several new key features and library that will change the way we use C++ dramatically (maybe even more dramatically that C++11 did). Of course, not everything is self-explanatory and there are hidden traps.

Now, 3 years later, the big picture becomes clear and the consequences for programming become more and more mature. At the same time, C++20 is still changing by applying significant fixes against C++20 and standardizing supplementary changes with C++23.

Time to look carefully at C++20 (with an eye on C++23) to see how all the new features of C++20 (concepts, ranges, views, operator<=>, coroutines, modules, and compile-time computing support) should be used in practice. It is key to understand all the concepts and their consequences to benefit best.

This 2-day workshop goes through all the major new C++20 features (covering both language and library) and provides many examples, unique background information, and advice for the use of C++20 in practice. It will cover topics for for application programmers as well as for library developers. The focus is on how these features impact day-to-day programming, what effect combining f...

Wednesday 09:00


Bristol II / Bristol Suites

Wednesday 11:00

B2B: Design Patterns

Some Use Cases and Examples (C++) - Bristol III

Join me on a tour of some of the more useful C++ Design Patterns that you will likely see and need to know. Knowing how to use Design Patterns will help your code's robustness and will enable others to better read your code and intent.

When designing and writing code you will see similar techniques and patterns repeatedly used throughout different systems and programs. An experienced developer saves these tried and true, well debugged techniques in their personal toolbox for later use.

Others have also noticed these patterns in designs. Some of the more useful techniques have been documented and organized in books like "Design Patterns" by the "Gang of Four" (aka "GoF") and "Code Complete" by Steve McConnell. As coding paradigms have changed new design patterns have evolved.

Other design patterns have worked their way into common use through usefulness. Techniques have been given names for quick reference and as a shorthand in the exchange of ideas. Think of Design Patterns as a mental standard library of building blocks for your designs.

Managing External API’s in Enterprise systems


Taking a real world application, it is shown how to properly encapsulate external APIs to protect the system and use modern idioms. How to manage changing requirements including decommissioning of old functionality in the real world. How abstracti...

Many codebases use external libraries and wrap their associated API's for application use. Once these external dependencies are entrenched and widely used in your system even small changes in the use of these external APIs can force sweeping changes across your codebase.
This presentation will take an example request API and demonstrate using sound engineering choices how to encapsulate it to provide a more efficient modern interface i.e. move-only results, futures/promise instead of callbacks, void pointers etc.
After showing the use of this API, new requirements will now emerge that require new source data from the API potentially causing large scale code changes with branching required for a gradual transition from the old data source to the new source is rolled out.
We will explore various techniques to preserve the global calling semantics and introduce localized decoupling so wide spread code changes are not needed. How abstractions can be a powerful absorber of change that limit the impact of changes on a production codebase. These codes changes are then transparent to the original callers of the API hence no calling code changes are needed. This approach will then be ...

Removing Needless Undefined Behavior for a Safer C++

Bristol II / Bristol Suites

The C++ standard defers to undefined behavior (UB) in a variety of situations, embracing the freedom for language implementers to achieve portability across the widest array of platforms. With UB, literally anything can happen, which is the proble...

Advanced C++20 Coroutines

Bristol I

There are a many excellent introductions to C++20 coroutines. However, beyond the introductory material, there are few examples of how to use C++20 coroutines in practice. This talk goes beyond the introductory material by providing practical exam...

This talk is suitable for users of all levels who are interested in C++20 coroutines (i.e. sufficient introductory material will be covered to make the talk standalone). The slides and example code will be made available on the author's GitHub page.

What is a random number and why should I care?

Randomly race your way out of a paper bag - SS Great Britain

How can a deterministic function possibly give random results? We will find out and learn how to use various random number distributions. We will also discover another way to code ourselves out of a paper bag in the process.

Most of us need a random number at some point if we write code. We will discover how they are generated. We will see how to ensure simulating a dice roll makes the numbers 1 to 6 equally likely, and note some pitfalls to be aware of in some programming languages.
We will have a brief aside into stochastic outcomes from deterministic models, also known as chaos. Applying a function iteratively can’t possibly give non-deterministic results, right? We shall see.
After this aside, we will return to using random numbers. We will consider more complicated situations, such as requiring numbers distributed around an average and how to generate with specific properties, such as being prime. To round off, we will think about how to test code using random numbers.
By the end we’ll be familiar with terms like pseudorandom number generator (PRNG), linear congruential generator and random distribution. Finally, we’ll use various distributions to race some blobs out of a paper bag. Seeing a visual demonstration will solidify some the learning outcomes.

Wednesday 14:00

C++ Standard Views

The design, the traps, how to use them, and how to use something better - Bristol II / Bristol Suites

C++20 introduced views, lightweight collections that refer or own collections like containers or other ranges. The design had to deal with several tradeoffs. As a result, the standard views come with so many pitfalls and traps that they are really hard to use for experiences programmers and more or less unusable for ordinary programmers.

Why? How could that happen? How can we deal with what was standardized? Can we do better? Can we even implement or use other views.

This talk will answer all these questions and for sure cause heated discussions.

It is time to have them.

Standard Attributes in C and C++

Bristol I

This talk is an in-depth tour of the standard attributes currently available in the C and C++ programming languages.

Some attributes such as deprecated, fallthrough, nodiscard, and maybe_unused are very helpful to produce or suppress warnings. Others, such as likely and unlikely, can be used as optimisation hints to the compiler, although it can be difficult to avoid misuse and accidentally pessimise your code instead. The attributes noreturn and assume can even inject undefined behaviour into your code. And then there is no_unique_address, which can be used to optimise the class layout, but comes with its own caveats regarding portability across major compilers.

C++ has had standard attributes since C++11, and every new standard is adding more. The C language introduced attributes in C23, adopted many attributes from C++, and added two new attributes exclusive to C: unsequenced and reproducible.

In this talk, we will describe the syntax and semantics of all existing standard attributes, including the latest additions in C23 and C++23, discuss the use cases for each one, show practical code examples, and offer guidelines on how to use them safely and effectively. We wil...

Maths: the fun parts

SS Great Britain

If you've always hated Maths but love programming, this session is aimed at you. We will stay well away from anything remotely useful, and write code that helps us understand Sets (collections of things), Groups (for people who find adding up too ...

If you've always hated Maths but love programming, this session is aimed at you. We will stay well away from anything remotely useful, and explore some cool ideas by writing code.

Sets are collections of things, Groups are for people who find adding up too complicated, and Graphs are dots with lines connecting them.

Crucially, all of these are fun*, and we will play around writing some code that helps us understand how they really work.

*Note: apart from Sets, those are not fun, sorry.

Let’s get more – social, environmental, and economic – sustainability based on data!


The world is on fire! None of our improvements in software development will matter at all if we can’t change the course of the climate crisis. The software lifecycle creates direct and indirect carbon emissions: it has a footprint, worsening envir...

Wednesday 16:00

The Practices That Make Continuous Integration

Bristol III

What are the practices that enable a team to reach Continuous Integration? Adopting each and every practice enables the fast flow of work, increased feedback, increased stability and higher throughput.

Continuous Integration is by itself already a practice. It is one of the most critical to adopt to enable the fast flow of work through the value stream.

However, many teams believe Continuous Integration is just a tooling problem, to then say they practice Continuous Integration. Though they often do not and hence miss out on the benefits that come along with it.

This session goes deeper into the practices that each on their own enables Continuous Integration. Learn how to gain fast feedback, increased stability and higher throughput!

Test-Driven Development of Embedded and System-Level Software

SS Great Britain

As with other complex software systems, test-driven development (TDD) practices offer benefits for development of embedded and system-level software. Unit testing enables a production of verified code independently from a target platform. Test-awa...

The test-driven development (TDD) process is a widely used practice that can significantly improve product quality and strengthen developers’ productivity. Unfortunately, in the areas of embedded and system-level development TDD applicability faces some extra challenges. Dependencies on hardware and/or C-based system APIs, portability issues and platform limitations require more sophisticated test designs.
The presentation is aimed at encouraging and enabling software engineers involved in the aforementioned fields to apply TDD principles in practices and consists of two consecutive parts.
In the first part the TDD process will be reviewed through examples, covering how requirements can be refined using TDD and translated into unit and integration test-cases.
The second, primary, part will be focused on design principles that enable testability and anti-patterns inhibiting it. Strong focus will be given to unit testing, the technique that allows not only to verify the correctness of code but significantly bolster developer’s productivity by providing a target independent environment. Cases where decomposition and abstractions can be used to produce testable, and platform inde...

A tour of C++ recognised user type categories

Bristol II / Bristol Suites

What's trivial about trivial types ? What can we say about the layout of the standard layout types? What is the lifetime of an implicit-lifetime type ? How are all these types different from aggregate types, literal types, and structural types? Wh...

Modern C++ offers several new classification of user defined types that are in certain contexts treated like built-in types. Getting familiar with them will allow you to take advantage of the special provisions the language gives you and write better code. Knowing the boundaries of those specific situations will prevent you from falling into the UB abyss. Join me as we take a tour of language recognised user types, noting their advantages and pitfalls.

Nobody can program correctly. Lessons from 20 years of debugging C++ code.

Bristol I

We like to write code but—despite our best efforts—we make mistakes. Our program will contain bugs. Sometimes, we don’t write what we mean to write, sometimes we don’t understand an aspect of our programming language and at other times we lack—or ...

Talks on debugging techniques are relatively rare at big C++ conferences. Most debugging talks focus on specific tools, such as gdb or the time-travel debugging in WinDbg. In my talk, I want to cover the important tools as well but most importantly, I want to proceed like a developer would, starting with a program that does not perform according to its specification. I will use different examples from my almost 20 years at think-cell to illustrate my talk and make it more interactive.
1) A program crashes or experiences some kind of bug. What can we learn from a single occurrence? What information can be gathered here (e.g. stack traces, full memory dumps)?
Sometimes this may be enough to diagnose and fix a bug! It should be a best practice to look at bugs immediately when they occur on your or a colleague’s computer. It might be your lucky day and you find a bug that is easy to fix yet very hard to reproduce!
2) Typically, you need a reproduction, for example, because the observable crash is only a delayed consequence of a problem that happened much earlier in your program. There are different degrees of reproducibility from “100% reproducible in debug builds in every ...

Gilding the Rose

Refactoring-Driven Development - Empire

Refactoring is a word on every developer's lips, but not always at their fingertips. Through the Gilded Rose kata, we'll explore the habits and choices that move us towards (or away from) solutions that match their problem.

We will also see we ...

Refactoring is a word on every developer's lips, but not always at their fingertips. There is more to refactoring than IDE shortcuts and code tidying. Refactoring is a tool for understanding and improving code by changing it and for revealing and implementing design choices. It is about uncovering possibilities, such as the paradigm that best fits the problem and new ways of thinking about solutions.

Many developers understand refactoring at a more superficial level and often do little more than rename identifiers or extract functions. This session looks to go deeper and to present refactoring as a first-class design practice.

We'll walk through the classic Gilded Rose refactoring kata — don't worry if you don't know it, all will be introduced! — taking it from its initial painfully realistic business logic all the way through a series small changes to a solution that better fits the problem as described and simplifies future changes. We'll look at what kinds of tests are suitable for the code, we'll question some common coding habits, we'll see that neither force-fitting an object-oriented approach nor tackling it just through procedural refactoring gives a good fit solut...

Wednesday 18:00

Lightning Talks

Bristol II / Bristol Suites

Wednesday 19:00

Welcome Reception

Sponsored by Mosaic - Bristol II / Bristol Suites

Thursday 09:00


Bristol II / Bristol Suites

Thursday 11:00

Linux Debuginfo Formats

DWARF, ELF, dwo, dwp - What are They All? - Empire

Debugging tools (debuggers, checkers, tracers, time-travel debuggers) all rely on debug info to map from the executable back to the source-code. This talk covers what exactly is in debug info, the different compiler options to control its generati...

Many different Linux debugging tools are available - as well as the traditional debuggers (GDB, LLDB) we have checkers (Valgrind, the sanitizers), tracing tools (strace, ltrace), time-travel debuggers (rr, UDB). They all rely on debug info to map from the executable back to the source-code. Most of us know to pass the -g option to gcc to generate debuggable binaries, but there is much more to it than that.

This talk covers what exactly is in debug info, the different compiler options to control its generation, and the different kind of object files and why you might want them (e.g. split dwarf files for quicker loading). We also introduce ways to manage this information, including the new debuginfod service.

As is usual for Greg's talks: few slides, many demos.

This talk will give the information you need in order to use the available tooling more effectively, and to troubleshoot when the debug experience doesn't quite "just work".

Improving Compilation Times: Tools & Techniques

Bristol III

"Modules will solve everything", people say -- some optimistically, others sarcastically. However, modules are far from reaching real-world maturity, and it is still not certain whether they will improve compilation times in every situation and how costly it will be to migrate a large codebase.

Do we have to suffer with excruciating compilation times until we are able to migrate to modules? Not at all!

If you are interested in learning about practical tools and techniques to improve compilation times on codebases of any size, *today*, this talk is for you! We will cover:

  • How to accurately benchmark the compilation time of a codebase and detect bottlenecks;

  • Enabling precompiled headers in CMake, leveraging the "reuse from" feature;

  • Automatically transforming your build into a "unity build";

  • When to selectively replace heavyweight standard library headers;

  • General techniques to reduce physical dependencies between components.

Vulnerable C++

Failures, Avoidance and Mitigations - Bristol II / Bristol Suites

Programming languages contain features that could cause code to behave badly. Either by creating hazards in safety critical software, or by creating entry points for attacks in security-critical software.

ISO SC22 WG23 working group collects co...

A Generic Talk About Go

SS Great Britain

A look into generics and some of the other languages features now available in Go, with live coding and live bugs, because who doesn't love trying to code up audience questions on the fly.

Go was designed to be simple, and easy to understand. Its use of interfaces and composable types meant it didn't need generics. So obviously it now has generics. Which is great. Sort of.

Join me as I fire up an IDE and demonstrate the highs and lows of generics, and a few other new languages features we've gained in Go recently.

Is linear_mapping the correct abstraction for a linear algebra proposal?

Bristol I

As the linear algebra proposal grinds its way through the process of standardisation, unexpected discussions have taken place about the expected nature of the product operator. Combining findings from recent investigations into colour, abstraction...

When I originally presented the linear algebra proposal to the Library Evolution Working Group, I was not expecting the tortuous journey it has taken. I thought that there was very little to consider: there is widespread existing practice in the form of, among others, the Eigen and Blaze libraries, and the domain is extremely well defined in any abstract algebra textbook.

It turns out I was completely wrong. Unexpectedly, there was controversy about the nature of the product operator. Should it offer memberwise multiplication, or should it offer matrix multiplication as described in the textbooks mentioned above?

This is a problem in abstraction itself. The domain of linear algebra lends terms to the domain of programming which are not necessarily isomorphic. As a mathematician, I have a particular notion of what a matrix is. This is not shared by some programmers. Cutting a path through this confusion has been the main cause of revisions of the proposal: as of writing I am now on version seven, and I fully expect to reach version eight before I deliver this presentation.

This talk will cover these coincidences of terminology, the difference between linear mappings and ...

Thursday 14:00

Breaking Enigma With the Power of Modern C++

Bristol II / Bristol Suites

During the Second World War, Alan Turing and his team at Bletchley Park used a very primitive computer to crack the German Enigma machine encryption and allow the Allies to read the Axis secret communications. To achieve this feat they used every ...

Rust for the recalcitrant C++ programmer

SS Great Britain

Andy teaches CB about neat features of Rust and CB tries to show that they have what they need in C++.

Andy has been working in Rust and is excited to share his experience of all the positive features that he has found useful.

CB has decades of experience with C++ and years of experience in other languages and is sceptical of the need to invest time in another language. They have reluctantly agreed to "hear Andy out" and are confident that they have everything which they need in C++ to tackle the same sort of problems that these Rust features are supposed to help with.

Andy is looking forward to demonstrating ownership, the type system, immutability, pattern matching, safe concurrency, helpful compiler messages and, worryingly for CB, the package ecosystem.

Micro-service delivery without the pitfalls

Bristol III

The rise of micro-service architectures offers the promise of a more agile software development process. Software systems will be made up of many collaborating components which are developed, deployed and operated by distributed teams and organisa...

The rise of micro-service architectures holds the promise of a more agile software development process. Software systems will be made up of many collaborating components which are developed, deployed and operated by distributed teams and organisations. But how can we avoid a recurring configuration nightmare (c.f. DLL hell) and ensure that we benefit from the promised flexibility, rather than creating a fragile, distributed monolith?

One approach is suggested by the test automation pyramid, which suggests that we favour unit and integration tests over end-to-end tests, which leads developers to use test doubles (fakes, stubs, mocks etc.). The risk is that the developer's test double does not behave in exactly the same way as the actual component that it is replacing. When this happens, the tests all pass in your build pipeline, but you get failures when it's released into an integration (or production) environment.

Contract testing is a technique that can give you confidence that your test doubles are accurately simulating the dependencies that they replace. This is not a new technique, but the extra investment in creating and maintaining (yet another) suite of tests has r...

Grinding, Farming, and Alliances: How words and ideas from casual gaming can make you a better programmer


If you play a game once in a while, you've levelled up in it. You've completed a quest, a mission, a level, or something. And you've been rewarded. Some of the mechanisms that are carefully coded into games are very similar to mechanisms that happ...

Every game has a core mechanic: winning battles, solving puzzles, finding matches, or whatever. In the same way, being a software developer involves a lot of writing code. But our careers involve a lot of other activities, too. Sometimes it's not clear what the value of a meeting is, why you should join a committee or working group in your company or outside it, how social media can have relevance for a developer, why conferences are worthwhile, and so on. It's rare for people to spell out the benefits of any work activity explicitly. I will show some of those benefits using the concepts and language that are common across a variety of games today,

In a game, you have to make decisions on the fly as new information arises. You may have to communicate plans to other people, without authority to make them follow the plan, and you may have to choose a path without all the information you need to make the decision. Surely that sounds familiar to programmers?
If you've figured out some meta-play that works for you in a game you like, you can do the same for your software development career.

C++23 ranges: conceptual changes and useful practicalities

Bristol I

Being introduced to C++20, ranges changed the way we write code. C++23 not only brings with it a large pile of new utilities but actually introduces a fundamental change to one of the core concepts in the ranges world - the view.

Absurd as it sounds, views can now also own their elements while still being cheap to pass around. This talk will explain how that works as well as describe the most useful algorithms and adaptors we can now take advantage of, like using `std::generator` to implement range adaptors, printing ranges, or even using the new `std::optional` monadic interface.

Thursday 16:00

Electronic Trading for Programmers

Bristol III

Electronic trading, in particular for high-frequency and low-latency strategies, is an area that is very much in demand of C++ developers, but sometimes seen as alien by traditional technologists. In this talk, we'll attempt to demystify this indu...

The talk will be primarily focused on electronic trading on centralized exchanges with continuous matching of limit orders, be it for delta-one or derived assets, on co-located or cloud exchanges. We'll first cover the basics with reference and market data, execution, and order book kinematics, then discuss how one would build a program with low-latency trading capabilities as a result, with optimized thread models, networking and memory management. Finally we'll delve into a few more quantitative topics to understand how it all fits together: matching engine simulation, alpha modeling, slippage and risk management.

Using Both Cores of Raspberry Pi Pico with C++OS

Coroutines and std::execution in Embedded Systems - Bristol II / Bristol Suites

This talk is about using the latest developments in C++ for really small systems.

Since C++11, Standard C++ already provides some mechanisms to run task on multpile cores.
RP2040, the processor of Raspberry Pi Pico, features two Cortex M0+ cores, but as an implementation of the Armv6-M architecture it's not really meant for symmetric multi-processing (SMP), so std::thread is not appropriate for using these two cores.

But with coroutines in C++20 and std::execution (probably in C++26) there are other standard mechanisms in C++ to utilize multiple cores.

C++OS is a proof of concept that implements the C++ Standard API as pre-emptive multitasking system on bare metal.
This makes it possible to explore how far the C++ Standard interfaces can provide the interface for portable embedded applications and what's still missing.

C++OS also provides a partial preliminary implementation for the std::execution interface that's currently proposed for C++26.
This allows for more task launching control than simply std::thread.

This presentation will not go deeply into the technical details of RP2040, but will show several applications that use both cores based on the the existing and proposed mechanisms of Standard C++.

C is great, long live C!

SS Great Britain

If you are a seasoned C++ programmer you might think about C as a prehistoric language stuck in the times of K&R. But have you ever heard about compound literals and about how they can be used to enable default function arguments in C? Or have you ever used flexible array members to simplify dynamic data structures creation? What about anonymous unions, designated initialisers or static array arguments? Never heard of those? C is a living language that has much to offer to those who care about performance, who program close to hardware or whose daily routine involves interfacing C++ with C code. If you are such a person, or you are just curious and would like to learn about the older, little brother of C++, this is a talk for you. We will (re-)discover the perks and perils of modern C. Step by step, we’ll see how leveraging the latest language features helps readability, improves safety and leads to better runtime performance. Who knows, maybe you’ll find writing C enjoyable (again)?

Concurrency approaches: past, present, and future


Concurrency: safe, efficient, structured and easy to use — pick four. This talk aims at looking at the advantages and disadvantages of various concurrency approaches, trying to make sense of them, and trying to paint a picture of the solution spac...

Concurrency is hard. It’s been hard since its inception, more than half a century ago. There are multiple approaches to concurrency, each with its advantages and disadvantages. This leaves programmers confused.

This talk aims at clarifying part of this confusion by looking at different approaches used in the past to tackle concurrency, providing a simple framework to analyse the advantages and disadvantages of these approaches. Moreover, by looking at past approaches and seeing the downsides that each approach has, we can infer a picture of how the future of concurrency might look like.

We dedicate a part of the talk to a concurrency model that is safe, efficient, structured, and very easy to use (with an emphasis on the usage). This model can be an important part of the future of concurrency.

Quo Vadis C++?

What is the future of C++? - Bristol I

The future of C++ is currently heavily discussed and at least two possible successor languages are currently under development.

Thursday 18:00

Lightning Talks

Bristol II / Bristol Suites

Friday 09:00

Keynote: C++ Horizons

Bristol II / Bristol Suites

In the next decade, three major new C++ will reshape how we write C++ code - reflection, pattern matching, and senders. Come join Bryce Adelstein Lelbach, one of the leaders of the C++ committee, to find out what's next for C++, and why you should...

Friday 11:00

What’s In A Bit

Designing, Using And Reverse-engineering Binary File Formats - Bristol III

Ever wonder how your computer went from ones and zeroes to full-color photos, streaming movies and high-paced 3D entertainment? Let's take a deep dive into how file formats work, how to read files and what makes a file format a good file format.

C++ Fundamentals: Value Types

Bristol II / Bristol Suites

A guide to implementing a class in C++ that models an abstract set of values, like int models whole numbers and string models the set of arbitrary character sequences. The usefulness of such “value types” is motivated through value semantics in C+...

This talk will discuss how to implement C++ classes that represent elements of a mathematical set of values. Known applications of this concept are the 'int' to model whole numbers and 'string' to model a sequence of characters, or, more theoretically speaking, finite words over some alphabet.

These two types are clearly the bread and butter of the working C++ engineer. However, programs also define their own classes to model domain-specific concepts. Often enough, these custom classes mix value representation with behaviour and business logic, like a configuration class that can read itself from a file or that implements virtual functions for some purpose.

In this presentation, we'll focus on the value aspects by addressing the following: What is a value and how does value semantics help us understand programs? What is the difference between representation and value? How does the mathematical value guide our implementation for accessors, relational operators, and the rest? Clear-cut value types not only benefit our understanding of a program, but also increase testability, reuse, separation of concerns, and much more.

Introduction to secure multi-party computation


How to jointly compute on private data, without revealing the inputs, but still getting the outputs

Sometimes multiple parties need to execute a computation where each of the parties holds one of the inputs that they can't or don't want to share with the other parties. A non-technical solution would be to find an external party trusted by all the data holders and have that external party run the computation and announce the results.

But sometimes such a mutually trusted party does not exist. Then a technical solution is to run the computation jointly in such a way that everyone involved learns the result, but nobody learns the inputs of the other parties. In this session we look at some of the protocols and techniques invented for this purpose. Perhaps unexpectedly for these results, high-school level algebra is sufficient for majority of the presentation.

C++ Coroutines From Scratch

Bristol I

I'll show a worked example with a "before" and "after" using C++ coroutines.

C++ 20 introduces coroutines into the language. Coroutines have the potential to greatly simplify some types of code - particularly, but not limited to, anything asynchronous in nature. But early adoption has been hindered by both the lack of library support in the standard and the inherent complexity of the feature itself (which, due to that lack of library support, you are typically more exposed to).

Now we have a bit of a “Blind men and an elephant” problem - where we’re getting disjointed glimpses of what coroutines, supposedly, are - without the big picture. I can’t claim to be able to give you a comprehensively big enough picture in a 90 minute talk, but my aim is to plot a journey through it by starting with a motivating example (a typical multiple async task problem), looking at how we might approach this without coroutines, then seeing what coroutines can do for us - and finally looking at what that might look like with library support, too.

Template Meta-State Machines, Madness and Shannon.

Investigating the limits of extreme micro-optimisation in C++. - SS Great Britain

After years indulging in the temptations of micro-optimisations, I shall present a definitive, micro-optimiser's guide to implementing template meta-state machines! This was motivated by the cut-throat arena of High-Frequency Trading (HFT) and my ...

Following on from my previous talks regarding optimisations in C++, I undertook a multi-year investigation into extreme micro-optimisation of template meta-state machines. This Herculean effort eventually hit a "hard limit": due to Shannon's Information Theory... The meta-state machine described was a cut-down variant of the renown Boost.MetaStateMachine (mine lacks guards and other such flexilty). Each transition has been instantiated in a custom-container I termed "unordered_tuple", it provides extremely fast run-time access to each element. The input state has been encoded, using template meta-programming, in the enum tag-value to try to ensure that fastest possible instruction-encoding. The hashing of the state to identify the correct transition in the table uses a custom-designed, data-parallel algorithm that attempts to generate via brute-force an extremely fast, perfect (possibly minimal) hash: this might fail due to inadequate entropy. All this to generate a ... computed goto! (Forgive me Dijkstra...) So having erased all type information via the generated computed goto, type-safety was restored via some futher template meta-programming: the "constrained_override_type" t...

Friday 14:00

Trivial Relocation Through Time

Bristol III

This talk considers why support for trivial relocatability would be a valuable addition to the C++ standard. Along the way, we also compare the various proposals that have been submitted to WG21 over the last eight years to achieve this.

A known performance issue for containers holding non-trivial types, such as std::vector<MyClass>, has been the focus of ongoing discussion for almost a decade. When such a container needs to increase its capacity, the MyClass objects need to be moved to a new location in memory. For simple types that are trivially copyable, that relocation can be performed quickly and efficiently by simply copying bytes and deallocating the original storage. For more complex types that are not trivially copyable, the container needs to loop over each existing object, moving each into the new location and destroying the old one. Numerous other types (such as std::string, std::unique_ptr, and std::list in some implementations), though not trivially copyable, could be relocated appropriately and efficiently with a simple memmove if such relocation were legal.

In this talk, we will first look at...

Introduction to Epoch-Based Memory Reclamation

What to do When no Thread is Watching - Empire

Memory reclamation in concurrent programs is difficult. Hazard pointers, which for C++ are currently progressing through the Standard Committee, are a scalable technique for solving the reclamation problem. Another library-level approach is epoc...

In single-thread applications, memory reclamation (making memory available for reuse) after logical deletion is always safe. In concurrent programs, memory must not be reused while other threads might still access the memory. For example, consider deleting the first node in a singly-linked list. While the node may be removed from the list immediately (ignoring ABA), other threads may still attempt to access the node. Until these attempts complete, the node's memory must not be reused.

In its simplest form, an epoch-based reclamation algorithm tracks how many threads have access to a data structure's nodes. This count is maintained in an active epoch and one or more waiting-until-empty epochs. Each epoch has an associated list of logically deleted nodes. A thread, prior to accessing any nodes, increments the active epoch count. When the thread completes accessing nodes, the thread decrements the count it previously incremented (not necessarily the active epoch count). Memory logically deleted is always added to the list associated with the active epoch. Periodically, a new active epoch is started and the current one, along with its associated list of logically delete...

How Behavior-Driven Development & Testing Improves Cross-Team Distributed Systems

Thoughtful testing make for happier, more efficient teams - SS Great Britain

Learn how Bloomberg leverages Behavior-Driven Development (BDD) and the ‘behave’ framework for end-to-end testing of cross-team distributed systems.

Software clients don’t care (and shouldn’t need to care) about how code works. They only care about two things: 1) Does it work? and 2) Is it reliable?

As engineers, this dual expectation around stability and quality creates the need for an essential part of our software development process – testing. However, in large-scale distributed systems that span multiple teams across an organization, how do we ensure full end-to-end test coverage is captured?

One possible solution could be hiring a Quality Assurance (QA) team to manually test every client workflow. But manual testing is rarely sufficient and extremely time consuming. Generally, the low ratio of testers to developers can delay production deployment for new code, while also opening the door for more errors to be caught by end-users.

Building out reliable automated testing requires a tight partnership between engineers, assurance experts, and customer support, as well as the thorough translation of client workflows into a technical pipeline. For distributed systems that span multiple teams, it is also critical to have an automated triage process and clear ownership for each part of the pipeline.

This talk will ...

CMake: A Case Study

Bristol II / Bristol Suites

Over the years, CMake has become the de facto standard build tool for C++, and sooner or later almost all C++ developers have to deal with it in one way or another. For many developers it will stop at entering the right CMake commands to kick off a build, and, maybe, occasionally add a new source file to the build. But somebody has to set up that build in the first place. This talk is directed at those (soon to be) experts. In a case study I will show some ideas and tricks to use a library and tools for which there is no support in CMake yet.

In the case study, we will look at a C++-application that uses embedded SQL to talk to an Oracle SQL-database. To build the application, it needs to link against Oracle’s client library and the files with embedded SQL need to be converted to pure C++ before they can be compiled. How can we find that library when there is no CMake module for it yet? (We write our own!) How can we execute Oracle’s preprocessor to convert files with embedded SQL in a structured way when there are tens, or hundreds, of those files, possibly spread over different CMake targets? Come to my talk and I will tell you.

Monads in Modern C++

Bristol I

Monads are a common technique in functional programming languages to reduce boilerplate, abstract detail in order to produce simple, pure pipelines. While traditionally associated with languages like Haskell, monads are making their way into more ...

This talk will serve as an introduction to the monad design pattern. We will start by introducing functors (a related pattern) and use it as a building block to introduce monads. Throughout the presentation, we will show examples of how monadic operations can help turn our imperative-style code into succinct functional pipelines, while removing boilerplate, error-prone control flow, and side effects. The examples will relate to recent and upcoming developments for std::vector and std::optional in the C++ standard. Finally, the talk will incorporate a walk-through of the available monadic support in C++, and we will discuss where C++ stands in comparison to other languages.

Friday 14:25

And Then() Some(T)

Don't look in the box! - Empire

Don't look in the box!
Forget about Monads and burritos - let's get practical and see how C++ got more functional by way of Rust Option(T) and Haskell Maybe.
Can we write cleaner code using continuations?
Let's see how combinators (higher-or...

From OOP to Go

SS Great Britain

Picking up Go after mastering OOP languages often leads to common yet avoidable mistakes. The question is - how can we avoid them?

Taking the example of inheritance, we will discuss how our process of thought needs to change when developing pro...

I’m guessing that Go wasn’t your first programming language. When you started to learn Go you probably thought to yourself that structs are like classes, and that embedding a struct is like inheriting from a class - I know that I did. Now, while that’s a good way to start learning Go’s concepts, using embedded structs as inheritance in Go code is problematic and may lead to design flaws, and, worse, to buggy code.

On the other hand, there’s a reason almost all high level programming languages have inheritance - it’s a good way to reuse code and to extend the behavior of external libraries. So, what’s the right way to reach these goals in Go?

In order to answer this question, we need to understand the difference between a struct in Go and a class in a high level language. This talk will focus on Go’s relationship with inheritance, but along the way we’ll also discuss our process of thought when designing a Go program, from what structs we create, to which interfaces they implement and the relationship between different types in our code.

A good Go developer is not one that has perfected the syntax, but one that knows how to use the language’s mechanisms to improve their ...

Friday 14:45


SS Great Britain

How to Master C++


This talk gives practical advice for learning and improving skills with modern C++. The talk identifies five programming ‘mindsets’ that are key to C++ and describes how to develop each. By blending these mindsets together (and consciously recogni...

This talk is intended to highlight the fact that C++ (and programming in general) does not consist purely of a single mindset. Moreover, software engineering requires many different ways of thinking to be blended together to produce the best possible solutions. The aim of the talk is to identify those mindsets that are key to C++ and to provide practical guidance for developing each. The talk is suitable for everyone and all levels of ability.

Friday 15:10


SS Great Britain

Friday 16:00

Adventures with React and JUCE

Doing UI with Typescript in a C++ application - Bristol III

Ever thought of doing a C++ application user interface in React (even using Typescript into the bargain)? I've been part of a team working on a large C++ audio application doing exactly that. This session is a report on how it's been going, what h...

You have a large C++ codebase that uses JUCE, a multi-platform C++ framework widely used in the audio world.

JUCE includes C++ GUI classes, so you can write your GUI directly with JUCE. But that means a compile and link every time you need to adjust anything, which can be tedious with a large code base, and besides, JUCE's GUI classes are pretty traditional. What if you could write your GUI in a more declarative fashion with React? And enjoy seeing changes in UI code show up immediately without a compile-link?

This the story of exactly this journey, using the open source react-juce library. We'll learn a bit about JUCE, take a dive into how react-juce works (and so see how potentially you might produce a React backend targeting a different C++ GUI toolbox), look at how such a GUI might perform, and reflect on the lessons from the project.

What I learned From Sockets

Applying the Unix Readiness Model When Composing Concurrent Operations in C++ - Empire

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

Unix systems implement a rich set of primitives for working concurrently with file descriptors. Interfaces like select, poll, epoll, and kqueue allow the caller to wait until an event occurs on any of the specified file descriptors - that is, until at least one of them becomes "ready" for some operation. The Go programming language has a "select" statement with similar semantics. It may be used to wait for any of several "channels" to become ready.

This talk will demonstrate to attendees that such an approach is also viable for solving problems that involve concurrent operations. It will also how C++ concurrency mechanisms could support similar semantics. By the end, it will provide answers to questions like: "How can I .get() the first of several futures?" and "How can I co_await the first of several coroutines?"

Preparing for Professionalism in Programming

A student perspective - SS Great Britain

The Software Engineering Culture module at the University of Portsmouth follows the model of preparation for a conference. The first assessment is submission of a bio and a selection of proposals to our 'call for papers'. The students act as the p...

Software Engineering students take this module in the final year of their degree. They discover the profession and its practices through videos, articles and debate, preparing them to learn from other professionals, share their own knowledge and engage in informed debate.

We include the issues of inclusion & systemic inequality, and the burgeoning responsibility upon Software Engineers to recognise these problems in order to promote healthy work environments for all and design-out systemic inequality and exclusion.

These issues are among the topics whose evolution we examine in the history of the profession. We also look at the how practices and architecture have changed in order to help students learn from the past and look to the future of their careers.

Are the old ways sometimes the best?

Comparing the 'classic C++' and 'modern' ways to solve various programming tasks - Bristol I

A look at some of the places where C++ now offers multiple ways to do the same thing, examining some of the strengths and weaknesses of each approach.

C++ has undergone many changes since the first ISO version was published in 1998.

Some of the features that have been added to the language provide a replacement for existing idioms.

In this talk I will look at some of the trade-offs involved in such replacements and examine some of the strengths and weaknesses of the different ways we have in the current language of achieving the same end.

The set of issues involved include:
- readability and expression of intent
- the likelihod and consequences of things going wrong
- the cost of change

The talk will be based on features of C++, although many of the principles have a wider application.

Friday 17:45

Lightning Talks

Bristol II / Bristol Suites

Friday 19:45

Conference Dinner

Bristol II / Bristol Suites

Saturday 09:30

Remote Mob Programming In a High Stakes Environment


An experience report showing how remote mob programming can be quite effective in high stake environments, which include very short deadlines, high visibility (especially for failure), limited knowledge of some of the technologies to use, and some...

When you have a newly formed remote team, which has to deliver a system in a high stakes environment—characterised by very short deadlines, high visibility (especially for failure), limited knowledge of some of the technologies to use, and some hard security and accessibility constraints—remote mob programming might not be at the top of your list of methods to use. Yet, this is what we did to deliver successfully, and to very high-quality standards one of the backend systems used by the COVID-19 app for England, and Wales, UK. In this talk Giovanni will share some lessons learned (warts and all) on how remote mob programming helped them achieve their very challenging goals, learning a lot in the process.

co_await All The Things!

Bristol I

With coroutines being readily available and supported in all mainstream compiler implementations, more use cases than simple generators and tasks are entirely within reach. As any operation which may use I/O or execute on a different context is ef...

Saturday 11:30

The Imperatives Must Go!

SS Great Britain

Can a language whose official motto is "Avoid Success at All Costs" teach us new tricks in modern C++ ?
If Haskell is so great, why hasn't it taken over the world? My claim is that it has. But not as a Roman legion loudly marching in a new...

Building Interfaces That Are Hard to Use Incorrectly

Bristol III

A collection of design techniques for hardening library interfaces against misuse and catching common user errors at compile time.

C++ is a language with many sharp edges. Besides the core language providing plenty of features that allow users to shoot themselves in the foot, higher-level library interfaces are also often designed with complex preconditions, the violation of which can again lead to undefined behavior and results that are just as unpredictable as what results from misuse of a lower level language feature. Fortunately, through clever use of the C++ type system we can design interfaces in a way that makes them much harder to misuse accidentally and drastically reduce the opportunities for bugs in user code.

In this talk, we will present a number of design techniques that allow library designers to reduce the possibilities of misuse by their users, by pushing the detection of precondition violations from run-time to compile-time. We will show how to distinguish different categories of preconditions and how we can use the C++ type system to prevent accidental violation of those preconditions at runt-time. We will demonstrate with a number of code samples how the use of such type-based techniques prevents interface misuse in practice and take a look at the trade-offs that arise from such an a...

mp-units: Lessons learned and a new library design

Bristol II / Bristol Suites

This lecture presents how Modern C++ features enable exciting features and attractive new design possibilities.

mp-units is a Modern C++ library that provides compile-time dimensional analysis and unit/quantity manipulation. It heavily uses C++20 features like concepts and values of class types used as non-type template parameters (NTTPs). Also, it introduced a new powerful technique called the Downcasting Facility.

During the talk, the library's author will describe the significant challenges with the initial design. He will explain the issues with the Downcasting Facility and why user-defined literals (UDLs) are not a good choice for creating quantities, and what the alternatives are. Mateusz will also describe additional requirements that couldn't be addressed with the previous framework and present how the new design addresses them. We will also see many C++20 and some C++23 features in action :-) In the end, we will discuss potential C++ language features that could be helpful to improve the design of this and similar libraries.

Designing for concurrency using message passing


One common way to design concurrent code with less potential for synchronization and other concurrency errors is to use message passing. In this talk, I will walk through the design of some example code, showing how to build such a system in practice

This talk will include a brief description of what message passing frameworks are, and how they can help avoid concurrency errors.

I will then work through some examples, showing how the tasks are divided between the elements, and how the system can therefore utilise concurrency, while insulating the application code from the details of synchronization.

Khronos SYCL language framework for C++ Accelerators

Take advantage of all the MIPS - Bristol I

Have you ever wanted to take advantage of all the MIPS in your machine with one programming language?
Have you ever wanted to support any kind of offload devices in C++, be they FPGA, GPUs, matrix/tensors, or DSPs? Many people have by augmenting ...

There are also many interesting use cases with complex modern C++. PyTorch, Blender, ray-tracing, Flashlight ML, Eigen and Tensorflow, Gromacs, and CERN’s ATLAS experiment for high energy physics.

This talk from members of the SYCL and C++ community will talk about highlighted features from the latest SYCL 2020 as related to ISO C++. SYCL can serve even more Extreme Heterogeneity where Data Movement is still King. We also are entering the era of software and hardware Codesign with extreme Heterogeneity and SYCL can be a part of a standard programming model for all HPC, Embedded AI/ML, and Automotive

This talk will showcase these features and show how SYCL 2020 has increased expressiveness and simplicity for modern C++ heterogeneous programming.

Saturday 13:30


Annual General Meeting - Empire

Saturday 14:30

Function Contracts in Practice

Bristol III

Designing a good function API is not an easy task, but many useful guidelines exist to facilitate this process. However, one aspect of a good API is often given insufficient attention: what to do when the function is called with arguments outside of its domain -- i.e., when the function preconditions are violated. Artificially expanding the function domain -- e.g., by throwing an exception or returning an error code -- might be a tempting option to handle inputs that are syntactically but not semantically valid. Instead, we will show how using a contract-checking facility -- even one as simple as C assert -- to detect misuse leads to reducing the incidence of software defects and facilitates robust, maintainable, and high-performance software.

We will start by considering what constitutes a complete function contract; when and why narrow contracts (those with preconditions) are preferable to wide ones, and how to use defensive checks to detect the function's misuse by its programmatic clients. We will then focus on the practical aspects of using function contracts in real-world software. We will touch on rendering function contracts for consumptio...

C++ Dependencies Don’t Have To Be Painful

Why You Should Use a Package Manager - SS Great Britain

The C++ community (especially professional developers) are increasingly looking for tools that can automate their development processes. Organizations spend significant amounts of time maintaining in-house tools, scripts, and other assets designed...

According to recent surveys from the Standard C++ Foundation, a majority of C++ developers are manually managing their library dependencies. Curiously, one of the top pain points cited in these surveys was also “managing libraries”. I believe these two points are correlated.

In this talk, I will discuss how different types of package managers address these pain points, from system package managers like apt and Homebrew to build system centric package managers like NuGet and language package managers like vcpkg and Conan. There are pros and cons to every solution, and some package managers are more effective in some workflows than others. Managing libraries doesn’t have to be painful. If you configure your workflow right, you will save time not having to maintain additional git submodules, source code, or reading build instructions on GitHub.

I’ll also talk about a few scenarios related to dependency management: acquiring open-source libraries vs. private libraries, automatically building libraries from source, using libraries locally and in CI, using libraries with different build systems and operating systems, and acquiring developer tools from a package manager. You will...

Productivity in C++ Game Development

Inside the Mind of an AAA Game Developer - Bristol II / Bristol Suites

Dive in the mind of a AAA game developer and learn the ins-and-outs of being a productive game developer.

As blockbuster AAA video games increase in complexity, so has game development in C++. In this talk, we will take a deep dive inside the mind of an AAA Unreal Engine developer at RareUK. Using Unreal Engine 5, we will showcase key productivity tips and tricks throughout the developer inner loop when working with Unreal Engine. Learn about how to reduce mental task switching with various productivity features and Unreal Engine IDE integrations in Visual Studio. See how a game dev can leverage little-known advanced debugger tricks and a custom Natvis file to their advantage.

You Are a Parenthesis

Callable Objects in Java, C#, Rust, and C++ - Empire

It is trivial to make a class callable in C++. Just define operator(). But what if you cannot?

Adding operator() requires three things to check simultaneously: you're working on an object of a class type, you own the class type, and the action of "call" has an unambiguous meaning in the class. You may think a closure or a bind_front object will solve all problems. But, depending on which pieces are missing, such a solution can range from adequate to a code smell.

The talk will begin with an old tale: Java -- a language with no operator() and was transitioning to adding lambda. Then, we will look into how Java, C♯, and Rust avoid all the restrictions of operator() by not adding operator() to the language. Finally, we'll introduce a small library change in C++ that achieves all the benefits we've seen and even more.

Cracking Collaboration: Problems and solutions for modern development

Bristol I

Working with others is tricky. Especially in the new world of remote work, having different workflows, habits, and backgrounds can cause friction in teams. But the "A-ha!" moments where someone else quickly fixes that bug you've been stuck on for ...

Saturday 16:30


Bristol II / Bristol Suites