CppCon 2014 Meta Techniques: Heterogeneous Polymorphism&Fast Prototyping at Facebook--Marcelo Juchem

By Adrien Hamelin | Mar 2, 2015 08:00 AM | Tags: intermediate c++14

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Meta Techniques: Heterogeneous Polymorphism & Fast Prototyping at Facebook

by Marcelo Juchem

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

As data driven systems evolve there's an ever growing demand for bringing new functionality into existing systems in an efficient, maintainable and least intrusive manner. When implementing features with different semantics or interfaces, virtual inheritance requires a compromise between design simplicity and performance. This implies a need for new techniques to achieve heterogeneous polymorphism efficiently. With C++11 and 14, type lists, type maps and variants can now be trivially implemented by the initiated. Facebook moves fast so we quickly adopted the new standards to further explore the capabilities of the type system. This talk demonstrates some meta-programming techniques like reflection and compile-time built structures to achieve heterogeneous polymorphism and fast prototyping.

CppCon 2014 Overview of Parallel Programming in C++--Pablo Halpern

By Adrien Hamelin | Feb 27, 2015 08:00 AM | Tags: performance intermediate

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Overview of Parallel Programming in C++

 

by Pablo Halpern

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Parallel programming was once considered to be the exclusive realm of weather forecasters and particle physicists working on multi-million dollar super computers while the rest us relied on chip manufacturers to crank out faster CPUs every year. That era has come to an end. Clock speedups have been largely replaced by having more CPUs on a chip. Your typical smart phone now has 2 to 4 cores and your typical laptop or tablet has 4 to 8 cores. Servers have dozens of cores and supercomputers have thousands of cores.

If you want to speed up a computation on modern hardware, you need to take advantage of the multiple cores available. This talk is provides an overview of the parallelism landscape. We'll explore the what, why, and how of parallel programming, discuss the distinction between parallelism and concurrency and how they overlap, and learn about the problems that one runs into. We'll conclude with an overview of existing parallelism technologies in C++ and the future directions being considered for parallel programming in standard C++.

CppCon 2014 C++11 in the Wild: Techniques from a Real Codebase--Arthur O'Dwyer

By Adrien Hamelin | Feb 25, 2015 08:00 AM | Tags: intermediate c++11

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

C++11 in the Wild: Techniques from a Real Codebase

by Arthur O'Dwyer

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This talk presents several reusable constructs from a production C++11 codebase, each of which would not be possible without C++11's new features. Auto() is what Alexandrescu's ScopeGuard looks like after a dozen years of C++ evolution. make_iterable() constructs a container from a pair of iterators, enabling simple "foreach" iteration over legacy containers. spaceship() is an efficient "strcmp" for tuples. Time permitting, we'll look at some more arcane code samples.

CppCon 2014 Using C++ on Mission and Safety Critical Platforms--Bill Emshoff

By Adrien Hamelin | Feb 23, 2015 08:00 AM | Tags: advanced

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Using C++ on Mission and Safety Critical Platforms

by Bill Emshoff

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

The Joint Strike Fighter (JSF) is the first major DOD aircraft program to use C++. Much of this software is either safety critical or mission critical and so must be written in such a way as to be clear, readable, unambiguous, testable, and maintainable. We discuss the driving requirements behind the standard and its evolution. We give a quick overview of our standard and discuss how it differs from later standards such as MISRA C++. We discuss lessons learned over our nine year history of applying the standard to a large embedded software program. We also address ambiguities in rules and difficulties with automated checking of conformance with the standard.

Video Tutorial: Handle-based entity management -- Vittorio Romeo

By Vittorio Romeo | Feb 23, 2015 06:35 AM | Tags: intermediate c++11

Almost every C++ application and game deals with entity management.

Video Tutorial -- Handle-based entity management

By Vittorio Romeo

From the tutorial:

Entities are usually self-contained objects that...

• ...store data and/or logic.
• ...are tied a specific concept (e.g. an UI widget, or a 3D model).
• ...we need to keep track of.
• ...can either be alive or dead.
• ...are extremely often used in groups.

Problem: we need to keep track of specific entity instances, and iterate on every instance. We also need to remove dead entities and add new entities.

Keeping track of specific instances is easily solved with pointers and smart pointers.
Fast-iteration of a group of objects with the same type is achieved with cache-friendly memory locality and no indirection.
Adding and removing entities stored in a cache-friendly manner invalidates existing pointers.

