Just Software Solutions

Conference Presentations

Our Technical Director, Anthony Williams, has been regularly speaking at conferences for over 10 years, and has also delivered workshops on Concurrency in C++ at NDC Oslo, CppCon and C++ on Sea. There is a list of these presentations below, with slides and video links.

In 2023, Anthony is currently booked to be presenting at:

  • ACCU 2023, 22nd April 2023. He will be presenting Designing for concurrency using message passing
  • C++ on Sea 2023, 28th June 2023. He will be presenting Designing for concurrency using message passing

Past conference presentations

DateEventTitle and Description
22nd April 2023ACCU 2023 (Bristol, UK)

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.

The slides are available as a PDF.

17th November 2022Meeting C++ 2022 (Online)

An introduction to multithreading in C++20

Where do you begin when you are writing your first multithreaded program using C++20? Whether you've got an existing single-threaded application, or you're starting from scratch, C++20 provides the basic tools to help. In this talk we’ll look at the C++20 facilities you should reach for first, and how to use them safely.

The slides are available as a PDF, and a video recording is available on youtube.

13th September 2022CppCon 2022 (Aurora, Colorado, USA)

An introduction to multithreading in C++20

Where do you begin when you are writing your first multithreaded program using C++20? Whether you've got an existing single-threaded application, or you're starting from scratch, C++20 provides the basic tools to help. In this talk we’ll look at the C++20 facilities you should reach for first, and how to use them safely.

The slides are available as a PDF, and a video recording is available on youtube.

6th July 2022C++ On Sea 2022 (Folkestone, UK)

An introduction to multithreading in C++20

Where do you begin when you are writing your first multithreaded program using C++20? Whether you've got an existing single-threaded application, or you're starting from scratch, C++20 provides the basic tools to help. In this talk we’ll look at the C++20 facilities you should reach for first, and how to use them safely.

The slides are available as a PDF, and a video recording is available on youtube.

9th April 2022ACCU 2022 (Bristol, UK)

An introduction to multithreading in C++20

Where do you begin when you are writing your first multithreaded program using C++20? Whether you've got an existing single-threaded application, or you're starting from scratch, C++20 provides the basic tools to help. In this talk we’ll look at the C++20 facilities you should reach for first, and how to use them safely.

The slides are available as a PDF, and a video recording is available on youtube.

November 2021C++ Russia 2021 (online)

Concurrency in C++20 and beyond

C++20 is set to add new facilities to make writing concurrent code easier. Some of them come from the previously published Concurrency TS, and others are new, but they all make our lives as developers easier. This talk introduced the new features such as std::jthread, std::latch and std::barrier, and explained how and why we should use them.

The evolution of the C++ Concurrency support doesn't stop there though: the committee has a continuous stream of new proposals. This talk also introduced some of the most important of these, including the new Executor model.

The slides are available as a PDF, and a video recording is available on youtube.

6th May 2021C++ Now 2021 (Online)

Library Approaches For Strong Type Aliases

It is tempting when writing function and class interfaces to use built-in or library types as function parameters and return values. "I want something to represent a count, I'll use an int", "I want something to represent a name, I'll use a std::string", etc. This works fine up to a point, but allows for confusion: if I pass two ints as the parameters to a std::vector<int> constructor, which is the size and which is the value? Is this float value for "timeout" a value in seconds or milliseconds?

One way to solve this issue is with use-specific classes: std::duration specifies time period with the units encoded, and many SI units libraries abound. However, writing such classes can be tedious and domain specific. To this end, many people advocate the idea of "strong typedefs": the ability to say "this type is like this other type, but is distinct from it", so I can have a "count" type that is essentially an "int", but is distinct from a "timeout_in_seconds" type that is also an int.

I will present the library approach I developed to address this problem, which uses templates to allow you to create specific types for specific purposes, with a set of "properties" that define the interface.

The slides are available as a PDF, and a video recording is available on youtube.

11th April 2021ACCU 2021 (Online)

Concurrency in C++20 and beyond

C++20 is set to add new facilities to make writing concurrent code easier. Some of them come from the previously published Concurrency TS, and others are new, but they all make our lives as developers easier. This talk introduced the new features such as std::jthread, std::latch and std::barrier, and explained how and why we should use them.

