Design by Contract అంటే ఏమిటి?

Question

Accepted Answer

**Design by Contract (DbC)** ఒక పద్ధతి మరియు దానిని పిలిచేవారి మధ్య సంబంధాన్ని ఔపచారిక ఒప్పందం వలె పరిగణిస్తుంది, ఇది మూడు విషయాలతో నిర్వచించబడుతుంది: **పూర్వ పరిస్థితులు** (పిలిచేవాడు గ్యారంటీ ఇవ్వాలిసిన వాటి), **పోస్ట్ పరిస్థితులు** (పద్ధతి ప్రతిఫలంగా గ్యారంటీ ఇచ్చేది) మరియు **నిర్ధారణలు** (వస్తువుకు ఎప్పుడూ నిజం ఉండేది).

## మూడు బాధ్యతలు

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

## కోడ్‌లో

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

ఒక *పూర్వ పరిస్థితి* విఫలమైతే, **పిలిచేవారికి** బగ్ ఉంది. ఒక *పోస్ట్ పరిస్థితి* లేదా *నిర్ధారణ* విఫలమైతే, **పద్ధతికి** బగ్ ఉంది — ఒప్పందాలు నిందను ఖచ్చితంగా చిన్న చిన్న విభజనలు చేస్తాయి.

## LSP కు సంబంధం

DbC లిస్కోవ్‌ను ఖచ్చితమైనదిగా చేస్తుంది: ఒక సబ్‌టైప్ **పూర్వ పరిస్థితులను బలహీనం చేయగలదు** మరియు **పోస్ట్ పరిస్థితులను బలపరచగలదు**, కానీ ఎన్నటికీ విరుద్ధంగా కాదు. ఇది ఖచ్చితమైన ప్రత్యామ్నాయ నియమం, ఒప్పందాలుగా వ్యక్తీకరించబడింది.

## ట్రేడ్‌ఆఫ్‌లు

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

## ఇది ఎందుకు ముఖ్యమైనది

ఒప్పందాలు అస్పష్ట అనుమానాలను ("మొత్తం సానుకూలంగా ఉండాలి, అని నేను భావిస్తున్నాను") స్పష్టమైన, చెక్ చేయదగిన నియమాలుగా మారుస్తాయి — మరియు ఏదైనా విరిగిపోయినప్పుడు నిందను ఖచ్చితంగా కేటాయించాయి.

అవి లిస్కోవ్ ప్రత్యామ్నాయం మరియు బలమైన API డిజైన్‌ను ఆధారం చేస్తాయి: ఒక పద్ధతి యొక్క ఒప్పందం దాని నిజమైన ఇంటర్‌ఫేస్, దాని రకం సంతకం కంటే మరింత సత్యవంతమైనది.