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.
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 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.
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.
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.
Algorithms from a Compiler Developer's Toolbox
Explore foundational algorithms in modern optimizing compilers, focusing on chains of recurrences and value numbering. Gain insights into compiler capabilities and implementation techniques with practical examples.
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.
Designing Concurrent C++ Applications
Explore advanced C++ concurrency techniques, focusing on high-level constructs and design patterns for building efficient multi-core applications without using locks or primitive threading tools.
STL Algorithms as Expressions
Explore advanced C++ techniques using Expression Templates for flexible algorithm customization, enhancing STL range algorithms and generic programming beyond traditional approaches.
What Neighborhoods Owe Each Other - Rights, Duties, Immunities & Disabilities of Functions & Objects
Explore how functions and objects form relationships in programming, using legal concepts to understand resource management, aliasing, and concurrency issues in C++.
Taskflow - A Heterogeneous Task Graph Programming System with Control Flow
Explore heterogeneous task graph programming with control flow using Taskflow, a C++ system for efficient parallel and GPU-accelerated computing with high productivity.
A Future of Value Semantics and Generic Programming Part 1
Explore the essence of value semantics and generic programming beyond C++, examining their fundamental concepts and potential language feature designs for enhanced programming paradigms.
A Future of Value Semantics and Generic Programming Part 2
Explores the essence of generic programming and value semantics beyond C++, drawing insights from Swift development to reimagine language features and expand programming paradigms.
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.
A Lock-free Atomic shared_ptr
Explore lock-free atomic shared_ptr implementation for C++, discussing motivation, existing solutions, and a new portable open-source implementation for low-latency applications.
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.