Contributions

Article
This post starts a miniseries about an almost unknown feature in C++17: polymorphic allocators. I often promised that I would write about polymorphic allocators. Today, I fulfill my promise.
Article
C++20 does not provide concrete coroutines, but C++20 provides a framework for implementing coroutines. This changes with C++23. std::generator is the first concrete coroutine.
Article
A std::mdspan is a non-owning multidimensional view of a contiguous sequence of objects. The contiguous sequence of objects can be a plain C-array, a pointer with a size, a std::array, a std::vector, or a std::string.
Article
he four associative containers std::flat_map, std::flat_multimap, std::flat_set, and std::flat_multiset in C++23 are a drop-in replacement for the ordered associative containers std::map, std::multimap, std::set, and std::multiset. We have them for two reasons in C++23: memory consumption and performance.
Article
C++23 extends the interface of std::optional and gets the new data type std::expected for error handling.
Article
The C++23 standard library has very impressive improvements. In this post, I will write about the modularized standard library and the two convenience functions std::print and std::println.
Article
Today, I’m happy to present a guest post from Victor J. Duvanenko about my favorite C++17 feature: the parallel STL algorithms.
Article
With the static multidimensional subscript and call operator, the C++23 core language has more to offer.
Article
The C++23 core language has more to offer than deducing this. Today, I will write about the small pearls.
Article
The Curiously Recurring Template Pattern (CRTP) is a heavily used idiom in C++. It is similarly resistant to understanding as the classic design pattern visitor I presented in my last post: "C++23: Deducing This". Thanks to deducing this, we can remove the C and R from the abbreviation.
Article
Anyone who thinks a small C++ standard follows a significant C++ standard is wrong. C++23 provides powerful extensions to C++20. These extensions include the core language, particularly the standard library. Today, I present a small but very impactful feature of the core language: deducing this.
Article
C++23 will be the next C++ standard after C++20. This new standard significantly improves C++ but is less game-changing than C++98, C++11, or C++20. C++23 is more in the tradition of C++17.
Article
In my last post "Monitor Object" I implemented a thread-safe queue. I made two serious errors. Sorry. Today, I will fix these issues.
Article
The monitor object design pattern synchronizes concurrent member function execution to ensure that only one member function at a time runs within an object. It also allows object’s member functions to schedule their execution sequences cooperatively. (Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects)
Article
The active object design pattern decouples method execution from method invocation for objects that each reside in their own thread of control.The goal is to introduce concurrency, by using asynchronous method invocation and a scheduler for handling requests.
Article
Guarded Suspension applies a unique strategy to deal with mutation. It signals when it is done with its modification.
Article
I continue my journey with concurrency patterns in today's post, dealing with mutation. The Thread-Safe Interface fits very well when the critical sections are just objects.
Article
Locking is a classical way to protect a shared, mutable state. Today, I will present the two variants, Scoped Locking and Strategized Locking.
Article
If you don’t share, no data races can happen. Not sharing means that your thread works on local variables. This can be achieved by copying the value, using thread-specific storage, or transferring the result of a thread to its associated future via a protected data channel.
Article
There are many well-established patterns used in the concurrency domain. They deal with synchronization challenges such as sharing and mutation but also with concurrent architectures. Today, I will introduce and dive deeper into them in additional posts.
Article
Event-driven applications, such as GUIs or servers, often apply the architecture pattern Reactor. A Reactor can accept multiple requests simultaneously and distribute them to different handlers.
Article
The Model-View-Controller (MVC) is one of the classic architectural patterns from the book "Pattern-Oriented Software Architecture, Volume 1". It addresses interactive applications with a flexible human-machine interface.
Article
The Broker Pattern structures distributed software systems that interact with remote service invocations. It is responsible for coordinating the communication, its results, and exceptions.
Article
The Pipes-and-Filters architecture pattern describes the structure of systems that process data streams.
Article
The layers pattern splits a task into horizontal layers. Each layer has a specific responsibility and provides a service to a higher layer.
Article
Architectural patterns describe the fundamental structure of a software system and are often based on design patterns. The five Pattern-Oriented Software Architecture series books provide a precious source of architectural patterns.
Article
I'm happy to present today a guest post from Alexander Eisenhut. Alexander will write about his passion: good software architecture.
Article
This post is unique because I have written about all the topics mentioned in this post already. Therefore, I only provide a few words about the topic and a link to the post mentioned.
Article
The Covariant Return Type of a member function allows an overriding member function to return a narrower type. This is particularly useful when you implement the Prototype Pattern.
Article
When you want to use a user-defined type in a range-based for-loop, your user-defined type has to implement the Iterator Protocol.

Showing the last 30 only...