October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By TartanLlama | May 13, 2024 08:09 AM | Tags: community
The recordings for all Pure Virtual C++ 2024 sessions are now online. This includes the 5 main sessions plus over a dozen pre-conference videos.
Pure Virtual C++ 2024 Recordings Available
By Sy Brand
From the article:
All recordings for our Pure Virtual C++ 2024 conference are now available. Thanks to everyone who came along and hope to see you again next year! You can find the full playlist on YouTube.
By Blog Staff | May 10, 2024 05:36 PM | Tags: None
In our previous discussion, we explored the intricacies of stateful but coalescing update notifications, shedding light on the pivotal role of the UI thread in implicit serialization. However, what if this luxury of implicit synchronization is absent? Delving into an alternate version of our solution, we confront the looming specter of race conditions and the necessity for meticulous thread management to ensure seamless operation. Join us as we navigate the complexities of thread synchronization and embark on a quest to refine our approach to asynchronous work handling.
Adding State to the Update Notification Pattern, Part 4
by Raymond Chen
From the article:
Last time, we developed a stateful but coalescing update notification, and we noted that the UI thread was doing a lot of heavy lifting. What if you don’t have a UI thread to do implicit serialization for you?
If there were no
resume_foreground(, we would have a race if aDispatcher()) TextChangedoccurs after the worker has decided to exit, but before it has had a chance to mark itself as not busy. Here’s an alternate version that demonstrates the race.
By Blog Staff | May 10, 2024 01:15 PM | Tags: None
Registration is now open for CppCon 2024! The conference starts on September 15 and will be held in person in Aurora, CO. 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 2024!
Lightning Talk: A Fast, Concurrent Data Loader for Time-Series Data
by Glenn Philen
Summary of the talk:
In this talk, I briefly share the design of a high performance data loader used to iterating over time series data stored on disk across many individual files. The data loader aggregates data streams from different sources and of different kinds of data, orders it by timestamp, and feeds it to an offline test harness concurrently and without locking.
By philsquared | May 10, 2024 04:48 AM | Tags: community
The C++ on Sea 2024 schedule is out, with 2-day workshops, 4-tracks of main conference, 2 lightning talk sessions and even a Movie Night!
Full schedule for 2024
by C++ on Sea
From the article:
We now have the full schedule for 2024 - and it's a doozy! We also have a few new features this year.
By Blog Staff | May 9, 2024 02:38 PM | Tags: None
Another meeting, another slew of potential changes to standard C++. In this recap, I’ll summarize the working draft’s most significant changes, spotlight my favorite proposal at the meeting, Member customization points for Senders and Receivers, and discuss a handful of notable developments.
Trip Report: Winter ISO C++ Meeting in Tokyo, Japan
by David Sankel
From the article:
What’s new in the draft standard?
This snippet summarizes the notable changes:
// wg21.link/p2573r2
void newapi();
void oldapi() = delete(“oldapi() is outdated, use newapi() instead”);
void f() {
std::println(); // Shorthand for ‘std::println(“”)’. wg21.link/p3142r0
// Paths can be printed/formatted now. wg21.link/p2845r8
std::println(“Here’s a path: {}”,
std::filesystem::path(“/stlab/chains”));
std::vector<int> x{1, 2, 3};
std::array<int,3> y{4, 5, 6};
// Outputs 1, 2, 3, 4, 5, and 6 separated by newlines.
for( auto i : std::views::concat(x, y) ) // concat is new from
std::cout << i << std::endl; // wg21.link/p2542r8
}
By Blog Staff | May 8, 2024 05:32 PM | Tags: None
In our continued exploration of efficient stateful update notifications, we delve into optimizing our existing solution to mitigate unnecessary background work. By introducing periodic checks for pending text and leveraging mutex protection, we aim to streamline the process and enhance performance. However, as we unravel these optimizations, we confront the complexities of managing thread safety and delve into the intricacies of background thread synchronization.Adding State to the Update Notification Pattern, Part 3
by Raymond Chen
From the article:
Last time, we developed a stateful but coalescing update notification, and we noted that the code does a lot of unnecessary work because the worker thread calculates all the matches, even if the work has been superseded by another request.
We can add an optimization to abandon the background work if it notices that its efforts are going to waste: Periodically check whether there is any pending text. This will cost us a mutex, however, to protect access to
m_pendingTextfrom multiple threads.
By Blog Staff | May 8, 2024 10:07 AM | Tags: None
Registration is now open for CppCon 2024! The conference starts on September 15 and will be held in person in Aurora, CO. 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 2024!
Lightning Talk: Interfaces in C++ - Megh Parikh - CppCon 2023
by Megh Parikh
Summary of the talk:
I explain some of the ways to make interfaces, both static and dynamic in this talk, and how concepts can be optionally used.
By Blog Staff | May 6, 2024 05:21 PM | Tags: None
In the realm of asynchronous programming, managing stateful update notifications presents a daunting challenge. In our ongoing exploration, we scrutinize a solution that aims to address this challenge by seamlessly handling multiple requests for work while ensuring that only the last one triggers a notification. However, beneath the surface of this endeavor lies a tangle of legal intricacies and logical pitfalls, urging us to dissect, refine, and ultimately fortify our approach.
Adding State to the Update Notification Pattern, Part 2
by Raymond Chen
From the article:
Last time, we started looking at solving the problem of a stateful but coalescing update notification, where multiple requests for work can arrive, and your only requirement is that you send a notification for the last one. Any time a new request for work arrives, it replaces the existing one.
One attempt to fix this is to check if the work is already in progress, and if so, then hand off the new query to the existing worker. We are using
winrt::, which fails fast on any unhandled exception. This saves us from having to worry about recovering from exceptions. (At least for now.)fire_ and_ forget
By Blog Staff | May 2, 2024 12:42 PM | Tags: None
std::format allows us to format values quickly and safely. Spencer Collyer demonstrates how to provide formatting for a simple user-defined class.
User-Defined Formatting in std::format
by Spencer Collyer
From the article:
Since my previous article was first published, based on the draft C++20 standard, the paper [P2216] was published which changes the interface of the
format,format_to,format_to_n, andformatted_sizefunctions. They no longer take astd::string_viewas the format string, but instead astd::format_string(or, for the wide-character overloadsstd::wformat_string). This forces the format string to be a constant at compile time. This has the major advantage that compile time checks can be carried out to ensure it is valid.The interfaces of the equivalent functions prefixed with
v(e.g.vformat) has not changed and they can still take runtime-defined format specs.One effect of this is that if you need to determine the format spec at runtime then you have to use the
v-prefixed functions and pass the arguments as an argument pack created withmake_format_argsormake_wformat_args. This will impact you if, for instance, you want to make your program available in multiple languages, where you would read the format spec from some kind of localization database.Another effect is on error reporting in the functions that parse the format spec. We will deal with this when describing the
parsefunction of theformatterclasses described in this article.
By Blog Staff | Apr 30, 2024 12:36 PM | Tags: None
In software development, handling notifications efficiently is pivotal, particularly in user interface scenarios. While traditional notification patterns inform handlers of changes, they often lack crucial state information. In this article, we explore the intricacies of managing stateful updates within the context of C++/WinRT, addressing challenges such as race conditions and ensuring that notification handlers operate on the most recent data for optimal user experience.
Adding State to the Update Notification Pattern, Part 1
by Raymond Chen
From the article:
Some time ago, we looked at the update notification pattern, but in those cases, the notification carried no state.
Consider the case where you want to call a notification handler, and the handler also receives a copy of data derived from the most recent state, rather than just being called to be told that something changed and forcing them to figure out what changed.
For example, suppose you want to add autocomplete to an edit control, but calculating the autocomplete results is potentially slow, so you want to do it in the background. But while you are calculating the autocomplete results, the user might type into the edit control, and you want the final autocomplete results to reflect the most recent edit in the edit control, rather than any results from what the edit control used to contain at some point in the past.