SOLID Principles: Deep Object-Oriented System Architecture

1. Theoretical Foundations of Architectural Modularity

In enterprise software design and Low-Level Architecture Design (LLD), software longevity depends on managing system complexity over time. As requirements evolve, poorly architected systems degrade into spaghetti code or big-balls-of-mud, exhibiting three structural anti-patterns:

Rigidity: Software becomes structurally rigid; a single modification forces cascading changes across unassociated subsystem modules.
Fragility: Modifications unexpectedly break seemingly orthogonal features located far away from the point of change.
Immobility: Domain algorithms and business abstractions are so tightly tangled with presentation or persistence layers that extracting them into reusable libraries or modular components becomes impractical.

The SOLID design principles—coined by Robert C. Martin (Uncle Bob)—represent five architectural rules that maximize High Cohesion (grouping logically related operations together) and Low Coupling (minimizing interdependence between separate system components).

        +-------------------------------------------------------------+
        |                 The SOLID Principles Mosaic                 |
        +-------------------------------------------------------------+
        |   [S] Single Responsibility Principle (SRP)                 |
        |       A module must have one and only one reason to change. |
        |   [O] Open-Closed Principle (OCP)                           |
        |       Open for structural extension; closed to modification.|
        |   [L] Liskov Substitution Principle (LSP)                   |
        |       Subtypes must be seamlessly substitutable for base.   |
        |   [I] Interface Segregation Principle (ISP)                 |
        |       Many domain-specific interfaces outshine fat general. |
        |   [D] Dependency Inversion Principle (DIP)                  |
        |       Depend entirely on abstractions, never on concretions.|
        +-------------------------------------------------------------+

2. Single Responsibility Principle (SRP)

First Principles Definition

"A module, class, or subsystem should have one, and only one, reason to change." — Robert C. Martin

In architectural systems, a "reason to change" corresponds directly to an actor or organizational stakeholder (e.g., Database Administrators, UX UI Engineers, Financial Auditors). If a single software class satisfies requirements for two divergent business actors, modifying business logic to satisfy one actor risks breaking critical behaviors relied upon by the other.

classDiagram
    class AntiPatternUserAccount {
        +String userId
        +String email
        +calculateUserTaxLiability()
        +saveUserToPostgreSQL()
        +renderUserJSONPayload()
    }
    note for AntiPatternUserAccount "VIOLATION:<br>Couples Data Model, Financial Tax Calculation,<br>SQL Persistence, and HTTP Serialization!"

    class UserAccount {
        +String userId
        +String email
        +getProfileMetadata()
    }
    class UserTaxCalculator {
        +calculateTaxLiability(UserAccount user)
    }
    class UserRepository {
        +save(UserAccount user)
        +find(String id)
    }
    class UserPayloadSerializer {
        +serializeToJSON(UserAccount user)
    }

    AntiPatternUserAccount --> UserAccount : Refactored via SRP
    UserAccount <-- UserTaxCalculator : Operates upon
    UserAccount <-- UserRepository : Operates upon
    UserAccount <-- UserPayloadSerializer : Operates upon

Production Refactor: Clean Architectural Domain Decomposition

# ==========================================
# ANTI-PATTERN: God Class violating SRP
# ==========================================
class EmployeeGodClass:
    def __init__(self, emp_id: str, name: str, base_salary: float):
        self.emp_id = emp_id
        self.name = name
        self.base_salary = base_salary

    def calculate_pay(self) -> float:
        # Actor 1: HR Compensation department business math
        return self.base_salary - (self.base_salary * 0.22)

    def save_to_database(self):
        # Actor 2: Infrastructure Database Administration
        import psycopg2
        connection = psycopg2.connect(dsn="postgres://user:pass@localhost:5432/corp")
        cursor = connection.cursor()
        cursor.execute("INSERT INTO employees VALUES (%s, %s, %s)", (self.emp_id, self.name, self.base_salary))
        connection.commit()

    def generate_pay_slip_html(self) -> str:
        # Actor 3: UI / Payroll Document Generation teams
        return f"<html><body><h1>Pay Slip: {self.name}</h1><p>Net: {self.calculate_pay()}</p></body></html>"


# ==========================================
# ENTERPRISE REFACTOR: Rigorous SRP Decomposition
# ==========================================
from abc import ABC, abstractmethod
from dataclasses import dataclass

@dataclass
class EmployeeDomainEntity:
    """Pure domain entity encapsulation representing structural data identity."""
    emp_id: str
    name: str
    base_salary: float

class PayrollCalculator:
    """Responsible solely to HR / Compensation business actors."""
    @staticmethod
    def calculate_net_pay(employee: EmployeeDomainEntity) -> float:
        tax_deduction = employee.base_salary * 0.22
        return employee.base_salary - tax_deduction

class EmployeeRepository(ABC):
    """Abstract interface defining data persistent infrastructure operations."""
    @abstractmethod
    def save_employee(self, employee: EmployeeDomainEntity) -> None:
        pass

class PostgreesEmployeeRepository(EmployeeRepository):
    """Responsible solely to Infrastructure Data Architecture actors."""
    def __init__(self, dsn_connection_string: str):
        self.dsn = dsn_connection_string

    def save_employee(self, employee: EmployeeDomainEntity) -> None:
        # Production safe query execution abstraction
        print(f"Executing robust SQL INSERT for entity ID [{employee.emp_id}] via pool [{self.dsn}]")

