I’m very pleased to announce that Dan Saks will be one of our keynotes this year! Dan is one of the world’s leading experts on the C and C++ programming languages and their use in developing embedded systems.

He is the president of Saks & Associates, which offers training and consulting in C, C++ and embedded programming. Dan has previously served as secretary of the ANSI and ISO C++ Standards committees and as a member of the ANSI C Standards committee.

Dan used to write the “Programming Pointers” column for embedded.com. He has also written for numerous publications including The C/C++ Users Journal, The C++ Report, The Journal of C Language Translation, Software Development, Embedded Systems Design and Dr. Dobb’s Journal. With Thomas Plum, he wrote C++ Programming Guidelines, which won a 1992 Computer Language Magazine Productivity Award. He has presented at conferences such as Software Development and Embedded Systems. More recently, he contributed to the CERT Secure C Coding Standard and the CERT Secure C++ Coding Standard.

Dan’s keynote, extern “C”: Talking to C Programmers About C++, will be about migrating C code (and C programmers) to modern C++:

Most of us have heard this story. We’ve even told it ourselves… C++ is nearly all of C, plus a whole lot more. Migrating code from C to C++ is pretty easy. Moreover, the migration itself can yield immediate benefits by exposing questionable type conversions that can be sources of latent bugs. After migration, the code performs as well in C++ as in the original C. And now that it’s C++, you have ready access to a wealth of advanced features you can (but don’t have to) use to implement enhancements. Who wouldn’t want that? Legions of C programmers, apparently. Despite the success of C++ in numerous application domains, C remains considerably more popular, especially in embedded, automotive, and aerospace applications. In many cases, projects resist C++ because their managers think the risks outweigh the benefits. In other cases, the resistance comes from programmers who persist in believing bad things about C++, even when those things aren’t true. What can the C++ community do to overcome this resistance? Drawing on lessons from cognitive science, linguistics and psychology, and (of course) computer science, this talk offers suggestions about how to make the case for C++ more persuasive to C programmers.

We’ve got some program previews from three tracks today:

Here’s some of our content on embedded programming:

We’ve also got a lot of great talks about the upcoming Coroutines TS:

And finally, some talks about accelerator and GPU programming:

Come join us at CppCon in Bellevue this September – registration is still open!

— Bryce Adelstein Lelbach

Implementing a Modern C++ MQTT Client for Embedded Devices

Many IoT (Internet of Things) devices have adopted MQTT (Message Queueing Telemetry Transport) as an efficient protocol for communication. Few IoT devices have embraced modern C++ as a viable language for implementations. MQTT is a reliable publish-subscriber based messaging protocol that can be found in diverse ecosystems such as servers, cell phones, and light bulbs. Unfortunately, existing open source libraries leave much to be desired and many are a rich source of bad practices when compared to modern techniques. This session will explore maqiatto, CiereLab’s open source MQTT client library written for embedded systems in modern C++ . There will be a brief demonstration of the library followed by digging into the design and implementation while providing the resource “cost” of various solutions. As we explore the C++14 code base to illustrate useful idioms and techniques for your own code we will answer the questions, what does is take to put modern C++ on a small OS-less device or a cell phone? Are there features to avoid? Join us and see how libraries can be elegantly designed and implemented for big or small targets alike.

Michael Caisse has been crafting code in C++ for 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and project recovery for failing multidisciplinary engineering projects. When he isn’t fighting with compilers or robots, he enjoys fencing with a sabre.

Control Freak++: Writing an Embedded RTPS Library in Modern C++

Software for embedded systems means writing code for a microprocessor with specs straight out of the 80s. But that doesn’t mean that embedded developers should be afraid of using the best tools that modern languages have to offer. This talk will explore embedded development through the source code of a modern C++ implementation of the RTPS (Real-Time Publish/Subscribe) wire protocol. Our targeting ARM STM32 microcontrollers (but generalizable to many platforms). We will put zero-cost abstractions to the test as we attempt to fit a system conforming to a 200-page OMG specification document onto an MCU with 384 KB of RAM and 2048 KB of flash. At a higher level, we will discuss the philosophy of using high-level abstractions in a low-level environment, and seek to settle the score with old-school C microcontroller hackers.

