Journey to the Alps: Participating in the C++ Standardization Process

Recently on the Spot blog:

Trip Report: Journey to the Alps -- Participating in the C++ Standardization Process

by Nathan Wilson

From the article:

... At Spot Trading, we currently utilize many of the C++11 features -- lambdas, keyword auto, nullptr, move operations, constexpr, range based for loops, explicit overrides, atomic operations, threading, futures, and new pointer types. Bjarne Stroustrup has said that we want to be able to continue to make simple things simple. These features of the language, mentioned above, certainly do that...

Demystifying C++ lambdas—Feabhas

In case you missed it:

Demystifying C++ lambdas

by Feabhas

From the article:

Lambdas are one of the new features added to C++ and seem to cause considerable consternation amongst many programmers. In this article we’ll have a look at the syntax and underlying implementation of lambdas to try and put them into some sort of context.

C++14 Is Out!—Jose Daniel GarcĂ­a

A view from our primary ISO representative from Spain, commenting on C++14's approval one week ago and providing a nice set of highlights showing what's new.

C++14 Is Out!

Jose Daniel García 

From the article:

After the long process that took a decade to produce C++11, the standards committee tried to define a more streamlined process to deliver updates and new versions of the C++ language and its standard library more frequently. The first target was to produce a new version for 2014. Now we can say that we have achieved the milestone.

... So, what’s new in C++14? In the language itself you will find a bunch of new/improved features. If you ask which is the most relevant new feature, the most common answer you may get is “generic lambdas”...

Trip Report: Red Hat at the ISO C++ Standards Meeting (June 2014)

As we celebrate the approval of C++14 this week, another trip report from the recent ISO C++ meeting:

Red Hat at the ISO C++ Standards Meeting (June 2014): Core and Library

Red Hat at the ISO C++ Standards Meeting (June 2014): Parallelism and Concurrency

From the articles:

Recently Red Hat sent several representatives to the JTC1/SC22/WG21 C++ Standards Committee meetings, which were held in June 2014 at the University of Applied Sciences in Rapperswil, Switzerland...

CppCon Program Highlights, 15 of N: Standardization, and Domain Experiences

The CppCon 2014 conference program has been posted for the upcoming September conference. We've received requests that the program continue to be posted in "bite-sized" posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.


Finally, rounding out the conference program, we have five final talks to announce in this blog stream... the last, pending any late-breaking additions. The first two sessions are about C++ standardization, covering what the committee is doing now that C++14 has been approved, and what's coming next including well in advance of C++17. The final three are about using C++ in specific domains, ones that are not only interesting to hear about (from Cinder creative graphics in C++, to the very small with MIT/Harvard gene sequencing, to the very large of simulating the universe, no less) but also instructive for C++ developers in general as the sessions cover modern C++11/14 techniques and solutions that are broadly applicable across many other domains as well.

In this post:

  • The Committee Experience
  • What the committee did next!
  • Creative Coding with C++
  • Gamgee: A C++14 library for genomics data processing and analysis
  • Simulating the Universe using modern C++


The Committee Experience

What happens behind the closed doors of the ISO Standard Committee? And just how closed are they? The session collects some anecdotes and relates what it is like to get involved in the process of standardizing C++, from the perspective of someone attending their first meeting - me 10 years ago! - to now. We will hear some of the highs and lows along the way to C++11, some misconceptions of what might be involved, and get some idea of what happens during a typical standard meeting, and between. By the end you will have some idea of how the standard itself is actually formed, and hopefully spark the interest of folks who might be interested in getting involved themselves...

What the committee did next!

After inking 8 years to produce the C++11 standard (arguably 13) there was a feeling we should be able to produce new work faster, more incrementally. With the renewed interest in C++, we have more participation on the committee, and have looked to harness that enthusiasm in new ways. In the last 3 years we have spun up at least a dozen new study groups, and have 8 or mode Technical Specifications in various stages of development that we hope to ship over the next 12-24 months. So what are all these new groups and specifications about? Come to this session and get a vision of where C++ is headed in the immediate and short-term future.