How can we facilitate instance tracking/addition/removal and still allow fast iteration?

In this video, we will create a generic container that stores objects in a cache-friendly way, allows to keep track of specific object instances and also allows addition and removal of entities. 
 

CppCon 2014 Make Simple Tasks Simple!--Bjarne Stroustrup

By Adrien Hamelin | Feb 20, 2015 08:00 AM | Tags: c++14 c++11 basics

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Elevate Your Code to Modern C++11 with Automated Tooling

by Bjarne Stroustrup

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

C++ faces two challenges: Helping programmers address the most demanding tasks in terms of performance, scale, and dependability. It must also help programmers be productive writing ordinary maintainable code. There is much more "ordinary code" than there is performance-critical code. Thus, C++ must make simple tasks simple while not getting in the way of tuning software for the last byte and last cycle where that's necessary. This talk focuses on what C++11 and C++14 offers to simplify programming: auto, range-for loops, move semantics, futures, concepts, and more. However, the focus is not primarily on language features: the key is programming: how can we write better, more readable, efficient, and more maintainable code? If you think that the essence of C++ is clever pointer manipulation and huge class hierarchies you may be in for a few surprises.

All videos of Meeting C++ 2014 are online!

By Meeting C++ | Feb 20, 2015 03:49 AM | Tags: performance meeting c++ intermediate experimental community c++14 c++11 basics advanced

Yesterday I uploaded the last video of Meeting C++ 2014:

All videos of Meeting C++ 2014 are online!

by Jens Weller

From the article:

I uploaded yesterday the last video of last years Meeting C++ conference! So you can now watch all 21 talks and the 2 keynotes at youtube!

cppcast episode 1: Jon Kalb loves the C++ Community

By robwirving | Feb 18, 2015 09:00 PM | Tags: community basics

This is the first episode of cppcast, the only podcast by C++ developers for C++ developers. In this first episode host Rob Irving interviews Jon Kalb about the state of the C++ Community.

cppcast episode 1: Jon Kalb loves the C++ Community

by Rob Irving

About the interviewee:

Jon has been writing C++ for two and half decades, does onsite C++ training, and works on the Amazon search engine for A9.com. He chairs the CppCon and C++Now conferences. He also programs the C++ Track for the Silicon Valley Code Camp and serves as chair of the Boost Libraries Steering Committee.

CppCon 2014 Elevate Your Code to Modern C++11 with Automated Tooling--Peter Sommerlad

By Adrien Hamelin | Feb 18, 2015 08:00 AM | Tags: intermediate c++11

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Elevate Your Code to Modern C++11 with Automated Tooling

by Peter Sommerlad

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This talk will motivate and demonstrate how to transform your existing C++ code into more modern style and better quality. A key to that is refactoring the code into better shape. While manual refactoring can be tedious and error prone the author demonstrates automated refactoring that was created by his students and assistants and himself over the last nine years on the basis of Eclipse CDT. The tooling works with all compilers, because it is independent of one.

For example, we will show how to eliminate unnecessary macros or replace them by type-safe C++11/14 alternative code automatically. Or, to replace pointers, plain arrays and manual memory management by references, smart pointers, std::string, std::array, or std::vector automatically. Also other transformations, such as introducing a template parameter to reduce a coupling to a single concrete type are demonstrated. All with the goal to modernize and hopefully simplify your C++ code. Even if you are not deeply interested in modernizing your code base, some helpful tooling, such as toggling function definitions into a single place, to change their signature, can be of great help. On the other hand, many of the proposed improvements can also be applied with your favorite code editor only more tediously.

CppCon 2014 Type Deduction and Why You Care--Scott Meyers

By Adrien Hamelin | Feb 16, 2015 08:00 AM | Tags: c++14 advanced

While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:

Type Deduction and Why You Care

by Scott Meyers

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

C++98 had template type deduction, and it worked so intuitively, there was little need to understand what took place under the covers. C++11 extends type deduction to include universal references, applies it to auto variables and lambda expressions, then throws in a special auto-only deduction rule. C++14 pushes the boundary further, adding two forms of function return type deduction (auto and decltype(auto)) for arbitrary functions and offering auto parameters for lambdas. The result is that what could be treated as a black box in C++98 has become a topic that practicing C++ developers really need to understand. This talk will give you the information you need to do that.