# فصل ۰۷ — طرحِ شکست

<div dir="rtl">

# فصل ۰۷ — طرحِ شکست

## در این فصل چه یاد می‌گیری

وسطِ ۶۰۰ درخواست، سرویسِ مدل می‌میرد و سیصد ثانیه بعد برمی‌گردد. **بدونِ هیچ تدبیری ۳۰۰ درخواست شکست می‌خورند و سرویس ۲۰۶ ثانیه از ترافیک عقب می‌افتد.**

بعد دو چیز اضافه می‌کنیم که هرکدام مسئلهٔ **متفاوتی** را حل می‌کنند. مسیرِ پشتیبان شکست‌ها را صفر می‌کند ولی انتظار را یک ثانیه هم کم نمی‌کند: **۶۱۵ ثانیه، همان‌طور که بود.** قطع‌کنندهٔ مدار همان انتظار را به **۴۱٫۹ ثانیه** می‌رساند و عقب‌افتادگی را به **صفر**.

![مداری با فیوز و یک مسیرِ کنارگذر](/lesson-assets/t4-s07-failure-design/prompt/01-image-breaker-bypass.png)

آخر این فصل می‌توانی:

- مسیرِ پشتیبان بسازی و **دقتش را اندازه بگیری**، نه اینکه فقط داشته باشی‌اش
- قطع‌کنندهٔ مدار با سه حالت بنویسی و بگویی هرکدام چه چیزی را می‌خرد
- تفاوتِ «نرخِ خطا» و «عقب‌افتادگی» را با عدد نشان بدهی
- «بدترین حالتِ قابلِ‌قبول» را قبل از حادثه تعریف کنی، نه وسطش

## قبل از شروع

**از فصلِ ۲:** مهلتِ زمانی، و اینکه کلاینتی که مهلتش تمام می‌شود معمولاً دوباره تلاش می‌کند. **از فصلِ ۴:** ساعتِ مجازی و عقب‌نشینی. **از فصلِ ۵:** `cache` — که خودش یکی از بهترین مسیرهای پشتیبان است، چون جوابِ دیروزِ همان سؤال را دارد.

> 📓 **نوت‌بوک:** [نوت‌بوک این فصل را در Colab باز کن](/notebooks/darbast/term-4-deployment/session-07-failure-design.ipynb) — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

</div>

| اجرا | زمانِ تقریبی |
|---|---|
| کلِ نوت‌بوک روی CPU | کمتر از یک دقیقه |
| GPU | لازم نیست |

<div dir="rtl">

## ۱. مسیرِ پشتیبان، و عددی که باید بدانی

وقتی مدل در دسترس نیست، سه جواب ممکن است: **خطا بده**، **جوابِ بدترِ ارزان بده**، یا **جوابِ کهنه از `cache` بده**. اینجا دومی را می‌سازیم: یک جدولِ کلمه که در حافظهٔ خودِ سرویس است و به هیچ شبکه‌ای نیاز ندارد.

</div>

```python
import random
from collections import Counter, defaultdict

model = fit_model(TRAIN[:800])
STREAM = random.Random(5).choices(TEST, k=600)
MODEL_SAYS = dict(zip([r["ticket_id"] for r in TEST],
                      model.predict([normalise(r["text"]) for r in TEST])))
TRUTH = {r["ticket_id"]: r["category"] for r in TEST}

votes = defaultdict(Counter)
for row in TRAIN[:800]:
    for word in sorted(set(normalise(row["text"]).split())):
        votes[word][row["category"]] += 1
WORD_OWNER = {w: c.most_common(1)[0][0] for w, c in sorted(votes.items())
              if sum(c.values()) >= 3}
DEFAULT = Counter(r["category"] for r in TRAIN[:800]).most_common(1)[0][0]


def rule_predict(text):
    """مسیرِ پشتیبان: یک جدولِ کلمه، بدونِ مدل و بدونِ شبکه."""
    seen = Counter(WORD_OWNER[w] for w in sorted(set(normalise(text).split()))
                   if w in WORD_OWNER)
    return seen.most_common(1)[0][0] if seen else DEFAULT


def accuracy(rows, fn):
    return sum(fn(r) == TRUTH[r["ticket_id"]] for r in rows) / len(rows)


print("اندازهٔ جدولِ کلمه:", len(WORD_OWNER))
print(f"دقتِ مدل روی جریان     : {accuracy(STREAM, lambda r: MODEL_SAYS[r['ticket_id']]):.4f}")
print(f"دقتِ مسیرِ پشتیبان      : {accuracy(STREAM, lambda r: rule_predict(r['text'])):.4f}")
print(f"دقتِ حدسِ همیشه‌یکسان    : {accuracy(STREAM, lambda r: DEFAULT):.4f}")
```

