Hva er design by contract?

Question

Accepted Answer

**Design by Contract (DbC)** behandler forholdet mellom en metode og dens oppkaller som en formell avtale, definert av tre ting: **prekondisjon** (hva oppkalleren må garantere), **postkondisjoner** (hva metoden garanterer til gjengjeld), og **invarianter** (hva som forblir sann for objektet til enhver tid).

## De tre forpliktelsene

```text
PRECONDITION  → caller's duty: inputs/state the method requires to run correctly
POSTCONDITION → method's duty: what it promises on return (if precondition held)
INVARIANT     → always-true property of the object, before and after every method
```

## I kode

```python
class Account:
    def __init__(self, balance):
        self._balance = balance
        self._check_invariant()

def withdraw(self, amount):
        assert amount > 0, "PRE: amount must be positive"        # precondition
        assert amount <= self._balance, "PRE: sufficient funds"  # precondition
        old = self._balance
        self._balance -= amount
        assert self._balance == old - amount, "POST: balance reduced"  # postcond
        self._check_invariant()

def _check_invariant(self):
        assert self._balance >= 0, "INVARIANT: balance never negative"
```

Hvis en *prekondisjon* mislykkes, har **oppkalleren** buggen. Hvis en *postkondisjoner* eller *invarianter* mislykkes, har **metoden** buggen — kontrakter peker på skyld presist.

## Forhold til LSP

DbC gjør Liskov presis: en subtype kan **svekke prekondisjonene** og **styrke postkondisjoner**, men aldri omvendt. Det er akkurat substitueringsregelen, uttrykt som kontrakter.

## Avveiinger

```text
✓ Bugs surface at the boundary, with clear blame   ✓ Contracts double as documentation
⚠️ Runtime checks cost performance (often disabled in prod via assertions)
⚠️ Not all languages enforce it natively (Eiffel does; most use asserts/validation)
```

## Hvorfor det betyr noe

Kontrakter gjør vage antagelser ("beløp bør være positivt, tror jeg") til eksplisitte, kontrollerbare regler — og de tildeler skyld presist når noe går galt.

De ligger til grunn for Liskov-substitusjon og robust API-design: en metodes kontrakt er dens sanne grensesnitt, mer ærlig enn bare typesignaturen alene.