Applying SOLID to real code in LLD - System Design Guide

Problem Statement

When code is tightly coupled and poorly organized, adding new features or fixing bugs becomes risky and slow. Changes in one part can break others unexpectedly, making the system fragile and hard to maintain.

Solution

Applying SOLID principles breaks code into smaller, focused parts with clear responsibilities. This reduces dependencies and makes the code easier to extend, test, and maintain without unintended side effects.

Architecture

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│  Single Class │──────▶│  Multiple     │──────▶│  Small Classes │
│  Doing Many   │       │  Classes with │       │  with One      │
│  Jobs         │       │  Clear Roles  │       │  Responsibility│
└───────────────┘       └───────────────┘       └───────────────┘

This diagram shows the evolution from one big class doing many jobs to multiple small classes each with a single responsibility, illustrating the Single Responsibility Principle from SOLID.

Trade-offs

✓ Pros

→

Improves code readability by separating concerns clearly.

→

Makes adding new features safer and easier without breaking existing code.

→

Facilitates unit testing by isolating functionality.

→

Enhances maintainability and reduces bugs caused by tight coupling.

✗ Cons

→

Initial design takes more time and thought to apply SOLID correctly.

→

May increase the number of classes and files, which can feel complex at first.

→

Over-applying SOLID can lead to unnecessary abstraction and complexity.

Use SOLID principles when building or refactoring medium to large codebases where maintainability, extensibility, and testability are priorities.

Avoid strict SOLID application in very small or throwaway scripts where simplicity and speed are more important than long-term maintenance.

Real World Examples

Amazon

Amazon applies SOLID principles in their microservices to ensure each service has a single responsibility, making it easier to update and deploy independently.

Netflix

Netflix uses SOLID principles in their backend code to keep services modular and maintainable, enabling rapid feature development without breaking existing functionality.

Uber

Uber applies SOLID to their ride-matching algorithms to separate concerns like pricing, routing, and driver availability, improving code clarity and scalability.

Code Example

The before code mixes calculation, saving, and emailing in one class, violating Single Responsibility Principle. The after code separates these concerns into distinct classes, making it easier to extend or modify each part independently, following SOLID principles.

LLD

### Before applying SOLID (violating SRP and OCP):

class OrderProcessor:
    def __init__(self, order):
        self.order = order

    def calculate_total(self):
        total = 0
        for item in self.order.items:
            total += item.price * item.quantity
        return total

    def save_order(self):
        # code to save order to database
        pass

    def send_confirmation_email(self):
        # code to send email
        pass


### After applying SOLID (SRP and OCP applied):

class OrderCalculator:
    def calculate_total(self, order):
        total = 0
        for item in order.items:
            total += item.price * item.quantity
        return total

class OrderRepository:
    def save(self, order):
        # code to save order to database
        pass

class EmailService:
    def send_confirmation(self, order):
        # code to send email
        pass

class OrderProcessor:
    def __init__(self, calculator, repository, email_service):
        self.calculator = calculator
        self.repository = repository
        self.email_service = email_service

    def process(self, order):
        total = self.calculator.calculate_total(order)
        self.repository.save(order)
        self.email_service.send_confirmation(order)
        return total

Alternatives

Procedural Programming

Focuses on sequences of instructions and shared state rather than objects with responsibilities.

Use when: Use for simple scripts or programs with straightforward logic and minimal complexity.

Anemic Domain Model

Separates data and behavior, often leading to procedural style within object-oriented code.

Use when: Choose when domain logic is simple and business rules are minimal, but avoid for complex domains.

Summary

Applying SOLID principles prevents fragile, tightly coupled code by enforcing clear responsibilities and modular design.

This approach improves maintainability, extensibility, and testability of software systems.

Balancing SOLID with simplicity is important to avoid unnecessary complexity.