Why more behavioral patterns solve communication in LLD - Why This Architecture

Problem Statement

When components or objects in a system communicate directly without clear protocols, the code becomes tightly coupled and hard to maintain. Changes in one part can cause unexpected failures elsewhere, making debugging and extending the system difficult.

Solution

Behavioral patterns define clear communication protocols between objects, organizing how they interact and share responsibilities. By encapsulating communication logic, these patterns reduce dependencies and improve flexibility, making the system easier to modify and extend.

Architecture

┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│  Component 1│──────▶│  Mediator   │──────▶│  Component 2│
└─────────────┘       └─────────────┘       └─────────────┘
       ▲                                         │
       │─────────────────────────────────────────┘

This diagram shows how the Mediator pattern centralizes communication between components, preventing direct dependencies between them.

Trade-offs

✓ Pros

→

Reduces tight coupling between communicating objects by centralizing interaction logic.

→

Improves code maintainability and readability by defining clear communication protocols.

→

Facilitates easier extension and modification of communication behavior without affecting other components.

✗ Cons

→

Introduces an additional layer which can add complexity and potential performance overhead.

→

Overuse can lead to a large mediator or controller class that becomes difficult to manage.

→

May obscure the flow of communication if not well documented or designed.

Use when multiple objects interact in complex ways and direct communication causes tight coupling or maintenance issues, especially in systems with many interdependent components.

Avoid when interactions are simple and direct communication is clear and unlikely to change, or when performance is critical and added indirection is unacceptable.

Real World Examples

Airbnb

Uses the Mediator pattern in their booking system to coordinate communication between availability, pricing, and payment components without tight coupling.

Uber

Applies Observer and Mediator patterns to manage real-time updates between drivers, riders, and dispatch systems, ensuring scalable and maintainable communication.

LinkedIn

Employs behavioral patterns like Observer to handle notifications and feed updates, decoupling event producers from consumers.

Code Example

Before, ComponentA directly calls ComponentB, creating tight coupling. After applying the Mediator pattern, both components communicate through the Mediator, which controls interactions and reduces dependencies.

LLD

### Before: Direct communication causing tight coupling
class ComponentA:
    def __init__(self, component_b):
        self.component_b = component_b

    def do_action(self):
        print("ComponentA does action")
        self.component_b.notify()

class ComponentB:
    def notify(self):
        print("ComponentB notified")

b = ComponentB()
a = ComponentA(b)
a.do_action()


### After: Using Mediator pattern to centralize communication
class Mediator:
    def __init__(self):
        self.component_a = ComponentA(self)
        self.component_b = ComponentB(self)

    def notify(self, sender, event):
        if sender == self.component_a and event == "action_done":
            self.component_b.handle()

class ComponentA:
    def __init__(self, mediator):
        self.mediator = mediator

    def do_action(self):
        print("ComponentA does action")
        self.mediator.notify(self, "action_done")

class ComponentB:
    def __init__(self, mediator):
        self.mediator = mediator

    def handle(self):
        print("ComponentB handles event")

mediator = Mediator()
mediator.component_a.do_action()

Alternatives

Direct Communication

Objects communicate directly without intermediaries, leading to tight coupling.

Use when: Use when the system is simple with few components and minimal interaction complexity.

Event-Driven Architecture

Uses asynchronous events and message queues for communication instead of synchronous behavioral patterns.

Use when: Choose when decoupling and scalability across distributed systems are priorities.

Summary

Direct communication between components can cause tight coupling and maintenance challenges.

Behavioral patterns organize communication, reducing dependencies and improving flexibility.

Using these patterns helps build scalable, maintainable systems with clear interaction protocols.

Practice

1. What is the main benefit of using more behavioral patterns in system design?

easy

A. They improve communication between system components.

B. They increase the number of classes needed.

C. They make the system run faster.

D. They reduce the need for documentation.

Solution

