Published Articles and Presentations
Here is a list of articles and other publications written by one of our directors, Anthony Williams. In each case, the title is linked to the online version.
Book
Anthony is the author of C++ Concurrency in Action, published by Manning, which provides a comprehensive tutorial and reference to the multithreading support in C++0x. The book is currently available as a PDF, with pre-orders for the final print edition. All purchasers will receive free updates to the PDF as the text is revised to track the C++0x standard.
Articles
| Issue / Publication Date | Publication | Title | Description |
|---|---|---|---|
| September 2009 | DevX.com | Avoiding the Perils of C++0x Data Races | Race conditions are one of the biggest causes of problems in multithreaded code. This article takes a brief look at some of the ways in which race conditions can occur. There is also sample code that demonstrates the perils of data races by showing how even simple code with a data race can lead to corrupt data. |
| May 2009 | DevX.com | Introduction to Variadic Templates in C++0x | This article introduces the new variadic template facility from C++0x, which allows you to write templates that take a variable number of template arguments. |
| November 2008 | Dr. Dobb's Journal | What's New in Boost Threads? | This article gives an overview of the new features added to the Boost thread library in the recent releases. |
| September 2008 | Codeguru.com | Deadlock: The problem and a solution | This is an excerpt from Anthony's book C++ Concurrency in Action, and describes the problem of deadlock and ways to avoid it. |
| August 2008 | DevX.com | Simpler Multithreading in C++0x | Part of DevX.com's Special Report on C++0x, this article provides a whistle-stop tour of the new C++0x multithreading support. |
| August 2008 | Overload 86 | Exceptions make for Elegant Code | This article is a slightly expanded version of my blog entry: Exceptions make for Elegant Code. |
| April 2008 | Dr. Dobb's Journal | Optimizing Math-intensive Applications with Fixed Point Arithmetic | This article describes the fixed-point techniques used to vastly improve the performance of an application using sines,
cosines and exponentials without hardware floating point support. The source code referenced in the article can be downloaded from here. It is released under the Boost Software License. |
| April 2007 | Overload 78 | Implementing Synchronization Primitives for Boost on Windows Platforms | This article describes the techniques involved in writing a new mutex implementation for Windows. |
| June 2006 | CVu 18.3 | Building on a Legacy | This article discusses ways of handling legacy code, and how to work so that maintenance gets easier rather than harder. |
| June 2006 | Overload 73 | Implementing drop-down menus in pure CSS (no JavaScript) | This article describes the details behind implementing drop-down menus with CSS in a cross-browser fashion. |
| May 2006 | Dr. Dobb's Journal | Message Handling Without Dependencies | This article describes a type-safe technique for passing messages around an application in C++, without requiring extensive coupling between the producer and consumer |
| April 2004 | CVu 16.2 | Writing Maintainable Code | A brief summary of techniques to help you write maintainable code. |
| November 2003 | C/C++ Users Journal | Strong Exception-Safe Storage | This article describes the use of a double-buffer technique to provide the Strong Exception Safety Guarantee without the use of dynamic memory, even when the underlying data only provides the Basic Exception Safety Guarantee. |
| April 2003 | Overload 54 | EXPR_TYPE — An Implementation of typeof Using Current Standard
C++ (PDF) |
typeof is a much-sought-after facility that is lacking from current C++; it is the
ability to declare a variable to have the same type as the result of a given expression, or make a
function have the same type as an expression. The general idea is that
typeof(some-expression) would be usable anywhere a type name could normally be
used. This article describes a way of providing this ability within the realms of current
C++. There is code to accompany this article. |
| October 2002 | Overload 51 | Pairing Off Iterators (PDF) | This article describes the implementation of an iterator adaptor that converts a pair of ranges into a range of pairs, so that two containers can be sorted by a key held in only one of them, for example. The code is available for download |
| October 2001 | Overload 45 | Introduction to C++ Templates (PDF) | This is a brief introduction to C++ templates - how they work, how to use them, and how to write your own. |
| August 2001 | Overload 44 | Flexible Functors and Binders (PDF) | This article describes a set of binders to assist writing programs using the Functional Programming style, and a set of adaptors for other functors, such as pointers-to-functions and pointers-to-member-functions, to enable them to be integrated seamlessly. The code to accompany the article can be downloaded. |
| April 2001 | Overload 42 | A Generic Non-Intrusive Smart Pointer Implementation (PDF) | This article describes the implementation of a smart pointer that can
be freely converted to and from a raw pointer, or other types of smart
pointer, without losing its reference count. It also permits the use of
arrays, and the use of dynamic_cast. The code to accompany the
article can be downloaded. There is an
erratum for this article. |
Presentations
| Date | Location | Title | Description |
|---|---|---|---|
| 23rd April 2009 | ACCU 2009 | "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 2008 | ACCU 2008 | 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 2002 | ACCU Spring Conference 2002 | Function Composition and Return Type Deduction (PDF) | 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. |
C++ Standards Committee Papers
| Issue / Publication Date | Publication | Title | Description | |
|---|---|---|---|---|
| September 2009 | C++ Standards Committee Mailing | N2959: Managing the lifetime of thread_local variables with contexts (Revision 1) | This is a revision of my earlier paper, N2907
which expands my proposal for a thread_local_context
class, along with full proposed wording. I think this provides a
workable solution to the general problem of ensuring that destructors
for thread_local variables are run at particular points
in the execution of a program as discussed in N2880. | |
| September 2009 | C++ Standards Committee Mailing | N2967: Issues on Futures | This paper that I co-authored with Detlef Vollmann provides a
complete rewording for the "Futures" section of the standard
(30.6). It folds the proposed changes from N2888
in with changes requested by the LWG at July's meeting (including the
addition of a new future type — atomic_future which
serializes all operations), and editorial comments on the earlier
wording. It doesn't resolve everything — there is still some
discussion over whether unique_future::get() should
return a value or a reference, for example — but it provides a
sound basis for further discussion. | |
| June 2009 | C++ Standards Committee Mailing | N2907: Managing the lifetime of thread_local variables with contexts | This paper introduces the idea of
a thread_local_context which manages the lifetime of
variables declared thread_local. In particular, this
concept is introduced to manage the interaction
of thread_local variables with detached threads and
asynchronous function calls. | |
| June 2009 | C++ Standards Committee Mailing | N2888: Moving Futures - Proposed Wording for UK comments 335, 336, 337 and 338 | This paper provides rationale and proposed wording for the UK
comments on the C++ working draft requesting move semantics
for std::unique_future
and std::shared_future. | |
| July 2008 | C++ Standards Committee Mailing | N2709: Packaging Tasks for Asynchronous Execution | This paper proposes a revised version
of packaged_task following its removal from N2671. | |
| June 2008 | C++ Standards Committee Post-Sophia Antipolis Mailing | N2671: An Asynchronous Future Value Proposed Wording | Jointly authored with Deltef Vollmann and Howard Hinnant. An updated version of N2627 with proposed
wording. packaged_task has been removed for a later proposal. | |
| May 2008 | C++ Standards Committee Pre-Sophia Antipolis Mailing | N2627: An Asynchronous Future Value (Revised) | Jointly authored with Deltef Vollmann and Howard Hinnant. An updated version of N2561. | |
| March 2008 | C++ Standards Committee Post-Bellevue Mailing | N2561: An Asynchronous Future Value | Jointly authored with Deltef Vollmann and Howard Hinnant. Futures, promises and packaged tasks for multi-threaded programming. See Futures and Tasks in C++0x for a summary. | |
| September 2007 | C++ Standards Committee Pre-Kona Mailing | Names, Linkage and Templates (Rev 2) (PDF) | This paper is an update to the earlier proposals for making local types usable with templates (N1945 and N2187), with revised wording. | |
| June 2007 | C++ Standards Committee Pre-Toronto Mailing | Multi-threading library for Standard C++ | This paper (jointly authored with Howard Hinnant, Beman Dawes, Lawrence Crowl and Jeff Garland) proposes a set of classes for a basic thread library for C++, including thread launching, mutexes and condition variables. | |
| May 2007 | C++ Standards Committee Post-Oxford Mailing | Thread Pools and Futures | This paper proposes new classes to the C++ Standard Library for thread pools and futures, to build on top of the new threading facilities. | |
| March 2007 | C++ Standards Committee Pre-Oxford Mailing | Names, Linkage and Templates (rev 1) (PDF) | This paper is an update to the earlier proposal for making local types usable with templates (N1945), with revised examples, motiviation and wording. | |
| November 2006 | C++ Standards Committee Post-Portland Mailing | Thoughts on a Thread Library for C++ | This paper outlines thoughts on various aspects of a thread library for C++, including one-time initialization, and general thread synchronization. | |
| February 2006 | C++ Standards Committee Pre-Berlin Mailing | Names, Linkage and Templates (PDF) | This paper proposes that the C++ Standard is changed, so that unnamed and local types have linkage, in order to simplify the language and make these types usable with templates. | |
| March 2003 | C++ Standards Committee Pre-Oxford Mailing | Making Local Classes more Useful (PDF) | This paper proposes a couple of small changes to the C++ Standard: to allow local classes to work with templates, and to allow local classes to declare friend functions. |