Forklar Open/Closed Principle i dybden.

Question

Accepted Answer

**Open/Closed Principle (OCP)** sier at softwareenheter skal være **åpne for utvidelse men lukkede for modifisering**: du bør legge til ny oppførsel ved å legge til ny kode, ikke ved å redigere eksisterende, testet kode.

## Problemet OCP adresserer

```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...
```

Hver ny type tvinger en endring til en økende `if/elif`-kjede — skjør og en magnet for feil.

## OCP via polymorfisme

```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)
```

Å legge til `Triangle` krever **null redigeringer** av `total_area` — utvidelse uten modifisering.

## Mekanismer som muliggjør OCP

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

## Felle

OCP gjort spekulativt blir over-engineering — abstraksjoner bygget for variasjon som aldri kommer. Bruk det der endring er *sannsynlig* ("regelen om tre": abstraher etter at variasjonen faktisk dukker opp).

## Hvorfor det betyr noe

Å redigere velutsilt kode for å legge til en funksjon risikerer regresjoner i alt som koden allerede støtter; OCP begrenser ny oppførsel til nye, isolerte enheter.

Det er prinsippet bak utvidbare rammeverk og plugin-systemer — og det avhenger av LSP, siden erstattbare undertyper er det som gjør den "lukkede" kjernen sikker å la uendret.