11. Observer / PubSub Pattern: Decoupled Event Emitters & State Sync • Low-Level Design (LLD) & Object-Oriented Machine Coding • Rishabh Ki Kaksha

Low-Level Design (LLD) & Object-Oriented Machine Coding › 11. Observer / PubSub Pattern: Decoupled Event Emitters & State Sync

45 mins

← Prev Next →

Course Syllabus

Module 1: Object-Oriented Principles, UML & SOLID Architecture

01. SOLID Principles Deep Dive with Real-World Refactoring Examples 02. UML Class Diagrams & Sequence Diagrams for Big Tech Machine Coding Rounds 03. Composition over Inheritance & The Open-Closed Architectural Principle

Module 2: Creational Design Patterns in Production

04. Thread-Safe Singleton Pattern (Double-Checked Locking & Bill Pugh Implementation) 05. Factory Method vs Abstract Factory Pattern for Extensible Plug-and-Play Systems 06. Builder Pattern with Method Chaining & Immutable Data Object Guarantees

Module 3: Structural Design Patterns & Object Composition

07. Adapter & Facade Patterns: Wrapping Legacy APIs and Third-Party SDKs 08. Decorator Pattern: Dynamic Behavior Wrapping (Logging, Caching, Encryption) 09. Proxy Pattern (Virtual, Protection & Remote Proxies) with Caching Layers

Module 4: Behavioral Design Patterns & Event Decoupling

10. Strategy Pattern: Pluggable Pricing, Payment Gateways & Routing Algorithms 11. Observer / PubSub Pattern: Decoupled Event Emitters & State Sync 12. Command Pattern: Undo/Redo Engine & Task Queue Serialization 13. State Pattern: Order Lifecycle Management & Finite State Machines (FSM)

Module 5: Concurrency, Thread Pools & Lock-Free Design

14. Multi-Threaded Producer-Consumer Architecture with BlockingQueues 15. Thread Pool Executor Implementation & Task Scheduling Engine 16. Read-Write Locks, Mutexes & Optimistic Concurrency Control in Memory

Module 6: FAANG Machine Coding Live Case Studies

17. Machine Coding Case Study 1: Multi-Level Parking Lot System (Vehicles, Slots, Payments) 18. Machine Coding Case Study 2: High-Concurrency Elevator Management System 19. Machine Coding Case Study 3: Rate Limiter (Token Bucket, Leaky Bucket, Sliding Window) 20. Machine Coding Case Study 4: Splitwise / Expense Sharing App with Graph Simplification

Interactive Lesson Studio

# 11. Observer / PubSub Pattern: Decoupled Event Emitters & State Sync

> Low-Level Design (LLD) Notes by Rishabh - Topic 11

---

### 1. Observer Pattern Kya Hai? (The YouTube Channel Notification Bell 🔔)

1 Publisher (Subject) jab apna state change karta hai, toh usse subscribe kiye gaye saare Subscribers (Observers) automatically notify ho jaate hain:

```
                  [ OrderService (Subject) ]
                              ⬇ (notifyObservers)
        ┌─────────────────────┼─────────────────────┐
        ▼                     ▼                     ▼
[ EmailNotifier ]     [ SMSNotifier ]     [ AnalyticsTracker ]
```

---

### 2. TypeScript Implementation

```typescript
interface IObserver {
    update(orderId: string, status: string): void;
}

class OrderService {
    private observers: IObserver[] = [];

public subscribe(observer: IObserver) { this.observers.push(observer); }
    public unsubscribe(observer: IObserver) {
        this.observers = this.observers.filter(o => o !== observer);
    }

public updateOrderStatus(orderId: string, status: string) {
        console.log(`📦 Order ${orderId} status changed to ${status}`);
        this.notifyAll(orderId, status);
    }

private notifyAll(orderId: string, status: string) {
        for (const obs of this.observers) {
            obs.update(orderId, status);
        }
    }
}

class EmailNotificationService implements IObserver {
    update(orderId: string, status: string) {
        console.log(`📧 Sending Email: Your Order ${orderId} is now ${status}`);
    }
}
```

---

### 3. Observer vs Publish-Subscribe (Pub/Sub) Matrix

---

### 4. Interview Ke 3 Sawal Is Topic Se

1. **Observer pattern me Memory Leak (Lapsed Listener Problem) kaise hota hai?** -> Jab observer unsubscribe kiye bina delete ho jata hai aur Subject ke internal array me uska reference baki rehne se Garbage Collector use clean nahi kar pata.
2. **Push Model vs Pull Model in Observer pattern me kya difference hai?** -> Push model me Subject poora data payload notification me bhejta hai; Pull model me Observer sirf event trigger receive karke apni zaroorat ka data Subject se query karta hai.
3. **WeakReference Observer pattern me memory leaks kaise solve karta hai?** -> Observers ko weak pointers se hold karta hai taaki garbage collection unhe uninhibited reclaim kar sake.

---
**Next Topic:** 12. Command Pattern: Undo/Redo Engine & Task Queue Serialization

Loading lesson content...

Python 3.12

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track