Jackie Kay is a software engineer at the Open Source Robotics Foundation, where she works on ROS, an open source framework for robotics software. She was a student volunteer at C++Now 2016 and a speaker at CppCon 2015.

An Introduction to C++ Coroutines

One of the most interesting new features being proposed for C++ standardization is coroutines, formerly known as “resumable functions”. C++ coroutines are designed to be highly scalable, highly efficient (no overhead), and highly extensible, while still interacting seamlessly with the rest of the C++ language.

This session will consist of an in-depth introduction to C++ coroutines. We will begin by looking at the rationale for adding coroutines to the C++ language. We will then demonstrate and explain a sequence of coroutines that gradually introduce the features of C++ coroutines. This part of the talk will show both how to write various forms of coroutines and also how the coroutines extensibility model enables existing libraries to be non-invasively adapted to work with C++ coroutines.

James McNellis is a senior engineer on the Visual C++ team at Microsoft, where he works on C++ library design and is responsible for the Microsoft C Runtime (CRT) and C Standard Library implementation. He can be found on Twitter at @JamesMcNellis.

C++ Coroutines: Under the Covers

Coroutines feel like magic. Functions that can suspend and resume in the middle of the execution without blocking a thread! We will look under the covers to see what transformations compilers perform on coroutines, what happens when a coroutine is started, suspended, resumed or cancelled. We will look at optimizations that can make a coroutine disappear into thin air.

Gor Nishanov is a Principal Software Design Engineer on the Microsoft C++ team. He works on the design of C++ coroutines. Prior to joining C++ team, Gor was working on distributed systems in Windows Clustering team.

Towards Heterogeneous Programming in C++

Current semiconductor trends show a major shift in computer system architectures towards heterogeneous systems that combine a CPU with other processors such as GPUs, DSPs and FPGAs; that work together, performing different tasks in parallel. This shift has brought a dramatic change in programming paradigms in the pursuit of a common language that will provide efficiency and performance portability across these systems. A wide range of programming languages and models has emerged over the last decade, all with this goal in their sights, and the trend is converging on C++ as the language of choice.

This new world of heterogeneous systems brings with it many new challenges for the C++ community and for the language itself, and if these were to be overcome then C++ would have the potential to standardize the future of heterogeneous programming. In fact this work has already begun in SG14 in form of a mandate to support massive parallel dispatch for heterogeneous devices in the C++ standard using recent models such as SYCL and HPX. A recent approach to solving these challenges comes in the form of SYCL, a shared-source C++ programming model for OpenCL. SYCL takes a very different approach from many before it, in that it is specifically designed to be standard C++ without any extensions to the language.

This talk will present the recent rise in demand for heterogeneous programming in C++ and the new challenges that this brings to the C++ community. It will then take a look at some of the different programming languages and models that have arrived in the heterogeneous landscape, the motivations behind them, how they have attempted to solve those challenges and what we can learn from them. Finally it will take a look at the future of heterogeneous programming in C++ and what that might look like.

Gordon Brown is a software engineer specializing in SYCL technologies and has been involved in the standardization of the Khronos standard and the development of Codeplay’s implementation from it’s inception.

Bringing Clang and C++ to GPUs: An Open-Source, CUDA-Compatible GPU C++ Compiler

GPU computing has gone mainstream. It is a dominant part of the performance landscape, providing the initial 10x performance lift to a wide variety of applications. However, programing for GPUs can be extremely challenging. C++ is rarely available in an unmodified form, and there are few portable and open source approaches available. One of the most popular platforms, CUDA, has no production quality open source implementation. As a consequence, its C++ support has lagged behind and it has been a less appealing area for researchers and others that weren’t comfortable relying on NVIDIA’s tooling.

However, today things are different. Clang is now a fully functional open-source GPU compiler. It provides a CUDA-compatible programming model and can compile most of the awesome CUDA libraries out there ranging from Thrust (the CUDA-enabled parallel algorithms library that gave rise to the new parallelism technical specification) to Eigen and TensorFlow.

In this talk we will give an overview of how LLVM and Clang support targeting C++ to GPUs, how they work to be compatible with existing CUDA code, and how you can build your code today to run on GPUs with this open source compiler.

Justin Lebar works at Google on the open-source Clang and LLVM projects to bring C++ and better compiler technology to GPU programming.