¿Qué es Design by Contract?

Question

Accepted Answer

**Design by Contract (DbC)** trata la relación entre un method y su llamador como un acuerdo formal, definido por tres cosas: **preconditions** (lo que el llamador debe garantizar), **postconditions** (lo que el method garantiza a cambio), e **invariants** (lo que permanece verdadero para el objeto en todo momento).

## Las tres obligaciones

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

## En código

```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 una *precondition* falla, el **llamador** tiene el error. Si una *postcondition* o *invariant* falla, el **method** tiene el error — los contratos señalan la culpa con precisión.

## Relación con LSP

DbC hace Liskov preciso: un subtipo puede **debilitar preconditions** y **fortalecer postconditions**, pero nunca lo opuesto. Esa es exactamente la regla de sustituibilidad, expresada como contratos.

## Por qué es importante

Los contratos convierten suposiciones vagas ("el monto debería ser positivo, creo") en reglas explícitas y comprobables — y asignan la culpa con precisión cuando algo se rompe.

Fundamentan la sustitución de Liskov y el diseño robusto de API: el contrato de un method es su verdadera interfaz, más honesto que su type signature por sí sola.

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