CppCon 2016: Implementing `static` control flow in C++14--Vittorio Romeo

By Adrien Hamelin | Aug 4, 2017 01:09 PM | Tags: performance c++14

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Implementing `static` control flow in C++14

by Vittorio Romeo

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

There has always been great interest in imperative compile-time control flow: as an example, consider all the existing `static_if` proposals and the recently accepted `constexpr_if` construct for C++17.

What if you were told that it is actually possible to implement imperative control flow in C++14?

In this tutorial, the implementation and design of a compile-time `static_if` branching construct and of a compile-time `static_for` iteration construct will be shown and analyzed. These constructs will then be compared to traditional solutions and upcoming C++17 features, examining advantages and drawbacks.

Italian C++ Conference 2017: Videos published--Marco Arena

By Marco Arena | Aug 3, 2017 12:24 AM | Tags: community

I am very happy to announce we published all the videos of the Italian C++ Conference 2017:

C++ executors to enable heterogeneous computing in tomorrow's C++ today (Michael Wong)

Quicker Sorting (Dietmar Kühl)

Boost vs Qt: What Could They Learn From Each Other? (Jens Weller)

Monads for C++ (Bartosz Milewski)

Functional C++ for Fun and Profit (Phil Nash)

The second track is in Italian:

An overly simple C++ idiomatic pattern language for message-based product families (Carlo Pescio)

Lambda out: a simple pattern for generic output (Davide Di Gennaro)

Diversity and Inclusion in Microsoft (Paola Presutto)

Costruire un bridge C++ tra NodeJS e C# (Raffaele Rialdi)

Una libreria di rete asincrona scritta in C++ ispirata a Node.js (Stefano Cristiano)

The Italian C++ Conference 2017 videos are powered by Bloomberg.

CppCon 2016: Examining applications that do not terminate on std::bad_alloc--Sergey Zubkov

By Adrien Hamelin | Aug 2, 2017 01:48 PM | Tags: community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Examining applications that do not terminate on std::bad_alloc

by Sergey Zubkov

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

System memory holds a special place in the hierarchy of program resources; its availability is the implied precondition for many innocuous lines of code, from std::string::substr() to passing std::function＜＞ by value. The ability to always create another object is ingrained in the OOP mindset so much that it is often said that immediate termination is the cleanest way to handle memory allocation failures in most situations. Nevertheless, C++, when consistently applying RAII, makes it possible to treat memory allocation exactly as any other resource acquisition.

To what degree do actual applications take advantage of that possibility and what responses to allocation failures are there in the wild? This presentation will examine over 300 open source projects that incorporate explicit handling for std::bad_alloc, examine the causes (it’s not always “out of memory”), response strategies (it’s more than just rollback), and related practical considerations.

CppCon 2016: Iterator Haiku--Casey Carter

By Adrien Hamelin | Jul 31, 2017 12:10 PM | Tags: experimental efficiency

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Iterator Haiku

by Casey Carter

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Iterator Haiku: How five iterator categories blossomed into seven, and Sentinels trimmed them back to five again. Recently proposed changes to the ranges TS distill its seven iterator categories back to five without sacrificing any expressive power. Removing operations that are extraneous in the Sentinel world eliminates a potential source of programming errors.

itCppCon17: C++ executors to enable heterogeneous computing in tomorrow's C++ today--Michael Wong

By Marco Arena | Jul 31, 2017 03:18 AM | Tags: performance c++20

Videos of the Italian C++ Conference 2017 are popping up. Here is the keynote:

C++ executors to enable heterogeneous computing in tomorrow's C++ today

by Michael Wong

Slides

Summary of the talk:

For a long time, C++ has been outpaced by other models such as CUDA, OpenMP, OpenCL, HSA, which has offered Heterogeneous computing capability to enable dispatch to GPU, DSP, FPGA or other accelerators.
SG14 is an ISO C++ SG that works on low-latency, in the areas of Games, Financial, Embedded programming. One of their mandate is support of heterogeneous in Native C++, without having to drop to some other model as is needed today.
This talk will describe the first and possibly the most important step towards supporting heterogeneous computing with a description of C++ executors, an interface between concurrency constructs, and the agents/resources, one of which can be a GPU core, or a SIMD unit.  I have led a small group of experts from Google, Nvidia, Codeplay, and NASDAQ, to define a specification to enable separation of concerns in defining where, when, and how execution is done in service of the constructs in existing C++ standard library, Concurrency, Parallelism, Transactional Memory, and Networking TS.
This talk will help you understand these TSes which currently only works on CPUs and how they will tie together in future to enable execution on accelerators based on C++ models we already have today such as SYCL, HPX, Kokkos, and Raja. This will enable native C++ to be usable on machine learning algorithms on future self-driving cars, or medical devices.

