Ranges for Distributed and Asynchronous Systems
Explore Functional Reactive Programming for asynchronous systems using range-inspired transformations. Learn to implement concurrent code with improved clarity and reduced shared state issues.
From Iterators to Ranges - The Upcoming Evolution of the Standard Library
Explore the evolution of C++ Standard Library from iterators to ranges, discussing design challenges, practical considerations, and potential future improvements for more efficient and readable code.
Concurrency in C++20 and Beyond
Explore new C++20 concurrency features and future proposals, including std::jthread, std::stop_token, std::latch, std::barrier, and std::counting_semaphore. Learn to write efficient concurrent code.
C++20 + Lua = Flexibility
Explore combining C++20 and Lua for flexible software architecture. Learn SWIG bindings, coroutine integration, and CMake build flow. Gain insights from a real-world commercial deployment example.
std::jthread - I Told You Concurrency Is Tricky
Explore the intricacies of C++20's std::jthread, uncovering concurrency challenges and design considerations. Gain insights into implementing robust threading mechanisms with expert guidance.
How to Use C++20 Coroutines for Networking
Explore event-driven programming with C++20 coroutines, focusing on a chat application example. Learn design strategies, debugging techniques, and performance comparisons with traditional callback methods.
Coroutines - C++ vs Rust
Explore the design differences between C++ and Rust coroutines, comparing their implementations, trade-offs, and approaches to asynchronous programming in systems languages.
Asynchronous I/O and Coroutines for Smooth Data Streaming
Explore asynchronous I/O with io_uring and C++20 coroutines for enhanced program responsiveness. Learn to write efficient, parallel-like code without threading complexities.
Applied C++20 Coroutines
Practical guide to implementing C++20 coroutines in real-world applications, focusing on web server development, performance evaluation, and future C++ updates.
Using Both Cores of Raspberry Pi Pico with C++OS - Coroutines and std - execution in Embedded Systems
Explore C++20 coroutines and std::execution for multi-core programming on Raspberry Pi Pico. Learn to implement portable embedded applications using C++OS, a proof-of-concept system for bare-metal multitasking.
Spooky Action at a Distance - Revisiting C++ Observers
Explore C++ Observer pattern implementations, trade-offs, and practical applications in various scenarios. Learn from real-world examples to improve code structure and design.
Concurrency Approaches - Past, Present, and Future
Explore the evolution of concurrency approaches, analyzing their pros and cons, and discover a new model that promises safety, efficiency, structure, and ease of use in concurrent programming.
How to Master C++
Practical advice for mastering modern C++ through five key programming mindsets: imperative, compile-time, functional, concurrency, and performance. Develop and blend these skills for continuous improvement.
What I Learned From Sockets - Applying the Unix Readiness Model When Composing Concurrent Operations in C++
Explore Unix socket concepts for composing concurrent operations in C++. Learn to apply select/poll mechanisms to various concurrency problems and discover C++ solutions for multi-future and coroutine scenarios.
Rust for IOT
Explore Rust for embedded systems: architecture support, paradigm shifts, and techniques for microcontrollers. Survey of outstanding embedded Rust projects in the ecosystem.
Asynchronous Programming in Java - Options to Choose from
Explore Java's asynchronous programming options with expert Venkat Subramaniam. Learn to leverage various techniques for efficient, non-blocking code execution in modern applications.
All About React 18
Explore React 18's new features: concurrency, automatic batching, transitions, Suspense, and server components. Learn upgrade strategies and performance optimization techniques.
Better Code - Concurrency
Explore advanced concurrency concepts and best practices for writing efficient, scalable parallel code with industry expert Sean Parent.
std - shared_ptr - T
Explore std::shared_ptr's intricacies, from RAII and resource ownership to thread safety, custom deleters, and allocators. Gain insights into C++ smart pointers and memory management best practices.
Concurrency in Rust
Explore Rust's concurrency features with Alex Crichton, covering safe and efficient parallel programming techniques for modern software development.
Thinking in Coroutines
Explore asynchronous programming with coroutines in Python, learning key concepts and practical applications for efficient concurrent execution.