Git, CMake, Conan - How to Ship and Reuse Our C++ Projects
Explore efficient C++ project management using Git, CMake, and Conan. Learn modern techniques for dependency handling, modular design, and package creation to streamline development and improve code reusability.
Smart Output Iterators
Explore smart output iterators in C++, their advantages, and how they complement STL algorithms and range libraries. Learn implementation techniques and performance comparisons for efficient collection manipulation.
What Else Has My Compiler Done For Me Lately
Explore recent compiler optimizations and features with Matt Godbolt, creator of Compiler Explorer, as he shares insights on efficient code writing and the latest compiler developments.
Moving Faster - Everyday Efficiency in Modern C++
Explore modern C++ efficiency techniques, from value semantics to container choice, for writing performant code that meets user expectations in everyday programming scenarios.
Generative Programming in Action - Emulating the 3DS
Explore generative programming in C++ for console emulation, focusing on the 3DS interprocess communication system. Learn to balance performance, maintainability, and correctness using modern C++ techniques.
Dependency Injection - A 25-Dollar Term for a 5-Cent Concept
Explore dependency injection in C++, its benefits for maintainable code, and various implementation approaches. Learn to apply DI effectively in projects with changing requirements.
Practical Interfaces for Practical Functions
Explores practical approaches to developing formal interfaces for familiar functions in C++, drawing lessons for effective interface design and building on previous work in software architecture.
A Generic Binary Tree - Why Grow Your Own?
Explore the design and implementation of a generic binary tree for Boost.Graph, discussing trade-offs, storage options, and performance comparisons while drawing insights from classic computer science texts.
The Truth of a Procedure in Programming
Explore the mathematical logic behind programming procedures, treating them as statements about event arrangements and bridging programming with formal languages and truth concepts.
Implementing Physical Units Library for C++
Explore the design and implementation of a Physical Units Library for C++, including challenges, tradeoffs, and C++20 features that enhance usability, maintainability, and extensibility.
Compile Time Regular Expressions with a Deterministic Finite Automaton
Explore advanced C++20 techniques for compile-time regular expressions using a Deterministic Finite Automaton, optimizing performance and showcasing novel metaprogramming approaches.
The Rough Road Towards Upgrading to C++ Modules
Explores challenges in adopting C++ Modules, discussing issues with existing systems, attempts at automated modularization, and implications for code organization and compilation performance.
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.
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.
C++11/14 at Scale - What Have We Learned?
Comprehensive analysis of C++11/14 features in large-scale production, examining benefits, drawbacks, and lessons learned over 8 years of use at Bloomberg. Insights on teachability and practical implications.
Better C++ Ranges
Explore advanced C++ range concepts, including efficient stacking, self-contained adaptors, internal iteration, and optimized text formatting, enhancing code expressiveness and performance.
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.
Customization Methods - Connecting User and Library Code
Explore customization points in C++ libraries, including CTS, ADL, Concepts, CTOs, and tag_invoke. Learn benefits, drawbacks, and future developments for connecting generic and user-specific code.
Embracing Noexcept Operators and Specifiers Safely
Explore the effective use and potential pitfalls of noexcept operators and specifiers in C++, their impact on performance and maintainability, and proposed improvements for C++23.
Managing External APIs in Enterprise Systems
Explore techniques for encapsulating and modernizing external APIs in enterprise systems, focusing on efficient interfaces, localized decoupling, and seamless migration paths for codebase changes.
Rust Features that I Want in C++
Explore Rust's attractive features for systems programming and their potential integration into C++. Gain insights on tooling, community, strategy, and language enhancements from an expert perspective.