Networking TS Workshop - Part 2 of 2
Hands-on workshop exploring the C++ Networking TS through practical exercises, building clients and servers while addressing common challenges and leveraging modern C++ techniques.
Local - Arena - Memory Allocators
Explore the impact of local memory allocators on C++ performance, examining six key dimensions and demonstrating potential order-of-magnitude speed improvements in long-running systems.
Networking TS Workshop - Part 1 of 2
Hands-on workshop exploring the Networking TS in C++, comparing it to Boost.Asio and implementing both clients and servers through practical exercises. Ideal for developers seeking to master C++ networking.
Rethinking Strings
Rethinking string design in C++: exploring modern approaches, optimizations, and considerations for encoding, storage, and performance in light of recent language and library developments.
Composite Arithmetic Types Are Greater Than the Sum of Their Parts
Explore advanced C++ arithmetic types using modern language features. Learn to build custom numeric types with improved safety, speed, and usability through compositional approaches and low-cost abstractions.
Rust - Hack Without Fear
Explore Rust's ownership concept, memory safety, and parallelism advantages. Learn how Rust combines low-level control with high-level programming, ensuring thread safety and efficient abstractions.
RaftLib - Simpler Parallel Programming
Explore RaftLib, a C++ library simplifying parallel programming for heterogeneous multicore processors. Learn to write efficient code for complex hardware without extensive low-level knowledge.
Customization Points That Suck Less
Explore advanced C++ customization techniques, including template specializations, ADL, and type erasure. Learn innovative approaches to create flexible, user-friendly customization points for libraries and language features.
No Raw std::thread! - Live Tweet Analysis in C++
Explore concurrent algorithms for complex interactions in C++ using a live tweet analysis app. Learn to apply algorithms for values distributed in time and space without raw std::thread.
Towards Painless Testing
Explore modern C++ testing techniques, including automatic mocks injection, TDD, and BDD. Learn to streamline your testing process and improve code quality with practical examples and future-oriented insights.
Building Useful Tools with LLVM and Clang for Fun and Profit
Explore LLVM and clang libraries for custom C++ tools. Learn AST representation, static analysis, and source-to-source transformations to enhance workflow and productivity.
Locally Atomic Capabilities and How to Count Them
Exploring local capabilities in programming, their flow between functions, and methods to ensure correct usage. Presents a notation for function interfaces and techniques for testing capability usage.
The Holy Grail - A Persistent Hash-Array-Mapped Trie for C++
Exploring Hash-Array-Mapped Tries: A persistent, efficient data structure for C++ that combines tree and hash table characteristics, offering superior memory efficiency and immutability benefits.
The Shape of a Program
Explore how programs can be viewed as mathematical shapes using topology, examining connections between actions, capabilities, time, and possibility in software architecture.
Undefined Behavior and Compiler Optimizations
Explores compiler optimizations, undefined behavior in intermediate representations, sequential memory models in C++, and the future of compiler technology, including formal verification and automatic generation.
A Quantum Data Structure for Classical Computers
Explore quantum data structures for classical computers, understanding superposition, entanglement, and coherence in C++ programming to broaden computational options and prepare for emerging quantum-reliant hardware.
C++ Mixins - Customization Through Compile Time Composition
Explore C++ mixins for customizable abstractions in embedded systems, focusing on compile-time composition techniques to enhance flexibility and performance in resource-constrained environments.
Fast Conversion From UTF-8 with C++ - DFAs - and SSE Intrinsics
Explore fast UTF-8 conversion using C++, DFAs, and SSE intrinsics. Learn efficient algorithms, bit manipulation techniques, and performance optimization strategies for text processing applications.
An Allocator Is a Handle to a Heap
Explore C++17's std::pmr framework, allocator concepts, and memory resource management. Learn about lightweight allocators, rebinding, and non-standard examples for efficient heap handling in C++.
Boost.Text - Fixing std::string, and Adding Unicode to Standard C++ - Part 1
Exploring Boost.Text: A modern approach to address std::string deficiencies and add Unicode support in C++, aiming for standardization and improved text handling.
Boost.Text - Fixing std::string, and Adding Unicode to Standard C++ - Part 2
Explores Boost.Text library, addressing std::string flaws and adding Unicode support. Discusses modern string handling, text encoding, and potential C++ standardization.