class PaySlipPresenter:
    """Responsible solely to Document / UX reporting actors."""
    @staticmethod
    def generate_html_slip(employee: EmployeeDomainEntity, net_pay: float) -> str:
        return f"<html><body><h1>Pay Slip: {employee.name}</h1><p>Net: {net_pay}</p></body></html>"

3. Open-Closed Principle (OCP)

First Principles Definition

"Software entities (classes, modules, functions) should be open for extension, but closed for modification." — Bertrand Meyer

When adding new application features (e.g., introducing a new payment provider or shipping discount rule), engineers should not alter existant, fully verified core business loop controllers. Modifying tested production code introduces structural regressions. Instead, architectures must be designed around abstract polymorphism and pluggable extension design patterns (such as the Strategy or Decorator patterns), allowing new capabilities to simply plug into the existing system.

classDiagram
    class CheckoutProcessor {
        -PaymentGateway gateway
        +executeOrder(Order order)
    }
    class PaymentGateway {
        <<interface>>
        +processTransaction(float amount)*
    }
    class StripeGateway {
        +processTransaction(float amount)
    }
    class PayPalGateway {
        +processTransaction(float amount)
    }
    class CryptoGateway {
        +processTransaction(float amount)
    }

    CheckoutProcessor --> PaymentGateway : Depends on Abstraction
    PaymentGateway <|-- StripeGateway : Extends (New Capability)
    PaymentGateway <|-- PayPalGateway : Extends (New Capability)
    PaymentGateway <|-- CryptoGateway : Extends (New Capability)

Production Refactor: Enterprise Payment Processor via Strategy Pattern

from abc import ABC, abstractmethod
from typing import List

# ==========================================
# ANTI-PATTERN: OCP Violation via Monolithic Conditional Branching
# ==========================================
class FragilePaymentProcessor:
    def process_order_payment(self, amount: float, method: str):
        if method == "credit_card":
            print(f"Transacting {amount} over Payment Gateway Stripe API...")
        elif method == "paypal":
            print(f"Transacting {amount} via PayPal Braintree execution API...")
        # Every time a new payment vendor is contracted, this stable core must be altered!
        elif method == "apple_pay":
            print(f"Transacting {amount} over ApplePay Secure Enclave Protocol...")
        else:
            raise ValueError("Unsupported payment method!")


# ==========================================
# ENTERPRISE REFACTOR: Extensible OCP Architecture
# ==========================================
class PaymentStrategy(ABC):
    """Abstract baseline interface enabling extensible polymorphism without modification."""
    @abstractmethod
    def execute_transaction(self, amount_dollars: float) -> bool:
        pass

class StripeCreditCardStrategy(PaymentStrategy):
    def __init__(self, api_token: str):
        self.api_token = api_token
        
    def execute_transaction(self, amount_dollars: float) -> bool:
        print(f"[Stripe] Transacting ${amount_dollars:.2f} using OAuth Token [{self.api_token[:6]}...]")
        return True

class PayPalStrategy(PaymentStrategy):
    def __init__(self, merchant_id: str):
        self.merchant_id = merchant_id
        
    def execute_transaction(self, amount_dollars: float) -> bool:
        print(f"[PayPal] Debiting ${amount_dollars:.2f} against Merchant API ID [{self.merchant_id}]")
        return True

class CryptoEthereumStrategy(PaymentStrategy):
    """New Payment vendor capability introduced cleanly WITHOUT modifying existing checkout controllers."""
    def __init__(self, wallet_address: str):
        self.wallet_address = wallet_address

    def execute_transaction(self, amount_dollars: float) -> bool:
        print(f"[Web3 Crypto] Transferred equivalent Ethereum to immutable vault [{self.wallet_address}]")
        return True

class EnterpriseOrderService:
    """Core domain business service - completely closed to modification!"""
    def __init__(self, payment_engine: PaymentStrategy):
        self.payment_engine = payment_engine

    def checkout(self, cart_total: float) -> None:
        logging_id = id(self)
        print(f"Order Service [{logging_id}]: Initializing checkout process for total ${cart_total:.2f}")
        success = self.payment_engine.execute_transaction(cart_total)
        if not success:
            raise RuntimeError("Transaction aborted by underlying payment Strategy processing network.")

4. Liskov Substitution Principle (LSP)

First Principles Definition

"If for each object $o_1$ of type $S$ there is an object $o_2$ of type $T$ such that for all programs $P$ defined in terms of $T$ , the behavior of $P$ is unchanged when $o_1$ is substituted for $o_2$ , then $S$ is a subtype of $T$ ." — Barbara Liskov

LSP is the mathematical foundation of subtyping and behavioral compatibility. A subclass must be cleanly substitutable for its parent class without altering normal program invariants or causing unhandled runtime exceptions.

Formal Behavioral Subtyping Requirements

To maintain mathematical Liskov substitutability, derived classes must satisfy three fundamental contractual rules:

Preconditions cannot be strengthened: A derived class cannot demand stricter operational input assumptions than those accepted by the parental baseline class.
Postconditions cannot be weakened: A derived class cannot produce system output guarantees that are less binding than those promised by the parent class.
Invariants must be preserved: Any property or structural domain condition that holds true across execution of the parent class must hold true across all implementations of the derived type.

The Classic Architectural Anomaly: Square vs. Rectangle

In geometric geometry, a Square is mathematically a specialized subset of a Rectangle (a rectangle where width equals height). However, modeling this real-world geometry directly using OOP inheritance fundamentally violates LSP!

# ==========================================
# ANTI-PATTERN: The Square/Rectangle LSP Violation
# ==========================================
class Rectangle:
    def __init__(self, width: int, height: int):
        self._width = width
        self._height = height

    def set_width(self, width: int):
        self._width = width

    def set_height(self, height: int):
        self._height = height

    def get_area(self) -> int:
        return self._width * self._height


