Just Software Solutions

Conference Presentations

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

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

Past conference presentations

DateEventTitle and Description
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-2019 Just Software Solutions Ltd. All rights reserved. | Privacy Policy