30.16-dars: Polyglot arxitektura

30-QISM — PYTHON VA BOSHQA TILLAR · 16-dars

1. Kirish va motivatsiya

Butun 30-qism davomida turli integratsiyalarni ko'rdik: C/Rust/C++ kengaytmalari (tezlik), Go/gRPC (parallel xizmatlar), JavaScript (veb). Endi ularni bir manzaraga birlashtiramiz: polyglot arxitektura (ko'p tilli tizim) — bir tizimda bir necha tilni ongli ravishda birga ishlatish. Poliglot (ko'p til biluvchi) tizim har vazifaga to'g'ri tilni tanlaydi: Python (ML, ma'lumot, tez ishlab chiqish), Rust/C++ (CPU-og'ir yadro), Go (yuqori yuk parallel), JavaScript (frontend). Lekin bu kuch narx bilan keladi: murakkablik (har til uchun bilim, vositalar, integratsiya, deploy). Bu yakuniy dars polyglot arxitekturani qachon va qanday qo'llashni, integratsiya usullarini (kengaytma vs xizmat) tanlashni va eng muhimi — murakkablik narxini boshqarishni o'rgatadi. "Ko'p til — kuch, lekin mas'uliyat bilan."

Polyglot arxitektura — bir tizimda bir necha dasturlash tilini ongli ravishda birga ishlatish: to'g'ri til to'g'ri ishga (Python — ML/ma'lumot, Rust/C++ — yadro, Go — parallel, JS — frontend), integratsiya usullari (kengaytma — bir jarayon, xizmat — tarmoq, aloqa — JSON/gRPC), murakkablik narxi (har til — bilim, vosita, deploy — muvozanat kerak). Foydalanish: katta tizimlar, har vazifaga optimal til. Bu 30.1 (til birlashtirish) ning yakuni, butun 30-qism sintezi. Bu 30.1-15 (barcha darslar), 25-qism (mikroservis) bilan bog'liq. Polyglot — ko'p til, ongli. To'g'ri til to'g'ri ishga. Narx muvozanat.

Real vaziyat. Katta tizim (video platforma): Python (ML — tavsiya modellar, ma'lumot quvuri), Go (yuqori yuk API — million foydalanuvchi, goroutine 30.13), Rust (video kodlash yadro — CPU-og'ir, xavfsiz 30.9), JavaScript (frontend — brauzer 30.15). Har til o'z kuchida (to'g'ri til to'g'ri ishga — 30.1); ular tarmoq (gRPC 30.14) va kengaytma (PyO3 30.10) orqali birlashdi. Natija: har qism optimal (ML Python, yuk Go, kodlash Rust, UI JS). Lekin narx: 4 til bilim, 4 vosita to'plami, murakkab deploy. Jamoa bu narxni ongli boshqardi (faqat zarur joyga yangi til). Polyglot — kuch (optimal), lekin narx (murakkablik).

Bu darsda polyglot arxitekturani o'rganamiz.

Bu darsda:

• Polyglot arxitektura nima
• To'g'ri til to'g'ri ishga (30-qism sintezi)
• Integratsiya usullari (kengaytma vs xizmat)
• Murakkablik narxi
• Qachon polyglot (qachon yo'q)
• Polyglot amaliyoti
• 30-qism xulosasi
• Amaliy: polyglot qaror modeli

ℹ Polyglot tizim ko'p vosita talab qiladi; misollar arxitektura qaror mantiqini (deterministik) modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. Polyglot arxitektura nima

Ko'p tilli tizim:

POLYGLOT TIZIM (bir mahsulot):
   Python   — ML, ma'lumot, tez ishlab chiqish
   Rust     — CPU-og'ir yadro (xavfsiz, tez)
   Go       — yuqori yuk parallel xizmat
   JavaScript — frontend (brauzer)

   har til — o'z kuchida (ongli tanlov)
   integratsiya — kengaytma / xizmat / aloqa

Polyglot arxitektura — bir tizimda bir necha dasturlash tilini ongli ravishda birga ishlatish (poliglot — ko'p til biluvchi): har vazifaga to'g'ri til tanlanadi (Python — ML, Rust — yadro, Go — parallel, JS — frontend). Sabab: hech bir til hamma ishda eng yaxshi emas (30.13 — "eng yaxshi til" noto'g'ri savol); har til o'z sohasida kuchli; polyglot har qismga optimal til beradi. Lekin ongli (tasodifiy emas — sabab bilan): har yangi til narx (murakkablik — 2.4). Bu 30-qism g'oyasi (til birlashtirish — 30.1) ning to'liq ko'rinishi. Polyglot — ko'p til, ongli tanlov. To'g'ri til to'g'ri ishga. Narx bilan.

2.2. To'g'ri til to'g'ri ishga (sintez)

Har til o'z kuchida:

Vazifa                    →  To'g'ri til
   ML / ma'lumot / tez PoC    Python (ekotizim, oson)
   CPU-og'ir yadro            Rust / C++ (tez, xavfsiz)
   yuqori yuk parallel        Go (goroutine, GIL'siz)
   frontend (brauzer)         JavaScript (majburiy)
   mavjud C++ kutubxona       pybind11 (o'rash)

To'g'ri til to'g'ri ishga (30-qism sintezi) — polyglot'ning asosiy tamoyili: har vazifaga eng mos til tanlash: Python (ML, ma'lumot, tez ishlab chiqish — ekotizim, oson), Rust/C++ (CPU-og'ir yadro — tez, Rust xavfsiz 30.9), Go (yuqori yuk parallel — goroutine, GIL'siz 30.13), JavaScript (frontend — majburiy 30.15), pybind11/PyO3 (mavjud C++/yangi Rust o'rash). Sabab: har til savdolar bilan qurilgan (30.13 — kuch + kamchilik); vazifaga mos tilni tanlash har ikki kuchdan foydalanadi (Python qulaylik + Rust tezlik). Bu 30.1 (birlashtirish) ning amaliy qoidasi. To'g'ri til to'g'ri ishga — vazifaga mos til. Kuchdan foydalanish. Sintez.

2.3. Integratsiya usullari (kengaytma vs xizmat)

Ikki asosiy yo'l:

KENGAYTMA (bir jarayon):
   C/Rust/C++/Cython — Python ichida (import)
   30.3-12 · funksiya chaqiruv (tez, mahalliy)
   → CPU-og'ir tezlashtirish

XIZMAT (alohida jarayon, tarmoq):
   Go/boshqa — alohida xizmat (gRPC/REST/JSON)
   30.13-15 · tarmoq so'rov (mustaqil, miqyoslanadi)
   → yuqori yuk, alohida deploy

Integratsiya usullari — polyglot'da tillar qanday birlashadi, ikki asosiy: kengaytma (bir jarayon — C/Rust/C++/Cython Python ichida, import, funksiya chaqiruv — 30.3-12, CPU-og'ir tezlashtirish, mahalliy tez), xizmat (alohida jarayon — Go/boshqa, tarmoq gRPC/REST — 30.13-15, mustaqil, miqyoslanadi, alohida deploy). Sabab: tezlik kerak bo'lsa kengaytma (bir jarayon — funksiya chaqiruv tez), miqyos/mustaqillik kerak bo'lsa xizmat (tarmoq — alohida deploy). Farq: kengaytma ichki (bir dastur), xizmat tashqi (alohida). Tanlov: CPU funksiya (kengaytma), yuqori yuk qism (xizmat). Integratsiya — kengaytma (bir jarayon) vs xizmat (tarmoq). Tezlik vs mustaqillik.

2.4. Murakkablik narxi

Har til narx qo'shadi:

Har yangi til narxi:
   BILIM — jamoa o'rganishi (vaqt)
   VOSITALAR — kompilyator, paket menejeri, IDE
   INTEGRATSIYA — aloqa qatlami (gRPC, kengaytma)
   DEPLOY — har til deploy quvuri
   DEBUG — ko'p til bo'ylab (qiyin)
   ISHGA OLISH — har tilga dasturchi

→ har til FOYDA berishi kerak (narxdan ko'p)

Murakkablik narxi — polyglot'ning asosiy jiddiy tomoni: har yangi til narx qo'shadi — bilim (jamoa o'rganishi — vaqt), vositalar (kompilyator, paket menejeri), integratsiya (aloqa qatlami — gRPC/kengaytma), deploy (har til quvuri), debug (ko'p til bo'ylab — qiyin), ishga olish (har tilga dasturchi). Sabab: ko'p til = ko'p murakkablik (chiziqli emas — har til qo'shadi, integratsiya ham); bu narx (doimiy — saqlash, o'rganish). Qoida: har yangi til foyda berishi kerak (narxdan ko'p — 29.1 o'lcha, arziydimi). Aks holda: ortiqcha til (murakkablik, foydasiz). Bu polyglot'ning muvozanatI (kuch vs narx). Murakkablik narxi — bilim, vosita, deploy, debug. Har til foyda bersin. Muvozanat.

2.5. Qachon polyglot (qachon yo'q)

Qachon polyglot: (1) aniq ehtiyoj — bir til yetmaganda (Python sekin — CPU yadro Rust, yuqori yuk Go); (2) katta tizim — har qism farqli talab (ML, yuk, frontend); (3) mavjud kod — boshqa tildagi kutubxona (C++ — pybind11 o'rash); (4) foyda > narx — yangi til aniq afzallik (o'lchangan). Qachon yo'q: (1) kichik loyiha — bir til yetadi (murakkablik ortiqcha); (2) "qiziqarli" uchun — yangi til shunchaki (sabab yo'q — narx); (3) noaniq foyda — afzallik aniq emas (o'lchamagan); (4) jamoa kichik — ko'p til boshqarib bo'lmaydi. Qoida: polyglot oxirgi chora (bir til yetmaganda — aniq sabab), oddiy boshla (bir til, keyin zarurat). Qachon — aniq ehtiyoj, foyda > narx. Qachon yo'q — kichik, sababsiz. Oddiy boshla.

2.6. Polyglot amaliyoti

Polyglot amaliyotlari: oddiy boshla (bir til — Python, keyin zarurat bo'lsa qo'sh); o'lcha (29.1 — bottleneck aniqla, keyin til tanla); to'g'ri til to'g'ri joyga (2.2 — vazifaga mos); integratsiya tanla (2.3 — tezlik kengaytma, miqyos xizmat); chegarani aniq (til orasi — API/shartnoma, 30.14 .proto); narxni hisobla (2.4 — foyda > narx); jamoa imkoniyati (har tilga bilim). Tuzoqlar: erta polyglot (aniq ehtiyoj yo'q — murakkablik), ko'p til (boshqarib bo'lmaydi), integratsiya murakkabligi (tarmoq — kechikish, xato), sababsiz til ("qiziq"). Amaliyot — oddiy boshla, o'lcha, to'g'ri til, narxni hisobla. Polyglot — ongli, muvozanatli.

2.7. 30-qism xulosasi

30-qism xulosasi (til integratsiyasi): nega ko'p til (30.1-2 — hech bir til hamma ishda yaxshi emas, subprocess); C oilasi (30.3-6 — ctypes, cffi, C API, C kengaytma — Python'ni C bilan tezlashtirish); Cython (30.7-8 — Python'ga o'xshash, C ga kompilyatsiya, eng amaliy tezlashtirish); Rust (30.9-11 — tez+xavfsiz, PyO3, maturin — zamonaviy yadro); C++ (30.12 — pybind11, mavjud C++ o'rash); Go/gRPC (30.13-14 — parallel xizmat, tez aloqa); JavaScript (30.15 — veb majburiy); polyglot (30.16 — ongli ko'p til, narx muvozanat). Asosiy saboq: to'g'ri til to'g'ri ishga (har til o'z kuchida), lekin ongli (murakkablik narxi — foyda > narx). Python markazda (qulaylik), boshqa tillar zarur joyga (tezlik, miqyos, frontend). 30-qism — Python ko'p til dunyosida. Integratsiya — kuch, mas'uliyat bilan.

2.8. Polyglot — kuch va mas'uliyat muvozanati

Polyglot arxitektura asosiy g'oyasi — kuch va mas'uliyat muvozanati: ko'p til kuch beradi (har vazifaga optimal — Python ML, Rust yadro, Go yuk, JS frontend), lekin mas'uliyat talab qiladi (murakkablik narxi — bilim, vosita, integratsiya, deploy). Donolik — bu muvozanatni ongli boshqarish: oddiy boshla (bir til — kamroq murakkablik), zarurat bilan qo'sh (o'lchangan ehtiyoj — 29.1, foyda > narx), to'g'ri til to'g'ri joyga (30.1 — kuchdan foydalanish), chegarani aniq (shartnoma — 30.14). Bu butun 30-qism (til integratsiyasi) ning sintezi va 27-qism (arxitektura — soddalik, muvozanat) bilan bog'liq. Polyglot noto'g'ri — ortiqcha murakkablik (sababsiz til); to'g'ri — optimal tizim (har qism eng yaxshi til, boshqarilgan narx). "Ko'p til — kuch, lekin mas'uliyat bilan." Polyglot — kuch (optimal) + mas'uliyat (narx). Ongli muvozanat. 30-qism yakuni.

3. Tez ma'lumotnoma

POLYGLOT ARXITEKTURA — ongli ko'p tilli tizim

TO'G'RI TIL TO'G'RI ISHGA:
   Python — ML, ma'lumot, tez ishlab chiqish
   Rust/C++ — CPU-og'ir yadro (tez, Rust xavfsiz)
   Go — yuqori yuk parallel (goroutine)
   JavaScript — frontend (brauzer, majburiy)

INTEGRATSIYA USULLARI:
   kengaytma (bir jarayon) — C/Rust/Cython (import, tez)
   xizmat (tarmoq) — Go/gRPC/REST (mustaqil, miqyos)

MURAKKABLIK NARXI (har til):
   bilim · vositalar · integratsiya · deploy · debug
   → har til foyda berishi kerak (narxdan ko'p)

QACHON:
   polyglot ← aniq ehtiyoj, foyda > narx, katta tizim
   yo'q ← kichik loyiha, sababsiz, noaniq foyda

QOIDA: oddiy boshla · o'lcha · to'g'ri til · narxni hisobla

Polyglot xulosasi

Polyglot — bir tizimda ongli ko'p til (to'g'ri til to'g'ri ishga)
Integratsiya — kengaytma (bir jarayon) vs xizmat (tarmoq)
Murakkablik narxi — bilim/vosita/deploy (foyda > narx)
Qachon — aniq ehtiyoj (kichik/sababsiz — yo'q, oddiy boshla)
Kuch (optimal) + mas'uliyat (narx) — ongli muvozanat

4. Batafsil misollar

Polyglot tizim ko'p vosita talab qiladi; misollar arxitektura qaror mantiqini (deterministik) modellashtiradi.

Misol 1 — To'g'ri til to'g'ri ishga

"""To'g'ri til: vazifaga mos tilni tanlash (model)."""


VAZIFA_TIL = {
    "ML / data": "Python (ekotizim)",
    "CPU-og'ir yadro": "Rust / C++ (tez, xavfsiz)",
    "yuqori yuk parallel": "Go (goroutine)",
    "frontend (brauzer)": "JavaScript (majburiy)",
}


def til_tanla(vazifa: str) -> str:
    return VAZIFA_TIL.get(vazifa, "Python (standart)")


def main() -> None:
    print("=== 1. Vazifa → til ===")
    for vazifa, til in VAZIFA_TIL.items():
        print(f"  {vazifa:22} → {til}")

    print("\n=== 2. ML vazifa ===")
    print(f"  {til_tanla('ML / data')}")

    print("\n=== 3. Yuqori yuk ===")
    print(f"  {til_tanla('yuqori yuk parallel')}")

    print("\n=== 4. Tamoyil ===")
    print("  har til o'z kuchida (savdolar bilan)")
    print("  ⭐ To'g'ri til to'g'ri ishga (kuchdan foydalanish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Vazifa → til ===
  ML / data              → Python (ekotizim)
  CPU-og'ir yadro        → Rust / C++ (tez, xavfsiz)
  yuqori yuk parallel    → Go (goroutine)
  frontend (brauzer)     → JavaScript (majburiy)

=== 2. ML vazifa ===
  Python (ekotizim)

=== 3. Yuqori yuk ===
  Go (goroutine)

=== 4. Tamoyil ===
  har til o'z kuchida (savdolar bilan)
  ⭐ To'g'ri til to'g'ri ishga (kuchdan foydalanish)

Nima ko'rsatdi: 2.1, 2.2-bo'limlar.

Misol 2 — Integratsiya usuli tanlovi

"""Integratsiya: kengaytma vs xizmat tanlovi (model)."""


def integratsiya_tanla(ehtiyoj: str) -> dict:
    if "CPU" in ehtiyoj or "tezlashtirish" in ehtiyoj:
        return {"usul": "kengaytma", "misol": "Cython/Rust (bir jarayon)"}
    else:  # miqyos, mustaqil
        return {"usul": "xizmat", "misol": "Go/gRPC (tarmoq)"}


def main() -> None:
    print("=== 1. CPU-og'ir funksiya ===")
    k = integratsiya_tanla("CPU-og'ir tezlashtirish")
    print(f"  usul: {k['usul']} ({k['misol']})")

    print("\n=== 2. Yuqori yuk qism ===")
    x = integratsiya_tanla("yuqori yuk mustaqil miqyos")
    print(f"  usul: {x['usul']} ({x['misol']})")

    print("\n=== 3. Farq ===")
    print("  kengaytma — ichki (bir jarayon, tez chaqiruv)")
    print("  xizmat — tashqi (tarmoq, mustaqil deploy)")

    print("\n=== 4. Tanlov ===")
    print("  tezlik → kengaytma, miqyos → xizmat")
    print("  ⭐ Integratsiya — kengaytma vs xizmat")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. CPU-og'ir funksiya ===
  usul: kengaytma (Cython/Rust (bir jarayon))

=== 2. Yuqori yuk qism ===
  usul: xizmat (Go/gRPC (tarmoq))

=== 3. Farq ===
  kengaytma — ichki (bir jarayon, tez chaqiruv)
  xizmat — tashqi (tarmoq, mustaqil deploy)

=== 4. Tanlov ===
  tezlik → kengaytma, miqyos → xizmat
  ⭐ Integratsiya — kengaytma vs xizmat

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Murakkablik narxi (foyda vs narx)

"""Murakkablik narxi: yangi til foyda vs narx (model)."""


def til_qarori(foyda: int, narx: int) -> dict:
    # foyda va narx (1-10 shartli)
    arziydi = foyda > narx
    return {"foyda": foyda, "narx": narx, "arziydi": arziydi}


def main() -> None:
    print("=== 1. Rust (CPU yadro — aniq foyda) ===")
    r = til_qarori(foyda=9, narx=5)
    print(f"  foyda: {r['foyda']}, narx: {r['narx']} → arziydi: {r['arziydi']}")

    print("\n=== 2. Yangi til (sababsiz — kam foyda) ===")
    y = til_qarori(foyda=2, narx=6)
    print(f"  foyda: {y['foyda']}, narx: {y['narx']} → arziydi: {y['arziydi']}")

    print("\n=== 3. Narx tarkibi ===")
    print("  bilim + vosita + integratsiya + deploy + debug")

    print("\n=== 4. Qoida ===")
    print("  har til: foyda > narx (o'lchangan)")
    print("  ⭐ Murakkablik narxi — foyda narxdan ko'p bo'lsin")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Rust (CPU yadro — aniq foyda) ===
  foyda: 9, narx: 5 → arziydi: True

=== 2. Yangi til (sababsiz — kam foyda) ===
  foyda: 2, narx: 6 → arziydi: False

=== 3. Narx tarkibi ===
  bilim + vosita + integratsiya + deploy + debug

=== 4. Qoida ===
  har til: foyda > narx (o'lchangan)
  ⭐ Murakkablik narxi — foyda narxdan ko'p bo'lsin

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Qachon polyglot (qaror)

"""Qachon polyglot: qaror mezonlari (model)."""


def polyglot_qaror(mezonlar: dict) -> str:
    ball = sum(mezonlar.values())
    if ball >= 3:
        return "polyglot (aniq ehtiyoj)"
    return "bir til (oddiy boshla)"


def main() -> None:
    katta_tizim = {"aniq_ehtiyoj": 1, "katta_tizim": 1, "foyda_kop": 1, "jamoa_katta": 1}
    kichik = {"aniq_ehtiyoj": 0, "katta_tizim": 0, "foyda_kop": 0, "jamoa_katta": 1}

    print("=== 1. Katta tizim ===")
    print(f"  mezonlar: {sum(katta_tizim.values())}/4")
    print(f"  qaror: {polyglot_qaror(katta_tizim)}")

    print("\n=== 2. Kichik loyiha ===")
    print(f"  mezonlar: {sum(kichik.values())}/4")
    print(f"  qaror: {polyglot_qaror(kichik)}")

    print("\n=== 3. Qoida ===")
    print("  polyglot — oxirgi chora (bir til yetmaganda)")

    print("\n=== 4. Boshlanish ===")
    print("  oddiy boshla, zarurat bilan qo'sh")
    print("  ⭐ Qachon polyglot — aniq ehtiyoj, foyda > narx")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Katta tizim ===
  mezonlar: 4/4
  qaror: polyglot (aniq ehtiyoj)

=== 2. Kichik loyiha ===
  mezonlar: 1/4
  qaror: bir til (oddiy boshla)

=== 3. Qoida ===
  polyglot — oxirgi chora (bir til yetmaganda)

=== 4. Boshlanish ===
  oddiy boshla, zarurat bilan qo'sh
  ⭐ Qachon polyglot — aniq ehtiyoj, foyda > narx

Nima ko'rsatdi: 2.5-bo'lim.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. Erta polyglot (aniq ehtiyojsiz)

# boshidan 4 til (murakkablik, ehtiyoj yo'q)                  # ⚠️
# oddiy boshla (Python), zarurat bilan qo'sh                   # ✅

2. Sababsiz til ("qiziq")

# yangi til shunchaki qiziqish uchun                          # ⚠️
# foyda > narx (o'lchangan sabab)                              # ✅

3. Narxni hisobga olmaslik

# yangi til qo'shildi, narx (deploy, bilim) unutildi          # ⚠️
# narxni hisobla (bilim, vosita, integratsiya)                # ✅

4. Noto'g'ri integratsiya (tezlikka xizmat)

# CPU funksiyaga alohida xizmat (tarmoq kechikish)            # ⚠️
# CPU → kengaytma (bir jarayon, tez)                           # ✅

5. Chegara noaniq (shartnomasiz)

# tillar orasi shartnomasiz (mos kelmaslik)                   # ⚠️
# .proto / API shartnoma 30.14-bob                               # ✅

6. O'lchamasdan til tanlash

# taxmin bilan til (bottleneck bilinmagan)                    # ⚠️
# o'lcha 29.1-bob, keyin til/integratsiya                        # ✅

7. Ko'p til (boshqarib bo'lmaydi)

# kichik jamoa 5 til (imkonsiz saqlash)                       # ⚠️
# jamoa imkoniyati (kam til, chuqur bilim)                     # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 30.1-15-darslar (o'tilgan): Butun 30-qism sintezi
• 27-qism (o'tilgan): Arxitektura — soddalik, muvozanat
• 25-qism (o'tilgan): Mikroservis — xizmat integratsiya
• 29.1-dars (o'tilgan): Profil — o'lchab til tanlash
• 31-qism (keyingi): Karyera — polyglot loyihalar

8. Eng yaxshi amaliyotlar

1. Oddiy boshla (bir til), zarurat bilan qo'sh.

2. O'lcha 29.1-bob, keyin til/integratsiya tanla.

3. To'g'ri til to'g'ri ishga (kuchdan foydalanish).

4. Integratsiya: tezlik → kengaytma, miqyos → xizmat.

5. Narxni hisobla (foyda > narx).

6. Chegara aniq (shartnoma — 30.14).

7. Jamoa imkoniyati (kam til, chuqur bilim).

8. Polyglot — ongli muvozanat (kuch + mas'uliyat).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # polyglot arxitektura nima?
2.  # to'g'ri til to'g'ri ishga?
3.  # ML uchun til?
4.  # CPU yadro uchun?
5.  # yuqori yuk uchun?
6.  # frontend uchun?
7.  # integratsiya usullari?
8.  # kengaytma vs xizmat?
9.  # murakkablik narxi?
10. # qachon polyglot?
11. # qachon yo'q?
12. # asosiy qoida?

Vazifa 2: Xatolarni tuzating

1.  # boshidan 4 til

2.  # yangi til "qiziq" uchun

3.  # CPU funksiyaga alohida xizmat

4.  # tillar orasi shartnomasiz

5.  # taxmin bilan til

1.  oddiy boshla, zarurat bilan

2.  foyda > narx (sabab)

3.  CPU → kengaytma (bir jarayon)

4.  .proto / API shartnoma

5.  o'lcha 29.1-bob, keyin til

Vazifa 3: To'g'ri til

Modellang:

1. Vazifa
2. Til
3. Kuch
4. Tanlov

Vazifa 4: Integratsiya

Modellang:

1. Kengaytma
2. Xizmat
3. Tezlik/miqyos
4. Tanlov

Vazifa 5: Narx

Modellang:

1. Foyda
2. Narx
3. Arziydi
4. Qoida

Vazifa 6: Qachon

Modellang:

1. Mezonlar
2. Katta tizim
3. Kichik
4. Boshlanish

Vazifa 7: O'ylash

Polyglot arxitektura "ko'p til — kuch, lekin mas'uliyat bilan" — har til foyda beradi, lekin murakkablik narxi bilan; donolik bu muvozanatni ongli boshqarish. Nima uchun deyarli har muhandislik qarori "savdo" (trade-off) — bepul yutuq yo'q, va nega "murakkablikni boshqarish" (uni yo'q qilish emas) tajribali muhandisning eng muhim mahorati? Butun 30-qism qanday shu tamoyilni ko'rsatadi?

Nimani mustahkamlaydi: 2.4, 2.8-bo'limlar.

Xulosa

Bu darsda polyglot arxitekturani o'rgandik va 30-qismni yakunladik.

Eng muhim uch fikr:

1. Polyglot va to'g'ri til to'g'ri ishga. Polyglot arxitektura — bir tizimda bir necha dasturlash tilini ongli ravishda birga ishlatish: har vazifaga to'g'ri til (Python — ML/ma'lumot, Rust/C++ — CPU yadro, Go — yuqori yuk parallel, JavaScript — frontend); hech bir til hamma ishda eng yaxshi emas, har til o'z sohasida kuchli. To'g'ri til to'g'ri ishga (30-qism sintezi) — har vazifaga mos til (har til savdolar bilan — kuch + kamchilik); vazifaga mos tilni tanlash har ikki kuchdan foydalanadi (Python qulaylik + Rust tezlik).

2. Integratsiya usullari va murakkablik narxi. Integratsiya usullari — tillar qanday birlashadi: kengaytma (bir jarayon — C/Rust/Cython Python ichida, import, funksiya chaqiruv — CPU-og'ir tezlashtirish, mahalliy tez), xizmat (alohida jarayon — Go/gRPC/REST, tarmoq, mustaqil, miqyoslanadi, alohida deploy); tezlik → kengaytma, miqyos/mustaqillik → xizmat. Murakkablik narxi — har yangi til narx qo'shadi (bilim, vositalar, integratsiya, deploy, debug, ishga olish); qoida — har til foyda berishi kerak (narxdan ko'p — o'lchangan); polyglot muvozanat (kuch vs narx).

3. Qachon polyglot va kuch-mas'uliyat muvozanati. Qachon polyglot: aniq ehtiyoj (bir til yetmagan), katta tizim, mavjud kod, foyda > narx; qachon yo'q: kichik loyiha, sababsiz, noaniq foyda, kichik jamoa; qoida — oddiy boshla (bir til, zarurat bilan qo'sh). 30-qism xulosasi: nega ko'p til (30.1-2), C oilasi (30.3-6), Cython (30.7-8), Rust (30.9-11), C++ 30.12-bob, Go/gRPC (30.13-14), JavaScript 30.15-bob, polyglot 30.16-bob. Polyglot — kuch va mas'uliyat muvozanati: ko'p til kuch (optimal), lekin mas'uliyat (murakkablik narxi); donolik — ongli boshqarish (oddiy boshla, zarurat bilan, to'g'ri til, chegara aniq). Har muhandislik qarori savdo (bepul yutuq yo'q); murakkablik boshqariladi (yo'q qilinmaydi — 27-qism). "Ko'p til — kuch, lekin mas'uliyat bilan."

30-QISM YAKUNLANDI. Python ko'p til dunyosida — ctypes/cffi/C API/C kengaytma (C bilan tezlik), Cython (amaliy tezlashtirish), Rust/PyO3/maturin (tez+xavfsiz yadro), pybind11 (C++ o'rash), Go/gRPC (parallel xizmat, tez aloqa), JavaScript (veb), polyglot (ongli ko'p til). Asosiy saboq: to'g'ri til to'g'ri ishga, murakkablik narxini ongli boshqarib.

Keyingi (31-)qismda Karyera va katta loyihalar ni o'rganamiz: bilimlarni real loyihalarga tatbiq etish — CLI vosita (PyPI'ga), REST API (baza + auth), ETL quvuri, mikroservisli tizim, Git/jamoa ishi, kod review, ochiq kodga hissa, portfolio, rezyume va texnik intervyu tayyorgarligi.