class Square(Rectangle):
    """Violates LSP by overriding mutations to alter orthogonal properties!"""
    def __init__(self, side: int):
        super().__init__(side, side)

    def set_width(self, width: int):
        self._width = width
        self._height = width  # Hidden side effect breaking parent invariants!

    def set_height(self, height: int):
        self._width = height
        self._height = height # Hidden side effect breaking parent invariants!

# Architectural domain test script evaluating polymorphism invariance
def verify_rectangle_area(rect: Rectangle):
    rect.set_width(5)
    rect.set_height(4)
    # Postcondition assertion expected by all clients consuming a standard Rectangle:
    assert rect.get_area() == 20, f"LSP Crash! Expected Area 20, but calculated {rect.get_area()}"

# Evaluation execution:
std_rect = Rectangle(2, 3)
verify_rectangle_area(std_rect) # Succeeds cleanly

problematic_sq = Square(2)
# When a Square is substituted for a Rectangle, the method fails!
# Setting height to 4 implicitly overwrote width to 4, resulting in an area of 16!
try:
    verify_rectangle_area(problematic_sq)
except AssertionError as err:
    print(f"CRITICAL ARCHITECTURAL BUG: {err}")

Production Refactor: Resolving LSP via Abstract Shape Hierarchies

To eliminate behavioral contradictions, extract invariant domain properties out of concrete implementation bindings by introducing abstract structural generalizations:

from abc import ABC, abstractmethod

class GeometricShape(ABC):
    """True polymorphic baseline abstracting solely validated immutable behavior."""
    @abstractmethod
    def calculate_area(self) -> int:
        pass

class ImmutableRectangle(GeometricShape):
    def __init__(self, width: int, height: int):
        self.width = width
        self.height = height

    def calculate_area(self) -> int:
        return self.width * self.height

class ImmutableSquare(GeometricShape):
    def __init__(self, side: int):
        self.side = side

    def calculate_area(self) -> int:
        return self.side * self.side

def print_surface_area(shape: GeometricShape):
    # Works consistently across all derived implementations without breaking assumptions
    print(f"Evaluated structural surface area: {shape.calculate_area()}")

5. Interface Segregation Principle (ISP)

First Principles Definition

"No client should be forced to depend on methods it does not use." — Robert C. Martin

When architecture relies on large, general-purpose ("fat") interfaces, implementing classes are forced to write stubbed, dummy, or error-throwing implementations for methods they don't actually support. This pollutes system codebases and violates separation of concerns. Instead, architectures should break large interfaces into smaller, cohesive, role-specific contracts.

classDiagram
    class FatDatabaseInterface {
        <<interface>>
        +connect()
        +executeSQLQuery()
        +createBTreeIndex()
        +flushLSMTableToDisk()
        +runMapReduceAggregators()
    }

    class RelationalEngine {
        +connect()
        +executeSQLQuery()
        +createBTreeIndex()
        +flushLSMTableToDisk()* -- Crash! Not an LSM engine!
        +runMapReduceAggregators()* -- Crash! Unsupported!
    }

    class DocumentNoSQLEngine {
        +connect()
        +executeSQLQuery()* -- Crash! No SQL syntax!
        +createBTreeIndex()
        +flushLSMTableToDisk()*
        +runMapReduceAggregators()
    }

    FatDatabaseInterface <|-- RelationalEngine : Fat Coupling Violation
    FatDatabaseInterface <|-- DocumentNoSQLEngine : Fat Coupling Violation

Production Refactor: Segregated Role-Based Interfaces

from abc import ABC, abstractmethod

# ==========================================
# ENTERPRISE REFACTOR: Segregated Role-Based Interfaces
# ==========================================
class DatabaseConnection(ABC):
    """Universal contract shared across all datastore implementations."""
    @abstractmethod
    def open_connection(self) -> None:
        pass
    
    @abstractmethod
    def close_connection(self) -> None:
        pass

class SQLQueryable(ABC):
    """Segregated abstraction purely for relational query processing."""
    @abstractmethod
    def execute_sql_transaction(self, sql_query: str) -> dict:
        pass

class DocumentAggregateQueryable(ABC):
    """Segregated abstraction purely for document aggregation operations."""
    @abstractmethod
    def execute_aggregation_pipeline(self, pipeline: list) -> dict:
        pass

class LSMEngineManageable(ABC):
    """Segregated interface for wide-column architecture engines (Cassandra, Scylla)."""
    @abstractmethod
    def compact_sstable_records(self) -> None:
        pass

# Implementations cleanly inherit only the specific behaviors they support:
class PostgreSQLDatabase(DatabaseConnection, SQLQueryable):
    def open_connection(self):
        print("Opening TCP standard pooled connection to PostgreSQL...")
    def close_connection(self):
        print("Closing PostgreSQL socket.")
    def execute_sql_transaction(self, sql_query: str) -> dict:
        print(f"Executing transactional statement: [{sql_query}]")
        return {"rows": 42}

class MongoDBDatabase(DatabaseConnection, DocumentAggregateQueryable):
    def open_connection(self):
        print("Opening MongoDB Wire Protocol TLS connection...")
    def close_connection(self):
        print("Terminating Mongo cluster cursor.")
    def execute_aggregation_pipeline(self, pipeline: list) -> dict:
        print("Executing BSON aggregation pipeline across sharded documents...")
        return {"document_count": 941}

6. Dependency Inversion Principle (DIP) & Hexagonal Architecture

