The C++ Reflection TS
Comprehensive overview of C++ Reflection TS, explaining its features, applications, and future directions in standardization, presented by project co-author David Sankel.
Clang Automated Refactoring for Everyone with Clangmetatool
Explore clang tooling for automated C++ refactoring, focusing on Bloomberg's open-source framework clangmetatool. Learn about static analysis tools and the development process for creating refactoring tools.
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.
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.
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.
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++.
Hop - A Language to Design Function-Overload-Sets
Explore a template library for creating complex function overload sets in C++, covering variadic functions, default arguments, and advanced overloading techniques.
The Complete Guide to `return x;`
Comprehensive exploration of Return Value Optimization, implicit move, and related C++ concepts. Covers historical context, recent developments, and practical implications for efficient code writing.
The Performance Price of Dynamic Memory in C++
Explore performance impacts of dynamic memory in C++, covering allocation costs, memory access patterns, and cache-aware design principles with practical examples and solutions.