Distributed-Systems on Rafiul Alam

Building Real-World Event Streaming Systems with Go and Kafka

Mon, 23 Mar 2026 00:00:00 +0000

A practical, hands-on guide to Apache Kafka with Go — covering producers, consumers, consumer groups, and three real-world use cases: e-commerce order processing, real-time analytics, and microservices event coordination.

Messaging Systems: A Visual Reference

Mon, 23 Mar 2026 00:00:00 +0000

15 messaging scenarios with increasing complexity — Kafka, RabbitMQ, and JetStream NATS compared through diagrams. Less words, more architecture.

Caching Strategies: A Visual Guide

Sun, 15 Mar 2026 00:00:00 +0000

Visual deep dive into caching strategies — cache-aside, write-through, write-behind, read-through, eviction policies, and distributed caching explained through Mermaid diagrams with incremental complexity.

Distributed Transactions: A Visual Guide

Fri, 13 Mar 2026 00:00:00 +0000

Visual deep dive into distributed transactions — Two-Phase Commit, Three-Phase Commit, Saga patterns, and compensation strategies explained through Mermaid diagrams with incremental complexity.

Distributed Storage: A Visual Guide

Wed, 11 Mar 2026 00:00:00 +0000

Visual deep dive into distributed storage — replication strategies, partitioning schemes, consistent hashing, and data placement explained through Mermaid diagrams with incremental complexity.

Consensus Algorithms: A Visual Guide

Mon, 09 Mar 2026 00:00:00 +0000

Visual deep dive into consensus algorithms — Raft leader election, log replication, Paxos prepare-accept, and Multi-Paxos optimizations explained through Mermaid diagrams with incremental complexity.

Building Resilient Workflows with Temporal.io: A Coffee Shop Tutorial

Sat, 22 Nov 2025 00:00:00 +0000

Building reliable distributed systems is challenging. Network failures, service outages, and unexpected errors can leave your workflows in inconsistent states. What if there was a way to build workflows that are inherently resilient, automatically handling retries, timeouts, and state management?

Enter Temporal.io - a workflow orchestration platform that makes building reliable distributed applications dramatically easier. In this comprehensive tutorial, we’ll build a coffee shop ordering system that demonstrates Temporal’s powerful capabilities.

The Token Ring: Fair Resource Access Through Token Passing

Mon, 10 Nov 2025 00:00:00 +0000

The Token Ring Problem

The Token Ring is a classic distributed mutual exclusion algorithm where nodes are arranged in a logical ring, and a single token circulates. Only the node holding the token can access the shared resource. It’s simple, fair, and starvation-free.

The Scenario

Nodes arranged in a ring:

N nodes form a logical ring
A single token passes around the ring
Only token holder can enter critical section
After using resource, pass token to next node
Properties: Fair (FIFO order), no starvation, deadlock-free

The challenge:

The Gossiping Problem: Efficient Information Spreading

Wed, 29 Oct 2025 00:00:00 +0000

The Gossiping Problem

The Gossiping Problem is a classic problem in distributed systems and graph theory. N people each know a unique secret, and they share information through phone calls. On each call, both parties share all secrets they know. The goal: find the minimum number of calls needed for everyone to know all secrets.

The Scenario

N people, N secrets:

Person i knows secret Si initially
When persons i and j call each other, they share ALL secrets they know
Goal: Everyone knows all N secrets
Question: What’s the minimum number of calls?

The Mathematical Result

For n ≥ 4 people:

Building Scalable Event-Driven Microservices in Go: A User and Notes Service Example

Wed, 15 Oct 2025 00:00:00 +0000

Learn how to build scalable, resilient event-driven microservices in Go using NATS JetStream, Watermill, Bun ORM, and PostgreSQL with practical User and Notes service examples.

Two Generals' Problem: The Impossibility of Perfect Consensus

Tue, 14 Oct 2025 00:00:00 +0000

The Two Generals’ Problem

The Two Generals’ Problem, also known as the Two Armies Problem, is a classic thought experiment that demonstrates the impossibility of achieving perfect consensus over an unreliable communication channel. It was first formulated by E. A. Akkoyunlu, K. Ekanadham, and R. V. Huber in 1975.

The Scenario

Two armies need to coordinate an attack:

General A and General B surround an enemy
They must attack simultaneously to win
If only one attacks → defeat
They communicate via messengers through enemy territory
Messages can be lost or intercepted
Question: Can they guarantee coordinated attack?

