C++20 Language Features for a New Library
Exploring C++20 language features and their impact on future standard library design, discussing compatibility, ambition, and priorities for a new C++ library.
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.
Type-Safe Programming
Explore advanced C++ type system techniques to prevent bugs at compile-time. Learn to leverage types for safer code, from minimizing implicit conversions to expressing preconditions and designing type-safe classes.
Effective CMake
Comprehensive guide to CMake, CTest, and CPack, covering best practices for building, testing, and packaging C++ projects, including dependency management and cross-platform development.
Promises in C++ - The Universal Glue for Asynchronous Programs
Explore promises in C++ for asynchronous programming, covering fundamental operations, construction helpers, continuations, and real-world examples to enhance your ability to write efficient and scalable code.
Sorting in Less Than O(n log n) - Generalizing and Optimizing Radix Sort
Explore advanced sorting techniques beyond O(n log n), focusing on generalizing and optimizing radix sort for various data types in C++. Learn to implement faster sorting algorithms for improved performance.
Type Based Template Metaprogramming is Not Dead
Exploring advanced C++ template metaprogramming techniques for improved compilation speed and efficiency, with a focus on type-based approaches and algorithm-data separation.
Multithreading Using Lockless Lists and RCU
Explore lockless lists and RCU technology for efficient multithreading in C++. Learn implementation techniques, benefits, and real-world applications in high-performance network daemons.
Postmodern Immutable Data Structures
Explore modern immutable data structures in C++, their benefits for concurrent systems, and efficient implementation techniques using Relaxed Radix Balanced Trees and the Immer library.
The Mathematical Underpinnings of Promises in C++
Explore the mathematical foundations of promises in C++ and their practical implementation, covering functional design principles, algebraic concepts, and real-world applications in library development.
Constexpr ALL the Things!
Explore the power of constexpr in C++17, examining techniques for compile-time computation, data structures, and algorithms. Learn to effectively combine compile-time and runtime computations for optimal performance.
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.
Local - Arena - Memory Allocators
Explore the impact of local memory allocators on C++ performance, examining six key dimensions and demonstrating potential order-of-magnitude speed improvements in long-running systems.
Rethinking Strings
Rethinking string design in C++: exploring modern approaches, optimizations, and considerations for encoding, storage, and performance in light of recent language and library developments.
C++17 Features
Comprehensive overview of C++17 features, covering major language and library changes. Explores structured bindings, if constexpr, lambdas, inline variables, and new standard library components like filesystem and parallel algorithms.
C++11's Quiet Little Gem - System Error
Explore C++11's ＜system_error＞ header, focusing on std::error_code and std::error_condition. Learn their design, intended use, and potential for extensibility in error handling and reporting across platforms.
Composite Arithmetic Types Are Greater Than the Sum of Their Parts
Explore advanced C++ arithmetic types using modern language features. Learn to build custom numeric types with improved safety, speed, and usability through compositional approaches and low-cost abstractions.
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.
Fun with Boost.Hana
Explore advanced C++ metaprogramming techniques using Boost.Hana, focusing on real-world applications like event systems and type erasure to enhance code expressiveness and maintainability.
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.
RaftLib - Simpler Parallel Programming
Explore RaftLib, a C++ library simplifying parallel programming for heterogeneous multicore processors. Learn to write efficient code for complex hardware without extensive low-level knowledge.