Google releases gRPC -- Mugur Marculescu

By NoSenseEtAl | Feb 27, 2015 10:40 AM | Tags: None

A new open source HTTP/2 RPC Framework for C++ and other languages has been released.

Introducing gRPC, a new open source HTTP/2 RPC Framework

by Mugur Marculescu

From the article:

Today, we are open sourcing gRPC, a brand new framework for handling remote procedure calls. It’s BSD licensed, based on the recently finalized HTTP/2 standard, and enables easy creation of highly performant, scalable APIs and microservices in many popular programming languages and platforms. Internally at Google, we are starting to use gRPC to expose most of our public services through gRPC endpoints as part of our long term commitment to HTTP/2.

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++.

Operator Overloading – Introduction to Boost.Operators -- Arne Metz

By Felix Petriconi | Feb 27, 2015 12:45 AM | Tags: boost basics

Arne Mertz goes into the details of using boost operators.

Operator Overloading – Introduction to Boost.Operators, Part 1

Operator Overloading – Introduction to Boost.Operators, Part 2

by Arne Mertz

From the articles:

In my first two posts about operator overloading I have written about the basics and common practice. This post shows some lessons from the common practice post on a concrete example and then introduces to Boost.Operators, a library that conveniently reduces the boilerplate involved when overloading multiple operators for a class.

Operators Travel in Packs

If we look at the list of operators, we see that there are about 50 of them, and many of them can be overloaded in different ways. Even if we restrict ourselves to a few operations that make sense for a given class, then one of those operations often brings two or more operators.

 

SFINAE std::result_of? Yeah, right!--Scott Prager

By Adrien Hamelin | Feb 26, 2015 02:10 PM | Tags: c++11 advanced

On the matter of having a useful error message:

SFINAE std::result_of? Yeah, right!

by Scott Prager

From the article:

Return type deduction pre-decltype and auto could really make one mad. Back then, if you wanted a function object, you had to make it "adaptable", meaning it had to inherit from std::unary_ or binary_function and define its first_argument_type, second_argument_type, and result_type. There had been no concept of "transparent functors" allowing us to pass polymorphic functions to higher order functions (like std::plus<> to std::accumulate). For an example of programming in these dark ages, check out the FC++ FAQ.

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.

Type Deduction and Braced Initializers--Arne Mertz

By Adrien Hamelin | Feb 23, 2015 02:39 PM | Tags: c++11 basics

If you are confused about the topic, read this article:

Type Deduction and Braced Initializers

by Arne Mertz

From the article:

I just finished watching a talk from CppCon 2014 by Scott Meyers: Type Deduction and Why You Care. All in all it was a very interesting and entertaining talk, and I learned a thing or two, especially about the combination of type deduction and braced initializers. Since this blog is about simplifying the use of C++, I want to have a short look at that special combination and derive a rule of thumb from it...

Non Static Data Members Initialization--Bartlomiej Filipek

By Adrien Hamelin | Feb 23, 2015 02:32 PM | Tags: c++11 basics

Here is a useful thing to know that appeared with C++11:

Non Static Data Members Initialization

by Bartlomiej Filipek

From the article:

My short summary for non static data members initialization from modern C++. A very useful feature. Should we use it or not?

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. 
 

John Lakos interviews Alexander Stepanov and Daniel Rose on their new Book

By Mantosh Kumar | Feb 21, 2015 10:38 PM | Tags: None

Published on InformIT in which John Lakos interviews Alexander Stepanov and Daniel Rose about various aspects of generic programming and modern C++.

From Mathematics to Generic Programming: An Interview with Alexander Stepanov and Daniel Rose

 

John Lakos interviews Alexander Stepanov and Daniel Rose, authors of From Mathematics to Generic Programming, on their new book, why it applies to everyday programmers, and their positions on some closely related technical issues — including value semantics, concepts, contracts, and polymorphic memory resources — facing the C++ Standards Committee today.