The Impossible Dilemma

%%{init: {'theme':'dark', 'themeVariables': {'primaryTextColor':'#e5e7eb','secondaryTextColor':'#e5e7eb','tertiaryTextColor':'#e5e7eb','textColor':'#e5e7eb','nodeTextColor':'#e5e7eb','edgeLabelText':'#e5e7eb','clusterTextColor':'#e5e7eb','actorTextColor':'#e5e7eb'}}}%% sequenceDiagram participant GA as General A participant Enemy as Enemy Territory participant GB as General B Note over GA: Wants to attack
at dawn GA->>Enemy: "Attack at dawn" Enemy->>GB: Message delivered Note over GB: Received message,
but A doesn't know! GB->>Enemy: "Acknowledged" Enemy->>GA: ACK delivered? Note over GA: Received ACK,
but B doesn't know! GA->>Enemy: "ACK of ACK" Enemy->>GB: Delivered? Note over GA,GB: This never ends!

The Core Problem

The infinite regress:

The Bully Election: Leader Election in Distributed Systems

Wed, 20 Aug 2025 00:00:00 +0000

The Bully Election Algorithm

The Bully Algorithm, proposed by Hector Garcia-Molina in 1982, is a classic leader election algorithm for distributed systems. It’s called “bully” because the highest-numbered process always wins and “bullies” the others into accepting it as leader.

The Scenario

A distributed system needs a coordinator:

N nodes in a network
Each node has a unique ID (priority)
One node must be elected as leader
When the leader fails, a new leader must be elected
Rule: The node with the highest ID wins

The protocol:

The Byzantine Generals: Achieving Consensus with Traitors

Thu, 14 Aug 2025 00:00:00 +0000

The Byzantine Generals Problem

The Byzantine Generals Problem, proposed by Leslie Lamport, Robert Shostak, and Marshall Pease in 1982, is one of the most important problems in distributed systems. It addresses the challenge of achieving consensus when some participants may be faulty or malicious.

The Scenario

Byzantine army divisions surround a city:

N generals command their divisions
They must coordinate: attack or retreat
They communicate via messengers
Some generals are traitors who send conflicting messages
Goal: All loyal generals must agree on the same plan

The challenge:

Building Payment Gateway Integrations in Go: A Complete Guide

Mon, 17 Feb 2025 00:00:00 +0000

Learn how to design and implement robust payment gateway integrations with multiple providers, handling transactions, retries, atomicity, scheduling, and data persistence in both SQL and NoSQL databases.

From Choreography to Durable Execution: Why Temporal Changes Everything

Sat, 08 Feb 2025 00:00:00 +0000

Discover how Temporal's durable execution model replaces hope-driven choreography with reliable, observable workflows. Learn the difference between event-driven choreography and durable execution with practical Go examples.

Microservices Architecture in Go: Building Distributed Systems

Sat, 25 Jan 2025 00:00:00 +0000

Learn how to implement Microservices Architecture in Go for building scalable, independently deployable services with clear boundaries and distributed communication patterns.

Go Concurrency Pattern: The Login Counter

Fri, 24 Jan 2025 00:00:00 +0000

← Ticket Seller | Series Overview | Monte Carlo Pi →

The Problem: Counting What You Can’t See

Count concurrent users. On login: increment. On logout: decrement. Simple, right?

Now add reality:

The counter is distributed across multiple servers
A user’s session times out on one server but they’re active on another
The increment message arrives after the decrement message
Network partitions split your cluster
Servers crash mid-operation

Suddenly, this “simple” counter becomes a distributed systems nightmare. Welcome to distributed counting, where even addition is hard.

Visual Guide to Distributed Systems Patterns

Fri, 17 Jan 2025 00:00:00 +0000

A comprehensive visual guide to distributed systems patterns including Raft consensus, circuit breakers, load balancing algorithms, and message queue patterns with interactive Mermaid diagrams.

Context Propagation Patterns in Go

Mon, 24 Jun 2024 00:00:00 +0000

Master context propagation for tracing, cancellation, and deadlines across service boundaries in distributed Go applications.

Circuit Breaker Pattern in Go

Wed, 12 Jun 2024 00:00:00 +0000

Implement the Circuit Breaker pattern in Go for fault tolerance, preventing cascading failures, and building resilient distributed systems.