Writing Clean Code: SOLID Principles with Python Examples

SOLID is a set of five object-oriented design principles introduced by Robert C. Martin. Code that violates SOLID is typically brittle (one change breaks many things), rigid (hard to extend), and opaque (difficult to understand). Let's explore each principle with Python examples.

S - Single Responsibility Principle

A class should have one, and only one, reason to change. A class that handles HTTP requests, validates data, and sends emails has three reasons to change.

# Wrong: Three responsibilities
class ArticleService:
    def save(self, article): ...  # persistence
    def validate(self, data): ... # validation
    def notify_subscribers(self): ... # notifications

# Right: Separate classes
class ArticleRepository:
    def save(self, article): ...

class ArticleValidator:
    def validate(self, data): ...

class ArticleNotifier:
    def notify_subscribers(self, article): ...

O - Open/Closed Principle

Open for extension, closed for modification. Add new behavior by adding new code, not changing existing code.

class ContentRenderer(ABC):
    @abstractmethod
    def render(self, content: str) -> str: ...

class MarkdownRenderer(ContentRenderer):
    def render(self, content): return markdown.render(content)

class HTMLRenderer(ContentRenderer):
    def render(self, content): return content  # Already HTML

L - Liskov Substitution Principle

Subclasses must be substitutable for their base classes without altering program correctness.

I - Interface Segregation Principle

Many specific interfaces are better than one general-purpose interface. Clients shouldn't depend on methods they don't use.

D - Dependency Inversion Principle

High-level modules should not depend on low-level modules. Both should depend on abstractions.

class ArticleUseCase:
    def __init__(self, repo: ArticleRepository):  # Depends on abstraction
        self.repo = repo

    def publish(self, article_id: int):
        article = self.repo.find(article_id)
        article.publish()
        self.repo.save(article)

Startup Operational Metrics Framework

The following Python script illustrates how to build a clean programmatic model to track unit economics, CAC payback period, NRR (Net Revenue Retention), and LTV ratios dynamically:

class SaaSUnitEconomicsTracker:
    def __init__(self, mrr: float, total_users: int, sales_marketing_cost: float, new_users: int, churned_users: int) -> None:
        self.mrr = mrr
        self.total_users = total_users
        self.sm_cost = sales_marketing_cost
        self.new_users = new_users
        self.churned_users = churned_users

    @property
    def arpu(self) -> float:
        """Average Revenue Per User (Monthly)"""
        return self.mrr / (self.total_users if self.total_users > 0 else 1)

    @property
    def cac(self) -> float:
        """Customer Acquisition Cost"""
        return self.sm_cost / (self.new_users if self.new_users > 0 else 1)

    @property
    def churn_rate(self) -> float:
        """Monthly Churn Rate"""
        return self.churned_users / (self.total_users if self.total_users > 0 else 1)

    @property
    def ltv(self) -> float:
        """Customer Lifetime Value"""
        return self.arpu / (self.churn_rate if self.churn_rate > 0 else 0.01)

    @property
    def ltv_cac_ratio(self) -> float:
        return self.ltv / (self.cac if self.cac > 0 else 1)

    @property
    def payback_period_months(self) -> float:
        """Payback period in months"""
        return self.cac / (self.arpu if self.arpu > 0 else 1)

# Example execution
if __name__ == "__main__":
    tracker = SaaSUnitEconomicsTracker(
        mrr=50000.0, total_users=1000,
        sales_marketing_cost=15000.0, new_users=50,
        churned_users=20
    )
    print(f"LTV:CAC Ratio: {tracker.ltv_cac_ratio:.2f} (Target: >3.0)")
    print(f"Payback Period: {tracker.payback_period_months:.1f} months")

Production Application Telemetry Wrapper

Here is an enterprise-grade telemetry decorator in Python to measure execution latency, record counts, and catch pipeline boundaries:

import time
import logging
from functools import wraps

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("MirahLabs.Telemetry")

def monitor_performance(operation_name: str):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            t0 = time.perf_counter()
            try:
                res = func(*args, **kwargs)
                dt = time.perf_counter() - t0
                logger.info(f"{operation_name} succeeded in {dt:.4f}s")
                return res
            except Exception as e:
                dt = time.perf_counter() - t0
                logger.error(f"{operation_name} failed after {dt:.4f}s: {str(e)}")
                raise e
        return wrapper
    return decorator

Runtime & Concurrency Metrics Profile

Below is a runtime latency and throughput benchmark compiled in a containerized environment (2 vCPU, 4GB RAM) running under simulated concurrent request volumes:

US & UK Compliance and Data Governance

Modern applications operating across US and UK regions must establish comprehensive data governance frameworks. This includes meeting the security baselines of the US NIST Cybersecurity Framework and the UK Cyber Essentials certification. Enforcing encryption at rest and in transit, keeping audit logs, and maintaining a clear incident response plan are essential to comply with both CCPA and UK GDPR regulations.