Time Brings All Things to Pass
Explore techniques for reliable testing of parallel software, including handling race conditions and timeouts. Learn to create a deterministic testing environment using innovative models and approaches.
There is a Better Future
Explores std::future limitations and introduces stlab::future as an enhanced alternative, covering advanced features like task graphs and CSP channels for parallel processing.
C++20 Coroutines - Introduction
Explore C++20 coroutines: their benefits, use cases, and potential pitfalls. Learn to write efficient, clean programs and understand coroutine implementation and composition.
C++20 Coroutines - Asynchronity Reimagined
Explore C++20 coroutines: their purpose, strengths, and potential impact on asynchronous programming. Discover how this new feature can revolutionize your code and shape the future of C++ development.
C++20 Coroutines - What's Next
Explore the future of C++20 coroutines, including proposed improvements and potential developments in upcoming language releases.
Deciphering Coroutines - A Visual Approach
Visual exploration of C++ coroutines, demystifying their mechanics and showcasing practical applications in modern software development for improved code efficiency and readability.
Asynchrony with ASIO and Coroutines
Explore asynchronous programming in C++ using ASIO and coroutines, enhancing performance and simplifying complex operations in high-performance systems.
C++11 - High-Level Threading
Explore C++11's high-level threading capabilities, including locks, mutexes, and futures. Learn to solve common threadsafe programming challenges using these components.
Yet Another Paradigm Shift - A Meta4 Model of Concurrency
Explore language evolution, C++ history, and a new paradigm shift in programming, using biological metaphors to propose innovative approaches to concurrency and language design.
Survey of Multi-Threaded Programming Support in C++11 and Boost
Comprehensive overview of C++11 and Boost tools for multi-threaded programming, covering threads, async operations, mutexes, condition variables, and atomics.
Libcppa - Designing an Actor Semantic for C++11
Explore libcppa, an open-source library combining the actor model with C++11 for efficient concurrent and distributed programming. Learn about its design, implementation, and benefits for building reliable systems.
Thread-Safe and Thread-Neutral Bags
Explores implementing thread-safe and thread-neutral bags in C++, introducing drawer and cupboard abstractions using C++11 multi-threading features for efficient concurrent data access.
Multi-Threading with C++11 and Boost
Explore C++11 and Boost for multi-threading through practical examples, including thread-safe queues, parallel tasks, and task interruption. Learn about threads, mutexes, and condition variables.
Coroutines, Fibers and Threads, Oh My
Explore the intricacies of coroutines, fibers, and threads in C++, understanding their differences, use cases, and implementation strategies for efficient concurrent programming.
C++ in Space Plasma Model Development
Explore space plasma modeling using C++11, covering numerical methods, advanced algorithms, and concurrency for efficient simulations in astrophysics and space weather.
Modern C++ as Concurrent Assembly
Explore how modern C++ can be utilized as a high-level assembly language for concurrent programming, enhancing performance and efficiency in multi-threaded applications.
The Future of Accelerator Programming in C++
Explore the evolving landscape of accelerator programming in C++, covering hardware models, vendor approaches, memory management, and advanced techniques for optimizing parallel computations.
Better Code - Concurrency
Explore advanced concurrency techniques in C++14, focusing on building a task system to create non-blocking software. Learn to leverage modern primitives for efficient parallel programming.
C++17 Coroutines for App and Library Developers
Explore C++17's efficient, scalable coroutines. Learn about stackless resumable functions, their implementation, and how to customize them for various use cases like tasks, goroutines, and generators.
Practical Performance Practices
Discover techniques to boost C++ performance through cleaner, idiomatic code. Learn practical strategies for optimization, thread safety, and efficient memory management.
Thread-Safe Observer Pattern - You're Doing It Wrong
Explore common pitfalls and solutions for implementing a thread-safe Observer Pattern, highlighting fundamental threading issues and providing practical approaches to avoid deadlocks and post-death calls.