Atomicity and Consistency Across Databases and Messaging Systems
Explore techniques for achieving atomicity and consistency between message queues and databases in modern application development. Learn how to synchronize database transactions with messaging activities, crucial for scenarios like updating order statuse…
Database Engineering
Comprehensive exploration of database engineering concepts, from ACID transactions to advanced indexing techniques. Covers various database systems, performance optimization, and real-world applications.
OpenStack Swift - Object Storage Architecture and Usage
Explore OpenStack Swift's architecture, features, and usage for efficient, secure, and cost-effective object storage. Learn implementation tips and best practices from an expert.
Multi-Region, Multi-Primary, and Eventually Consistent Database Systems
Explore a clever implementation of multi-region, multi-primary databases with eventual consistency using service mesh and open policy agent. Learn benefits for financial trading and auctions.
Building Fintech Solutions with Dapr - Stock Trading Case Study
Explore building a stock trading solution using Dapr and Actor Framework. Learn about CQRS, microservices, GraphQL, and design choices for eventual consistency in fintech applications.
CAPtivating Architecture - Navigating Distributed Systems and Microservices
Explore distributed systems architecture, from CAP theorem fundamentals to microservices communication patterns, timeout configurations, and practical implementation strategies for robust systems.
Mixed and Verified Consistency with Propel and ConOpY
Explore mixed consistency in distributed systems using ConOpY language and Propel type system for verifying CRDTs, enhancing data replication and local-first applications.
How to Build a Distributed System and Should You - Lessons from Production
Explore the journey of building an eventually consistent system, including challenges, tools used, and lessons learned. Gain insights into distributed systems concepts and evaluate if building your own is right for you.
Enhancing Flexibility and Productivity with Access Patterns and Storage-Agnostic Abstractions
Explore a platform bridging data management gaps, offering storage-agnostic abstractions and ACID guarantees across streaming, batch, and random-access storages for flexible, consistent data handling.
A Different Flavor of Distributed Transactions
Explore distributed transactions beyond traditional approaches, delving into innovative solutions for managing complex data operations across distributed systems.
Saga Pattern for Distributed Transactions
Explore the Saga Pattern for managing distributed transactions in cloud-native systems. Learn implementation strategies and best practices for data consistency.
Tracking Millions of Ganks in Near Real Time
Explore Riot Games' transition to Riak for real-time statistics in League of Legends, discussing data modeling, scalability challenges, and strategies for handling eventually consistent data in gaming.
Message-Based Microservices Architectures - Benefits and Practical Matters
Explore message-based microservices architecture: benefits, design patterns, and practical implementation using Docker, addressing challenges like consistency, versioning, and data protection.
Message-Based Microservices Architectures Driven With Docker
Explore microservices architectures using Docker, covering topics like distributed data, identity management, and event-driven systems for improved scalability and flexibility.
Welcome to the State Machine
Explore sagas for modeling complex collaborative domains without distributed transactions, focusing on failure handling and eventual consistency in stateful systems.
Modernizing an Existing System to Take a More Domain-Driven Approach
Explore refactoring patterns and steps to transform a non-DDD SOA system into a domain-driven design approach, covering key concepts, implementation strategies, and decision-making processes.
The Hardest Part of Microservices - Your Data
Explore data challenges in microservices, using Domain Driven Design to manage complexity. Learn about transactional boundaries, CAP theorem, and technologies like Kafka and Camel for building scalable, autonomous systems.
State or Events - Which Shall I Keep
Comparing event sourcing and ORM-based approaches through live coding, exploring benefits and challenges in implementing complex data models and microservices architecture.
Lost in Transaction - Strategies to Deal with Inconsistency in Modern Architecture
Strategies for handling consistency challenges in distributed systems, including eventual consistency, distributed transactions, and message delivery semantics. Includes live demonstrations using Spring, Hystrix, Kafka, and Camunda.
You Got Arrested by the CAP, You Have the Right to Remain Consistent
Explore patterns for handling distributed transactions, scaling data across data centers, and migrating schemas without downtime in large-scale microservices architectures.
State or Events? Which Shall I Keep?
Practical implementation of event-driven architecture, exploring benefits and challenges through live coding. Covers event sourcing, CQRS, distributed systems, and DDD concepts.