```text
اندازهٔ جدولِ کلمه: 269
دقتِ مدل روی جریان     : 0.8533
دقتِ مسیرِ پشتیبان      : 0.8200
دقتِ حدسِ همیشه‌یکسان    : 0.2717
```

<div dir="rtl">

**سه عدد، و عددِ وسط دو خبر با هم دارد.**

خبرِ اول: مسیرِ پشتیبان کار می‌کند — سه واحد بدتر از مدل و پنجاه‌وپنج واحد بهتر از حدس زدن. **این یعنی در روزِ بد سرویس هنوز مفید است.**

خبرِ دوم ناراحت‌کننده‌تر است و صادقانه می‌نویسیمش: **یک جدولِ کلمهٔ ده‌خطی به سه واحدیِ مدلی رسیده که یک ترمِ کامل رویش کار کرده‌ایم.** روی این پیکره، مدل خیلی بیشتر از خطِ پایه نمی‌فهمد. **این دقیقاً همان چیزی است که سرنخ ترمِ ۳ اسمش را «خطِ پایه» گذاشت**، و اگر در پروژهٔ خودت چنین چیزی دیدی، سؤالِ درست این نیست که «پشتیبانم چقدر خوب است»، این است که «مدلم چقدر لازم است».

**و مهم‌ترین قاعدهٔ این بخش:** مسیرِ پشتیبانی که اندازه نگرفته‌ای، یک وعده است نه یک طرح. **روزِ حادثه اولین چیزی که می‌پرسند این است: «الان جواب‌ها چقدر بد شده‌اند؟»** اگر عددش را از قبل نداشته باشی، جوابی نداری.

## ۲. قطع‌کنندهٔ مدار، در سه حالت

</div>

```python
class Clock:
    def __init__(self, start=0.0):
        self.t = float(start)

    def now(self):
        return self.t

    def advance(self, seconds):
        self.t += seconds
        return self.t

    def jump_to(self, moment):
        self.t = max(self.t, moment)
        return self.t


class Breaker:
    """بسته: همه‌چیز عادی. باز: اصلاً تماس نگیر. نیمه‌باز: فقط یک تماسِ آزمایشی."""

    def __init__(self, clock, threshold=5, cooldown=30.0):
        self.clock, self.threshold, self.cooldown = clock, threshold, cooldown
        self.state, self.failures, self.opened_at = "بسته", 0, 0.0
        self.probes = 0

    def allow(self):
        if self.state == "بسته":
            return True
        if self.clock.now() - self.opened_at >= self.cooldown:
            self.state = "نیمه‌باز"
            self.probes += 1
            return True
        return False

    def record(self, ok):
        if ok:
            self.state, self.failures = "بسته", 0
        else:
            self.failures += 1
            if self.state == "نیمه‌باز" or self.failures >= self.threshold:
                self.state, self.opened_at = "باز", self.clock.now()


demo_clock = Clock()
demo = Breaker(demo_clock)
for step in range(8):
    allowed = demo.allow()
    print(f"گام {step}: حالت={demo.state:<8} تماس مجاز؟ {str(allowed):<5}", end="")
    if allowed:
        demo.record(False)                          # هر تماس شکست می‌خورد
    print(" → حالت پس از تماس:", demo.state)
    demo_clock.advance(10.0)
```

```text
گام 0: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: بسته
گام 1: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: بسته
گام 2: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: بسته
گام 3: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: بسته
گام 4: حالت=بسته     تماس مجاز؟ True  → حالت پس از تماس: باز
گام 5: حالت=باز      تماس مجاز؟ False → حالت پس از تماس: باز
گام 6: حالت=باز      تماس مجاز؟ False → حالت پس از تماس: باز
گام 7: حالت=نیمه‌باز تماس مجاز؟ True  → حالت پس از تماس: باز
```

<div dir="rtl">

