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 Liskov ஐ துல்லியமாகக் கூறுகிறது: ஒரு உப-வகை **முன்நிபந்தனைகளை பலவீனப்படுத்த** முடியும் மற்றும் **பின்நிபந்தனைகளை வலுப்படுத்த** முடியும், ஆனால் எப்போதும் நேர்மாறாக இல்லை. இது சரியாக பதிலீட்ட விதி, ஒப்பந்தங்களாக வெளிப்படுத்தப்படுகிறது.

## நகர்வாக்கு

```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 பதிலீடு மற்றும் வலுவான API வடிவமைப்பு ஆகியவற்றின் அடிப்படை: ஒரு முறையின் ஒப்பந்தம் அதன் உண்மையான இடைமுகம், அதன் வகை கையொப்பத்தை விட அधिक நேர்மையாக உள்ளது.