An Introduction to Multithreading in C++20
Explore C++20's multithreading tools for beginners, covering essential facilities and safe usage in new or existing applications.
Deciphering Coroutines - A Visual Approach
Explore C++20 coroutines through visual diagrams and examples. Learn to decipher complex syntax, understand core concepts, and navigate advanced presentations on this powerful feature.
Trading at Light Speed: Designing Low Latency Systems in C++ - Lecture
Explore designing low-latency trading systems in C++, focusing on upfront design, CPU optimization, concurrency handling, and performance strategies for high-speed automated trading.
C++ Coroutines from Scratch - Lecture 1
Explore C++ 20 coroutines: simplify async code, understand core concepts, and see practical applications with library support. Gain insights into this powerful feature.
Clean Test: A Modern C++20 Testing Framework
Explore Clean Test, a modern C++20 testing framework with unique constexpr expression introspection, no dependencies, and thread-safe execution for efficient software development.
Concurrency in C++20: A Deep Dive
Explore advanced concurrency features in C++20, including higher-level abstractions built on the C++11 multithreading foundation.
C++20's Coroutines for Beginners - Lecture 1
Explore C++20 coroutines from basics to advanced concepts. Learn new keywords, customization points, and how to implement generators. Understand cooperative multitasking and coroutine benefits in concurrent programming.
Top 6 Worst Apache Kafka JIRA Bugs
Explore six critical Apache Kafka bugs with expert Anna McDonald. Gain insights into batching, replication protocols, networking, and Scala implementation, enhancing your understanding of Kafka's inner workings.
Concurrency Hylomorphism - A Structured Approach to Safe and Efficient Concurrent Programming
Explore a structured concurrency model for safe, efficient, and easy concurrent programming, inspired by Aristotle's hylomorphism. Learn to build effective abstractions with safety guarantees and performance considerations.
C++20's Coroutines for Beginners - Lecture
Explore C++20 coroutines from basics to advanced concepts. Learn new keywords, customization points, and benefits like lock-free multitasking. Gain practical knowledge for effective implementation.
Deciphering C++ Coroutines - A Diagrammatic Coroutine Cheat Sheet - Lecture 2022
Explore C++20 coroutines through visual diagrams, learning to read and reason about their complex syntax. Gain a solid foundation for understanding advanced coroutine concepts in future presentations.
HPX - A C++ Library for Parallelism and Concurrency
Explore HPX, a C++ library for parallelism and concurrency, enabling efficient parallel applications for heterogeneous resources with excellent performance and scaling characteristics.
Understanding C++ Coroutines by Example: Generators - Part 1
Explore C++20 coroutines, focusing on generators. Learn about co_yield, simple and asynchronous generators, and emerging best practices for effective implementation in your projects.
Understanding C++ Coroutines by Example: Generators - Part 2
Explore C++20 coroutines, focusing on generators. Learn co_yield keyword, simple and asynchronous generator concepts, and emerging best practices for effective coroutine usage.
Contemporary C++ in Action
Explore modern C++ features in action through a practical application. Journey through modules, network programming with coroutines, and C++23 innovations for real-world development.
A Pattern Language for Expressing Concurrency in C++ - CppCon 2022
Explore structured concurrency in C++ using senders/receivers, learn visual pattern representations, and discover efficient ways to handle concurrent programming challenges.
Back to Basics: The C++ Core Guidelines - CppCon 2022
Explore essential C++ Core Guidelines for writing correct software by design. Learn best practices for interfaces, functions, classes, concurrency, and templates in modern C++ development.
Embedded Asynchronous Abstraction C++ - Implementing Senders and Receivers Without an OS
Explore implementing senders and receivers for asynchronous work in embedded systems without an OS. Learn about P2300, concurrent behavior, and zero-cost abstractions for microcontrollers.
Employing Senders and Receivers to Tame Concurrency in C++ Embedded Systems
Explore how Senders and Receivers pattern can solve complex concurrency issues in baremetal systems, using Intel's open source library on an ARM-based development board.
The Dapr Actors Journey: From Understanding to Intuition
Dive into the fundamentals of Dapr Actors, exploring their implementation, patterns, and practical applications in cloud-native development through expert insights and real-world examples.
Building a Browser Rendering Engine in Rust - The Servo Project
Explore the evolution of Servo, a web rendering engine built in Rust, and discover how its memory safety and concurrent design are revolutionizing browser technology and web standards implementation.