**سه حالت، و هرکدام یک تصمیم:**

- **بسته** — همه‌چیز عادی است، تماس بگیر. شکست‌های پیاپی شمرده می‌شوند.
- **باز** — سرویس مریض است، **اصلاً تماس نگیر**. هر تماس فقط دو ثانیه هدر می‌دهد و به سرویسی که دارد بلند می‌شود دوباره فشار می‌آورد.
- **نیمه‌باز** — بعد از یک مهلت، **دقیقاً یک** تماسِ آزمایشی. موفق شد؟ برگرد به بسته. شکست خورد؟ برگرد به باز و مهلت را از نو بشمار.

در خروجیِ بالا این را قدم‌به‌قدم می‌بینی: چهار شکستِ اول حالت را عوض نمی‌کنند، پنجمی قطع‌کننده را **باز** می‌کند، دو گام تماس اصلاً اجازه نمی‌گیرد، و در گامِ هفتم — سی ثانیهٔ مجازی بعد — یک تماسِ آزمایشی مجاز می‌شود که چون آن هم شکست می‌خورد، دوباره **باز** می‌شود.

**شمارنده روی شکست‌های «پیاپی» است، نه کل.** یک شکستِ تکی در دلِ صد تماسِ موفق طبیعی است؛ پنج شکستِ پشتِ سرِ هم یعنی چیزی واقعاً خراب است.

## ۳. سه حالت، یک قطعی

حالا قطعیِ واقعی: از درخواستِ ۲۰۰ تا ۵۰۰ سرویسِ مدل جواب نمی‌دهد و هر تماس دو ثانیه طول می‌کشد تا با مهلت تمام شود.

</div>

```python
DOWN = range(200, 500)
TIMEOUT, FAST, CHEAP = 2.0, 0.05, 0.001


def run(use_fallback, use_breaker, half_open=True):
    clock = Clock()
    breaker = Breaker(clock)
    if not half_open:
        breaker.cooldown = float("inf")
    served = failed = degraded = late = right = 0
    wait = 0.0
    for i, row in enumerate(STREAM):
        clock.jump_to(i * 1.0)                      # یک درخواست در هر ثانیه می‌رسد
        answer = None
        if not use_breaker or breaker.allow():
            if i in DOWN:
                clock.advance(TIMEOUT)
                wait += TIMEOUT
                if use_breaker:
                    breaker.record(False)
            else:
                clock.advance(FAST)
                wait += FAST
                answer = MODEL_SAYS[row["ticket_id"]]
                if use_breaker:
                    breaker.record(True)
        if answer is None:
            if not use_fallback:
                failed += 1
                continue
            clock.advance(CHEAP)
            wait += CHEAP
            answer = rule_predict(row["text"])
            degraded += 1
            if i >= DOWN.stop:
                late += 1
        served += 1
        right += answer == TRUTH[row["ticket_id"]]
    return {"served": served, "failed": failed, "degraded": degraded, "late": late,
            "wait": wait, "end": clock.now(), "acc": right / max(served, 1),
            "probes": breaker.probes}


plain = run(use_fallback=False, use_breaker=False)
fb = run(use_fallback=True, use_breaker=False)
both = run(use_fallback=True, use_breaker=True)
print(f"{'حالت':<26}{'سرو':>6}{'شکست':>7}{'پشتیبان':>9}{'انتظار':>10}{'دقت':>9}")
for name, r in (("بدونِ پشتیبان و قطع‌کننده", plain),
                ("فقط مسیرِ پشتیبان", fb),
                ("پشتیبان + قطع‌کنندهٔ مدار", both)):
    print(f"{name:<26}{r['served']:>6}{r['failed']:>7}{r['degraded']:>9}"
          f"{r['wait']:>9.1f}s{r['acc']:>9.4f}")
```

```text
حالت                         سرو   شکست  پشتیبان    انتظار      دقت
بدونِ پشتیبان و قطع‌کننده    300    300        0    615.0s   0.8133
فقط مسیرِ پشتیبان            600      0      300    615.3s   0.8283
پشتیبان + قطع‌کنندهٔ مدار    600      0      329     41.9s   0.8200
```

<div dir="rtl">

**دو ابزار، دو مسئلهٔ کاملاً متفاوت — و این مهم‌ترین جدولِ فصل است.**

