Qu'est-ce que la conception par contrat ?

Question

Accepted Answer

**Design by Contract (DbC)** traite la relation entre une méthode et son appelant comme un accord formel, défini par trois choses : les **préconditions** (ce que l'appelant doit garantir), les **postconditions** (ce que la méthode garantit en retour) et les **invariants** (ce qui reste vrai pour l'objet à tout moment).

## Pourquoi c'est important

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

Si une *précondition* échoue, l'**appelant** a un bug. Si une *postcondition* ou un *invariant* échoue, la **méthode** a un bug — les contrats désignent la responsabilité de manière précise.

## Relationship to LSP

DbC rend Liskov précis : un sous-type peut **affaiblir les préconditions** et **renforcer les postconditions**, mais jamais l'inverse. C'est exactement la règle de substituabilité, énoncée sous forme de contrats.

## Trade-offs

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

## Pourquoi c'est important

Les contrats transforment les hypothèses vagues (« le montant doit être positif, je pense ») en règles explicites et vérifiables — et ils assignent la responsabilité précisément quand quelque chose se casse.

Ils sont à la base de la substitution de Liskov et d'une conception d'API robuste : le contrat d'une méthode est sa véritable interface, plus honnête que sa signature de type seule.