Clean Code

# Bad
d = 7         # elapsed time in days
lst = []      # list of flagged accounts
temp = get()  # temporary result

# Good
elapsed_days = 7
flagged_accounts = []
active_user = get_authenticated_user()

// Bad
Date genymdhms;  // generation date, year-month-day-hour-minute-second
int pdcnt;       // past due count

// Good
Date generationTimestamp;
int pastDueCount;

// Bad: searching for "7" finds thousands of results
if (days > 7) { ... }

// Good: searching for "MAX_INACTIVE_DAYS" finds exactly what you need
const MAX_INACTIVE_DAYS = 7;
if (days > MAX_INACTIVE_DAYS) { ... }

# Bad: mixed levels of abstraction
def process_order(order):
    # High-level
    validate_order(order)

    # Suddenly low-level
    conn = psycopg2.connect(host="db", port=5432, dbname="orders")
    cursor = conn.cursor()
    cursor.execute("INSERT INTO orders (id, total) VALUES (%s, %s)", (order.id, order.total))
    conn.commit()

    # Back to high-level
    send_confirmation(order)

# Good: consistent level of abstraction
def process_order(order):
    validate_order(order)
    save_order(order)
    send_confirmation(order)

# Pure: predictable, testable, parallelizable
def calculate_discount(price: float, discount_percent: float) -> float:
    return price * (1 - discount_percent / 100)

# Impure: depends on external state, has side effects
def apply_discount(order):
    discount = get_global_discount()  # external dependency
    order.total -= order.total * discount  # mutation
    log(f"Applied discount to {order.id}")  # side effect

// Bad: does it check or set?
boolean set(String attribute, String value);
if (set("username", "john")) { ... }

// Good: separate command and query
boolean attributeExists(String attribute);
void setAttribute(String attribute, String value);

if (attributeExists("username")) {
    setAttribute("username", "john");
}

// Bad: UserService handles auth, validation, persistence, and notifications
class UserService {
  authenticate(credentials) { ... }
  validateEmail(email) { ... }
  saveToDatabase(user) { ... }
  sendWelcomeEmail(user) { ... }
}

// Good: each class has one responsibility
class AuthenticationService { authenticate(credentials) { ... } }
class UserValidator { validateEmail(email) { ... } }
class UserRepository { save(user) { ... } }
class NotificationService { sendWelcomeEmail(user) { ... } }

# Bad: adding a new shape requires modifying AreaCalculator
class AreaCalculator:
    def calculate(self, shape):
        if isinstance(shape, Circle):
            return math.pi * shape.radius ** 2
        elif isinstance(shape, Rectangle):
            return shape.width * shape.height
        # Must modify this class for every new shape

# Good: extend without modifying
class Shape(Protocol):
    def area(self) -> float: ...

class Circle:
    def __init__(self, radius): self.radius = radius
    def area(self) -> float: return math.pi * self.radius ** 2

class Rectangle:
    def __init__(self, width, height): self.width, self.height = width, height
    def area(self) -> float: return self.width * self.height

# New shapes can be added without changing existing code
class Triangle:
    def __init__(self, base, height): self.base, self.height = base, height
    def area(self) -> float: return 0.5 * self.base * self.height

# Violation: Square changes the behavior contract of Rectangle
class Rectangle:
    def set_width(self, w): self.width = w
    def set_height(self, h): self.height = h

class Square(Rectangle):
    def set_width(self, w): self.width = self.height = w   # Surprising!
    def set_height(self, h): self.width = self.height = h  # Surprising!

# Fix: use separate types or an immutable approach
class Shape(Protocol):
    def area(self) -> float: ...

class Rectangle:
    def __init__(self, width, height): ...
    def area(self): return self.width * self.height

class Square:
    def __init__(self, side): ...
    def area(self): return self.side ** 2

// Bad: a printer-only device must implement fax and scan
interface Machine {
  print(doc: Document): void;
  fax(doc: Document): void;
  scan(doc: Document): Image;
}

// Good: segregated interfaces
interface Printer { print(doc: Document): void; }
interface Fax { fax(doc: Document): void; }
interface Scanner { scan(doc: Document): Image; }

class SimplePrinter implements Printer {
  print(doc: Document) { ... }
}

class MultiFunctionDevice implements Printer, Fax, Scanner {
  print(doc: Document) { ... }
  fax(doc: Document) { ... }
  scan(doc: Document) { ... }
}

# Bad: high-level OrderService depends on low-level MySQLDatabase
class OrderService:
    def __init__(self):
        self.db = MySQLDatabase()  # hard-coded dependency

# Good: depend on abstraction
class OrderService:
    def __init__(self, repository: OrderRepository):  # abstract dependency
        self.repository = repository

# Wire up at composition root
db = PostgresOrderRepository(connection_string)
service = OrderService(db)

# Over-DRY: shared utility for unrelated things
def format_thing(thing, type):
    if type == "user":
        return f"{thing.first_name} {thing.last_name}"
    elif type == "product":
        return f"{thing.name} - ${thing.price}"
    elif type == "order":
        return f"Order #{thing.id}"

# Two similar functions: leave them separate
def validate_user_email(email): ...
def validate_contact_email(email): ...

# Third instance: now extract
def validate_email(email): ...