2015-09 pre-Kona mailing available

The 2015-09 mailing of new standards papers is now available.

NOTE: A number of these papers have already been publicized on this blog. This is the complete list including ones not previously publicized.


WG21 Number Title Author Document Date Mailing Date Previous Version Subgroup Disposition
SD-1 2015 PL22.16/WG21 document list John Spicer 2015-09-29 2015-09      
2015-09 pre-Kona
N4545 PL22.16/WG21 draft agenda: 19-24 Oct 2015, Kona, HI/US Clark Nelson 2015-06-04 2015-09      
N4546 Agenda and Meeting Notice for WG21 Concepts Telecon Herb Sutter 2015-06-29 2015-09      
N4547 Business Plan and Convener's report Herb Sutter 2015-07-13 2015-09      
N4548 WG21 2015-07-20 Telecon Minutes Roger Orr 2015-07-20 2015-09      
N4549 Programming Languages -- C++ Extensions for Concepts Andrew Sutton 2015-07-27 2015-09      
N4550 Record of Response: National Body Comments on ISO/IEC PDTS 19217, Technical Specification: C++ Extensions for Concepts Barry Hedquist 2015-07-25 2015-09      
N4551 National Body Comments, ISO/IEC PDTS 19571, C++ Extensions for Concurrency Barry Hedquist 2015-08-13 2015-09      
N4552 Pre-Kona WG21 Telecon Herb Sutter 2015-09-28 2015-09      
P0001R0 Removing Deprecated Register Keyword Alisdair Meredith 2015-09-28 2015-09   Core  
P0002R0 Removing Deprecated Operator++ for bool Alisdair Meredith 2015-09-28 2015-09   Core  
P0003R0 Removing Deprecated Dynamic Exception Specifications Alisdair Meredith 2015-09-28 2015-09   Evolution  
P0004R0 Removing Deprecated Aliases in iostreams Alisdair Meredith 2015-09-28 2015-09   Library Evolution  
P0005R0 Adopt not_fn from Library Fundamentals 2 for C++17 Alisdair Meredith 2015-09-28 2015-09   Library  
P0006R0 Adopt Type Traits Variable Templates from Library Fundamentals TS for C++17 Alisdair Meredith 2015-09-28 2015-09   Library  
P0007R0 Constant View: A proposal for a std::as_const helper function template Alisdair Meredith 2015-09-28 2015-09   Library Evolution  
P0008R0 C++ Executors Chris Mysen 2015-09-27 2015-09   Concurrency  
P0009R0 Polymorphic Multidimensional Array View H. Carter Edwards, Christian Trott, Juan Alday, Jesse Perla, Mauro Bianco, Robin Maffeo, Ben Sander, Bryce Lelbach 2015-09-23 2015-09   Library Evolution  
P0011R0 Additions to Filesystem supporting Relative Paths Jamie Alsop 2015-09-25 2015-09   File System  
P0012R0 Make exception specifications be part of the type system, version 4 Jens Maurer 2015-09-08 2015-09 N4533 Core  
P0013R0 Logical Operator Type Traits Jonathan Wakely 2015-07-05 2015-09   Library Evolution  
P0014R0 Proposal to add the multiline option to std::regex for its ECMAScript engine Nozomu Kato 2015-07-11 2015-09   Library Evolution  
P0015R0 A specialization-friendly std::common_type David Stone 2015-08-13 2015-09   Library Evolution  
P0017R0 Extension to aggregate initialization Oleg Smolsky 2015-07-13 2015-09 N4404 Evolution  
P0018R0 Lambda Capture of *this by Value H. Carter Edwards, Christian Trott, Hal Finkel, Jim Reus, Robin Maffeo, Ben Sander 2015-09-23 2015-09   Evolution  
P0019R0 Atomic View H. Carter Edwards, Hans Boehm, Olivier Giroux, James Reus 2015-09-23 2015-09   Concurrency  
P0020R0 Floating Point Atomic View H. Carter Edwards, Hans Boehm, Olivier Giroux, JF Bastien, James Reus 2015-09-23 2015-09   Concurrency  
P0021R0 Working Draft, C++ Extensions for Ranges Eric Niebler, Casey Carter 2015-09-28 2015-09   Library Evolution  
P0022R0 Proxy Iterators for the Ranges Extensions Eric Niebler 2015-06-30 2015-09   Library Evolution  
P0024R0 The Parallelism TS Should be Standardized Jared Hoberock 2015-09-25 2015-09   Concurrency  
P0025R0 An algorithm to "clamp" a value between a pair of boundary values Martin Moene, Niels Dekker 2015-09-18 2015-09 N4536 Library Evolution  
P0026R0 multi-range-based for loops Matthew McAtamney-Greenwood 2015-08-11 2015-09   Evolution  
P0027R0 Named Types Troy Korjuslommi   2015-09   Evolution  
P0028R0 Using non-standard attributes J. Daniel Garcia, Luis M. Sanchez, Massimo Torquati, Marco Danelutto, Peter Sommerlad 2015-09-15 2015-09   Evolution  
P0029R0 A Unified Proposal for Composable Hashing Geoff Romer, Chandler Carruth 2015-09-21 2015-09   Library Evolution  
P0030R0 Proposal to Introduce a 3-Argument Overload to std::hypot Benson Ma 2015-09-08 2015-09   Library Evolution  
P0031R0 A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access Antony Polukhin 2015-09-09 2015-09   Library Evolution  
P0032R0 Homogeneous interface for variant, any and optional Vicente J. Botet Escriba 2015-09-24 2015-09   Library Evolution  
P0033R0 Re-enabling shared_from_this Jonathan Wakely, Peter Dimov 2015-09-23 2015-09   Library Evolution  
P0034R0 Civil Time for the Standard Library Bill Seymour 2015-09-25 2015-09   Library Evolution  
P0035R0 Dynamic memory allocation for over-aligned data Clark Nelson 2015-09-09 2015-09 N3396 Evolution  
P0036R0 Unary Folds and Empty Parameter Packs (Revision 1) Thibaut Le Jehan 2015-09-10 2015-09 N4358 Core  
P0037R0 Fixed point real numbers John McFarlane 2015-09-28 2015-09   Library Evolution, SG14  
P0038R0 Flat Containers Sean Middleditch 2015-09-25 2015-09   Library Evolution, SG14  
P0039R0 Extending raw_storage_iterator Brent Friedman 2015-09-11 2015-09   Library Evolution, SG14  
P0040R0 Extending memory management tools Brent Friedman 2015-09-11 2015-09   Library Evolution, SG14  
P0041R0 Unstable remove algorithms Brent Friedman 2015-09-11 2015-09   Library Evolution, SG14  
P0042R0 std::recover: undoing type erasure David Krauss 2015-09-27 2015-09   Library Evolution  
P0043R0 Function wrappers with allocators and noexcept David Krauss 2015-09-27 2015-09   Library Evolution  
P0044R0 unwinding_state: safe exception relativity David Krauss 2015-09-17 2015-09   Evolution  
P0045R0 Overloaded and qualified std::function David Krauss 2015-09-27 2015-09   Library Evolution  
P0046R0 Change is_transparent to metafunction Tomasz Kamiński 2015-09-10 2015-09   Library Evolution  
P0047R0 Transactional Memory (TM) Meeting Minutes 2015/06/01-2015/09/21 Michael Wong 2015-09-25 2015-09   Transactional Memory  
P0048R0 Games Dev/Low Latency/Financial Trading/Banking Meeting Minutes 2015/08/12-2015/09/23 Michael Wong 2015-09-25 2015-09   SG14  
P0050R0 C++ generic match function Vicente J. Botet Escriba 2015-09-24 2015-09   Library Evolution  
P0051R0 C++ generic overload function Vicente J. Botet Escriba 2015-09-22 2015-09   Library Evolution  
P0052R0 Generic Scope Guard and RAII Wrapper for the Standard Library Peter Sommerlad, Andrew L. Sandoval 2015-09-27 2015-09 N4189 Library  
P0053R0 C++ Synchronized Buffered Ostream Lawrence Crowl, Peter Sommerlad 2015-09-23 2015-09 N4187 Library  
P0054R0 Coroutines: reports from the fields Gor Nishanov 2015-09-12 2015-09   Evolution  
P0055R0 On Interactions Between Coroutines and Networking Library Gor Nishanov 2015-09-12 2015-09   Library Evolution  
P0056R0 Soft Keywords Gor Nishanov 2015-09-12 2015-09   Evolution  
P0057R0 Wording for Coroutines (Revision 3) Gor Nishanov 2015-09-26 2015-09 N4499 Core, Library Evolution  
P0058R0 An Interface for Abstracting Execution Jared Hoberock, Michael Garland, Olivier Girioux 2015-09-25 2015-09   Concurrency  
P0059R0 Add rings to the Standard Library Guy Davidson 2015-09-25 2015-09   SG14, Library Evolution  
P0060R0 Function Object-Based Overloading of Operator Dot Mathias Gaunard, Dietmar Kühl 2015-09-18 2015-09   Evolution  
P0061R0 Feature-testing preprocessor predicates for C++17 Clark Nelson 2015-09-16 2015-09   Feature Testing  
P0062R0 When should compilers optimize atomics? JF Bastien, Peter Dimov, Hal Finkel, Paul McKenney, Michael Wong, Jeffrey Yasskin 2015-09-25 2015-09   Concurrency  
P0063R0 C++17 should refer to C11 instead of C99 Hans Boehm 2015-09-25 2015-09   Concurrency  
P0065R0 Movable initializer lists, rev. 2 David Krauss 2015-09-27 2015-09 N4166 Evolution  
P0066R0 Accessors and views with lifetime extension David Krauss 2015-09-28 2015-09 N4221 Evolution  
P0067R0 Elementary string conversions Jens Maurer 2015-09-25 2015-09   Library  
P0068R0 Proposal of [[unused]], [[nodiscard]] and [[fallthrough]] attributes Andrew Tomazos 2015-09-03 2015-09   Evolution  
P0069R0 A C++ Compiler for Heterogeneous Computing Ben Sander, Greg Stoner, Siu-chi Chan, Wen-Heng (Jack) Chung 2015-09-28 2015-09   Concurrency  
P0070R0 Coroutines: Return Before Await Gor Nishanov 2015-09-12 2015-09   Evolution  
P0071R0 Coroutines: Keyword alternatives Gor Nishanov 2015-09-12 2015-09   Evolution  
P0072R0 Light-Weight Execution Agents Torvald Riegel 2015-09-24 2015-09 N4439 Concurrency  
P0073R0 On unifying the coroutines and resumable functions proposals Torvald Riegel 2015-09-25 2015-09   Evolution  
P0074R0 Making std::owner_less more flexible Jonathan Wakely 2015-09-23 2015-09   Library  
P0075R0 Template Library for Index-Based Loops Arch Robison, Pablo Halpern, Robert Geva, Clark Nelson 2015-09-25 2015-09   Library  
P0076R0 Vector and Wavefront Policies Arch Robison, Pablo Halpern, Robert Geva, Clark Nelson 2015-09-25 2015-09   Library  
P0077R0 is_callable, the missing INVOKE related trai Agustín Bergé 2015-09-22 2015-09 N4446 Library Evolution  
P0078R0 The [[pure]] attribute Karl-Étienne Perron 2015-09-25 2015-09 N3744 Evolution  
P0079R0 Extension methods in C++ Roger Orr 2015-09-28 2015-09   Evolution  
P0080R0 Variant: Discriminated Union with Value Semantics Michael Park 2015-07-28 2015-09   Library Evolution  
P0081R0 A proposal to add sincos to the standard library Paul Dreik 2015-09-25 2015-09   Numerics  
P0082R0 For Loop Exit Strategies (Revision 1) Alan Talbot 2015-09-24 2015-09 N3587 Evolution  
P0083R0 Splicing Maps and Sets (Revision 2) Alan Talbot 2015-09-24 2015-09 N3645 Library Evolution  
P0084R0 Emplace Return Type Alan Talbot 2015-09-24 2015-09   Library Evolution  
P0085R0 Oo... adding a coherent character sequence to begin octal-literals Michael Jonker, Axel Naumann 2015-05-08 2015-09   Evolution  
P0086R0 Variant design review Axel Naumann 2015-09-28 2015-09   Evolution  
P0087R0 Variant: a type-safe union without undefined behavior (v2) Axel Naumann 2015-09-28 2015-09 N4542 Library Evolution  
P0088R0 Variant: a type-safe union that is rarely invalid (v5) Axel Naumann 2015-09-27 2015-09 N4542 Library Evolution  
P0089R0 Quantifying Memory-Allocatiom Strategies John Lakos, Jeffrey Mendelsohn, Alisdair Meredith, Nathan Myers 2015-09-28 2015-09 N4468 Library Evolution  
P0090R0 Removing result_type, etc. Stephan T. Lavavej 2015-09-24 2015-09   Library Evolution  
P0091R0 Template parameter deduction for constructors (Rev. 3) Mike Spertus, Richard Smith 2015-09-24 2015-09 N4471 Evolution  
P0092R0 Polishing Howard Hinnant 2015-09-23 2015-09   Library Evolution  
P0093R0 Simply a strong variant David Sankel 2015-09-24 2015-09   Library Evolution  
P0094R0 Simply a basic variant David Sankel 2015-09-24 2015-09   Library Evolution  
P0095R0 The case for a language based variant David Sankel 2015-09-24 2015-09   Library Evolution  
P0096R0 Feature-testing recommendations for C++ Clark Nelson 2014-09-16 2015-09   Feature Testing  
P0097R0 Use Cases for Thread-Local Storage Paul E. McKenney, JF Bastien, Pablo Halpern, Michael Wong, Thomas Richard William Scogland, Robert Geva 2015-09-24 2015-09 N4376 Concurrency  
P0098R0 Towards Implementation and Use of memory order consume Paul E. McKenney, Torvald Riegel, Jeff Preshing, Hans Boehm, Clark Nelson, Olivier Giroux, Lawrence Crowl 2015-09-24 2015-09 N4321 Concurrency  
P0099R0 A low-level API for stackful context switching Oliver Kowalke, Nat Goodspeed 2015-09-27 2015-09 N4397 Concurrency  
P0100R0 Comparison in C++ Lawrence Crowl 2015-09-27 2015-09 N4367 Library Evolution  
P0101R0 An Outline of a C++ Numbers Technical Specification, Lawrence Crowl 2015-09-27 2015-09   Numerics  
P0102R0 C++ Parametric Number Type Aliases Lawrence Crowl 2015-09-27 2015-09   Numerics  
P0103R0 Overflow-Detecting and Double-Wide Arithmetic Operations Lawrence Crowl 2015-09-27 2015-09   Numerics  
P0104R0 Multi-Word Integer Operations and Types Lawrence Crowl 2015-09-27 2015-09   Numerics  
P0105R0 Rounding and Overflow in C++ Lawrence Crowl 2015-09-27 2015-09 N4448 Numerics  
P0106R0 C++ Binary Fixed-Point Arithmetic Lawrence Crowl 2015-09-27 2015-09 N3352 Numerics  
P0107R0 Better support for constexpr in std::array Louis Dionne 2015-09-23 2015-09   Library Evolution  
P0108R0 Skeleton Proposal for Thread-Local Storage (TLS) Paul E. McKenney, JF Bastien 2015-09-24 2015-09   Concurrency  
P0109R0 Function Aliases + Extended Inheritance = Opaque Typedefs Walter E. Brown 2015-09-25 2015-09 N3471 Evolution  
P0110R0 Implementing the strong guarantee for variant<> assignment Anthony Williams 2015-09-25 2015-09   Evolution, Library Evolution  
P0112R0 Networking Library (Revision 6) Christopher Kohlhoff 2015-09-25 2015-09   Library Evolution  
P0113R0 Executors and Asynchronous Operations, Revision 2 Christopher Kohlhoff 2015-09-25 2015-09 N4242 Concurrency  
P0114R0 Resumable Expressions (revision 1) Christopher Kohlhoff 2015-09-25 2015-09 N4453 Concurrency  
P0116R0 Boolean conversion for Standard Library types Robert Kawulak 2015-09-25 2015-09   Library Evolution  
P0117R0 Generic to_string/to_wstring functions Robert Kawulak 2015-09-25 2015-09   Library Evolution  
P0118R0 Concepts-TS editors report Andrew Sutton 2015-09-26 2015-09   Concepts  
P0119R0 Overload sets as function arguments Andrew Sutton 2015-09-25 2015-09   Evolution  
P0120R0 constexpr unions and common initial sequences Anthony Williams 2015-09-25 2015-09   Evolution  
P0121R0 Working Draft, C++ extensions for Concepts Andrew Sutton 2015-09-25 2015-09   Concepts  
P0122R0 array_view: bounds-safe views for sequences of objects Neil MacIntosh 2015-09-25 2015-09   Library Evolution  
P0123R0 Unifying the interfaces of string_view and array_view Neil MacIntosh 2015-09-25 2015-09   Library Evolution  
P0124R0 Linux-Kernel Memory Model Paul E. McKenney, Ulrich Weigand 2015-09-25 2015-09 N4444 Concurrency  
P0125R0 std::bitset inclusion test methods Vittorio Romeo 2015-09-25 2015-09   Library  
P0126R0 std::synchronic Olivier Giroux 2015-09-24 2015-09 N4195 Concurrency  
P0127R0 Declaring non-type template arguments with auto James Touton 2015-09-25 2015-09   Evolution  
P0128R0 constexpr_if Ville Voutilainen 2015-09-26 2015-09   Evolution  
P0129R0 We cannot (realistically) get rid of throwing moves Ville Voutilainen 2015-09-26 2015-09   Evolution  
P0130R0 Comparing virtual functions Scott Wardle, Roberto Parolin 2015-09-27 2015-09   SG14  
P0131R0 Unified call syntax concerns Bjarne Stroustrup 2015-09-27 2015-09   Evolution  
P0132R0 Non-throwing container operations Ville Voutilainen 2015-09-27 2015-09   Evolution, Library Evolution  
P0133R0 Non-throwing container operations Ville Voutilainen 2015-09-27 2015-09   Evolution, Library Evolution  
P0134R0 Introducing a name for brace-or-equal-initializers for non-static data members Richard Smith 2015-09-23 2015-09   Evolution  
P0135R0 Guaranteed copy elision through simplified value categories Richard Smith 2015-09-27 2015-09   Evolution  
P0136R0 Rewording inheriting constructors (core issue 1941 et al) Richard Smith 2015-09-25 2015-09 N4429 Core  
P0137R0 Core Issue 1776: Replacement of class objects containing reference members Richard Smith 2015-09-27 2015-09 N4430 Core  

