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.
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.
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.
Library Approaches for Strong Type Aliases
Explore library approaches for creating strong type aliases in C++, addressing issues with built-in types and enhancing code clarity through domain-specific and use-specific classes.
Frictionless Allocators
Explore frictionless allocators in C++, discussing benefits, challenges, and potential language extensions to simplify allocator-aware code. Preview proposals for C++23 and beyond.
Simplest Safe Integers
Explore pitfalls of C++ built-in types and learn about a simple integer library for MISRA-C++ compliance. Discover safe integer types that prevent promotion and maintain signedness, enhancing code safety and reliability.
Don't Constexpr All the Things
Explore limitations of constexpr metaprogramming and discover a compelling alternative in circle metaprogramming, offering intuitive and powerful solutions for C++ developers.
Taking Template Classes Further with Opaque Types & Generic NTTPs
Explore advanced C++20 techniques for template classes using opaque types and generic NTTPs. Learn to design expressive interfaces, reduce parameter bloat, and create powerful customization points for generic programming.
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.
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.
Top 5 Library Additions in C++23
Explore the top 5 library additions in C++23, including std::format, range algorithms, std::expected, and standard modules. Gain insights into new features and their implementation.
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.