C++ Weekly Episode 12: C+17's std::any -- Jason Turner
Episode 12 of C++ Weekly.
C++17's std::any
by Jason Turner
About the show:
In this episode Jason introduces std::any from the upcoming proposed C++17 standard.
Video & On-Demand
James McNellis' talks @Italian C++ Conference 2016
The talks James McNellis gave at the Italian C++ Conference 2016 are now online:
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 and then look at several examples that show [1] how to write a coroutine, [2] how to use the extensibility model to adapt existing libraries to work with C++ coroutines, and [3] how coroutines really work “under the hood,” using the Visual C++ implementation as a reference. Finally, we will look briefly at the status of the C++ coroutines proposal and some of the competing ideas.
Adventures in a Legacy Codebase
Three years ago, the Visual C++ team undertook a project to substantially modernize and redesign the Microsoft C Runtime (CRT) with the goals of improving long-term maintainability, performance, and usability. This work culminated with the release of the Universal CRT with Windows 10 and Visual Studio 2015.
In this session, I will discuss our team’s experiences from this project. We’ll look at some of the techniques we used in modernizing a decades-old codebase and look at some of the challenges that we faced, lessons that we learned, and best practices that we developed during the course of the project.
CppCon 2015 Faster Complex Numbers--André Bergner
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
Faster Complex Numbers
by André Bergner
Summary of the talk:
Complex numbers are an important tool from mathematics enabling many problems to be written in a more generic form. The C++ standard library comes with an implementation to work with complex numbers in a natural way.
Motivated by useful real world examples from theoretical physics and audio dsp I will discuss benchmarks of std::complex and demonstrate how alternative implementations, naïve or advanced ones based on expression templates, outperform std::complex and can compete with hand-crafted C code (depending on compiler and std lib). A quick introduction to expression templates will be provided.
ACCU 2016 All videos are online
All videos from the this year's ACCU conference are now online.
ACCU 2016 Videos
by the ACCU
From the schedule
The keynotes were:
Jim Coplien: A Glimpse of Trygve: From Class oriented Programming to Real OO
Andrei Alexandrescu: Fastware
Marian Petre: Balacing Bias in Software Development
Anna-Jayne Metcalfe: Comfort Zone
The talks with C++ content in no particular order were:
Dietmar Kühl: Constant Fun
Roger Orr: C++ Concepts 'Lite' in Practice
Felix Petriconi: Leaving The Dark Side - Behaviour Testing of a C++ Based Medical Device
J. Daniel Garcia: Improving Performance and Maintainability in Modern C++
Marshall Clow: STL Algorithms – How to Use Them and How to Write Your Own
Kevlin Henney: Declarative Thinking, Declarative Practice
Dmitri Nesteruk: Design Pattern in Modern C++
Jamie Allsop: Managing C++ Build Complexity Using Cuppa: A SCons-based Build System
Nikos Athanasiou: Benchmarking in C++
Sławomir Zborowski: What Every C++ Programmer Should Know About Modern Compilers
Peter Sommerlad: Visualize Template Instantiations - Understand your Template Bugs
Peter Sommerlad: Using Units, Quantities, and Dimensions in C++14
Niall Douglas: Distributed Mutual Exclusion using Proposed Boost.AFIO
John Lakos: Proper Inheritance Part 1 (Part 2 is not available)
Bernhard Merkle: Finding Bugs with Clang at Compile and Run Time
Guy Davidson: WG21-SG14: The Story So Far
C++ Weekly Episode 10: Variadic Expansion Wrap-Up
Episode 10 of C++ Weekly.
Variadic Expansion Wrap-Up
by Jason Turner
About the show:
In this episode Jason wraps up what we've learned so far about variadic templates and shows some additional techniques to consider.
CppCon 2015 Expression Templates - Past, Present, Future--Joel Falcou
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
Expression Templates - Past, Present, Future+
by Joel Falcou
Part 1: (watch on YouTube) (watch on Channel 9)
Summary of the talk:
Expression Templates is one of this C++ idiom people learn to either love or hate. The main issues with ET is that everubody has its own conception about what they are, when they should be used, what benefits they give and what are their trade off. For a long time, Expression Tempaltes has been seen has a way to improve temporary heavy code. If the seminal implementation of ET by Todd Veldhuizen was actually about this, the landscape has changed since C++11 and C++14.
This workshop will go over : - what are exactly Expression Templates and what kind of use case they can solve elegantly and efficiently - what are the benefits that one may reap by using expression tempalte in its library - what are the real cost of expressont empaltes both at runtime and compile-time - which tools to use to not reinvent the tempalte wheel everytime including an introduction to Boost.PROTO an Boost.HANA.
The main objective is to clarify why, even in C++1*, this idiom has a meaningful set of applications and how to navigate around its pitfalls.
CppCon 2015 Implementation of a component-based entity system in modern C++--Vittorio Romeo
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
Implementation of a component-based entity system in modern C++
by Vittorio Romeo
Summary of the talk:
An alternative to deep inheritance trees for game and application architecture design is "composition". Separating data (in independent components) from logic (in independent systems) allows the code to be more reusable and more efficient, alongside additional benefits. Using modern C++11 and C++14 features, it is possible to design an efficient and user-friendly component-based entity system library, with intuitive syntax and convenient cost-free abstractions.
CppCon 2015 Ranges for the Standard Library--Eric Niebler
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
Ranges for the Standard Library
by Eric Niebler
Summary of the talk:
Range-based interfaces are functional and composable, and lead to code that is correct by construction. With concepts and ranges coming to the STL, big changes are in store for the Standard Library and for the style of idiomatic C++. The effort to redefine the Standard Library is picking up pace. Come hear about one potential future of the STL from one of the key people driving the change.
CppCon 2015 Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!--Chandler Carruth
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!
by Chandler Carruth
Summary of the talk:
A primary use case for C++ is low latency, low overhead, high performance code. But C++ does not give you these things for free, it gives you the tools to control these things and achieve them where needed. How do you realize this potential of the language? How do you tune your C++ code and achieve the necessary performance metrics?
This talk will walk through the process of tuning C++ code from benchmarking to performance analysis. It will focus on small scale performance problems ranging from loop kernels to data structures and algorithms. It will show you how to write benchmarks that effectively measure different aspects of performance even in the face of advanced compiler optimizations and bedeviling modern CPUs. It will also show how to analyze the performance of your benchmark, understand its behavior as well as the CPUs behavior, and use a wide array of tools available to isolate and pinpoint performance problems. The tools and some processor details will be Linux and x86 specific, but the techniques and concepts should be broadly applicable.
C++ Weekly Episode 9: std::future Quick-Start -- Jason Turner
Episode 9 of C++ Weekly.
std::future Quick-Start
by Jason Turner
About the show:
In this episode Jason gives a very fast quick-start to what std::future is and how to use std::async to run a function in another thread.