N4548: WG21 2015-07-20 Telecon Minutes—Roger Orr

A new WG21 paper is available. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N4548

Date: 2015-07-20

WG21 2015-07-20 Telecon Minutes

by Roger Orr


"Move to direct the Convener to transmit the approved updated Concepts TS working paper (attachment ts.pdf r2) for publication." [...] There were no objections, so the poll was carried.

N4546: Agenda and Meeting Notice for WG21 Concepts Telecon—Herb Sutter

New WG21 papers are available. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N4546

Date: 2015-06-29

Agenda and Meeting Notice for WG21 Concepts Telecon

by Herb Sutter


This meeting has the specific agenda of finalizing the Concepts PDTS ballot comment resolutions with the goal of approving a document for publication.

Standardizing Variant: Difficult Decisions—Anthony Williams

Techincal discussion information while standardizing N4542.

Standardizing Variant: Difficult Decisions

by Anthony Williams

From the article:

One of the papers proposed for the next version of the C++ Standard is N4542: Variant: a type safe union (v4). As you might guess from the (v4) in the title, this paper has been discussed several times by the committee, and revised in the light of discussions.

Boost has had a variant type for a long time, so it only seems natural to standardize it. However, there are a couple of design decisions made for boost::variant which members of the committee were uncomfortable with, so the current paper has a couple of differences from boost::variant. The most notable of these is that boost::variant has a "never empty" guarantee, whereas N4542 proposes a variant that can be empty.

