SOLID — Open - Closed Principle — Coding notes

WHY does OCP exist?

WHAT exactly is "open" and "closed"?

HOW to actually achieve it (the mechanism)

The core enablers are polymorphism and the Dependency Inversion habit:

Find the part of the code that varies (the thing that keeps making you edit a switch/if-else).
Hide that variation behind an abstract interface.
Make high-level code depend on the interface, not the concrete types.
New requirement → write a new class implementing the interface. Old code never opens.

Figure — SOLID — Open - Closed Principle

Worked Example 1 — Area calculator (the classic smell)

Worked example ❌ Violating OCP

class AreaCalculator:
    def area(self, shape):
        if shape.type == "circle":
            return 3.14159 * shape.r ** 2
        elif shape.type == "rectangle":
            return shape.w * shape.h
        # Add triangle? → must EDIT this method again 😖

Why is this bad? Every new shape forces you to reopen and edit area() — a working, tested method. The if/elif chain is the variation point screaming to be abstracted.

Worked example ✅ Following OCP

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     # Why? Circle owns its formula
 
class Rectangle(Shape):
    def __init__(self, w, h): self.w, self.h = w, h
    def area(self): return self.w * self.h
 
class AreaCalculator:
    def total(self, shapes):
        return sum(s.area() for s in shapes)          # Why? Depends only on the Shape contract

Why this step (the Shape ABC)? It freezes the contract "every shape can compute area()." Why this step (AreaCalculator.total)? It now needs zero edits ever — it only talks to the abstraction. Adding a Triangle? Just write class Triangle(Shape). ✅ Closed code untouched, new behavior added.

Worked Example 2 — Discount strategies

Worked example Requirement keeps growing: regular, premium, seasonal... customers

class Discount(ABC):
    @abstractmethod
    def apply(self, price): ...
 
class NoDiscount(Discount):
    def apply(self, price): return price
 
class PremiumDiscount(Discount):
    def apply(self, price): return price * 0.80        # Why? 20% off lives HERE
 
class SeasonalDiscount(Discount):
    def __init__(self, pct): self.pct = pct
    def apply(self, price): return price * (1 - self.pct)
 
def checkout(price, discount: Discount):               # Why? takes the abstraction
    return discount.apply(price)

Why this is OCP: A new "Black Friday 70% off" rule = one new class BlackFriday(Discount). checkout never changes. This is the Strategy pattern, the most common OCP realization.

Common Mistakes (Steel-manned)

Flashcards

OCP stands for and states what

Open/Closed Principle — software entities should be open for extension but closed for modification.

What does "open for extension" mean

You can add new behavior to the module as requirements grow.

What does "closed for modification" mean

You add that behavior without editing the existing source code.

The key mechanism that makes OCP possible

Abstraction + polymorphism — depend on a stable interface, add new implementations behind it.

The design-pattern most associated with OCP

Strategy pattern (and Template Method / plugin architectures).

A long if/elif or switch on a "type" field is a smell for which violated principle

Open/Closed Principle.

The "Rule of Three" tells you to

Refactor to polymorphism on the third variation, not before (avoid premature abstraction).

Does OCP forbid bug fixes

No — it targets adding new behavior; fixing bugs still requires editing code.

Which SOLID letter is OCP

The "O".

What goes inside a new Shape class vs the AreaCalculator

The shape's own area formula goes in the new class; the calculator only calls the area() abstraction.

Recall Feynman: explain to a 12-year-old

Imagine you have a toy robot that can do tricks. Right now it can wave and spin. You want it to also dance. Bad way: open up the robot and rewire its brain — you might break the waving. OCP way: the robot has slots where you can plug in trick cards. To add dancing, you just slide in a new "dance card." The robot's insides never get opened. Old tricks stay safe, new tricks get added. That's "open for new tricks, closed for cutting it open."

Connections

SOLID — Single Responsibility Principle — SRP isolates one reason to change; OCP then makes that change additive.
SOLID — Liskov Substitution Principle — OCP relies on subclasses being safely substitutable behind the interface.
SOLID — Dependency Inversion Principle — DIP ("depend on abstractions") is the structural backbone that makes OCP work.
Strategy Pattern / Template Method Pattern — concrete patterns that realize OCP.
Polymorphism — the language feature OCP is built on.
Refactoring — Replace Conditional with Polymorphism — the move that fixes OCP violations.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Open/Closed Principle ka matlab simple hai: code ko naya behavior add karne ke liye open hona chahiye, lekin purana tested code edit karne ke liye band (closed) hona chahiye. Soch ke dekho — jab bhi aap ek already-working file ko kholke if/else me ek aur branch ghusate ho, to risk hai ki kuch jo pehle chal raha tha woh toot jaye. OCP kehta hai: edit mat karo, naya class add karo.

Yeh kaise hota hai? Jadoo ki cheez hai abstraction aur polymorphism. Aap ek interface banate ho (jaise Shape jisme area() hai). Aapka main code sirf us interface pe depend karta hai, concrete classes pe nahi. Ab naya shape chahiye? Bas Triangle(Shape) likh do — AreaCalculator ko haath lagane ki zarurat hi nahi. Yahi Strategy pattern ka core idea hai.

Ek practical tip: har jagah interface mat banao "future ke liye" — woh over-engineering ho jata hai. Rule of Three yaad rakho: pehli-doosri baar if/else chalega, lekin teesri variation aaye to refactor karke polymorphism la do. Aur dhyan rakho — OCP bug fix karne se mana nahi karta; woh sirf naye features ke liye purana code chhedne se rokta hai. Yaad rakhne ka mantra: "Add, don't edit" — purana code closed, naya code plug-in.

SOLID — Open - Closed Principle

WHY does OCP exist?

WHAT exactly is "open" and "closed"?

HOW to actually achieve it (the mechanism)

Worked Example 1 — Area calculator (the classic smell)

Worked Example 2 — Discount strategies

Common Mistakes (Steel-manned)

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Design Principles

Connections