First Principles Definition

"High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions." — Robert C. Martin

In legacy layered architectures, high-level business domain modules (e.g., Transaction Validation) directly instantiate and invoke low-level concrete infrastructure modules (e.g., PostgreSQL driver sockets or SMTP server connectors). This tightly locks business algorithms to ephemeral third-party integrations.

Dependency Inversion inverts this architectural dependency graph. High-level modules declare purely abstract interfaces defining the contractual behavior they require. Low-level infrastructure modules must import and implement those domain abstractions. This decoupling underpins Hexagonal Architecture (Ports and Adapters) and Clean Architecture.

graph TD
    subgraph Legacy Coupling Architecture
        HL1[High-Level Business Logic] -->|Direct Concrete Invocation| LL1[Low-Level MySQL Driver]
        HL1 -->|Direct Concrete Invocation| LL2[Low-Level SMTP Email Client]
    end

    subgraph Dependency Inverted (Hexagonal/Clean) Architecture
        HL2[High-Level Domain Logic Engine] -->|Defines & Calls Abstraction| IRepo["<<Interface>><br>DataRepositoryPort"]
        HL2 -->|Defines & Calls Abstraction| INotif["<<Interface>><br>NotificationPort"]
        
        LL3[PostgreSQL Adapter Class] -->|Implements & Fills Abstraction| IRepo
        LL4[Mongo NoSQL Adapter Class] -->|Implements & Fills Abstraction| IRepo
        LL5[AWS SES Email Adapter Class] -->|Implements & Fills Abstraction| INotif
    end

Production Code: Clean Architecture Dependency Inversion via Inversion of Control (IoC)

from abc import ABC, abstractmethod

# ==========================================
# 1. CORE DOMAIN ABSTRACTIONS (PORTS)
# High-Level modules define these interfaces without any concrete dependencies.
# ==========================================
class EventCachePort(ABC):
    @abstractmethod
    def get_cached_payload(self, key: str) -> str:
        pass

    @abstractmethod
    def set_cached_payload(self, key: str, data: str, ttl_seconds: int) -> None:
        pass

class NotificationDispatcherPort(ABC):
    @abstractmethod
    def dispatch_alert(self, recipient: str, message: str) -> bool:
        pass

# ==========================================
# 2. HIGH-LEVEL DOMAIN SERVICE
# Completely decoupled from database systems, network protocols, or third-party vendors.
# ==========================================
class DistributedOrderProcessingService:
    def __init__(self, cache_adapter: EventCachePort, notifier: NotificationDispatcherPort):
        # Dependencies injected dynamically via construction (Dependency Injection)
        self.cache = cache_adapter
        self.notifier = notifier

    def process_customer_order(self, order_id: str, client_email: str) -> None:
        cached_status = self.cache.get_cached_payload(f"order:{order_id}")
        if cached_status:
            print(f"[Order Service] Order [{order_id}] already processed. Exiting.")
            return

        # Execute complex enterprise domain algorithmic logic here...
        print(f"[Order Service] Successfully verified and billed order [{order_id}].")

        # Update cache and dispatch notifications via interface abstractions
        self.cache.set_cached_payload(f"order:{order_id}", "PROCESSED", ttl_seconds=86400)
        self.notifier.dispatch_alert(client_email, f"Your order {order_id} is on its way!")

# ==========================================
# 3. LOW-LEVEL INFRASTRUCTURE ADAPTERS
# Implements domain abstraction interfaces using specific third-party client drivers.
# ==========================================
class RedisCacheAdapter(EventCachePort):
    def __init__(self, redis_host: str):
        self.host = redis_host
        self._memory_map = {} # Simulating active production Redis clustered memory pool
        
    def get_cached_payload(self, key: str) -> str:
        return self._memory_map.get(key)

    def set_cached_payload(self, key: str, data: str, ttl_seconds: int) -> None:
        print(f"[Redis Adapter @ {self.host}] Storing token [{key}] with TTL {ttl_seconds}s")
        self._memory_map[key] = data

class SendGridNotificationAdapter(NotificationDispatcherPort):
    def __init__(self, api_key: str):
        self.api_key = api_key

    def dispatch_alert(self, recipient: str, message: str) -> bool:
        print(f"[SendGrid Adapter] Pushing HTTPS email payload to [{recipient}] via key [{self.api_key[:4]}...]")
        return True

# ==========================================
# 4. SYSTEM BOOTSTRAP / IOC COMPOSITION ROOT
# Assembles the runtime dependency graph at application startup.
# ==========================================
if __name__ == "__main__":
    print("Bootstrapping system architecture via IoC root...")
    redis_adapter = RedisCacheAdapter("10.0.4.15")
    sendgrid_adapter = SendGridNotificationAdapter("SG.841983_production_key")

    # Inject concrete implementations into our high-level service architecture
    order_service = DistributedOrderProcessingService(cache_adapter=redis_adapter, notifier=sendgrid_adapter)

    # Execute enterprise transaction execution loop
    order_service.process_customer_order(order_id="ORD-2026-901", client_email="sarthak@enterprise-dev.org")

7. Advanced System Design Interview Questions & Rigorous Explanations

Q1: In large-scale systems architecture, how does adhering to the Open-Closed Principle (OCP) directly mitigate operational blast radiuses during continuous automated deployment pipelines?

Answer: Modifying existing code to support new business capabilities violates OCP and forces QA suites to re-validate every single dependency and codepath executing through that modified class. In contrast, when an architecture follows OCP (e.g., extending abstract base classes via the Strategy or Template patterns), introducing a new payment provider or streaming protocol requires writing a completely isolated, decoupled module.

