
Sign up to save your podcasts
Or


This episode focuses on the Polling Publisher pattern, a crucial technique for publishing messages in a microservices architecture. Explore its workings, benefits, drawbacks, and alternatives like Transaction Log Tailing.
Reference: https://microservices.io/patterns/data/polling-publisher.html
In this episode, we explore the Transaction Log Tailing pattern, a powerful technique for ensuring reliable message delivery in a microservices architecture. We'll discuss how this pattern works, its benefits and drawbacks, and how it compares to alternative solutions. Join us as we demystify transaction log tailing and unlock its potential for your microservices applications.
References: https://microservices.io/patterns/data/transaction-log-tailing.html
While event sourcing is a popular approach for managing data consistency in microservices, there are alternative patterns worth considering. This episode explores the Transactional Outbox pattern, a versatile solution for reliably sending messages and events even when distributed transactions are not an option. Uncover the inner workings of this pattern and how it guarantees message ordering and delivery while maintaining the flexibility of your microservices architecture.
Reference: https://microservices.io/patterns/data/transactional-outbox.html
In today's fast-paced business environment, agility is key. This podcast explores how microservices empower organisations to achieve rapid development cycles, adapt quickly to changing requirements, and maintain a competitive edge. Join us as we discuss the principles, practices, and real-world experiences of adopting microservices for increased agility.
Reference: https://microservices.io/patterns/decomposition/service-per-team.html
Are you considering adopting microservices or looking to improve your existing architecture? This podcast is your one-stop shop for all things microservices. We discuss proven patterns, best practices, and common pitfalls to help you navigate the challenges of this architectural style. We'll cover topics such as service communication, data consistency, testing, deployment, and more, drawing on real-world experiences and industry insights.
Reference: https://microservices.io/patterns/index.html
In the world of distributed systems, performance is paramount. Discover how the 'Consistent Core' pattern allows large data clusters to coordinate efficiently by leveraging a smaller, dedicated cluster for critical functions. We'll unpack the problem of quorum-based algorithms in large clusters and explain how 'Consistent Core' offers a practical alternative.
Reference: https://martinfowler.com/articles/patterns-of-distributed-systems/consistent-core.html
In distributed systems, leadership can emerge organically without explicit elections. This podcast unpacks the "Emergent Leader" pattern, where the oldest node in a cluster naturally assumes the role of coordinator. We'll discuss how this approach simplifies coordination, enhances fault tolerance, and enables efficient decision-making in complex, decentralized environments. Tune in to understand the intricacies of this powerful pattern and its implications for modern system design.
Reference: https://martinfowler.com/articles/patterns-of-distributed-systems/emergent-leader.html
Imagine a world where your online shopping experience becomes a confusing mess because different parts of the system can't agree on what time it is! This is the challenge of external consistency in distributed systems, and it's the topic of today's episode. We'll explore the Clock-Bound Wait pattern – a clever solution that ensures all nodes in a system are on the same page, time-wise, before reading or writing data. This episode will be particularly interesting for software developers, architects and anyone curious about the hidden complexities of building reliable distributed systems.
Ever wonder how Netflix manages to send real-time updates to a billion devices worldwide? This podcast explores the fascinating story of Pushy, Netflix's custom-built WebSocket server. We'll hear from the engineers who built and scaled Pushy, and learn about the technical challenges they faced along the way. We'll also explore the future of Pushy, and how it will continue to evolve to meet the needs of Netflix's growing user base.
Reference: https://netflixtechblog.com/pushy-to-the-limit-evolving-netflixs-websocket-proxy-for-the-future-b468bc0ff658
In this episode, we explore the fascinating world of traffic replay at Netflix. Discover how this powerful technique allows engineers to simulate real-world scenarios, test new features at scale, and identify potential issues before they impact users. We'll examine the 'Basic with Ads' launch as a case study and discuss the broader applications of traffic replay in software development.
Reference: https://netflixtechblog.com/ensuring-the-successful-launch-of-ads-on-netflix-f99490fdf1ba