Code Impact

Code Impact

By Sanket MakhijaEducation
Download on the App Store

All Code Impact episodes

  • The Polling Publisher Pattern Deep Dive

    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

    8 min
  • The Power of Transaction Log Tailing

    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

    10 min
  • Mastering Reliable Messaging in the Transactional Outbox Beyond Event Sourcing

    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

    15 min
  • Microservices for Agile Organisations

    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

    6 min
  • Microservices Patterns, Practices, and Pitfalls

    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

    9 min
  • Seamless Scaling Without Slowing Down

    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

    4 min
  • Unpacking the "Emergent Leader" Pattern

    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

    4 min
  • Taming Time in Distributed Systems

    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.

    9 min
  • How Netflix Handles Real-Time Updates

    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

    12 min
  • How Netflix Uses Traffic Replays to Build Confidence

    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

    9 min