The evolution of the C++ Concurrency support doesn't stop there though: the committee has a continuous stream of new proposals. This talk also introduced some of the most important of these, including the new Executor model.

The slides are available as a PDF, and a video recording is available on youtube.

16th September 2020CppCon 2020 (Online)

Get off my thread: Techniques for moving work to background threads

If you're writing a GUI application and you want the interface to feel "responsive" to the user then you need the code that response to UI events to be short and fast. Similarly, if you are handling network I/O you may not want the processing of one request to prevent the system receiving further input. If the work to be done in response to an event is complex and time consuming then you can maintain the "responsiveness" of the system by passing the work off to a background thread. This talk looked at the ways of doing this, including managing ongoing work, providing progress updates, and cancelling work if it is no longer needed.

The slides are available as a PDF, and a video recording is available on youtube.

17th September 2019CppCon 2019 (Aurora, Colorado, USA)

Concurrency in C++20 and beyond

C++20 is set to add new facilities to make writing concurrent code easier. Some of them come from the previously published Concurrency TS, and others are new, but they all make our lives as developers easier. This talk introduced the new features such as std::jthread, std::latch and std::barrier, and explained how and why we should use them.

The evolution of the C++ Concurrency support doesn't stop there though: the committee has a continuous stream of new proposals. This talk also introduced some of the most important of these, including the new Executor model.

The slides are available as a PDF.

23rd May 2019The Developers 2019 (Romania)

Concurrency in C++20 and beyond

C++20 is set to add new facilities to make writing concurrent code easier. Some of them come from the previously published Concurrency TS, and others are new, but they all make our lives as developers easier. This talk introduced the new features such as std::jthread, std::latch and std::barrier, and explained how and why we should use them.

The evolution of the C++ Concurrency support doesn't stop there though: the committee has a continuous stream of new proposals. This talk also introduced some of the most important of these, including the new Executor model.

The slides are available as a PDF.

11th April 2019ACCU 2019 (Bristol, UK)

Here's my number; call me, maybe. Callbacks in a multithreaded world

A common pattern in multithreaded applications is the use of callbacks, continuations and task pipelines to divide the processing of data across threads. This has the benefit of ensuring that threads can quickly move on to further processing, and can minimize blocking waits, since tasks are only scheduled when there is work to be done.

The downside is that they can weave a tangled web of connections, and managing object lifetimes can now become complicated.

This presentation looked at ways of managing this complexity and ensuring that your code is as clear as possible, and there is no possibility of dangling references or leaked objects. The slides are available as a PDF, and a video recording is available on youtube.

23rd October 2018MUC++ (Munich, Germany)

Designing Multithreaded Code for Scalability

As the number of cores in our machines increases, scalability is no longer just a concern for HPC developers, but something everyone writing multithreaded code needs to think about. If you don't think about scalability, then adding more cores might hurt rather than help. This presentation we will look at the issues that prevent multithreaded code from being scalable, and how to address those issues, both from a design perspective, and also with regard to the tools available in the C++ toolkit to help us. The slides are available as a PDF.

11th April 2018ACCU 2018 (Bristol, UK)

Designing Multithreaded Code for Scalability

As the number of cores in our machines increases, scalability is no longer just a concern for HPC developers, but something everyone writing multithreaded code needs to think about. If you don't think about scalability, then adding more cores might hurt rather than help. This presentation we will look at the issues that prevent multithreaded code from being scalable, and how to address those issues, both from a design perspective, and also with regard to the tools available in the C++ toolkit to help us. The slides are available as a PDF.

26th September 2017CppCon 2017 (Bellevue, USA)

Concurrency, Parallelism and Coroutines

C++17 is adding parallel overloads of most of the Standard Library algorithms. There is a TS for Concurrency in C++ already published, and a TS for Coroutines in C++ and a second TS for Concurrency in C++ in the works. What does all this mean for programmers? How are they all related? How do coroutines help with parallelism? This session attempts to answer these questions and more. We look at the implementation of parallel algorithms, and how continuations, coroutines and work-stealing fit together. We also look at how this meshes with the Grand Unified Executors Proposal, and how you will be able to take advantage of all this as an application developer. The slides are available as a PDF, and the video is available on youtube.

