ડિઝાઇન બાય કોન્ટ્રેક્ટ શું છે?

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

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

જો *પ્રી-કન્ડીશન* નિષ્ફળ જાય, તો **કૉલર** પાસે બગ છે. જો *પોસ્ટ-કન્ડીશન* અથવા *ઇનવેરિયંટ* નિષ્ફળ જાય, તો **પદ્ધતિ** પાસે બગ છે — કરાર દોષ સાચવે છે.

## Relationship to 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 ડિઝાઇનને આધાર આપે છે: પદ્ધતિનો કરાર તેનું સાચું ઇન્ટરફેસ છે, તેના પ્રકાર હસ્તાક્ષર કરતાં વધુ સત્ય.