Practical Implementation of Domain-Driven Design
Explore practical implementation of Domain Driven Design, focusing on tools and approaches for microservices in both monolith breakdowns and greenfield projects.
Best Practices in Domain Driven Design
Explore key concepts and best practices in Domain Driven Design, including Ubiquitous Language, Bounded Context, Aggregates, and more.
Integrating C++ Code Generation Into a Large CMake Build
Explore challenges and solutions for integrating C++ code generation tools into CMake builds, focusing on developer experience and build performance optimization.
Our Road to Exascale: Particle Accelerator and Laser-Plasma Modeling
Explore the journey to exascale computing in particle accelerator and laser-plasma modeling, featuring WarpX's development and the 2022 ACM Gordon Bell Prize.
Why C++ Loops End - Midnote
Explore reasons for loop termination in C++ and learn to formally express them in code. Gain insights into stability, substitutability, and repeatability principles for robust loop design.
Polymorphism, Cohesion, and Coupling in C++ - Lecture
Explore low coupling and high cohesion through polymorphism in C++. Learn to implement a performance-efficient framework using template metaprogramming for easy composition and feature addition.
How Microsoft Uses C++ to Deliver Office - Huge Size, Small Components
Explore Microsoft's C++ engineering in Office, focusing on codebase management, design standards, and the 'liblet' component architecture for this massive, multi-platform software suite.
Back to Basics: C++ API Design - Making APIs Hard to Use Wrong
Master C++ API design techniques to create user-friendly interfaces. Learn strategies for making APIs intuitive, robust, and hard to misuse, enhancing code quality and developer productivity.
Breaking Dependencies - C++ Type Erasure Implementation Details - Lecture
Explore C++ Type Erasure implementation details, from basic wrappers to advanced optimization techniques. Learn to reduce coupling and enhance software design with this powerful pattern.
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.
Using Modern C++ to Revive an Old Design
Revive the Unix System V STREAMS framework using modern C++ techniques. Learn to build modular, reusable components for efficient data processing systems while optimizing runtime performance.
Innovating the Next Discontinuity in HPC and AI Computing
Explore innovative solutions for HPC and AI bottlenecks through Memory Coupled Compute architecture, addressing bandwidth limitations and accelerator efficiency for post-exascale computing.
Dependency Injection in C++ - A Practical Guide
Master dependency injection principles in C++ through practical examples, exploring building blocks like link-time substitution, interfaces, templates, and smart pointers while learning strategies for legacy codebase integration.
MyWebstrates - Building Local-first Software with Webstrates
Discover how Webstrates technology enables local-first software development, combining web-based collaboration with offline capabilities and data sovereignty in modern applications.
Kubernetes SIG Architecture Introduction and Design Principles
Discover how Kubernetes SIG Architecture maintains design principles, API conventions, and architectural consistency while exploring its key roles, subprojects, and latest community developments.
Scaling and Safeguarding the Heart of Kubernetes: Deep Dive Into etcd
Dive into etcd development efforts, exploring feature gates, operator working group progress, compaction correctness, and community updates for enhanced Kubernetes cluster management and scalability.
Multi-Zone Clusters Inside and Out - Understanding Topology Aware Routing and Cost Management
Dive into the mechanics of multi-zone Kubernetes clusters, exploring topology-aware routing, cost management strategies, and practical implementation techniques through live demonstrations.
Mastering Cell-Based Architecture: Practical Solutions and Best Practices
Discover practical solutions for implementing cell-based architecture, from defining enterprise-wide boundaries to managing greenfield and brownfield implementations, with real-world examples and comprehensive best practices.
Lessons Learned Adopting OpenTelemetry at Scale
Discover practical strategies and real-world insights for implementing OpenTelemetry in complex enterprise environments through Heroku's journey, including adoption challenges, technical guidance, and success factors.
Cash App's Journey Into a Multi-Cluster Kubernetes Ecosystem
Discover how Cash App implemented multi-cluster Kubernetes architecture to enhance reliability, enable seamless service migrations, and streamline maintenance processes for improved system resilience.
Engineering a Kubernetes Operator - Lessons Learned from Versions 1 to 5
Discover the evolution of Kubernetes Operator development through 5 versions of a Postgres implementation, exploring architectural decisions, design patterns, and practical strategies for building robust operators.