Because existing production classes are entirely untouched and unmodified, regressions in historical functionalities are structurally impossible. If the newly deployed module contains a fatal bug, the blast radius remains strictly isolated to customers accessing that newly added capability. Furthermore, feature flags can instantly toggle off the problematic module without rolling back overarching microservice binaries.

Q2: How do the Dependency Inversion Principle (DIP) and Dependency Injection (DI) frameworks interact to enable reliable high-speed unit testing across complex enterprise microservices?

Answer: DIP ensures that high-level domain modules depend strictly on abstract interface contracts rather than concrete low-level infrastructure integrations (like real SQL socket drivers or remote gRPC network endpoints). Dependency Injection (DI) is the concrete pattern that passes implementations of those abstract interfaces into the consuming classes at runtime.

This architecture accelerates automated unit testing by entirely removing external network dependencies. During deployment automated build verifications, tests instantiate high-level domain engines by injecting Test Mocks or In-Memory Fakes that conform directly to the interface abstractions. Tests execute in microseconds in pure computer memory without requiring live databases, staging servers, or API keys.

Q3: Give a concrete real-world engineering failure where violating the Liskov Substitution Principle (LSP) caused a systemic runtime system failure in a production environment.

Answer: A classic production failure occurs when development teams build custom Read-Only database connection pools that inherit directly from a fully functional transactional DatabaseConnection base class.

The parental DatabaseConnection class declares operational transactional interfaces: begin_transaction(), execute_write(query), and commit(). To save code development time, an engineer creates a specialized subclass called ReadReplicaConnection extending DatabaseConnection, but internally overrides execute_write() and commit() to explicitly throw an unsupported runtime exception: raise ReadOnlyReplicaException("Writes barred!").

This fundamentally breaches LSP's behavioral subtyping rules: postconditions are weakened and parental contract invariants are shattered. When a production connection pool load-balancer substitutes an instance of ReadReplicaConnection into a high-level background batch processing worker that expected a baseline standard DatabaseConnection, the worker executes its read-logic successfully, invokes execute_write(), intercepts the unexpected runtime fatal exception, crashes the processing thread, and leaves distributed application transaction queues deadlocked.

SOLID Principles: Deep Object-Oriented System Architecture

1. Theoretical Foundations of Architectural Modularity

Rigidity: Software becomes structurally rigid; a single modification forces cascading changes across unassociated subsystem modules.
Fragility: Modifications unexpectedly break seemingly orthogonal features located far away from the point of change.
Immobility: Domain algorithms and business abstractions are so tightly tangled with presentation or persistence layers that extracting them into reusable libraries or modular components becomes impractical.

        +-------------------------------------------------------------+
        |                 The SOLID Principles Mosaic                 |
        +-------------------------------------------------------------+
        |   [S] Single Responsibility Principle (SRP)                 |
        |       A module must have one and only one reason to change. |
        |   [O] Open-Closed Principle (OCP)                           |
        |       Open for structural extension; closed to modification.|
        |   [L] Liskov Substitution Principle (LSP)                   |
        |       Subtypes must be seamlessly substitutable for base.   |
        |   [I] Interface Segregation Principle (ISP)                 |
        |       Many domain-specific interfaces outshine fat general. |
        |   [D] Dependency Inversion Principle (DIP)                  |
        |       Depend entirely on abstractions, never on concretions.|
        +-------------------------------------------------------------+

2. Single Responsibility Principle (SRP)

First Principles Definition

"A module, class, or subsystem should have one, and only one, reason to change." — Robert C. Martin

classDiagram
    class AntiPatternUserAccount {
        +String userId
        +String email
        +calculateUserTaxLiability()
        +saveUserToPostgreSQL()
        +renderUserJSONPayload()
    }
    note for AntiPatternUserAccount "VIOLATION:<br>Couples Data Model, Financial Tax Calculation,<br>SQL Persistence, and HTTP Serialization!"

    class UserAccount {
        +String userId
        +String email
        +getProfileMetadata()
    }
    class UserTaxCalculator {
        +calculateTaxLiability(UserAccount user)
    }
    class UserRepository {
        +save(UserAccount user)
        +find(String id)
    }
    class UserPayloadSerializer {
        +serializeToJSON(UserAccount user)
    }

    AntiPatternUserAccount --> UserAccount : Refactored via SRP
    UserAccount <-- UserTaxCalculator : Operates upon
    UserAccount <-- UserRepository : Operates upon
    UserAccount <-- UserPayloadSerializer : Operates upon

Production Refactor: Clean Architectural Domain Decomposition

# ==========================================
# ANTI-PATTERN: God Class violating SRP
# ==========================================
class EmployeeGodClass:
    def __init__(self, emp_id: str, name: str, base_salary: float):
        self.emp_id = emp_id
        self.name = name
        self.base_salary = base_salary

    def calculate_pay(self) -> float:
        # Actor 1: HR Compensation department business math
        return self.base_salary - (self.base_salary * 0.22)

    def save_to_database(self):
        # Actor 2: Infrastructure Database Administration
        import psycopg2
        connection = psycopg2.connect(dsn="postgres://user:pass@localhost:5432/corp")
        cursor = connection.cursor()
        cursor.execute("INSERT INTO employees VALUES (%s, %s, %s)", (self.emp_id, self.name, self.base_salary))
        connection.commit()

    def generate_pay_slip_html(self) -> str:
        # Actor 3: UI / Payroll Document Generation teams
        return f"<html><body><h1>Pay Slip: {self.name}</h1><p>Net: {self.calculate_pay()}</p></body></html>"