Trip Report: C++ Standards Meeting in Lenexa, May 2015—Jason Merrill, Red Hat

With a Core language perspective, with extensive notes about modules discussions:

Lenexa C++ Meeting Report (Core Language)

by Jason Merrill

From the report:

Red Hat sent four engineers to the spring C++ meeting this year, in Lenexa, Kansas, a suburb of Kansas City.  It was hosted by Perceptive Software, a division of Lexmark.  The meeting went very smoothly overall; while there were some disagreements they were pretty cordial...

Trip report: Spring ISO C++ meeting

(I'm writing my trip report now that all the post-meeting papers are available and linkable this week.)

The spring ISO C++ meeting was held on May 4-9 in Lenexa, KS, USA. Many thanks again to Lexmark for hosting us! There were 93 experts at this meeting, officially representing 5 nations. Last fall’s meeting (see trip report) saw a recent-record number of over 120 papers; for this meeting it was over 140 papers in the two pre-meeting mailings (February and April).

As usual, we met for six days, starting Monday morning and ending on Saturday afternoon, with a number of evening sessions to fill out the round-the-clock technical discussions.

There was particular interest in planning for C++17; this was the subject of the Monday evening sessions led by Bjarne Stroustrup based on this draft “Thoughts on C++17” paper published a week before the meeting... after Bjarne’s initial internal and more informal committee email leaked to Reddit. There’s nothing like having a forcing function to write up an actual paper!

For a detailed list of papers that were adopted at this meeting, see the post-meeting mailing that just went live for the papers marked “Adopted 2015-05.” Also, check out STL’s nice summary posted on Reddit, and the video “The future of C++[17] -- Updates from Lenexa” on Channel 9 with Gabriel Dos Reis and Artur Laksberg. [ETA: Also Botond Ballo's detailed trip report.]

TS Milestones: 3 Completed, 1 Sent For Comment Ballot

We finished three more Technical Specifications, incorporating their ballot comments and sending the final text to ISO for publication. These should all be formally published this summer: Transactional Memory TS (project editor: Michael Wong), Parallelism TS (project editor: Jared Hoberock), and the Library Fundamentals TS (project editor: Jeffrey Yasskin). All of them had only minor tweaks at this meeting.

In addition, we also sent the Concurrency TS out for its comment ballot (project editor: Artur Laksberg). We hope to address the comments at our fall meeting in Kona; if they can all be addressed in one meeting, the Concurrency TS would be completed this year, making four TSes published this year. I asked Artur for a summary and here’s what he wrote: “The Concurrency TS consists of three parts: First, it introduces improvements to std::future<T> to enable wait-free composition of asynchronous operations. It introduces the concepts of continuation (the “then” API) for chaining multiple futures as well join and choice operations, represented by, respectively, when_all and when_any APIs. Second, the TS introduces thread coordination mechanisms called latch, barrier and flex_barrier. These mechanisms allow one or more threads to block until an operation is completed. An individual latch is a single-use object: once the operation has been completed, it cannot be reused. A barrier is re-usable: once the operation has been completed, the threads can re-use the same barrier. Flex barriers allow additional behavior to be defined when an operation has completed. Finally, the TS introduces class templates atomic_shared_ptr<T> and atomic_weak_ptr<T>, which are useful for writing lock free code. Compared to the existing mechanisms, the new concepts offer superior performance and are less error-prone.” -- On a personal note, I’m especially happy with that last bit because that was my proposal. Not all proposals succeed even after several meetings’ worth of work, and it’s nice to see the atomic smart pointers make it into the TS.

Note that this means that in under 12 months we have published the C++14 International Standard and three Technical Specifications, and it’s possible that the Concurrency TS might become a fourth. That’s quite an achievement, and thanks very much to the above-mentioned editors and all of our hardworking project editors and contributors! You can always find a list of current projects and their editors at

Other Major Projects Update

The Concepts TS just completed its comment ballot, and we considered most of the ballot comments in Lenexa. We’re going to have one more telecon to finish the comments, then decide whether it’s ready to publish this year. Of course, what matters to you as a developer is not just when the committee blesses a document, but when you can try out the feature in your compiler, so I’m happy to report that my understanding is that vendors are not waiting for the TS to be published to implement Concepts in real compilers: I’m told that GCC expects to adopt the Concepts reference implementation into its next release, GCC 6, which if GCC follows its usual schedule would likely be spring 2016; and I’m also told that one or two other major implementations are working on implementing Concepts.

Modules also made good progress where the redesign led by Gabriel Dos Reis got encouragement form the committee and I’m told agreement among the major compiler vendors, though there are still a few important but relatively minor details to decide. Among the major C++ compilers, I’m told there should be at least one shipping experimental implementation of the current modules design available by the end of this year.

Ranges made great progress. Eric Niebler has worked hard over the winter and spring and brought initial draft wording for applying ranges to the entire iterators and algorithms clauses of the standard – this is no small wording undertaking! A reference implementation tracking the proposal is available on GitHub. We hope to see, and possibly adopt, initial working draft wording for Ranges at our fall meeting.

Networking is well on the way to producing a TS working paper based on the Boost.ASIO library with detailed wording also expected for the next meeting where we might be able to start a working draft.

Coroutines (await, generators) made good progress at this meeting and might also have working draft wording in Kona for the primary proposal: Visual C++ is shipping a reference implementation in VS2015, and my understanding is that at least one other major compiler is looking at implementing it this summer for possible release around the end of the year. There are also complementary/alternative coroutines proposals still in flight, so this is an active and important space.

Finally, Reflection had an evening session to progress some papers, and many other papers and proposals made progress too.

CppCon, Games, and a new SG14: Game Development and Low-Latency

I want to end with one interesting thing that happened in Lenexa that involves the C++ community beyond just the traditional standards committee attendees.

This past September, the first-ever CppCon was held, and it’s surprising how influential it already is. Here is one example. There at CppCon, we had a Meet the Authors session – that’s not too unusual at this kind of conference, and you might even think it would likely be a “lightweight” or “fluffy” kind of session. Well, never mind that there were a dozen heavyweight authors on the panel, from Bjarne Stroustrup and Scott Meyers on down all on the same stage, but that hour of discussion had real influence. In particular, the topic of ISO C++ and game development came up from the audience, and Michael Wong volunteered to arrange and lead a session later in the CppCon week on that topic. (CppCon deliberately leaves room for this kind of flexibility to be able to respond to whatever will get the most benefit out of the face-to-face time we have at the event.)

That extra session was strongly attended. In that session and since, Mike has continued to be approached by a steady stream of game developers who are interested in contributing to C++ standardization. And in addition to game-specific developers, there also seems to be a strong overlap with other developers interested in low latency programming for reasons other than frame rates.

What does all this have to do with the spring ISO C++ meeting? In Lenexa, Mike Wong reported the above backstory. When I polled the ISO C++ committee members in the room, a couple of dozen said they would be interested in participating in such work – and that’s a very strong response for a single topic area.

So this discussion that started brewing at CppCon has had a real result: At the Lenexa meeting, I created a new Study Group 14 on Game Development and Low-Latency Computing, with Mike Wong graciously volunteering to serve as the initial SG14 chair.

The next question was, how do we engage with this community? To get started, based on the community’s feedback through Mike, we realized need to overcome two particular challenges:

  • Some of these experts have submitted proposals to ISO C++ before, but it was at a time when the committee was busy shutting down C++11 and it might have appeared that the committee wasn’t interested (though we are).
  • These developers remain interested in contributing to C++ standardization, but they’re busy with their own conference schedule and product deadlines (so we need to meet them where they are).

Together, we felt this means we should start by meeting the gamers (and other low-latency developers) where they already are – by having official SG14 meetings “out in the field” starting at CppCon this September because that’s where they already were to start this drive last year. Having “side meetings on particular topic areas” that are separate from full ISO C++ meetings is exactly what Study Groups are for.

Our intention is to have formal SG14 meetings in the coming months located where these developers are, in addition to our full ISO C++ meetings:

1. SG14 @ CppCon 2015 in September. Mike and I will convene a full-day formal SG14 meeting at CppCon itself, currently tentatively scheduled for Wednesday. In attendance will be a number of long-time ISO C++ committee members and leadership, including but not limited to Mike (SG14 chair, CEO of OpenMP, and chair of Canada’s C++ committee), Ville Voutilainen (WG21 Evolution Working Group chair, Finland C++ committee), and myself (WG21 convener). We hope this shows we’re serious about engaging on this topic area! The agenda will be to entertain proposal ideas, to find a core set of proposals that could have critical mass of support and volunteers that we can encourage work on, and to set a draft agenda for #2 below... (Note: CppCon registration is not required to attend just the SG14 meeting, but is required if you also want to attend some of the 100+ CppCon sessions.)

Following the outcome of meeting #1 at CppCon, there may also be topics raised at additional SG14 telecons, and/or the two intervening full ISO C++ meetings in October and February. Then...

2. SG14 @ GDC 2016 in March. Mike and I then plan to convene a 2-3 day SG14 meeting (or as much time as is needed), again likely on-site at GDC. As soon as this was suggested, ISO C++ committee member organizations in the room started approaching me to offer facilities support to host this meeting at the GDC site or within short walking distance.

Thanks again everyone in the game development and low-latency computing industries for the strong interest, and to the over 100 volunteers whose hard work behind the scenes made CppCon possible last year to enable this kind of interaction, and who are hard at work as we speak organizing it again this September! CppCon is clearly already getting to be “the place to be” for the whole C++ community – including the intersection of the standard and the industry. This is important, and great to see.

Next meeting

Our next full WG21 face-to-face meeting will be in October in Kona, HI, USA, hosted by Plum Hall and the Standard C++ Foundation.

In the meantime, over the summer we’ll be having several other smaller telecon meetings, including as noted above to try to finalize the Concepts TS and meet at CppCon for the new SG14.

Many thanks especially to the meeting hosts for graciously volunteering to organize these meetings!