**مسیرِ پشتیبان شکست را حل می‌کند:** ۳۰۰ شکست به صفر رسید و همهٔ ۶۰۰ درخواست جواب گرفتند. **ولی به ستونِ «انتظار» نگاه کن: ۶۱۵٫۳ ثانیه، تقریباً همان ۶۱۵ ثانیهٔ حالتِ اول.** چون هر درخواست **اول** دو ثانیه منتظرِ مدلِ مرده می‌ماند و **بعد** سراغِ پشتیبان می‌رود.

**قطع‌کننده انتظار را حل می‌کند:** ۴۱٫۹ ثانیه به‌جای ۶۱۵. چون بعد از پنج شکستِ اول دیگر اصلاً تماس نمی‌گیرد و مستقیم می‌رود سراغِ پشتیبان.

**و هیچ‌کدام جای دیگری را نمی‌گیرد.** قطع‌کننده بدونِ پشتیبان فقط سریع‌تر خطا می‌دهد؛ پشتیبان بدونِ قطع‌کننده جوابِ درست می‌دهد ولی سرویس را همان‌قدر کند نگه می‌دارد.

> ✅ **چک کن:** ستونِ «پشتیبان» در ردیفِ سوم ۳۲۹ است، نه ۳۰۰. **بیست‌ونه درخواستِ اضافه بعد از بهبودِ سرویس با مسیرِ پشتیبان جواب گرفتند** — چون قطع‌کننده هنوز باز بود و خبر نداشت که مدل برگشته. **قیمتِ ندانستن، همیشه در همین ستون پیدا می‌شود**؛ بخشِ ۵ دقیقاً دربارهٔ همین است.

## ۴. عقب‌افتادگی: عددی که در نرخِ خطا دیده نمی‌شود

</div>

```python
print(f"آخرین درخواست در ثانیهٔ {len(STREAM) - 1} رسید.")
print(f"  بدونِ قطع‌کننده: سرویس در ثانیهٔ {plain['end']:.0f} کارش تمام شد"
      f" — {plain['end'] - (len(STREAM) - 1):.0f} ثانیه عقب")
print(f"  با قطع‌کننده  : سرویس در ثانیهٔ {both['end']:.0f} کارش تمام شد"
      f" — {both['end'] - (len(STREAM) - 1):.0f} ثانیه عقب")
print("  تماس‌های آزمایشیِ قطع‌کننده:", both["probes"])
```

```text
آخرین درخواست در ثانیهٔ 599 رسید.
  بدونِ قطع‌کننده: سرویس در ثانیهٔ 805 کارش تمام شد — 206 ثانیه عقب
  با قطع‌کننده  : سرویس در ثانیهٔ 599 کارش تمام شد — 0 ثانیه عقب
  تماس‌های آزمایشیِ قطع‌کننده: 10
```

<div dir="rtl">

**۲۰۶ ثانیه عقب، در برابرِ صفر.**

درخواست‌ها هر ثانیه یکی می‌رسند و هرکدام دو ثانیه طول می‌کشد. **هر ثانیه یک ثانیه عقب‌تر می‌افتی، و این عقب‌افتادگی تا مدت‌ها بعد از پایانِ قطعی ادامه دارد.**

**این عدد در هیچ‌کدام از متریک‌های معمول دیده نمی‌شود.** نرخِ خطا در ردیفِ دوم صفر بود. `p95` هم فقط تأخیرِ درخواست‌هایی را می‌گوید که **جواب گرفته‌اند**. **عقب‌افتادگی چیزی است که باید جداگانه شمرده شود** — طولِ صف، یا اختلافِ زمانِ ورود و زمانِ پاسخ.

**و ده تماسِ آزمایشی، کلِ چیزی است که قطع‌کننده در سیصد ثانیه قطعی خرج کرد** — به‌جای سیصد تماسِ بی‌فایده.

> 📏 **اندازه بگیر:** **با چه چیزی مقایسه شد؟** با همان ۶۰۰ درخواست، همان قطعی و همان مدل؛ تنها متغیر داشتن یا نداشتنِ پشتیبان و قطع‌کننده بود. **روی کدام داده؟** یک جریانِ یکسان، ساخته‌شده با `Random(5)`. **با چند `seed`؟** یکی، **و اینجا `seed` فقط جریان را می‌سازد، نه نتیجه را**: قطعی در بازهٔ ثابتِ ۲۰۰ تا ۵۰۰ است و ساعت مجازی است، پس ۶۱۵٫۰ و ۴۱٫۹ روی هر ماشینی همان عددهایند. **اگر با `time.sleep` نوشته بودیمش، همین آزمایش ده دقیقه طول می‌کشید و هیچ‌کدام از عددها تکرارپذیر نبود.**

