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++.
The Worst Best Practices
Explore controversial C++ best practices, self-publishing experiences, and handling criticism in modern programming. Gain insights from Jason Turner's journey writing a book on C++ best practices.
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.
What is an ABI and Why is Breaking it a Problem?
Explore the concept of Application Binary Interface (ABI), its importance in C++ development, and the implications of breaking it, with examples and historical context.
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.
Preconditions, Postconditions, Invariants - How They Help Write Robust Programs
Explore key concepts for program correctness: function contracts, preconditions, postconditions, and invariants. Learn to write more robust code, leverage tools, and distinguish between bugs and symptoms.
Polymorphism À La Carte - CppNow 2021
Explore advanced runtime polymorphism techniques in C++, comparing mechanisms from other languages and showcasing their implementation using the Zoo framework for improved performance and flexibility.
Semantic Sugar - Tips for Effective Template Library APIs
Explore advanced C++20 concepts and alternative methods for creating effective template library APIs, focusing on semantic vs. syntactic approaches and potential pitfalls in library design.
Techniques for Overloading Any Invocable - CppNow 2021
Explore advanced techniques for implementing multiple overloads of operator() in any_invocable, enhancing its flexibility and power in C++ interface design beyond std::function capabilities.
Adventures in SIMD-Thinking
Explore SIMD capabilities in modern hardware, focusing on SSE, AVX, and AVX-512 instruction sets. Learn to leverage C++ for improved performance in real-world computing problems through vertical thinking.
Iterators and Ranges - Comparing C++ to D to Rust
Comparative analysis of iterator and range models in C++, D, and Rust, exploring their strengths and trade-offs for sequence traversal and algorithm implementation.
Simplest Strong Typing Instead of Language Proposal
Explore simplest strong typing in C++ to create safer, more robust code. Learn techniques to define useful types, avoid common pitfalls, and implement a framework for easier strong type creation.
CMake + Conan - 3 Years Later
Explore advancements in C++ project management, focusing on CMake and Conan. Learn updated best practices for packaging and highlights of Conan 2.0, essential for large-scale enterprise development.
Windows, MacOS and Web - Lessons from Cross-platform Development
Explore cross-platform development challenges and solutions, including porting Windows software to Mac and web, hiding platform-specific code, and generating C++ bindings from TypeScript for WebAssembly projects.
Variations on Variants
Explore std::variant in C++, its implementation, and alternative approaches for serialization. Learn about Intrusive-Variant and Variant-of-Base techniques, and gain insights into modernizing C-style code with variants.
C++ Insights - How Stuff Works, Lambdas and More
Explore C++ compiler's perspective with Andreas Fertig, diving into implicit conversions, lambdas, and variadic templates using C++ Insights tool for deeper understanding of code mechanics.