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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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.
Less information

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).
Less information