# ==========================================
# ENTERPRISE REFACTOR: Rigorous SRP Decomposition
# ==========================================
from abc import ABC, abstractmethod
from dataclasses import dataclass

@dataclass
class EmployeeDomainEntity:
    """Pure domain entity encapsulation representing structural data identity."""
    emp_id: str
    name: str
    base_salary: float

class PayrollCalculator:
    """Responsible solely to HR / Compensation business actors."""
    @staticmethod
    def calculate_net_pay(employee: EmployeeDomainEntity) -> float:
        tax_deduction = employee.base_salary * 0.22
        return employee.base_salary - tax_deduction

class EmployeeRepository(ABC):
    """Abstract interface defining data persistent infrastructure operations."""
    @abstractmethod
    def save_employee(self, employee: EmployeeDomainEntity) -> None:
        pass

class PostgreesEmployeeRepository(EmployeeRepository):
    """Responsible solely to Infrastructure Data Architecture actors."""
    def __init__(self, dsn_connection_string: str):
        self.dsn = dsn_connection_string

    def save_employee(self, employee: EmployeeDomainEntity) -> None:
        # Production safe query execution abstraction
        print(f"Executing robust SQL INSERT for entity ID [{employee.emp_id}] via pool [{self.dsn}]")

class PaySlipPresenter:
    """Responsible solely to Document / UX reporting actors."""
    @staticmethod
    def generate_html_slip(employee: EmployeeDomainEntity, net_pay: float) -> str:
        return f"<html><body><h1>Pay Slip: {employee.name}</h1><p>Net: {net_pay}</p></body></html>"

3. Open-Closed Principle (OCP)

First Principles Definition

"Software entities (classes, modules, functions) should be open for extension, but closed for modification." — Bertrand Meyer

classDiagram
    class CheckoutProcessor {
        -PaymentGateway gateway
        +executeOrder(Order order)
    }
    class PaymentGateway {
        <<interface>>
        +processTransaction(float amount)*
    }
    class StripeGateway {
        +processTransaction(float amount)
    }
    class PayPalGateway {
        +processTransaction(float amount)
    }
    class CryptoGateway {
        +processTransaction(float amount)
    }

    CheckoutProcessor --> PaymentGateway : Depends on Abstraction
    PaymentGateway <|-- StripeGateway : Extends (New Capability)
    PaymentGateway <|-- PayPalGateway : Extends (New Capability)
    PaymentGateway <|-- CryptoGateway : Extends (New Capability)

Production Refactor: Enterprise Payment Processor via Strategy Pattern

from abc import ABC, abstractmethod
from typing import List

# ==========================================
# ANTI-PATTERN: OCP Violation via Monolithic Conditional Branching
# ==========================================
class FragilePaymentProcessor:
    def process_order_payment(self, amount: float, method: str):
        if method == "credit_card":
            print(f"Transacting {amount} over Payment Gateway Stripe API...")
        elif method == "paypal":
            print(f"Transacting {amount} via PayPal Braintree execution API...")
        # Every time a new payment vendor is contracted, this stable core must be altered!
        elif method == "apple_pay":
            print(f"Transacting {amount} over ApplePay Secure Enclave Protocol...")
        else:
            raise ValueError("Unsupported payment method!")


# ==========================================
# ENTERPRISE REFACTOR: Extensible OCP Architecture
# ==========================================
class PaymentStrategy(ABC):
    """Abstract baseline interface enabling extensible polymorphism without modification."""
    @abstractmethod
    def execute_transaction(self, amount_dollars: float) -> bool:
        pass

class StripeCreditCardStrategy(PaymentStrategy):
    def __init__(self, api_token: str):
        self.api_token = api_token
        
    def execute_transaction(self, amount_dollars: float) -> bool:
        print(f"[Stripe] Transacting ${amount_dollars:.2f} using OAuth Token [{self.api_token[:6]}...]")
        return True

class PayPalStrategy(PaymentStrategy):
    def __init__(self, merchant_id: str):
        self.merchant_id = merchant_id
        
    def execute_transaction(self, amount_dollars: float) -> bool:
        print(f"[PayPal] Debiting ${amount_dollars:.2f} against Merchant API ID [{self.merchant_id}]")
        return True

class CryptoEthereumStrategy(PaymentStrategy):
    """New Payment vendor capability introduced cleanly WITHOUT modifying existing checkout controllers."""
    def __init__(self, wallet_address: str):
        self.wallet_address = wallet_address

    def execute_transaction(self, amount_dollars: float) -> bool:
        print(f"[Web3 Crypto] Transferred equivalent Ethereum to immutable vault [{self.wallet_address}]")
        return True

class EnterpriseOrderService:
    """Core domain business service - completely closed to modification!"""
    def __init__(self, payment_engine: PaymentStrategy):
        self.payment_engine = payment_engine

    def checkout(self, cart_total: float) -> None:
        logging_id = id(self)
        print(f"Order Service [{logging_id}]: Initializing checkout process for total ${cart_total:.2f}")
        success = self.payment_engine.execute_transaction(cart_total)
        if not success:
            raise RuntimeError("Transaction aborted by underlying payment Strategy processing network.")

4. Liskov Substitution Principle (LSP)

First Principles Definition

"If for each object $o_1$ of type $S$ there is an object $o_2$ of type $T$ such that for all programs $P$ defined in terms of $T$ , the behavior of $P$ is unchanged when $o_1$ is substituted for $o_2$ , then $S$ is a subtype of $T$ ." — Barbara Liskov