CppCast Episode 111: Toronto Trip Report with Patrice Roy

By robwirving | Jul 28, 2017 07:02 AM | Tags: None

Episode 111 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Patrice Roy to talk about the changes made to the C++20 Draft at the Toronto C++ Standards Committee Meeting.

CppCast Episode 111: Toronto Trip Report with Patrice Roy

by Rob Irving and Jason Turner

About the interviewee:

Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 20 years. After a few years doing R&D and working on military flight simulators, he moved on to academics and has been teaching computer science since 1998. Since 2005, he’s been involved more specifically in helping graduate students and professionals from the fields of real-time systems and game programming develop the skills they need to face today’s challenges. The rapid evolution of C++ in recent years has made his job even more enjoyable.

He’s been a participating member in the ISO C++ Standards Committee since late 2014 and has been involved with the ISO Programming Language Vulnerabilities since late 2015. He has five kids, and his wife ensures their house is home to a continuously changing number of cats, dogs and other animals.

CppCon 2016: GDB - A Lot More Than You Knew--Greg Law

By Adrien Hamelin | Jul 26, 2017 01:15 PM | Tags: community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

GDB - A Lot More Than You Knew

by Greg Law

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

If you’re writing C++ for anything other than Windows, chances are that you occasionally break out GDB. This session presents some of the lesser known features of GDB that can change the way you debug. GDB has come a long way in the last few years and now does so much more than break, print, step and continue. Reversible debugging; Non-Stop Mode; Multi-process Debugging; and Dynamic Printf are but some of its best features, and its built-in Python scripting is particularly powerful. Join Undo co-founder and CEO, Greg Law, as he takes you through a series of demos to show some amazing tricks with GDB and some of its powerful new (and not-so-new) features that you may not have heard of.

CppCon 2016: Constant Fun--Dietmar Kühl

By Adrien Hamelin | Jul 24, 2017 12:43 PM | Tags: performance efficiency

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

Constant Fun

by Dietmar Kühl

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This presentation discusses why it is useful to move some of the processing to compile time and shows some applications of doing so. In particular it shows how to create associative containers created at compile time and what is needed from the types involved to make it possible. The presentation also does some analysis to estimate the costs in terms for compile-time and object file size.

Specifically, the presentation discusses:
- implications of static and dynamic initialization – the C++ language rules for implementing constexpr functions and classes supporting constexpr objects.
- differences in error handling with constant expressions.
- sorting sequences at compile time and the needed infrastructure – creating constant associative containers with compile-time and run-time look-up.

CppCon 2016: There and Back Again: An Incremental C++ Modules Design--Richard Smith

By Adrien Hamelin | Jul 21, 2017 10:54 AM | Tags: experimental community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:

There and Back Again: An Incremental C++ Modules Design

by Richard Smith

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

The Clang project has been working on Modules in one form or another for many years. It started off with C and Objective-C many years ago. Today, we have a C++ compiler that can transparently use C++ Modules with existing C++ code, and we have deployed that at scale. However, this is very separate from the question of how to integrate a modular compilation model into the language itself. That is an issue that several groups working on C++ have been trying to tackle over the last few years.

Based on our experience deploying the core technology behind Modules, we have learned a tremendous amount about how they interact with existing code. This has informed the particular design we would like to see for C++ Modules, and it centers around incremental adoption. In essence, how do we take the C++ code we have today, and migrate it to directly leverage C++ Modules in its very syntax, while still interacting cleanly with C++ code that will always and forever be stuck in a legacy mode without Modules.

In this talk we will present our ideas on how C++ Modules should be designed in order to interoperate seamlessly with existing patterns, libraries, and codebases. However, these are still early days for C++ Modules. We are all still experimenting and learning about what the best design is likely to be. Here, we simply want to present a possible and still very early design direction for this feature.

CppCast Episode 110: Coroutines with Gor Nishanov

By robwirving | Jul 21, 2017 07:07 AM | Tags: None

Episode 110 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Gor Nishanov to talk about the C++ Coroutines proposal.

CppCast Episode 110: Coroutines with Gor Nishanov

by Rob Irving and Jason Turner

About the interviewee:

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