Home » Blog » Tags » experimental

experimental

How C++ coroutines work--Kirit Sælensminde

By Adrien Hamelin | Jul 4, 2017 01:12 PM | Tags: experimental efficiency

What's the point of coroutines?

How C++ coroutines work

by Kirit Sælensminde

From the article:

If you look at coroutines in other language, JavaScript or Python for example, you'll see that the language documents how the coroutines work. How you can use co_yield and co_await etc. (however they're spelled) and what the language does for you with them. This is all very useful, and lets you do a lot of cool things with them, but always within the confines of what the language runtime allows.

In C++ they're quite different. The compiler provides a scaffolding on which you can decide how things work. This means that C++ doesn't provide generators, but it provides you a way to write a ton of different generators that work in different ways depending on your needs.

This is what this series of articles is going to be about. Not how to use or write coroutines that work according to some pre-established pattern, but how the underlying machinery allows you to customise the way that the coroutines work...

CppCon 2016: Deploying C++ modules to 100s of millions of lines of code--Manuel Klimek

By Adrien Hamelin | Jun 30, 2017 02:57 PM | Tags: performance 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:

Deploying C++ modules to 100s of millions of lines of code

by Manuel Klimek

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Compile times are a pain point for C++ programmers all over the world. Google is no exception.. We have a single unified codebase with hundreds of millions of lines of C++ code, all of it built from source. As the size of the codebase and the depth of interrelated interfaces exposed through textually included headers grew, the scaling of compiles became a critical issue.

Years ago we started working to build technology in the Clang compiler that could help scale builds more effectively than textual inclusion. This is the core of C++ Modules: moving away from the model of textual inclusion. We also started preparing our codebase to migrate to this technology en masse, and through a highly automated process. It's been a long time and a tremendous effort, but we'd like to share where we are as well as what comes next.

In this talk, we will outline the core C++ Modules technology in Clang. This is just raw technology at this stage, not an integrated part of the C++ programming language. That part is being worked on by a large group of people in the ISO C++ standards committee. But we want to share how Google is using this raw technology internally to make today's C++ compiles faster, what it took to get there, and how you too can take advantage of these features. We will cover everything from the details of migrating a codebase of this size to use a novel compilation model to the ramifications for both local and distributed build systems. We hope to give insight into the kinds of benefits that technology like C++ Modules can bring to a large scale C++ development environment.

CppCon 2016: Channels - An alternative to callbacks and futures--John Bandela

By Adrien Hamelin | May 29, 2017 12:55 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:

Channels - An alternative to callbacks and futures

by John Bandela

(watch on YouTube)

Summary of the talk:

Currently in the C++ Networking TS and Concurrency TS, callbacks and futures are the means for communicating an asynchronous value. However, there are disadvantages with both. Callbacks are low overhead, but hard to compose. Futures are easy to compose, but have increased overhead. In this talk we will consider channels as a third alternatives that can have lower overhead than futures while still being easy to compose

corsl - Coroutine support library--Alexander Bessonov

By Adrien Hamelin | May 25, 2017 11:35 AM | Tags: experimental community

Interesting library

corsl - Coroutine support library

by Alexander Bessonov

From the article:

corsl stands for "Coroutine Support Library" and consists of a number of utility classes and functions that simplify asynchronous programming in Windows. It is inspired by an amazing cppwinrt library, developed by Microsoft.

cppwinrt was created as a language projection for Windows Runtime, which is supported by Windows 8 or later operating systems. It is impossible to use in prior Windows versions.

One of the goals of corsl library was being able to use it under Windows Vista or later operating system...

C++Now 2017--Michael Park

By Adrien Hamelin | May 23, 2017 09:23 AM | Tags: experimental community

Trip report!

C++Now 2017

by Michael Park

From the article:

I just returned from C++Now 2017 in Aspen, CO. This was my second time attending the conference and it was just as amazing as last year. My girlfriend decided to come along this time, since Aspen is such a beautiful place. We flew into Denver, rented a car and took the beautiful 4-hour drive into Aspen. She was very happy ��. Strongly recommended...

Using C++ Coroutines with Boost C++ Libraries--Eric Battalio

By Adrien Hamelin | May 19, 2017 11:38 AM | Tags: experimental boost

Working with the future tools.

Using C++ Coroutines with Boost C++ Libraries

by Eric Battalio

From the article:

Last month, Jim Springfield wrote a great article on using C++ Coroutines with Libuv (a multi-platform C library for asynchronous I/O). This month we will look at how to use coroutines with components of Boost C++ libraries, namely boost::future and boost::asio...

CppCon 2016: Using Types Effectively--Ben Deane

By Adrien Hamelin | May 19, 2017 11:29 AM | Tags: performance 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:

Using Types Effectively

by Ben Deane

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

C++ has a pretty good type system, and modern C++ gives us a greater ability than ever before to use that type system for good: to make APIs easier to use and harder to misuse, to make our datatypes more closely express our intent, and generally to make code safer, more obvious in function and perhaps even faster.

This is an interactive session - incorporating games played between presenter and audience, even - taking a look at choices available to us as datatype and API designers, and examining how a little knowledge about the algebra of algebraic datatypes can help. We'll see why std::optional and (hopefully soon) std::variant will quickly become an essential part of everyone's toolbox, and also explore how types can be used to express not just the structure of data, but also the behaviour of objects and functions.

ACCU 2017 trip report--Anastasia Kazakova

By Adrien Hamelin | May 8, 2017 01:00 PM | Tags: experimental community

You want to know what happened?

ACCU 2017 trip report

by Anastasia Kazakova

From the article:

Hi,

We’ve just returned from ACCU 2017 in Bristol, UK. Being amazed by the event I decided to share some notes here, and hope Phil will also jump in and share his impression. There are also reports by Vittorio Romeo, Simon Brand and Samathy Barratt which you might find interesting...

Understand ranges better with the new Cartesian Product adaptor--Jonathan Boccara

By Adrien Hamelin | Apr 18, 2017 01:17 PM | Tags: intermediate experimental

The future explained:

Understand ranges better with the new Cartesian Product adaptor

by Jonathan Boccara

From the article:

A couple of days ago, the range-v3 library got a new component: the view::cartesian_product adaptor.

Understanding what this component does, and the thought process that went through its creation is easy and will let you have a better grasp of the range library. (Note that you could just as well understand all the following by looking at the zip adaptor. But cartesian_product is brand new, so let’s discover this one, in order to hit two birds with one stone)...