All Activity

Whether you’re in a coding interview or writing production code, you’ll eventually face the question: What’s the right way to look up values in a std::map or std::unordered_map? For simplicity, we’ll refer to both containers as maps in this post. How to Look up Values in a Map by Sandor Dargo From the article: Let’s explore the different options — along with their pros and cons. operator[] Using operator[] is the old-fashioned way to access elements of a map. It takes a key and returns a reference to the corresponding value. The complexity is log(n) for std::map and average constant time (with worst-case linear) for std::unordered_map. However, there’s a big caveat. What if the key is not present in the map? Unlike a vector — where accessing an invalid index with operator[] leads to undefined behavior — a map will instead insert a new entry with the given key and a default-constructed value. This side effect makes operator[] unsafe for lookups where insertion is not desired. View the full article

Passing a string temporary into a string_view can make the latter dangling Safely passing std::strings and std::string_view by Niek J Bouman From the article: Many of you will agree that C++ is a language that comes with sharp edges. One example is `std::string_view`; introduced as a type to prevent unnecessary std::string-copies, but it introduces a new footgun, namely when passing a temporary string into it: View the full article

Sometimes some object A needs to interact with another object B, e.g., A calls one of B’s methods. In a language like C++, it is left to the programmer to assure that B outlives A; if B happens to be already destructed, this would be a use-after-free bug. Managing object lifetimes can be tricky, especially with asynchronous code. A safe pointer in C++ that protects against use after free and updates when the pointee is moved by Niek J. Bouman From the article: We propose a design for a safe pointer to an object of type T that is weak in that it does not have ownership semantics, and gets notified in case the pointee is either destructed or moved. We will pay a price at runtime for these extra guarantees in terms of a small heap-allocated state, a double pointer indirection when accessing the pointee (comparable to a virtual function call), and a check against nullptr. The main idea of our design is to internally use a std::shared_ptr<T*> to share ownership of a (heap-allocated) pointer T*. The ownership is shared by the pointee and all safe_ptr<T> instances. The pointee type T must derive from the base class safe_ptr_factory (templated on T, using the Curiously Recurring Template Pattern) with a destructor that automatically notifies the shared state about destruction by setting T* to nullptr, and with a move constructor and move assignment operator that update T* to the new this pointer (which we must properly cast with static_cast<T*>). The double indirection thus comes from having to dereference the shared_ptr to obtain an ordinary pointer T*, after which you must dereference once more to access the pointee. You might recognize an instance of Gang-of-Four’s observer pattern in our design. View the full article

Some reflections on a harsh critic by Linus Torvalds on a RISC-V Linux kernel contribution. Linus Torvalds and the Supposedly “Garbage Code” by Giovanni Dicanio From the article: So, the correct explicit code is not something as simple as “(a << 16) + b”. [...] As you can see, the type casts, the parentheses, the potential bit-masking, do require attention. But once you get the code right, you can safely and conveniently reuse it every time you need! View the full article

CppCon 2025 was packed with exciting talks, deep dives, and great conversations. CppCon 2025 Trip Report by tipi.build by EngFlow About the report tipi.build by EngFlow attended both as a developer team and as a CppCon sponsor. Discover in our trip report the highlights from the sessions we attended and the talks we gave, How monday’s afternoon break started with ice cream + key takeaways and resources if you’d like to dive deeper. View the full article

