The View from a Standard Library Implementor
Insights into C++ standard library implementation, challenges, and advantages, with applications to Boost library maintenance and balancing user needs across different scenarios.
Identifying Monoids - Exploiting Compositional Structure in Code
Explore monoids as a powerful compositional pattern in code architecture. Learn to identify, exploit, and apply monoids to improve API design, incremental computation, and work distribution.
Algorithm Intuition
Explore STL algorithms, their common uses, and how to unlock their potential through intuition and lambdas. Develop algorithm intuition to complement your data structure knowledge and enhance your C++ programming skills.
An Alternate Smart Pointer Hierarchy
Explore Pure Storage's custom smart pointers: owned and delete_ptr. Learn their semantics, conventions, and advantages over C++'s std::unique_ptr and std::shared_ptr.
Trivially Relocatable
Explore C++ object relocation, its importance in optimizing vector reallocation and type-erased move-construction, and proposed language features for efficient memory management and performance improvements.
Pattern Matching - Match Me If You Can
Explore pattern matching in C++: declarative data inspection, proposal details, and code simplification examples. Learn about this powerful feature and its potential impact on C++ programming.
Taking the Plunge Towards CMake in Boost
Exploring CMake integration for Boost: benefits, user needs, script structure, modules, and migration strategies to enhance accessibility and community support.
The Ongoing Saga of ISO-C++ Executors
Explore the evolution of ISO-C++ executors, a generic abstraction for execution. Learn about concept-driven design principles and the latest developments in concurrent programming abstractions for C++23 and beyond.
C++ Development with Visual Studio Code
Explore Visual Studio Code's powerful features for C++ development, including editing, building, and debugging, with live demonstrations and insights on remote development capabilities.
Audio in Standard C++
Explore audio programming in C++, covering digital representation, soundcard communication, and a proposal for a standard audio API. Learn key concepts and potential future developments.
C++ - Engineers Wanted, Programmers Not so Much
Explore the shift from programming to engineering in C++, focusing on system-level thinking, business value, and mature software development practices for large-scale projects.
CMake - One Tool To Build Them All
Explore CMake's vital role in C++ development, its history, and key features for building, testing, and deploying software across platforms with Bill Hoffman, CMake's creator.
The C++ Rvalue Lifetime Disaster
Explores rvalue reference lifetime issues in C++, discussing const& binding and temporary lifetime extension problems, with proposed solutions for safer memory management in generic code.
A Crash Course in Unicode for C++ Developers
Comprehensive introduction to Unicode concepts and processing for C++ developers, covering encodings, normalization, and text algorithms to handle user text correctly.
How to - Colony
Dive deep into the mechanics of the colony container, exploring its implementation details, performance optimizations, and potential applications in C++ programming.
When Should You Give Two Things the Same Name
Explore when and why to give entities the same name in C++, examining overloading, polymorphism, and naming conventions to improve code design and maintainability.
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.
Surveying the C++ Community
Explore C++ community trends, usage statistics, and insights from the Meeting C++ continuous survey, comparing data with other annual surveys and revealing key findings about the ecosystem.
Interactive C++ in a Jupyter Notebook Using Modules for Incremental Compilation
Explore interactive C++ in Jupyter notebooks using modules for incremental compilation, addressing limitations of existing tools and enabling a more robust computational chain for experimentation.
Weak Interfaces - Weak Defences - The Bane of Implicit Conversion in Function Calls
Explore strategies to enhance function interfaces and prevent parameter mix-ups through type safety, refactoring, and code analysis tools. Gain insights on improving C++ code quality and maintainability.
Parallelism on Ranges - Should We?
Explore parallelizing C++ ranges, discussing implementation challenges, algorithmic fusion, and potential benefits using HPX library examples. Insights on combining composability with performance in modern C++.