Formal Behavioral Subtyping Requirements

To maintain mathematical Liskov substitutability, derived classes must satisfy three fundamental contractual rules:

Preconditions cannot be strengthened: A derived class cannot demand stricter operational input assumptions than those accepted by the parental baseline class.
Postconditions cannot be weakened: A derived class cannot produce system output guarantees that are less binding than those promised by the parent class.
Invariants must be preserved: Any property or structural domain condition that holds true across execution of the parent class must hold true across all implementations of the derived type.

The Classic Architectural Anomaly: Square vs. Rectangle

# ==========================================
# ANTI-PATTERN: The Square/Rectangle LSP Violation
# ==========================================
class Rectangle:
    def __init__(self, width: int, height: int):
        self._width = width
        self._height = height

    def set_width(self, width: int):
        self._width = width

    def set_height(self, height: int):
        self._height = height

    def get_area(self) -> int:
        return self._width * self._height


class Square(Rectangle):
    """Violates LSP by overriding mutations to alter orthogonal properties!"""
    def __init__(self, side: int):
        super().__init__(side, side)

    def set_width(self, width: int):
        self._width = width
        self._height = width  # Hidden side effect breaking parent invariants!

    def set_height(self, height: int):
        self._width = height
        self._height = height # Hidden side effect breaking parent invariants!

# Architectural domain test script evaluating polymorphism invariance
def verify_rectangle_area(rect: Rectangle):
    rect.set_width(5)
    rect.set_height(4)
    # Postcondition assertion expected by all clients consuming a standard Rectangle:
    assert rect.get_area() == 20, f"LSP Crash! Expected Area 20, but calculated {rect.get_area()}"

# Evaluation execution:
std_rect = Rectangle(2, 3)
verify_rectangle_area(std_rect) # Succeeds cleanly

problematic_sq = Square(2)
# When a Square is substituted for a Rectangle, the method fails!
# Setting height to 4 implicitly overwrote width to 4, resulting in an area of 16!
try:
    verify_rectangle_area(problematic_sq)
except AssertionError as err:
    print(f"CRITICAL ARCHITECTURAL BUG: {err}")

Production Refactor: Resolving LSP via Abstract Shape Hierarchies

To eliminate behavioral contradictions, extract invariant domain properties out of concrete implementation bindings by introducing abstract structural generalizations:

from abc import ABC, abstractmethod

class GeometricShape(ABC):
    """True polymorphic baseline abstracting solely validated immutable behavior."""
    @abstractmethod
    def calculate_area(self) -> int:
        pass

class ImmutableRectangle(GeometricShape):
    def __init__(self, width: int, height: int):
        self.width = width
        self.height = height

    def calculate_area(self) -> int:
        return self.width * self.height

class ImmutableSquare(GeometricShape):
    def __init__(self, side: int):
        self.side = side

    def calculate_area(self) -> int:
        return self.side * self.side

def print_surface_area(shape: GeometricShape):
    # Works consistently across all derived implementations without breaking assumptions
    print(f"Evaluated structural surface area: {shape.calculate_area()}")

5. Interface Segregation Principle (ISP)

First Principles Definition

"No client should be forced to depend on methods it does not use." — Robert C. Martin

classDiagram
    class FatDatabaseInterface {
        <<interface>>
        +connect()
        +executeSQLQuery()
        +createBTreeIndex()
        +flushLSMTableToDisk()
        +runMapReduceAggregators()
    }

    class RelationalEngine {
        +connect()
        +executeSQLQuery()
        +createBTreeIndex()
        +flushLSMTableToDisk()* -- Crash! Not an LSM engine!
        +runMapReduceAggregators()* -- Crash! Unsupported!
    }

    class DocumentNoSQLEngine {
        +connect()
        +executeSQLQuery()* -- Crash! No SQL syntax!
        +createBTreeIndex()
        +flushLSMTableToDisk()*
        +runMapReduceAggregators()
    }

    FatDatabaseInterface <|-- RelationalEngine : Fat Coupling Violation
    FatDatabaseInterface <|-- DocumentNoSQLEngine : Fat Coupling Violation

Production Refactor: Segregated Role-Based Interfaces

from abc import ABC, abstractmethod

# ==========================================
# ENTERPRISE REFACTOR: Segregated Role-Based Interfaces
# ==========================================
class DatabaseConnection(ABC):
    """Universal contract shared across all datastore implementations."""
    @abstractmethod
    def open_connection(self) -> None:
        pass
    
    @abstractmethod
    def close_connection(self) -> None:
        pass

class SQLQueryable(ABC):
    """Segregated abstraction purely for relational query processing."""
    @abstractmethod
    def execute_sql_transaction(self, sql_query: str) -> dict:
        pass

class DocumentAggregateQueryable(ABC):
    """Segregated abstraction purely for document aggregation operations."""
    @abstractmethod
    def execute_aggregation_pipeline(self, pipeline: list) -> dict:
        pass

class LSMEngineManageable(ABC):
    """Segregated interface for wide-column architecture engines (Cassandra, Scylla)."""
    @abstractmethod
    def compact_sstable_records(self) -> None:
        pass

# Implementations cleanly inherit only the specific behaviors they support:
class PostgreSQLDatabase(DatabaseConnection, SQLQueryable):
    def open_connection(self):
        print("Opening TCP standard pooled connection to PostgreSQL...")
    def close_connection(self):
        print("Closing PostgreSQL socket.")
    def execute_sql_transaction(self, sql_query: str) -> dict:
        print(f"Executing transactional statement: [{sql_query}]")
        return {"rows": 42}