Speaker: Alisdair Meredith, Bloomberg and Library Working Group chair. Alisdair Meredith is a software developer at BloombergLP in New York, and the C++ Standard Committee Library Working Group chair. He has been an active member of the C++ committee for just over a decade, and by a lucky co-incidence his first meeting was the kick-off meeting for the project that would become C++11, and also fixed the contents of the original library TR. He is currently working on the BDE project, BloombergLP's open source libraries that offer a foundation for C++ development, including a standard library implementation supporting the polymorphic allocator model proposed for standardization.


Creative Coding with C++

Realtime graphics, computer vision, hardware hacking, and audio synthesis are just a few of the crafts that fall under the banner term of "creative coding". In this session we'll talk about some of the creative projects putting C++ in places you might not expect it - everywhere from the Smithsonian's permanent design collection to robotic Coca-Cola dispensers on California beaches. We'll look at a wide spectrum of projects ranging from those of the "maker" community to commercial work from full-time professionals earning their livings in advertising and design agencies. And finally we'll take a look at how you can use the C++ you already know to jumpstart your own creative coding projects using the open source toolkit Cinder.

Speaker: Andrew Bell, Technology Research Fellow, The Barbarian Group. Andrew Bell is a Technology Research Fellow working at the creative agency The Barbarian Group. He maintains Cinder, a C++ open source creative coding framework, as his full-time job. When he's not coding on Cinder he can be found doing everything from writing emails about Cinder to being asleep, and yet somehow he remains single. In his career he has also coded too much in other capacities, specifically for the visual effects companies The Mill and Method.


Gamgee: A C++14 library for genomics data processing and analysis

Our group has defined the standards for DNA and RNA sequencing data processing and analysis for disease research and clinical applications. In the last 5 years we have published our tools in the GATK (genome analysis toolkit) which is completely written in java. With the scaling of next generation sequencing and the immense amount of that needs to be processed we hit a performance wall and found ourselves limited by the language to make optimizations and rewrite the algorithms in a way that would conform better to modern hardware.

Enter Gamgee. A free and open source C++14 library that offers much of the functionality of the GATK framework with the performance necessary to scale to the hundreds of petabytes of todays complex diseases projects. We will show how the tools developed using the Gamgee library replaced legacy java GATK tools in the production pipeline of the Broad Institute. We will also talk about how the algorithms have changed to take advantage of the native libraries and modern hardware features such as SSE/AVX and GPUs.

Speaker: Mauricio Carneiro, Group Lead, Computational Technology Development, Broad Institute of MIT and Harvard. Dr. Carneiro leads the computational technology development team at the Broad Institute of MIT and Harvard. He has contributed to major advances in DNA sequencing analysis with compression algorithms, statistical methods, heterogeneous compute optimizations and a systematic approach to the institute's computational development, distribution and support. His team is also responsible for the evaluation of new sequencing technologies and has provided several methods and tools to handle new data types in the world of next generation sequencing through the Genome Analysis Toolkit (GATK). Dr. Carneiro joined the Broad Institute in December 2010 after completing a Ph.D. in computational biology from Harvard University. He holds two championships in the International Collegiate Programming Contest organized by the Association for Computing Machinery (ACM) in 2002 and 2003, respectively, and a Programming Excellence Award from the ACM Upsilon Pi Epsilon Society in 2003. In his previous life, he was a video game developer and has led the development of the world's first massive online location based multiplayer game: Alien Revolt.Website: handle: @mauricinho


Simulating the Universe using modern C++

What is the link between C++11/14, parallelism and the open question of the origin of the accelerated expansion of the Universe ? Answer: numerical cosmology and all the techniques to make the best out of supercomputers to shed a new light on unsolved problem in physics. In this talk, I will present the numerical lessons coming from the Full Universe Run, a numerical experiment realized in 2012 on the entire Curie thin-nodes Supercomputer to simulate the evolution of cosmological structures during the last 13.7 billion years. I will focus on how this experiment has changed our view on software design in astrophysics and how we started to implement new approaches using C++11, template metaprogramming, constant expressions and std::thread in order to maximize both genericity and performance. I will also discuss optimization issues related to data locality, cache efficiency and spatial trees which are extensively used in our domain. I will also try to give some inputs on the cultural challenges raised by the introduction of C++11/14 in our domain. This talk will be concluded by thoughts on the needs of computational physicists and how C++17 may help us to solve some of the open problems we are currently facing.

