Che cos'è il design by contract?

Question

Accepted Answer

**Design by Contract (DbC)** tratta la relazione tra un metodo e il suo chiamante come un accordo formale, definito da tre elementi: **precondizioni** (cosa il chiamante deve garantire), **postcondizioni** (cosa il metodo garantisce in cambio), e **invarianti** (cosa rimane vero per l'oggetto in ogni momento).

## Le tre obbligazioni

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

## Nel codice

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

Se una *precondizione* fallisce, il **chiamante** ha il bug. Se una *postcondizione* o un *invariante* fallisce, il **metodo** ha il bug — i contratti identificano la colpa con precisione.

## Relazione con LSP

DbC rende Liskov preciso: un sottotipo può **indebolire le precondizioni** e **rafforzare le postcondizioni**, ma mai il contrario. Questa è esattamente la regola di sostituibilità, espressa come contratti.

## Compromessi

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

## Perché è importante

I contratti trasformano supposizioni vaghe ("l'importo dovrebbe essere positivo, penso") in regole esplicite e verificabili — e assegnano la colpa con precisione quando qualcosa si rompe.

Sostengono la sostituzione di Liskov e il design robusto delle API: il contratto di un metodo è la sua vera interfaccia, più onesta della sola firma di tipo.