Wat is design by contract?

Question

Accepted Answer

**Design by Contract (DbC)** behandelt de relatie tussen een methode en de aanroeper als een formeel akkoord, gedefinieerd door drie dingen: **precondities** (wat de aanroeper moet garanderen), **postcondities** (wat de methode ervoor terug garandeert), en **invarianten** (wat voor het object altijd waar blijft).

## De drie verplichtingen

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

## In code

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

Als een *precondities* mislukt, heeft de **aanroeper** de bug. Als een *postcondities* of *invarianten* mislukt, heeft de **methode** de bug — contracten wijzen nauwkeurig schuld aan.

## Relatie tot LSP

DbC maakt Liskov nauwkeurig: een subtype mag **precondities verzwakken** en **postcondities versterken**, maar nooit andersom. Dat is precies de substitueerbaarheidsregel, uitgedrukt als contracten.

## Afwegingen

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

## Waarom het belangrijk is

Contracten veranderen vage aannames ("bedrag moet positief zijn, denk ik") in expliciete, controleerbare regels — en zij wijzen schuld nauwkeurig aan wanneer iets breekt.

Zij vormen de basis voor Liskov-substitutie en robuust API-ontwerp: het contract van een methode is de ware interface, eerlijker dan alleen de typesignatuur.