Workshops at using std::cpp 2026 with Mateusz Pusz and Jeff Garland

By jdgarcia | Jan 17, 2026 10:12 AM | Tags: None

Once more the using std::cpp conference is here and they bring two interesting training workshops.

• Mastering std::execution: A Hands-On Workshop by Mateus Pusz.
  https://www.fundacion.uc3m.es/formacion/mastering-stdexecution-a-hands-on-workshop/
• Function and Class Design with C++2x by Jeff Garland.
  https://www.fundacion.uc3m.es/formacion/function-and-class-design-with-c2x/

Both workshops happen in the post-conference day on March 19th in Madrid.

You may also want to have a look to the list of speakers for the main conference.

If you are one of the first 20 attendees to each workshops, your are eligible for a free ticket for the main conference.

Talk: Who’s Afraid of the Big Bad Template -- Coral Kashri

By Blog Staff | Jan 15, 2026 11:14 AM | Tags: None

Templates and metaprogramming considered as the big bad wolf of C++, and it’s time to stop being scared of this wolf, as it’s one of the most powerful creatures of C++.

Talk: Who’s Afraid of the Big Bad Template

by Coral Kashri

From the description:

In this talk I’ve demonstrated the power of this incredible creature, while I hope that this talk would be an easy enterence to this concept (pan intended), and to help you developing the anticipation to walk into the cave of metaprogramming.

The talk was give on Core C++ 2025.

Talk: Who’s Afraid of the Big Bad Template -- Coral Kashri

By Blog Staff | Jan 15, 2026 11:14 AM | Tags: None

Templates and metaprogramming considered as the big bad wolf of C++, and it’s time to stop being scared of this wolf, as it’s one of the most powerful creatures of C++.

Talk: Who’s Afraid of the Big Bad Template

by Coral Kashri

From the description:

In this talk I’ve demonstrated the power of this incredible creature, while I hope that this talk would be an easy enterence to this concept (pan intended), and to help you developing the anticipation to walk into the cave of metaprogramming.

The talk was give on Core C++ 2025.

2025, A Year of Conferences -- Sandor Dargo

By Blog Staff | Jan 9, 2026 10:32 AM | Tags: None

Conferences are never just about the talks — they’re about time, travel, tradeoffs, and the people you meet along the way. After a year of attending several C++ events across formats and cities, this post is a personal look at how different conferences balance technical depth, community, and the experience of being there.

2025, A Year of Conferences

by Sandor Dargo

From the article:

This year I had the chance to attend three conferences onsite, plus one online, and even a meetup in my hometown, Budapest. Depending on who you ask, maybe it’s not a lot — I know some speakers do twice as many. But if you ask my family, you’d probably get a different (and understandable) answer. For me — for us — it’s a lot. It’s also an honour and a privilege in many ways.

To express my appreciation and gratitude toward the organizers and the community, I do two things:

• I try to prepare well for my talks.
• I post trip reports soon after each event — usually within a week.

Those trip reports are moderately personal: I share which talks I liked and also some of my impressions, but I try to make them useful rather than purely personal. Still, I think that once in a while, a more personal, less serious post has its place — and that’s what this one wanted to be originally.

At one of the social dinners at CppCon, a developer working for a FAANG company in New York asked me which conference I’d recommend. My answer: it depends on your goals — and your budget and constraints.

 

A Guest Editorial -- Quasar Chunawala, Frances Buontempo

By Blog Staff | Jan 7, 2026 10:28 AM | Tags: None

C++20 introduced coroutines. Quasar Chunawala, our guest editor for this edition, gives an overview.

A Guest Editorial

by Quasar Chunawala, Frances Buontempo

From the article:

You’ve likely heard about this new C++20 feature, coroutines. I think that this is a really important subject and there are several cool use-cases for coroutines. A coroutine in the simplest terms is just a function that you can pause in the middle. At a later point the caller will decide to resume the execution of the function right where you left off. Unlike a function therefore, coroutines are always stateful - you at least need to remember where you left off in the function body.

Coroutines can simplify our code! Coroutines are a great tool, when it comes to implementing parsers.

The coroutine return type

The initial call to the coroutine function will produce a return object of a certain ReturnType and hand it back to the caller. The interface of this type is what is going to determine what the coroutine is capable of. Since coroutines are super-flexible, we can do a whole lot with this return object. If you have some coroutine, and you want to understand what it’s doing, the first thing you should look at is the ReturnType, and what it’s interface is. The important thing here is, we design this ReturnType. If you are writing a coroutine, you can decide what goes into this interface.

15 Different Ways to Filter Containers in Modern C++ -- Bartłomiej Filipek

By Blog Staff | Jan 5, 2026 10:25 AM | Tags: None

Filtering items from a container is a common situation. Bartłomiej Filipek demonstrates various approaches from different versions of C++.

15 Different Ways to Filter Containers in Modern C++

by Bartłomiej Filipek

From the article:

Do you know how many ways we can implement a filter function in C++? While the problem is relatively easy to understand – take a container, copy elements that match a predicate and the return a new container – it’s good to exercise with the C++ Standard Library and check a few ideas. We can also apply some modern C++ techniques, including C++23. Let’s start!

The problem statement

To be precise by a filter, I mean a function with the following interface:

  auto Filter(const Container& cont,
              UnaryPredicate p) {}

It takes a container and a predicate, and then it creates an output container with elements that satisfy the predicate. We can use it like the following:

  const std::vector<std::string> vec{
    "Hello", "**txt", "World", "error", "warning",
    "C++", "****" };
  auto filtered = Filter(vec, [](auto& elem) {
    return !elem.starts_with('*'); });
    // filtered should have "Hello", "World",
    // "error", "warning", "C++"

Writing such a function can be a good exercise with various options and algorithms in the Standard Library. What’s more, our function hides internal things like iterators, so it’s more like a range-based version.

Time in C++: std::chrono::high_resolution_clock: Myths and Realities -- Sandor Dargo

By Blog Staff | Jan 2, 2026 10:21 AM | Tags: None

std::chrono::high_resolution_clock sounds like the obvious choice when you care about precision, but its name hides some important caveats. In this article, we’ll demystify what “high resolution” really means in <chrono>, why this clock is often just an alias, and when—if ever—it’s actually the right tool to use.

Time in C++: std::chrono::high_resolution_clock - Myths and Realities

by Sandor Dargo

From the article:

If there’s one clock in <chrono> that causes the most confusion, it’s std::chrono::high_resolution_clock. The name sounds too tempting — who wouldn’t want “the highest resolution”? But like many things in C++, the details matter.

In the earlier parts of this series, we looked at system_clock as the wall-clock time source, and at steady_clock as the reliable choice for measuring intervals. This time, we’ll tackle the so-called “high-resolution” clock, separate fact from myth, and see why it’s not always the right choice — even when you think you need precision.

What “high resolution” actually means

A clock’s resolution (or precision) is the granularity of its tick period — i.e., the smallest representable step in time for that clock’s time_point. In <chrono> it’s exposed via Clock::period, a std::ratio.

Notice an important difference. I didn’t mention accuracy, only precision. A clock might represent nanoseconds, but still be inaccurate due to hardware or OS scheduling. A higher resolution doesn’t necessarily mean better measurement. For timing, stability and monotonicity matter much more than how fine-grained the tick is.