## ۵. نیمه‌باز: چطور بفهمی سرویس برگشته

قطع‌کننده‌ای که باز بماند و هیچ‌وقت امتحان نکند، خودش تبدیل به قطعی می‌شود. حالا همان اجرا را با مهلتِ بی‌نهایت — یعنی بدونِ حالتِ نیمه‌باز — مقایسه کنیم.

</div>

```python
stuck = run(use_fallback=True, use_breaker=True, half_open=False)
print("بعد از بهبودِ سرویس در درخواستِ", DOWN.stop, ":")
print("  با نیمه‌باز  : درخواست‌هایی که هنوز پشتیبان گرفتند:", both["late"])
print("  بدونِ نیمه‌باز:", stuck["late"])
```

```text
بعد از بهبودِ سرویس در درخواستِ 500 :
  با نیمه‌باز  : درخواست‌هایی که هنوز پشتیبان گرفتند: 29
  بدونِ نیمه‌باز: 100
```

<div dir="rtl">

**۲۹ در برابرِ ۱۰۰.** بدونِ نیمه‌باز، سرویس تا آخرِ عمرش جوابِ پشتیبان می‌دهد در حالی که مدل کاملاً سالم است.

عددِ ۲۹ هم اتفاقی نیست: مهلتِ ما ۳۰ ثانیه است، پس در بدترین حالت ۳۰ درخواست قبل از تماسِ آزمایشیِ بعدی می‌گذرند. **مهلت را کم کنی، سریع‌تر برمی‌گردی ولی به سرویسی که هنوز مریض است بیشتر فشار می‌آوری.** این همان معاملهٔ فصلِ ۴ است، این بار در جای دیگری.

## ۶. بدترین حالتِ قابلِ‌قبول

تا اینجا فرض کردیم جوابِ بدتر از هیچ جواب بهتر است. **این یک فرض است، نه یک حقیقت — و باید قبل از حادثه دربارهٔ آن تصمیم بگیری، نه وسطش.**

برای دسته‌بندیِ تیکتِ پشتیبانی، جوابِ بدتر بی‌ضرر است: تیکت به صفِ اشتباه می‌رود و یک نفر جابه‌جایش می‌کند. **برای تشخیصِ پزشکی یا تأییدِ تراکنشِ مالی، جوابِ بدترِ بی‌اعلام از هیچ جواب خطرناک‌تر است.**

</div>

| اگر مدل نیست… | کِی درست است | چه چیزی باید در پاسخ باشد |
|---|---|---|
| خطای صریح بده | تصمیم بدونِ مدل بی‌معناست | کدِ ۵۰۳ و `Retry-After` |
| جوابِ پشتیبان بده | جوابِ تقریبی هم مفید است | نشانه‌ای که می‌گوید پشتیبان بوده |
| جوابِ `cache` بده | کهنگیِ کوتاه بی‌ضرر است | سنِ جواب |
| صف کن و بعداً جواب بده | کاربر منتظر نیست | شناسهٔ کار (فصلِ ۴) |

<div dir="rtl">

**و در هر سه حالتِ اول، پاسخ باید صادق باشد.** اگر سرویس در حالتِ تخریب‌شده همان شکلِ پاسخِ همیشگی را بدهد، هیچ‌کس بالادست نمی‌فهمد که کیفیت افت کرده — نه کاربر، نه داشبورد، نه تیمی که فردا از روی همین جواب‌ها آمار می‌گیرد. **یک فیلدِ `degraded: true` کلِ هزینه‌اش یک کلید است.**

> 🔧 **اگر کار نکرد:** اگر قطع‌کننده‌ات باز شد و **هیچ‌وقت** بسته نشد، نگاه کن ببین `record(True)` را در مسیرِ موفق صدا می‌زنی یا نه — رایج‌ترین باگ این است که فقط شکست‌ها ثبت می‌شوند. و اگر برعکس **هرگز** باز نشد، `failures` را جایی صفر می‌کنی که نباید. یک راهِ سریعِ تشخیص: در هر گام `breaker.state` را چاپ کن؛ اگر رشتهٔ «باز» یک بار هم دیده نشد، شمارنده هرگز به آستانه نرسیده است.

