Multithreading is the Answer. What Was the Question? - Part I
Explore multithreading concepts, challenges, and solutions in C++ development. Learn when to use or avoid multithreaded code, and discover techniques for improved readability and maintainability.
The Fiber Library
Explore Boost.Fiber for fine-grained concurrency, efficient CPU usage, and simplified asynchronous I/O. Learn integration techniques, useful patterns, and load-balancing strategies for improved application performance.
No Sane Compiler Would Optimize Atomics
Explore compiler optimizations for atomics, memory accesses, and architecture-specific features. Learn about standardizing concurrency tools and debunking misconceptions in low-level programming.
Multicore Synchronization - The Lesser-Known Primitives
Explore advanced multicore synchronization primitives, their performance properties, and practical challenges in complex concurrent systems, with examples from the Concurrency Kit project.
Networking TS Workshop - Part 2 of 2
Hands-on workshop exploring the C++ Networking TS through practical exercises, building clients and servers while addressing common challenges and leveraging modern C++ techniques.
Rust - Hack Without Fear
Explore Rust's ownership concept, memory safety, and parallelism advantages. Learn how Rust combines low-level control with high-level programming, ensuring thread safety and efficient abstractions.
Good FIFOs Make Good Thread Neighbors
Explore microarchitectural implications of FIFO queues in parallel programming, analyzing open-source implementations and their impact on processor core performance through code and assembly examination.
The Holy Grail - A Persistent Hash-Array-Mapped Trie for C++
Exploring Hash-Array-Mapped Tries: A persistent, efficient data structure for C++ that combines tree and hash table characteristics, offering superior memory efficiency and immutability benefits.
Converting a State Machine to a C++ 20 Coroutine
Explore converting state machines to C++20 coroutines, leveraging async operations and co_await. Learn to simplify complex code using modern C++ features for more readable and maintainable asynchronous programming.
What Neighborhoods Owe Each Other - Rights, Duties, Immunities & Disabilities of Functions & Objects
Explore how functions and objects form relationships in programming, using legal concepts to understand resource management, aliasing, and concurrency issues in C++.
Concurrency in C++ - A Programmer’s Overview - Part 1 of 2
Comprehensive overview of C++ concurrency features from C++11 to C++20, focusing on performance optimization with live benchmarks and practical insights for efficient concurrent programming.
Concurrency in C++ - A Programmer’s Overview - Part 2 of 2
Explore advanced C++ concurrency features, including memory models, thread-safety, primitives, parallel algorithms, and C++20 coroutines. Gain insights for maximum performance through live benchmarks and practical examples.
C++ Coroutine Intuition
Explore C++20 coroutines for improved code design. Gain intuition on stackless asyncrony, generators, and senders/receivers through examples, leading to cleaner and safer implementations.
What is Low Latency C++? - Part 2
Explore advanced C++ techniques for low-latency systems, covering CPU caching, data structures, concurrency, and memory management to optimize performance in finance, audio, and gaming.
Hands-On Web App Test Automation
Learn to build reliable automated tests for web apps using Python, pytest, and Selenium. Hands-on project testing DuckDuckGo searches, covering browser switching and avoiding race conditions.
Python Concurrency - From Beginner to Pro
Comprehensive guide to Python concurrency, covering processes, threads, modules, race conditions, and the GIL. Includes coding examples and activities to build a multithreaded and multiprocessing web server.
Cuándo Usar Extensiones Nativas en Rust - Rendimiento Accesible y Seguro
Explora el uso de extensiones nativas en Rust para mejorar el rendimiento de Python, ofreciendo seguridad y accesibilidad. Aprende cuándo implementarlas basado en la experiencia del proyecto Pants.
Creating Extensible Workflows with Off-Label Use of Python
Discover how to create flexible yet constrained workflow systems using Python's type annotations, coroutines, and dataclasses for extensible APIs in data processing, ETL, CI/CD, and more.
A Per-Interpreter GIL - Concurrency and Parallelism with Subinterpreters
Explore Python 3.12's new solution for concurrent code and multi-core computing. Learn about per-interpreter GIL and subinterpreters to simplify concurrency and boost performance.
Generators, Coroutines and Nanoservices
Explore generators, coroutines, and nanoservices in Python. Learn lesser-known aspects like the "send" method and "yield from" syntax. Discover practical applications and when to use these powerful features in your code.
Instrumentation Nightmares - A Review of Our Toughest Cases
Explore advanced Python instrumentation techniques, challenging real-world cases, and design patterns. Learn to hook into import systems, instrument popular libraries, and make your code instrumentation-friendly.