Ce este design by contract?

Question

Accepted Answer

**Design by Contract (DbC)** tratează relația dintre o metodă și apelantul acesteia ca un acord formal, definit de trei lucruri: **preconditions** (ce trebuie să garanteze apelantul), **postconditions** (ce garantează metoda la rândul ei), și **invariants** (ce rămâne adevărat pentru obiect în orice moment).

## Cele trei obligații

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

## În cod

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

Dacă o *precondition* eșuează, **apelantul** are bug-ul. Dacă o *postcondition* sau *invariant* eșuează, **metoda** are bug-ul — contractele arată vina cu precizie.

## Relația cu LSP

DbC face Liskov precis: un subtip poate **slăbi preconditions** și **întări postconditions**, dar niciodată invers. Aceasta este exact regula de substituibilitate, exprimată ca contracte.

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

## De ce este important

Contractele transformă ipotezele vagi ("valoarea ar trebui să fie pozitivă, cred") în reguli explicite și verificabile — și atribuie vina cu precizie atunci când ceva se rupe.

Ele susțin substituția Liskov și designul robust de API: contractul unei metode este interfața sa adevărată, mai onestă decât doar semnătura tipului.