> 🤖 **از دستیارت بپرس:** «`bulkhead` در طراحیِ مقاوم چیست و چه فرقی با `circuit breaker` دارد؟» جوابِ درست به «جدا کردنِ منابع تا یک وابستگیِ خراب همهٔ نخ‌ها را نگیرد» می‌رسد. بعد این را بپرس: **«اگر ده سرویسِ من همه به یک سرویسِ خراب وصل باشند و همه قطع‌کننده داشته باشند، آیا هنوز خطرِ فروریختنِ زنجیره‌ای هست؟»**

## واژه‌های تازهٔ این فصل

</div>

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| graceful degradation | گریسفول دگرادیشن | بدتر شدنِ کیفیت به‌جای از کار افتادنِ کامل |
| fallback | فال‌بک | مسیرِ ارزان‌تری که وقتی مسیرِ اصلی نیست جواب می‌دهد |
| circuit breaker | سرکیت بریکر | نگهبانی که بعد از چند شکستِ پیاپی تماس را قطع می‌کند |
| half-open | هاف-اوپن | حالتی که فقط یک تماسِ آزمایشی اجازه می‌دهد |
| backlog | بک‌لاگ | کارهایی که رسیده‌اند و هنوز نوبتشان نشده |
| blast radius | بلست ریدیس | دامنهٔ آسیبی که یک خرابی می‌تواند بزند |
| bulkhead | بالک‌هد | جدا کردنِ منابع تا خرابیِ یک بخش کلِ سامانه را نگیرد |

<div dir="rtl">

## تمرین‌ها

قبل از تمرین، بدونِ نگاه به بالا جواب بده: چرا مسیرِ پشتیبان به‌تنهایی ستونِ «انتظار» را تکان نداد؟

**تمرینِ اجباری:** `threshold` را ۲، ۵ و ۲۰ و `cooldown` را ۱۰، ۳۰ و ۱۲۰ بگذار و برای هر ترکیب **سه عدد** گزارش کن: انتظارِ کل، تعدادِ تماس‌های آزمایشی، و درخواست‌هایی که بعد از بهبود هنوز پشتیبان گرفتند. **جدولت را نگاه کن و جواب بده: کدام ترکیب برای سرویسی که قطعی‌های کوتاه و مکرر دارد مناسب است و کدام برای سرویسی که کم ولی طولانی می‌افتد؟**

**تمرینِ ستاره‌دار ⭐:** آستانه را از «پنج شکستِ پیاپی» به **«نرخِ خطا در پنجرهٔ اخیر»** تغییر بده — مثلاً «اگر بیش از نیمی از بیست تماسِ آخر شکست خورده باشند، باز شو». بعد یک قطعیِ **متناوب** بساز که در آن سرویس یکی‌درمیان جواب می‌دهد، و نشان بده کدام آستانه آن را می‌گیرد و کدام نمی‌گیرد. **و سؤالِ سخت: قطع‌کننده‌ات با پنجرهٔ لغزان در ثانیهٔ اولِ راه‌اندازیِ سرویس چه رفتاری دارد، وقتی هنوز بیست تماس اصلاً انجام نشده؟** — جوابت باید به «کمینهٔ نمونه» برسد، همان چیزی که فصلِ ۶ دربارهٔ دروازهٔ قناری گفت.

## در فصل بعد

سامانه‌ات حالا سریع است، ارزان است، و در روزِ بد هم جواب می‌دهد. **فصلِ بعد می‌پرسد چقدر خرج برمی‌دارد.** هزینهٔ هر درخواست را از روی **واحدهای شمرده‌شده** می‌سازیم — نه از روی قیمت‌هایی که فردا عوض می‌شوند — و روی یک منحنیِ بارِ بیست‌وچهارساعته می‌بینیم مقیاس‌پذیریِ افقی و عمودی هرکدام چند برابر ساعت‌ماشین می‌خواهند.

</div>

---
Source: https://yaadestan.com/courses/darbast/lessons/t4/s07-failure-design (یادستان, Yaadestan)
