Czym jest design by contract?

Question

Accepted Answer

**Design by Contract (DbC)** traktuje relację między metodą a jej wywołującym jako formalną umowę, zdefiniowaną trzema rzeczami: **preconditions** (co musi zagwarantować wywołujący), **postconditions** (co metoda gwarantuje w zamian), i **invariants** (co pozostaje prawdziwe dla obiektu przez cały czas).

## Trzy obowiązki

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

## W kodzie

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

Jeśli *precondition* nie powiedzie się, błąd ma **wywołujący**. Jeśli *postcondition* lub *invariant* nie powiedzą się, błąd ma **metoda** — umowy wskazują winę precyzyjnie.

## Relacja do LSP

DbC czyni Liskov precyzyjnym: podtyp może **osłabić preconditions** i **wzmocnić postconditions**, ale nigdy odwrotnie. To dokładnie reguła substytucyjności, wyrażona jako umowy.

## Kompromisy

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

## Dlaczego to ważne

Umowy zamieniają niejasne założenia ("kwota powinna być dodatnia, myślę") w jawne, sprawdzalne reguły — i przypisują winę precyzyjnie, gdy coś się psuje.

Underpinują substytucję Liskov i solidny design API: umowa metody to jej prawdziwy interfejs, bardziej uczciwy niż sama sygnatura typu.