August 2022

Talks and Speaker for Meeting C++ 2022 released

Since yesterday its possible to have a first look at the program of Meeting C++ 2022

A first view on the talks and speakers of Meeting C++ 2022

by Jens Weller

From the article:

I'm excited to release this update for Meeting C++ 2022: the talks and speakers for this years conference!

As you can see in the talk listing, this is still an ongoing process, getting the speaker pictures from the new speakers for this year will still take a while. Creating the schedule will also take a few weeks, as of now Tracks A and B are planned on site, with Tracks C and D being part of the online part.

CopperSpice: Is Virtual Of Value?

New video on the CopperSpice YouTube Channel:

Is Virtual Of Value

by Barbara Geller and Ansel Sermersheim

About the video:

Virtual methods have a specific meaning in C++. Are virtual destructors the same? Where does virtual have no meaning? Can using virtual cause UB? Watch our new video and find out if you really know the difference between delete and destroy.

Please take a look and remember to subscribe!

Adding a REST API with Pistache -- Richard Thomson

Utah C++ Programmers has released a new video:

Adding a REST API with Pistache

by Richard Thomson

From the video description:

Many times you need to integrate your C++ infrastructure with services written in other languages on other machines from other teams. In the past, this might have been accomplished with custom RPC (remote procedure call) networking services that exposed resource data in your application to authorized clients.

HTTP REST (representational state transfer) APIs have become a common architectural pattern for exposing resource data across the network. With SSL/TLS (secure socket layer/transport layer security) connections and the HTTPS protocol, the client/server exchange can be secured. Authentication can be implemented with a session mechanism or the built-in authentication mechanisms in HTTP itself.

This month, Richard Thomson will give us an introduction to pistache, a high-performance REST toolkit written in C++. After an overview of the library, we'll look at what it takes to implement an HTTP server that responds to resource requests.

Lessons Learned from Packaging 10,000+ C++ Projects - Bret Brown & Daniel Ruoso - CppCon 2021

Registration is now open for CppCon 2022, which starts on September 11 and will again be held both in person and online. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year’s conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2022 to attend in person, online, or both!

Lessons Learned from Packaging 10,000+ C++ Projects

by Bret Brown & Daniel Ruoso

Summary of the video:

At Bloomberg, we maintain a system that coherently builds and integrates more than 10,000 C++ packages that are maintained independently by thousands of software engineers on hundreds of teams across our Engineering department. In this talk, we will go over the lessons we have learned about maintaining these packages, as well as how package management should interact with third-party libraries, third-party tools, build systems, IDEs, static analysis tools, and refactoring automation. We hope this will start a conversation around the potential requirements for a more complete package management solution in the C++ ecosystem.

Improved automated instance construction in C++--Marius Elvert

The series continue.

Improved automated instance construction in C++

by Marius Elvert

From the article:

In my last blog post, I wrote about how I am automatically deducing constructor parameters in my dependency injection container. The approach had a major drawback: It worked only for 2 or more parameters, since there was an ambiguity with copy- or move-constructors with exactly one parameter...

HPX V1.8.1 released -- STE||AR Group

The STE||AR Group has released V1.8.1 of HPX -- A C++ Standard library for Concurrency and Parallelism.

HPX V1.8.1 Released

We have released HPX 1.8.1 that adds a number of small new features and fixes a handful of problems discovered since the last 1.8.0 release, in particular: a lot of work has been done to improve vectorization support for our parallel algorithms. HPX now supports using EVE – the Expressive Vector Engine as a vectorization backend. More work was done towards full compatibility with the sender/receiver proposal P2300. We have fixed all collective operations to properly avoid overlapping consecutive operations on the same communicator. We also fixed a dangling reference problem while serializing non-default constructible types. We have added support for static linking on Windows (using MSVC) and have added support for M1/MacOS based architectures. A full list of changes can be found in the release notes.

If you have any questions, comments, or exploits to report you can reach us on IRC or Matrix (#ste||ar on or email us at hpx-users. We depend on your input!

You can download the release from our releases page or check out the 1.8.1 tag using git. A full list of changes can be found in the release notes.

HPX is a general-purpose parallel C++ runtime system for applications of any scale. It implements all of the related facilities as defined by the C++20 Standard. As of this writing, HPX provides the only widely available open-source implementation of the new C++17 and C++20 parallel algorithms, including a full set of parallel range-based algorithms. Additionally, HPX implements functionalities proposed as part of the ongoing C++ standardization process, such as large parts of the features related parallelism and concurrency as specified by the upcoming C++23 Standard, the C++ Concurrency TS, Parallelism TS V2, data-parallel algorithms, executors, and many more. It also extends the existing C++ Standard APIs to the distributed case (e.g., compute clusters) and for heterogeneous systems (e.g., GPUs).

HPX seamlessly enables a new Asynchronous C++ Standard Programming Model that tends to improve the parallel efficiency of our applications and helps reducing complexities usually associated with parallelism and concurrency.