class MongoDBDatabase(DatabaseConnection, DocumentAggregateQueryable):
    def open_connection(self):
        print("Opening MongoDB Wire Protocol TLS connection...")
    def close_connection(self):
        print("Terminating Mongo cluster cursor.")
    def execute_aggregation_pipeline(self, pipeline: list) -> dict:
        print("Executing BSON aggregation pipeline across sharded documents...")
        return {"document_count": 941}

6. Dependency Inversion Principle (DIP) & Hexagonal Architecture

First Principles Definition

"High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions." — Robert C. Martin

graph TD
    subgraph Legacy Coupling Architecture
        HL1[High-Level Business Logic] -->|Direct Concrete Invocation| LL1[Low-Level MySQL Driver]
        HL1 -->|Direct Concrete Invocation| LL2[Low-Level SMTP Email Client]
    end

    subgraph Dependency Inverted (Hexagonal/Clean) Architecture
        HL2[High-Level Domain Logic Engine] -->|Defines & Calls Abstraction| IRepo["<<Interface>><br>DataRepositoryPort"]
        HL2 -->|Defines & Calls Abstraction| INotif["<<Interface>><br>NotificationPort"]
        
        LL3[PostgreSQL Adapter Class] -->|Implements & Fills Abstraction| IRepo
        LL4[Mongo NoSQL Adapter Class] -->|Implements & Fills Abstraction| IRepo
        LL5[AWS SES Email Adapter Class] -->|Implements & Fills Abstraction| INotif
    end

Production Code: Clean Architecture Dependency Inversion via Inversion of Control (IoC)

from abc import ABC, abstractmethod

# ==========================================
# 1. CORE DOMAIN ABSTRACTIONS (PORTS)
# High-Level modules define these interfaces without any concrete dependencies.
# ==========================================
class EventCachePort(ABC):
    @abstractmethod
    def get_cached_payload(self, key: str) -> str:
        pass

    @abstractmethod
    def set_cached_payload(self, key: str, data: str, ttl_seconds: int) -> None:
        pass

class NotificationDispatcherPort(ABC):
    @abstractmethod
    def dispatch_alert(self, recipient: str, message: str) -> bool:
        pass

# ==========================================
# 2. HIGH-LEVEL DOMAIN SERVICE
# Completely decoupled from database systems, network protocols, or third-party vendors.
# ==========================================
class DistributedOrderProcessingService:
    def __init__(self, cache_adapter: EventCachePort, notifier: NotificationDispatcherPort):
        # Dependencies injected dynamically via construction (Dependency Injection)
        self.cache = cache_adapter
        self.notifier = notifier

    def process_customer_order(self, order_id: str, client_email: str) -> None:
        cached_status = self.cache.get_cached_payload(f"order:{order_id}")
        if cached_status:
            print(f"[Order Service] Order [{order_id}] already processed. Exiting.")
            return

        # Execute complex enterprise domain algorithmic logic here...
        print(f"[Order Service] Successfully verified and billed order [{order_id}].")

        # Update cache and dispatch notifications via interface abstractions
        self.cache.set_cached_payload(f"order:{order_id}", "PROCESSED", ttl_seconds=86400)
        self.notifier.dispatch_alert(client_email, f"Your order {order_id} is on its way!")

# ==========================================
# 3. LOW-LEVEL INFRASTRUCTURE ADAPTERS
# Implements domain abstraction interfaces using specific third-party client drivers.
# ==========================================
class RedisCacheAdapter(EventCachePort):
    def __init__(self, redis_host: str):
        self.host = redis_host
        self._memory_map = {} # Simulating active production Redis clustered memory pool
        
    def get_cached_payload(self, key: str) -> str:
        return self._memory_map.get(key)

    def set_cached_payload(self, key: str, data: str, ttl_seconds: int) -> None:
        print(f"[Redis Adapter @ {self.host}] Storing token [{key}] with TTL {ttl_seconds}s")
        self._memory_map[key] = data

class SendGridNotificationAdapter(NotificationDispatcherPort):
    def __init__(self, api_key: str):
        self.api_key = api_key

    def dispatch_alert(self, recipient: str, message: str) -> bool:
        print(f"[SendGrid Adapter] Pushing HTTPS email payload to [{recipient}] via key [{self.api_key[:4]}...]")
        return True

# ==========================================
# 4. SYSTEM BOOTSTRAP / IOC COMPOSITION ROOT
# Assembles the runtime dependency graph at application startup.
# ==========================================
if __name__ == "__main__":
    print("Bootstrapping system architecture via IoC root...")
    redis_adapter = RedisCacheAdapter("10.0.4.15")
    sendgrid_adapter = SendGridNotificationAdapter("SG.841983_production_key")

    # Inject concrete implementations into our high-level service architecture
    order_service = DistributedOrderProcessingService(cache_adapter=redis_adapter, notifier=sendgrid_adapter)

    # Execute enterprise transaction execution loop
    order_service.process_customer_order(order_id="ORD-2026-901", client_email="sarthak@enterprise-dev.org")

7. Advanced System Design Interview Questions & Rigorous Explanations

Q1: In large-scale systems architecture, how does adhering to the Open-Closed Principle (OCP) directly mitigate operational blast radiuses during continuous automated deployment pipelines?

Q2: How do the Dependency Inversion Principle (DIP) and Dependency Injection (DI) frameworks interact to enable reliable high-speed unit testing across complex enterprise microservices?

Q3: Give a concrete real-world engineering failure where violating the Liskov Substitution Principle (LSP) caused a systemic runtime system failure in a production environment.