Explain the Open/Closed Principle in depth.

Question

Accepted Answer

The **Open/Closed Principle (OCP)** says software entities should be **open for extension but closed for modification**: you should add new behavior by adding new code, not by editing existing, tested code.

## The smell OCP targets

```python
# CLOSED to extension: every new shape edits this method (risky, retests everything)
def area(shape):
    if shape.kind == "circle":   return 3.14159 * shape.r ** 2
    elif shape.kind == "square": return shape.s ** 2
    elif shape.kind == "rect":   return shape.w * shape.h
    # add a triangle → modify this function again...
```

Each new type forces a change to a growing `if/elif` chain — fragile and a magnet for bugs.

## OCP via polymorphism

```python
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self): ...

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r ** 2

class Triangle(Shape):                 # NEW behavior = NEW class
    def __init__(self, b, h): self.b, self.h = b, h
    def area(self): return 0.5 * self.b * self.h

def total_area(shapes):                # never changes again
    return sum(s.area() for s in shapes)
```

Adding `Triangle` requires **zero edits** to `total_area` — extension without modification.

## Mechanisms that enable OCP

```text
→ polymorphism / inheritance     → strategy pattern (inject behavior)
→ plugins / interfaces           → higher-order functions / callbacks
```

## Pitfall

OCP done speculatively becomes over-engineering — abstractions built for variation that never arrives. Apply it where change is *likely* (the "rule of three": abstract after the variation actually appears).

## Why it matters

Editing battle-tested code to add a feature risks regressions in everything that code already supports; OCP confines new behavior to new, isolated units.

It's the principle behind extensible frameworks and plugin systems — and it depends on LSP, since substitutable subtypes are what make the "closed" core safe to leave untouched.