डिजाइन बाय कन्ट्र्याक्ट भनेको के हो?

Question

Accepted Answer

**डिजाइन बाय कन्ट्र्याक्ट (DbC)** ले एक मेथड र यसको कलरको बीचको सम्बन्धलाई एक औपचारिक सहमति मान्छ, जसलाई तीन कुराले परिभाषित गरिन्छ: **preconditions** (कलरले कस्तो ग्यारान्टी दिनु पर्छ), **postconditions** (मेथडले बदलामा कस्तो ग्यारान्टी दिन्छ), र **invariants** (अबजेक्टको लागि सधैं सत्य के रहन्छ)।

## तीन दायित्व

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

यदि *precondition* असफल हुन्छ, **कलरलाई** बग छ। यदि *postcondition* वा *invariant* असफल हुन्छ, **मेथडलाई** बग छ — कन्ट्र्याक्टले दोषलाई सटीक रूपमा निर्दिष्ट गर्छ।

## LSP सँगको सम्बन्ध

DbC ले Liskov लाई सटीक गर्छ: एक subtype ले **preconditions कमजोर गर्न** र **postconditions शक्तिशाली गर्न** सक्छ, तर विपरीत कहिले पनि होइन। यो ठ्याक्कै substitutability नियम हो, कन्ट्र्याक्टको रूपमा कथन गरिएको।

## ट्रेड-अफहरू

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

## किन यो महत्त्वपूर्ण छ

कन्ट्र्याक्टले अस्पष्ट अनुमान ("रकम सकारात्मक हुनु पर्छ, मलाई लाग्छ") लाई स्पष्ट, जाँचयोग्य नियमहरूमा परिणत गर्छ — र जब कुनै कुरा टुट्छ, दोषलाई सटीकसँग निर्दिष्ट गर्छ।

यो Liskov substitution र robust API डिजाइनलाई समर्थन गर्छ: एक मेथडको कन्ट्र्याक्ट यसको सत्य इन्टरफेस हो, यसको type signature मात्र भन्दा बढी ईमानदार।