29th April 2017ACCU 2017 (Bristol, UK)

Concurrency, Parallelism and Coroutines

C++17 is adding parallel overloads of most of the Standard Library algorithms. There is a TS for Concurrency in C++ already published, and a TS for Coroutines in C++ and a second TS for Concurrency in C++ in the works. What does all this mean for programmers? How are they all related? How do coroutines help with parallelism? This session attempts to answer these questions and more. We look at the implementation of parallel algorithms, and how continuations, coroutines and work-stealing fit together. We also look at how this meshes with the Grand Unified Executors Proposal, and how you will be able to take advantage of all this as an application developer. The slides are available as a PDF, and the video is available on youtube.

20th September 2016Cppcon 2016 (Bellevue, USA)

The continuing future of C++ concurrency

An overview at the additions to the Standard C++ concurrency libraries proposed for the C++ concurrency TS and C++17, including: continuations, executors, and parallel algorithms, as well as std::shared_mutex from C++14. The slides are available as a PDF, and the video is available on youtube.

9th June 2016NDC Oslo 2016 (Oslo, Norway)

Safety: off. How not to shoot yourself in the foot with C++ atomics

If you're writing multithreaded code, it is tempting to use atomics to optimize the inter-thread synchronization and access to shared state. However, this is not always easy, and can all too often lead to code that appears to work but is subtly broken. I showed tools and techniques for using atomics safely in C++, as well as discussing scalability and lock-freedom. The slides are available as a PDF, and the video is available on vimeo.

8th June 2016NDC Oslo 2016 (Oslo, Norway)

The continuing future of C++ concurrency

An overview at the additions to the Standard C++ concurrency libraries proposed for the C++ concurrency TS and C++17, including: continuations, executors, and parallel algorithms, as well as std::shared_mutex from C++14. The slides are available as a PDF, and the video is available on vimeo.

23rd April 2016ACCU 2016 (Bristol, UK)

Concurrent Thinking

One of the most difficult issues around designing software with multiple threads of execution is synchronizing data.

Whether you use actors, active objects, futures and continuations or mutable shared state, every non-trivial system with multiple threads needs to transfer data between them. This means thinking about which data needs to be processed by which thread, and ensuring that the right data gets to the right threads in the right order. It also means thinking about API design to avoid race conditions.

In this presentation I described techniques we can use when doing this "thinking", as well as the tools we have available to help us describe our requirements and enforce them in code.

All examples use C++, but the thought processes are widely applicable. The slides are available as a PDF.

3rd September 2015Agile on the Beach 2015 (Falmouth, UK)

Test Driving User Interfaces

User interfaces are generally considered one of the harder things to develop with Test-Driven Development (TDD). So much so that a common recommendation is to make your user interface code as thin as possible, and test the layer behind the UI rather than the UI itself.

In this presentation I showed that it is possible to test the UI layer with the techniques we already use for backend code, and that this doesn’t have to be painful.

If you truly can get your thin UI layer so simple that it couldn’t possibly break, it makes sense not to test it. However, if your UI layer is more than just a few simple controls with minimal behaviour then doing this properly requires that the thin UI layer actually ends up quite complex, as it has to pass through all the events generated by the UI, as well as provide facilities for any UI changes made through the UI API. At this point, testing behind the UI leaves quite a lot of complex code untested, and thus a prime breeding ground for bugs.

What is needed therefore is a way of working that allows us to bring our TDD experience to the development of UI code in a pain free fashion. This session showed that this isn’t just a pipe dream. The slides are available as a PDF, and the video is available on youtube.

25th April 2015ACCU 2015 (Bristol, UK)

Safety: off. How not to shoot yourself in the foot with C++ atomics

If you're writing multithreaded code, it is tempting to use atomics to optimize the inter-thread synchronization and access to shared state. However, this is not always easy, and can all too often lead to code that appears to work but is subtly broken. I showed tools and techniques for using atomics safely in C++, as well as discussing scalability and lock-freedom. The slides are available as a PDF.

12th April 2014ACCU 2014 (Bristol, UK)

The continuing future of C++ concurrency

An overview at the additions to the Standard C++ concurrency libraries proposed for the C++ concurrency TS and C++17, including: continuations, executors, and parallel algorithms, as well as std::shared_mutex from C++14. The slides are available as a PDF.