Speaker: Vincent Reverdy, Ph.D. student, Observatory of Paris. Vincent Reverdy is a Ph.D. student in numerical cosmology at the Observatory of Paris. He studies the propagation of light according to general relativity in order to probe the unexplained accelerated expansion of the Universe. In this context, he is using supercomputing facilities on a daily basis and he develops scientific codes for these facilities, mainly in C++. He is working now on approaches based on template metaprogramming to make the best out of supercomputers and to facilitate the implementation of non-standard cosmological models. Since the Bristol committee meeting, he also follows and contributes to the online discussions on the evolution of C++.

Near-final version of Effective Modern C++ available—Scott Meyers

Scott's long-awaited book on using C++11 and C++14 is nearing completion:

Near-Final Draft of Effective Modern C++ Now Available (plus TOC and sample Item)

by Scott Meyers

From the announcement:

Effective Modern C++ is moving closer and closer to reality. This post contains:

  •     Information about availability of an almost-final draft of the book.
  •     The current (and probably final) table of contents.
  •     A link to the I-hope-I-got-it-right-this-time version of my Item on noexcept.

Note: Scott's session at CppCon ("Type Deduction and Why You Care") is based on the first chapter of Effective Modern C++.

CppCon Evening Panel Topics Confirmed—Boris Kolpackov

Announced this morning, as part of the free-and-open-to-all part of the CppCon program:

Evening Panel Topics Confirmed

by Boris Kolpackov 

From the announcement:

We have now confirmed details for the Monday [8:30pm], Wednesday [8:30pm], and Friday [2:00pm] panels:

Monday: "Meet the Authors"

Moderator: Chandler Carruth

Panelists: Ade Miller, Alex Allain, Kate Gregory, Pablo Halpern, Scott Meyers, Peter Sommerlad, Herb Sutter

Come to this panel to put your questions to many of the world’s top C++ published authors, and hear them discuss what they think is most important about C++ today. The CppCon 2014 program includes many of the world’s top C++ published authors, so we’re taking advantage of their being in town to bring them together in our opening panel for a discussion and Q&A session.

Wednesday: "Grill the Committee"

Moderator: Jon Kalb

Panelists: Chandler Carruth, Nevin Liber, Alisdair Meredith, Herb Sutter, Michael Wong

What would you like to know about how the C++ Standard happens? The panel is made up of members of the C++ Standards Committee and the audience asks what’s on their mind.

Friday: "Paying for Lunch: C++ in the ManyCore Age"

Moderator: Herb Sutter

Panelists: Jared Hoberock, Artur Laksberg, Ade Miller, Gor Nishanov, Michael Wong, Pablo Halpern

If you’re serious about efficient computation, from efficient battery-sipping apps on mobile devices to efficient use of compute cloud nodes, you need to know how to exploit the massive parallelism already available in all of today’s mainstream devices. Even small tablets and smartphones already contain multiple CPU/GPU cores and vector units. CppCon 2014 includes lots of talks about implementing such parallelism in C++ using existing products and techniques, and the standardization committee is actively working on standardizing several C++ extensions for concurrency and parallelism, including resumable functions, a Parallel STL, and transactional memory support. In this panel, we bring together several experts, including the primary authors of these products and standard specifications – in other words the who’s-who driving C++ parallelism forward – to discuss this topic across all devices and form factors, large and small.

CppCon Program Highlights, 14 of N: Parallel Computation on GPUs

The CppCon 2014 conference program has been posted for the upcoming September conference. We've received requests that the program continue to be posted in "bite-sized" posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.