1. Step 1: Understand behavioral patterns' purpose

   Behavioral patterns focus on how objects communicate and interact.

2. Step 2: Identify the main benefit

   They organize communication, reducing confusion and tight coupling.

3. Final Answer:

   They improve communication between system components. -> Option A

4. Quick Check:

   Behavioral patterns = improve communication [OK]

Hint: Behavioral patterns organize communication clearly [OK]

Common Mistakes:

• Thinking they speed up system execution
• Assuming they reduce documentation needs
• Believing they increase class count unnecessarily

2. Which of the following is a correct example of a behavioral pattern that helps communication?

easy

A. Singleton

B. Observer

C. Factory

D. Decorator

Solution

1. Step 1: Identify behavioral patterns

   Observer is a behavioral pattern that manages communication between objects.

2. Step 2: Exclude non-behavioral patterns

   Singleton is creational, Factory is creational, Decorator is structural.

3. Final Answer:

   Observer -> Option B

4. Quick Check:

   Observer = behavioral pattern [OK]

Hint: Observer is a classic behavioral pattern [OK]

Common Mistakes:

• Confusing creational or structural patterns as behavioral
• Choosing Singleton or Factory incorrectly
• Not knowing pattern categories

3. Consider a system using the Mediator pattern to manage communication. What is the expected output when a component sends a message through the mediator?

medium

A. The mediator handles and routes the message to appropriate components.

B. The message is broadcast to all components directly.

C. The message is ignored unless the sender handles it.

D. The message causes the system to crash due to tight coupling.

Solution

1. Step 1: Understand Mediator pattern role

   Mediator centralizes communication, routing messages between components.

2. Step 2: Analyze message flow

   Messages go through mediator, which decides recipients, avoiding direct component coupling.

3. Final Answer:

   The mediator handles and routes the message to appropriate components. -> Option A

4. Quick Check:

   Mediator routes messages = A [OK]

Hint: Mediator centralizes communication flow [OK]

Common Mistakes:

• Assuming direct broadcast without mediator
• Thinking messages are ignored
• Believing mediator causes crashes

4. A developer implemented the Chain of Responsibility pattern but notices that requests are not handled properly. What is a likely cause?

medium

A. Handlers are tightly coupled and call each other directly.

B. All handlers process the request simultaneously causing conflicts.

C. The chain is broken because a handler does not pass the request forward.

D. The pattern requires all handlers to be singletons.

Solution

1. Step 1: Review Chain of Responsibility behavior

   Requests pass along a chain until a handler processes it or passes it on.

2. Step 2: Identify common error

   If a handler fails to forward unhandled requests, the chain breaks and requests stop prematurely.

3. Final Answer:

   The chain is broken because a handler does not pass the request forward. -> Option C

4. Quick Check:

   Broken chain = missing forwarding [OK]

Hint: Ensure each handler forwards unhandled requests [OK]

Common Mistakes:

• Confusing tight coupling with chain behavior
• Assuming all handlers process requests simultaneously
• Believing singleton pattern is required

5. In a complex system, why does applying multiple behavioral patterns improve communication and maintainability?

hard

A. They eliminate the need for interfaces and abstractions.

B. They reduce the number of components needed in the system.

C. They enforce synchronous communication only.

D. They isolate responsibilities and define clear communication paths.

Solution

1. Step 1: Understand multiple behavioral patterns' role

   Using several patterns helps separate concerns and organize interactions clearly.

2. Step 2: Analyze impact on system design

   Clear communication paths reduce confusion and tight coupling, improving maintainability.

3. Final Answer:

   They isolate responsibilities and define clear communication paths. -> Option D

4. Quick Check:

   Multiple patterns = clear roles and communication [OK]

Hint: Multiple patterns clarify roles and communication [OK]

Common Mistakes:

• Thinking they reduce component count
• Assuming only synchronous communication is allowed
• Believing interfaces become unnecessary