11th April 2013ACCU 2013 (Bristol, UK)

C++11 features and real-world code

C++11 has many nifty features, but how do they actually impact developers at the code face? Which C++11 features offer the best bang for the buck? In this session I looked at a selection of C++11 language and library features that I've found of real practical benefit in application and library code, with examples of equivalent C++03 code. The features covered included the concurrency support (of course), lambdas, and “auto”, amongst a variety of others.

27th April 2012ACCU 2012 (Oxford, UK)

C++11 concurrency tutorial

In this tutorial-style session, I introduced the C++11 concurrency library in depth, with live practical examples. This was for both those who've never used concurrency before, but want to start, and those who have used other concurrency libraries but want to learn how to take advantage of the C++11 library. I covered the details of the library, along with practical guidelines about how best to avoid deadlock, race conditions and other concurrency problems. The slides are available as a PDF.

26th April 2012ACCU 2012 (Oxford, UK)

Dataflow, actors, and high level structures in concurrent applications

In this session I gave an overview of various high level approaches to concurrency, including dataflow architectures and actor libraries. Examples were be drawn from several languages and platforms, including C++ and Groovy. The slides are available as a PDF.

16th April 2011ACCU 2011 (Oxford, UK)

Choosing patterns for your parallel program

There are many ways of structuring parallel programs, and a good many buzzwords surrounding them. In this talk I looked at several of the standard patterns that you can use to take advantage of concurrency in your application alongside the circumstances under which each might be appropriate. I also talked about the various patterns for communicating between threads, how those relate to the structural patterns, and the trade-offs involved with the choices. The slides are available as a PDF.

14th April 2010ACCU 2010 (Oxford, UK)

Concurrency in the Real World

This talk covered the common problems people have with multithreaded and concurrent code, and some solutions to those problems, with examples in C++. It also covered the potential benefits of using concurrency, along with some things to watch out for in pursuit of those benefits. The slides are available as a PDF.

23rd April 2009ACCU 2009 (Oxford, UK)

Designing Multithreaded Applications with C++0x

This talk covered the issues involved in designing multithreaded applications, along with examples of how to approach them from a C++0x perspective. This included an overview of the new C++0x thread library, examples of how features such as futures can affect the programming model, and issues to think about when reviewing and testing multithreaded code. The slides are available as a PDF, along with a ZIP file with the sample code for the Concurrent Queue and Numerical Integration demonstrations that I did during the presentation using our just::thread implementation of the C++0x thread library.

3rd April 2008ACCU 2008 (Oxford, UK)

The Future of Concurrency in C++

With the next version of the C++ Standard (C++0x), concurrency support is being added to C++. This means a new memory model with support for multiple threads of execution and atomic operations, and a new set of library classes and functions for managing threads and synchronizing data. There are also further library enhancements planned for the next technical report (TR2). This talk will provide an overview of the new facilities, including an introduction to the new memory model, and an in-depth look at how to use the new library. Looking forward to TR2, this talk covered the proposed library extensions, and how facilities like futures will affect the programming model. The slides are available as a PDF.

3rd April 2002ACCU Spring Conference 2002 (Gaydon, UK)

Function Composition and Return Type Deduction

A key feature of functional programming is the ability to create a function h(x) which is equivalent to f(g(x)) for some functions f(x) and g(x). Here I present a set of function- and class- templates which enable the inline composition of functions, for use with standard algorithms - the function h(x) can be written as compose(f,compose(g,_1)) when used as the function argument for something like std::for_each, rather than having to be written explicitly. An important part of the implementation of such functors is determining the return type. Traditionally, this is done using typedefs, as in std::binder1st, but the mechanism I present here eliminates the need for such typedefs, using automatic type deduction instead. This enables the writing of functors that wrap operators, that are normal classes with template member operator(), rather than template classes.

This presentation describes my function composition library, which is available for download. This library provides a facility for creating composite functions from basic ones at the point of use, and can be used to create a simple lambda expression facility. It is based on my article Function Composition and Return Type Deduction (PDF).

Design and Content Copyright © 2005-2024 Just Software Solutions Ltd. All rights reserved. | Privacy Policy