Distributed System Design Interview — Complete Guide

# Conceptual model of CAP trade-offs
class DistributedDatabase:
    def __init__(self, consistency, availability):
        self.nodes = {}
        self.consistency = consistency
        self.availability = availability

    def write(self, key, value, partition_occurred=False):
        if partition_occurred:
            # CP system: reject writes during partition
            if self.consistency == "strong":
                return "write unavailable"
            # AP system: accept writes, resolve conflicts later
            if self.availability == "high":
                self.nodes[key] = value
                return "accepted (conflict possible)"
        self.nodes[key] = value
        return "written"

db_cp = DistributedDatabase("strong", "low")
db_ap = DistributedDatabase("eventual", "high")

print(db_cp.write("x", 1, partition_occurred=True))
print(db_ap.write("x", 2, partition_occurred=True))
print(db_ap.nodes)

import java.util.*;

public class ConsistentHash {
    private final TreeMap<Integer, String> ring = new TreeMap<>();
    private final int replicas;
    private static final int HASH_LIMIT = 1 << 30;

    public ConsistentHash(int replicas) {
        this.replicas = replicas;
    }

    public void addNode(String node) {
        for (int i = 0; i < replicas; i++) {
            int hash = (node + "#" + i).hashCode() % HASH_LIMIT;
            ring.put(Math.abs(hash), node);
        }
    }

    public void removeNode(String node) {
        for (int i = 0; i < replicas; i++) {
            int hash = (node + "#" + i).hashCode() % HASH_LIMIT;
            ring.remove(Math.abs(hash));
        }
    }

    public String getNode(String key) {
        if (ring.isEmpty()) return null;
        int hash = Math.abs(key.hashCode()) % HASH_LIMIT;
        Map.Entry<Integer, String> entry = ring.ceilingEntry(hash);
        if (entry == null) entry = ring.firstEntry();
        return entry.getValue();
    }

    public static void main(String[] args) {
        ConsistentHash ch = new ConsistentHash(3);
        ch.addNode("server-1");
        ch.addNode("server-2");
        ch.addNode("server-3");
        System.out.println(ch.getNode("user-42"));
    }
}

import random
import threading
import time

class RaftNode:
    def __init__(self, node_id, nodes):
        self.node_id = node_id
        self.nodes = nodes
        self.state = "follower"
        self.current_term = 0
        self.voted_for = None
        self.votes_received = 0

    def start_election(self):
        self.state = "candidate"
        self.current_term += 1
        self.voted_for = self.node_id
        self.votes_received = 1
        print(f"Node {self.node_id} starting election for term {self.current_term}")
        for node_id in self.nodes:
            if node_id != self.node_id:
                self.request_vote(node_id)

    def request_vote(self, target_id):
        # Simulated network message
        print(f"Node {self.node_id} -> Node {target_id}: vote request")
        # In a real implementation, target responds with vote granted or not

def simulate_raft():
    nodes = [1, 2, 3]
    leaders = {}
    for node_id in nodes:
        node = RaftNode(node_id, nodes)
        timeout = random.uniform(0.15, 0.3)
        time.sleep(timeout)
        node.start_election()
        if node.votes_received > len(nodes) // 2:
            leaders[node.current_term] = node.node_id
            print(f"Term {node.current_term}: Leader elected = Node {node.node_id}")
            break

simulate_raft()