In addition to other performance-focused CppCon talks posted yesterday, CppCon 2014 also has thorough coverage of a very specific form of high performance parallel code -- using GPUs for general-purpose computation (aka GPGPU). This is important because every desktop machine and notebook, and nearly every tablet and smartphone, contains not only multiple CPU cores and vector units, but also a "compute-class" GPU -- these three forms of hardware parallelism are part of the mainstream hardware platform for the foreseeable future in all form factors. If you have a computationally intensive app or an app that could benefit from faster local processing, and you're not exploiting the GPU, you're leaving performance (and battery life) on the table and should be sure to attend these sessions.

In this post:

  • Writing Data Parallel Algorithms on GPUs
  • Another fundamental shift in Parallelism Paradigm? OpenMP 4.0 for GPU/Accelerators and other things
  • Introduction to C++ AMP (GPGPU Computing)


Writing Data Parallel Algorithms on GPUs

Today most PCs, tablets and phones support multi-core processors and most programmers have some familiarity with writing (task) parallel code. Many of those same devices also have GPUs but writing code to run on a GPU is harder. Or is it?

Getting to grips with GPU programming is really about understanding things in a data parallel way. This talk will look at some of the common patterns for implementing algorithms on today's GPUs using examples from the C++ AMP Algorithms Library. Along the way it will cover some of the unique aspects of writing code for GPUs and contrast them with a more conventional code running on a CPU.

Speaker: Ade Miller. Ade Miller writes C++ for fun. He wrote his first N-body model in BASIC on an 8-bit microcomputer 30 years ago and never really looked back. Recently, he's written two books on parallel programming with C++; "C++ AMP: Accelerated Massive Parallelism with Microsoft Visual C++" and "Parallel Programming with Microsoft Visual C++". Ade spends the long winters in Washington contributing to the open source C++ AMP Algorithms Library and well as a few other projects. His summers are mostly spent crashing expensive bicycles into trees.


Another fundamental shift in Parallelism Paradigm? OpenMP 4.0 for GPU/Accelerators and other things

Another fundamental shift in Parallelism Paradigm? Sure. When was the last time you heard that before?

But seriously, as the number of threads/cores continue to increase, there is a growing pressure on applications to exploit more of the available parallelism in their codes, including coarse-, medium-, and fine-grain parallelism. OpenMP has been one of the dominant shared-memory programming models but is evolving beyond that with a new Mission Statement (no, really!) making it well suited for exploiting medium- and fine-grained parallelism.

OpenMP 4.0 exhibits many of these features to support the next step in both consumer, high-performance and exascale computing, with one of the world's first programming model for high-level language support for GPU/Accelerators and vector SIMD across not 1 but 3 high-level languages: C++, C, and that language whose name we dare not speak, but starts with F.

Speaker: Michael Wong, OpenMP CEO/Architect, IBM/OpenMP. Anything including C++, Transactional Memory, Parallel Programming, OpenMP, stars, tennis, travel, and the best food.


Introduction to C++ AMP (GPGPU Computing)

Meet C++ AMP (Accelerated Massive Parallelism), an abstraction layer on top of accelerators such as GPUs. In its current version it allows you to run code on any DX11 GPU, independent of the vendor, and it will even distribute workload across GPUs of different vendors simultaneously. C++ AMP was originally designed by Microsoft but is now an open standard. C++ AMP can deliver orders of magnitude performance increase with certain algorithms by utilizing the GPU to perform mathematical calculations. This talk will give a high level overview of what C++ AMP is and what it can do for you. It is time to start taking advantage of the computing power of GPUs!

Speaker: Marc Gregoire, Nikon Metrology. Marc Gregoire has worked as a software engineer consultant for 6 years for Siemens and Nokia Siemens Networks on critical 2G and 3G software running on Solaris for telecom operators. This required working in international teams stretching from South America and USA to EMEA and Asia. Now, Marc is working for Nikon Metrology on 3D scanning software. Marc is the author of "Professional C++, Second and Third Edition", published by Wiley/Wrox, is the founder of the Belgian C++ Users Group (, and has written a number of articles which have been published on CodeGuru and/or his personal blog. He also creates freeware and shareware programs that are distributed through his website at, and maintains a blog on