Last week, we discussed why we should sometimes use remove_cvref_t on our template parameters before applying concepts to them. We also saw that the solution is not super readable because we lose access to the terse, shorthand syntax. C++26: Concept and variable-template template-parameters by Sandor Dargo From the article: C++ already allows passing templates as template parameters, but only if they are class templates. A common reason for doing this is to allow higher-level abstractions. For instance, you may want to pass in a container template like std::vector, without specifying the type it contains. Jason Turner explains this well in C++ Weekly - Ep 368 - The Power of template-template Parameters: A Basic Guide, but here’s his example for quick reference: template<template <typename Contained, typename Alloc = std::allocator<Contained>> typename ResultType> auto get_data() { ResultType<double> result; // ... return result; } int main() { auto data = get_data<std::vector>(); } View the full article

Meeting C++ is offering online and onsite student and support tickets for this years conference! Highlighting the student and support tickets for Meeting C++ 2025 by Jens Weller From the article: I'd like to point towards the programs for those that can't afford to pay for a ticket for Meeting C++ 2025: the programs for the student and support tickets. And let me start with thanking those that enable these programs through their ticket buying: the attendees and sponsors of Meeting C++ 2025! With the schedule published, I'd like to highlight the student and support tickets for Meeting C++ 2025. For a few years now Meeting C++ has hosted programs to give students, underrepresented folks and those who can't afford a ticket access to the conference. View the full article

Let’s talk about templates, constraints, and concepts. We’ll start with a quick reminder of why concepts are essential when working with templates. Then we’ll dive into the challenge posed by reference-qualified types and finish with a practical solution. Use concepts with std::remove_cvref_t by Sandor Dargo From the article: By now, it’s well known that using unconstrained templates is discouraged. Even the C++ Core Guidelines strongly recommend against it. T.47 only advises avoiding highly visible unconstrained templates with common names due to the risks of argument-dependent lookup going wrong. T.10 goes further, recommending that we specify concepts for every template argument to improve both simplicity and readability. The same idea appears in I.9, which suggests documenting template parameters using concepts. It’s hard to argue with these guidelines. Concepts make code more readable — just by looking at a function, class, or variable template, the reader can immediately tell what kinds of types are accepted. If you want to learn more about concepts, check out my concepts-related articles or my book on concepts. But what makes a good concept? That’s a more complex topic — and one we can’t fully cover in a single article. View the full article

The implementation of Nix functional package manager from nixos.org relies on Boost libraries Container, Context, Coroutine, Core, Format, LexicalCast, Unordered and URL. https://nixos.org/ https://github.com/NixOS/nix https://www.boost.org/ View the full article

Compile time code can be very efficient. Andrew Drakeford demonstrates how to write efficient chains of matrix multiplication. Simple Compile-Time Dynamic Programming in Modern C++ by Andrew Drakeford From the article: Modern C++ enables us to solve mathematical optimisation problems at compile time. With the expanded constexpr capabilities [Fertig21, Turner18, Turner19, Wu24], we can now write clear and efficient optimisation logic that runs during compilation. Fixed-size containers such as std::array fit naturally into these routines. Even standard algorithms, such as std::sort and std::lower_bound, are now constexpr, enabling more straightforward code and more powerful compile-time computations. Additionally, compile-time optimisation generates constant results, which enables the compiler to create even more efficient code. We will use the matrix chain multiplication problem as our worked example. Matrix chain multiplication Matrix chain multiplication is a classic dynamic programming problem [Corman22, Das19, Mount]. It aims to determine the most efficient method for multiplying a sequence of matrices. Since matrix multiplication is associative, the order of grouping does not affect the result. However, the number of scalar multiplications involved can vary depending on the grouping. Consider the three matrices A₁ (10×100), A₂ (100×5), and A₃ (5×50), multiplied in a chain, A₁ × A₂ × A₃. There are two ways to multiply them: Grouping as (A₁ × A₂) × A₃ first computes a 10×5 matrix, then multiplies that with A₃. This results in 5,000 operations for the first multiplication, and another 2,500 for the second – a total of 7,500 scalar multiplications. Grouping as A₁ × (A₂ × A₃) first multiplies A₂ and A₃, then A₁. This results in 25,000 operations for the first step and 50,000 for the second – a total of 75,000, which is clearly worse. View the full article

In today's post, I like to talk about C++26 and one of the probably most impactful features that have been added to the working draft. While C++26 is still some months away from official completion, since the WG21 summer meeting in June we all now know what will be in C++26. C++26 reflection at compile-time by Andreas Fertig From the article: While the new standard will have plenty of great improvements the one that will most likely change a lot is reflection at compile-time! In Sofia we voted seven reflection papers into C++26: P1306R5 Expansion statements P2996R13 Reflection for C++26 P3096R12: Function parameter reflection in reflection for C++26 P3293R3: Splicing a base class subobject P3394R4: Annotations for reflection P3491R3: define_static_ P3560R2: Error handling in reflection The papers above should give you enough to read for your vacation. I'll leave that theoretical study up to you for now. Let's talk practical The main question is, what can you do with that new feature? Well, I'm not the first one who published their ideas. View the full article

External link to https://becheler.github.io/effective-boost-review-manager/.View the full article

Boost.SQLite proposal from Klemens Morgenstern has been rejected. The author is encouraged to resubmit after addressing the issues identified in the review. Thanks to Review Manager Mohammad Nejati. Repo: https://github.com/klemens-morgenstern/sqlite Docs: https://klemens.dev/sqlite Review results: https://lists.boost.org/archives/list/boost@lists.boost.org/thread/J74OTT6TZ5W6ZHCBTPPBGM6WW54PBFNR/ View the full article

Meeting C++ is hosting a job fair in October online and planning a job fair in November in Berlin at Meeting C++ 2025! Planning the next Meeting C++ job fairs by Jens Weller From the article: The next Meeting C++ online job fair is planned for October 14th & 15th, also I'd like to talk about the onsite job fair plans for Meeting C++ 2025! If you have open positions you should advertise them in the bi-weekly Meeting C++ Jobs Newsletter, which now also powers the candidate listing of Meeting C++ with 80+ international candidates at the moment. View the full article

I recently published two posts about how C++26 improves std::format and the related facilities. (If you missed them, here are Part 1 and Part 2). Now it’s time to explore how you can format your own types using std::format. Format your own type (Part 1) by Sandor Dargo From the article: std::format was introduced in C++20 and is based on Victor Zverovich’s <fmt> library, which in turn was inspired by Python’s string formatting capabilities. Let’s skip the fancy formatting options and simply see how to interpolate values using std::format. #include <format> #include <iostream> #include <string> int main() { std::string language{"C++"}; int version{20}; std::cout << std::format("{}{} is fun", language, version) << '\n'; } /* C++20 is fun */ That was easy. Now imagine you want to print your own type. That won’t work by default. View the full article

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025! Changing /std:c++14 to /std:c++20 - How Hard Could It Be? Monday, September 15 15:15 - 16:15 MDT by Keith Stockdale Summary of the talk: Rare put in huge amounts of work to bring Sea of Thieves to PlayStation 5 and to upgrade from the old XDK and UWP platforms to the new GDK platform. In this session, Rare will discuss why they made the decision to take this opportunity to also upgrade from C++14 to C++20. It shouldn’t be much harder than changing a 14 to a 20, right? How hard could it be? Rare will discuss all the work that was involved in upgrading their language standard and share some anecdotes of some of the challenges that were met along the way. They will go through the benefits that they have felt from this upgrade along with some plans for continuing this work in the future. Keith Stockdale is a Northern Irish senior software engineer who has been working on the Engine and Rendering teams at Rare Ltd for the last 8 years working on Sea of Thieves. At Rare, Keith's main areas of focus are involved in maintaining and creating general purpose simulations that run on the GPU. For example, he is the owner of the GPU particle system that drives the visual effects in Sea of Thieves. Keith is enthusiastic about promoting writing good quality code, whether it is running on the CPU on the GPU. He is driven towards ensuring that the code-bases he works in are enjoyable to work in for all current and future developers on his team. View the full article

A full day of C++ in Pavia (Italy) on October 25: C++ Day 2025 An event organized by the Italian C++ Community and SEA Vision. Sponsors: SEA Vision, ELT, Sigeo (and others in the pipeline). All talks will be in English. In a nutshell Launched in 2016, C++ Day is a community-driven event format by the Italian C++ Community, co-organized with external partners like companies and universities. The C++ Day 2025 will be held in person on October 25 in Pavia, a joint effort between the Italian C++ Community and SEA Vision, who is also generously hosting the event at their venue. The event is free to attend, runs for an entire day, and includes coffee breaks and lunch. Who should attend the C++ Day 2025? This event is made by passionate C++ professionals for C++ professionals, companies, students and enthusiasts. What can I find at the C++ Day 2025? 6 tech talks 2+ hours of networking Some Sponsors on site 2 coffee breaks and lunch included Cozy atmosphere, games and gadgets You can refer to the detailed program for more information. When does the C++ Day 2025 take place? The event will be held on October 25, 2025 at SEA Vision headquarters, in Pavia. Open doors at 8.30 AM. The event starts at 9.15 AM and will last for a full day. Who supports this event? Sponsors: SEA Vision, ELT, Sigeo (and others in the pipeline). Do I need to register? The C++ Day 2025 is free, but you must register to facilitate the organization of the event. You can register here. View the full article

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025! Clean code! Horrible performance? Friday, September 18 14:45 - 15:45 MDT by Sandor Dargo Summary of the talk: Clean code promises readability, maintainability, and clarity. But is it possible that the pursuit of clean code comes at a catastrophic cost to performance? Some sceptics argue that adhering to clean code practices means sacrificing years - if not decades - of hardware advancements. Is clean code really that expensive? Let’s explore the complex relationship between clean code and software performance. In this talk, we’ll delve into what makes software performant. We’ll demystify the effects of clean code on performance and discover what real bottlenecks are that you’ll encounter while working on enterprise software. But what is performance, really? While many immediately think of raw runtime speed, the landscape is far more intricate. We’ll explore different facets of performance, including compile-time efficiency, memory usage, and the performance of developers themselves. However, our primary focus will be on runtime performance. The pivotal question we aim to answer is whether sheer runtime performance always reigns supreme. Can you truly achieve a 10x scale-up by eliminating dynamic polymorphism and virtual function calls? The very idea might seem absurd, but, believe it or not, in some specialized niches, that’s part of the solution. Still, the vast majority of us don’t work in those niches. We face different challenges. We’ll navigate through real-life examples where awful algorithms hardly mattered, where prudent database and network management became the true path to scalability. I don’t claim that writing code that’s easy to understand and modify always yields optimal performance. Yet, more often than not, performance bottlenecks and the road to performant software lie elsewhere. Sandor is a passionate software developer focusing on reducing the maintenance costs by developing, applying and enforcing clean code standards. His other core activity is knowledge sharing both oral and written, within and outside of his employer. When not reading or writing, he spends most of his free time with his two children and his wife baking at home or travelling to new places. View the full article

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025! Graphics Programming with SDL 3 Friday, September 19 13:30 - 14:30 MDT by Mike Shah Summary of the talk: The C++ programming language does not have a standard graphics library, However, there exists many popular graphics frameworks for cross-platform graphics. In this talk, I will provide an introduction to the Simple Directmedia Layer (SDL) library, which has at the start of 2025 released version 3. This library for several decades has been a standard in the games and graphics industry. Throughout this talk, I will show how to get started with the library, some more advanced examples (including compiling graphics applications to web), and then talk about what a standard graphics library could look like in C++, or if it is even necessary. I will also talk about the 3D GPU library in SDL3. Attendees will leave this talk ready to build multimedia / game applications and with an understanding on if SDL3 is the right tool for them. Mike Shah is currently a teaching faculty with primary teaching interests in computer systems, computer graphics, and game engines. Mike's research interests are related to performance engineering (dynamic analysis), software visualization, and computer graphics. Along with teaching and research work, Mike juggles occasional consulting work as a 3D Senior Graphics Engineer in C++ and producing programming content at his YouTube channel https://www.youtube.com/@MikeShah View the full article

Meeting C++ is putting together a 5th track, which will feature onsite in Berlin Planning a 5th track for Meeting C++ 2025 by Jens Weller From the article: I'm working on adding a 5th Track to Meeting C++ 2025 for onsite. Already last year I've been thinking about this, but in the end its been to expensive to do, and hence only feasible with a large increase in onsite attendees. This year I'm able to go a different route through sponsorship, and thus for onsite the cost is covered by sponsors. Which in turn then also contribute talks. I hope that most talks will be in the schedule by October, and I plan to release the first talks in September for the new track. Right now the track is not visible in the schedule, as I don't want to add an empty track. We may also stream the online track into the conference in a room. View the full article

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025! The Pattern Matching We Already Have Friday, September 19 09:00 - 10:00 MDT by Braden Ganetsky Summary of the talk: All the way since C++98, we have already had pattern matching in C++! It's limited to specific places, but it's there. Template argument deduction, function overload resolution, and class template specializations are all instances of pattern matching in the C++ language, dating all the way back to the original standard. The C++11 additions to the language also require library constructs to help deal with type deduction in forwarding references, namely std::forward, among others. Even experienced C++ developers may run into unexpected situations using it, especially in newer scenarios like concepts from C++20. This talk will lay clear the rules of forwarding and std::forward, and how you can forward your arguments properly every time. This interactive talk is a deep dive into template argument deduction, helping you to understand it at deeper level across all of C++'s lifespan. Almost all that applies in C++98 still applies today, so a foundational understanding is important. Additionally, newer language standards have introduced further wrinkles, like C++11's move semantics and variadic template parameters, as well as C++17's class template argument deduction. By the end of this talk, you will have a solid understanding of how C++ deduces the types used in your code. Braden Ganetsky graduated from the University of Manitoba with a degree in mechanical engineering, fueled by his passion for mechanical puzzles. During his final year of school, when all classes and activities were remote, he discovered C++ and has been hooked ever since. He interned as a C++ developer, which turned into a full time job, completing a successful pivot of his career. Now he spend his nights working on fun projects like parser combinators, and getting involved in the C++ community. Since 2023, Braden sits on the ISO C++ Committee as a representative of Canada. View the full article

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025! Using Distributed Trace for End-to-End Latency Metrics Thursday, September 18 15:15 - 16:15 MDT by Kusha Maharshi Summary of the talk: In this talk, we'll delve into how we utilized distributed trace to address a prevalent need at a large technology company that serves the finance industry: timing requests from point A to point Z in a complex system, where a whole alphabet's worth of steps occur in between. We'll show how tracing, an open source telemetry standard, helped us generate insights from tracking requests in a complicated, microservices-driven architecture. We'll discuss the challenges faced and lessons learned while building a C++ solution that turns trace data into end-to-end latency metrics. We hope to inspire attendees to apply these lessons to telemetry solutions tailored to their own firms' needs. Distributed tracing was introduced within our company before it was a stable, open standard. We saw its potential and invested in solutions that utilized its rich, cross-service information. However, existing open source or commercial products didn't fit the complexity and scale of our trace data. Our engineers, incident responders, and managers wanted end-to-end latency metrics to observe complex workflows, so we built our own solution! The resulting metrics now drive service level objectives (SLOs) that set measurable targets that define a system's quality and reliability. When these targets are not met, teams are alerted, thus driving quick remediation. Furthermore, the traces corresponding to any degradation in system health can be used to pinpoint faulty components, as well as aid in the development and testing phases when building new solutions. From a technical point of view, trace data is represented as directed acyclic graphs (DAGs), and our challenge was processing more than 50 billion daily nodes, with deep fan-outs and fan-ins. These graphical structures mirror real-world scenarios like queuing systems for high-volume messaging, order processing or batched email notifications, and present concurrency choke points at scale. In this talk, we'll break down the design of the C++ microservices we built to process large-scale streaming graphs into metrics, while also addressing scalability bottlenecks. We'll also highlight why we chose C++ and its libraries, powerful profiling tools, and efficient data structures. If you're into building low-latency, high-throughput distributed systems, want to build telemetry solutions that best suit your needs, or just enjoy geeking over graphs, this talk is for you! Kusha Maharshi is a Senior Software Engineer at Bloomberg, where she passionately works on distributed tracing and observability infrastructure. An avid public speaker, she loves breaking down complex technical challenges with clarity – and a dose of humor. Kusha holds a degree in Computer Science from Carnegie Mellon University, where she specialized in computer systems. Her favorite programming language? Assembly. View the full article

C++26 has brought big advances, especially with reflection making its way into the working draft, but one long-standing challenge remains: supporting richer class types as constant template parameters. Although the language solution isn’t here yet, we can get surprisingly far with a library approach that uses reflection and static objects to extend what’s possible today. A Library Approach to Constant Template Parameters by Barry Revzin From the article: This library achieves two things. First, it is just, in general, very useful. I’m hoping to make it more of a Real Library™️ once Reflection gets implemented in more than just the Bloomberg fork of Clang that Dan Katz implemented. Second, I think it demonstrates the power of Reflection. There are so many problems that were not possible in C++23 that become solvable in C++26. We’re going to spend the next several years discovering more of those, and that makes it a pretty exciting time for C++. View the full article

Since 2013, I have been working on libraries that implement open multi-methods in modern C++. After releasing the first one - YOMM11 - I asked on the Boost mailing list if there was an interest in bringing YOMM11 into Boost. Back then there was not much. I made another attempt when I released the much improved YOMM2, but interest was still feeble. Or maybe I did not explain what it was about well enough. Anyway, I continued improving YOMM2 as a stand-alone project, and, in retrospect, I now think that it was for the best, at the time. YOMM2 had a bunch of users, engaged enough to send me PRs, and did not cause much trouble in terms of bugs. As for its internals, let's say, they looked like an experiment in progress. Over the years, though, I cleaned up the implementation. Following discussions on reddit, I raised the bar in terms of features, performance, footprint, etc. For example, I added support for custom RTTI. I talked about YOMM2 at conferences once in a while. In 2024, I attended "using std::cpp", organized by Prof J.D. Garcia at the Universidad Carlos III in Madrid. Joaquín M López Muñoz was giving a talk about perfect hashing, a technique that is used in YOMM2. Prof Garcia introduced me to Joaquín, and I told them the story of my library, and about my interactions with the Boost community. It turned out that Joaquín was a Boost author himself. He suggested that I try again, offering to endorse me. That would secure me a formal review. I said I would think about it. I decided to go ahead for several reasons. I admit that vanity was one of them! But I also had "better" motives. I felt that I was not having a lot of success making the C++ community aware of my work. I figured having it in Boost would help. The most important reason was...well, I am 62, with a couple of health issues. Probably I'll still be around for some time, but, just in case, I would like to give my library a chance to outlive me, as long as possible. And Boost has been very good at conserving C++ libraries, even as authors and maintainers come and go. Dmitry Arkhipov, a member of C++ Alliance (like Joaquín), offered to manage the review. It turns out that he needed open multi-methods in a past project. He would have used YOMM2, if only he had known that it existed. I did another round of cleanups, during which I moved some internals (like virtual_traits) to the public interface, refining them in the process. Should the library be accepted, it would go by the name Boost.OpenMethod. The review started. To be honest, I was steeling myself, expecting indifference. To the contrary, after a few days, comments, then formal reviews started flowing in (a formal review must follow a format, in particular it must clearly vote "accept", "accept with conditions", or "reject"). All the comments, reviews, and the debates they triggered, were very interesting. They honed my designs further. For example, I redesigned the policy system (an important set of customization points that supports things like custom RTTI). Only one reviewer voted for rejection. Nonetheless, the conversation with him was just as stimulating. Like others, and more strongly than others, he criticized a feature that I ended up relegating to an opt-in. I will try to describe it without going into too many details. My library is strongly inspired by papers that Stroustrup and col wrote while attempting to bring open multi-methods into the C++ standard. In their last paper on the subject (google for N2216), they suggest a treatment of ambiguities that essentially makes them non-errors. I disliked the idea, and YOMM2 never implemented it, but I (sheepishly) adopted it for OpenMethod. And almost everybody disliked it! Mistake avoided. Some reviewers showed an astonishing grasp of low level details of the implementation. I was delighted when Steven Watanabe dropped two pieces of code that interface OpenMethod with Boost.Any and Boost.TypeErasure. At the end of the review, OpenMethod was accepted with conditions - a few changes that I completely agreed with. But even if it had been rejected, it would have been well worth the journey. OpenMethod is a much better library than YOMM2. And it was accepted! OpenMethod will join the flock in the Boost 1.90.0 release. View the full article

Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025! C++ Parallel Programming Models Thursday, September 18 14:00 - 15:00 MDT by Eran Gilad Summary of the talk: Modern C++ offers a wealth of parallel programming features. Those features belong to four different programming models: low-level, a-sync, cooperative multitasking, and data parallel. The low-level model (or rather, non-model) contains the basic building blocks – threads, atomics, mutex etc. The a-sync model contains async, future and related classes. The cooperative multitasking model relies on coroutines. Lastly, the data parallel model contains the parallel algorithms. The four models aren’t just different abstraction levels – each is appropriate for a different program structure. This talk will review the four models, describe the central features used by each model, and discuss the expected use case for each one. Since many of the parallelism features are not new to the language at this point, the talk will not focus on the details of the features themselves. Instead, the talk will put them in the context of a programming model and make the choice of parallel programming features easier for C++ developers. Eran Gilad is a software engineer at Regatta Data, where he works on one of the most fascinating areas of software development: database internals. Before diving deep into database engineering, Eran was a principal research engineer at Yahoo Research and a member of a systems research group. He holds a PhD in Computer Science from the Technion, where his work centered on various aspects of parallel programming and execution. Beyond his professional work, Eran is passionate about developer communities. He co-organizes the Core C++ conference, the Haifa::C++ meetup group, and the Medabrim C++ WhatsApp group. His involvement in these communities stems from his first job experience, where he was the sole C++ developer at his company for several years. View the full article