Distributed Systems Lessons for Distributed Teams

The Beautiful Simplicity of Actors

• •Receive messages
• •Process one message at a time
• •Send messages to other actors
• •Create new actors
• •Decide how to handle the next message

1
// Simple Actor Pattern
2
class Actor {
3
  constructor(name) {
4
    this.name = name;
5
    this.state = {};  // Private state
6
    this.mailbox = [];  // Message queue
7
    this.processing = false;
8
  }
9
  
10
  // Send message to this actor
11
  receive(message) {
12
    this.mailbox.push(message);
13
    if (!this.processing) {
14
      this.processMessages();
15
    }
16
  }
17
  
18
  // Process messages one at a time
19
  async processMessages() {
20
    this.processing = true;
21
    while (this.mailbox.length > 0) {
22
      const message = this.mailbox.shift();
23
      await this.handleMessage(message);
24
    }
25
    this.processing = false;
26
  }
27
  
28
  // Override in subclasses
29
  async handleMessage(message) {
30
    console.log(`${this.name} handling:`, message);
31
  }
32
}
33
 
34
// Supervisor Pattern
35
class Supervisor extends Actor {
36
  constructor(name) {
37
    super(name);
38
    this.children = [];
39
  }
40
  
41
  createChild(ChildClass, name) {
42
    const child = new ChildClass(name);
43
    this.children.push(child);
44
    return child;
45
  }
46
  
47
  async handleMessage(message) {
48
    if (message.type === 'child_failed') {
49
      // Supervision strategy
50
      console.log(`${this.name} handling failure of ${message.child}`);
51
      // Could restart, escalate, or handle locally
52
    }
53
  }
54
}

1
# How organizations can implement actor patterns
2
class TeamMember:
3
    def __init__(self, name, role):
4
        self.name = name
5
        self.role = role
6
        self.inbox = []  # Async message queue
7
        self.owned_domains = []  # Clear ownership
8
        
9
    def send_message(self, recipient, message):
10
        # Async communication
11
        recipient.inbox.append({
12
            'from': self.name,
13
            'message': message,
14
            'timestamp': datetime.now()
15
        })
16
        # Don't wait for response - continue working
17
        
18
    def process_inbox(self):
19
        # Handle messages at your own pace
20
        while self.inbox:
21
            msg = self.inbox.pop(0)
22
            self.handle_message(msg)
23
            
24
    def claim_ownership(self, domain):
25
        # Clear ownership of domains
26
        self.owned_domains.append(domain)
27
        print(f"{self.name} now owns {domain}")

Message-Passing vs. Meetings

The Mailbox: Your Most Underrated Organizational Tool

• •Messages queue up without interrupting current work
• •Processing happens serially, not in parallel
• •The actor (person) controls the pace

Isolated State: The Power of Ownership

• •They can move fast without coordination
• •They develop deep expertise
• •They can innovate without permission
• •They're accountable for outcomes

Supervision Trees: How Real Leadership Works

• •They spawn new actors (hire and delegate)
• •They handle failures locally when possible
• •They escalate only when necessary
• •They restart failed processes (training, reassignment)
• •They protect their actors from outside interference

Location Transparency: The Remote Work Revelation

Resilience Through Isolation

• •Clear interfaces (how to send messages to a role, not a person)
• •Message persistence (documentation and handoffs)
• •Supervision strategies (succession planning)
• •Isolation boundaries (limiting blast radius of failures)

Let It Crash: The Uncomfortable Truth

• •Run more experiments
• •Learn faster
• •Waste less time on doomed efforts
• •Build more resilient cultures

The Message Buffer Problem

• •The ability to reject messages ("No")
• •Bounded buffers (limited WIP)
• •Priority queues (not everything is urgent)
• •Load shedding (letting some things drop)

Composition Over Inheritance

Practical Lessons for Your Organization

1. •Embrace asynchronous communication: Default to written, persistent messages over meetings
2. •Create clear ownership: Every domain needs one owner who controls its state
3. •Design for failure: Build systems that gracefully handle people leaving or failing
4. •Respect human buffers: People can only process one thing at a time effectively
5. •Supervise, don't micromanage: Handle failures and route messages, don't control execution
6. •Location doesn't matter: Focus on message flow, not physical proximity
7. •Keep actors simple: Complex behavior should emerge from interaction, not from superhero individuals

The Future Is Distributed