Initial commit

Author: yakhyo

.github/workflows/pages.yml

@@ -0,0 +1,44 @@
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.3"
+          bundler-cache: true
+
+      - name: Build site
+        run: bundle exec jekyll build
+        env:
+          JEKYLL_ENV: production
+
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: _site
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

.gitignore

@@ -0,0 +1,30 @@
+# IDEs
+.idea/
+.vscode/
+
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.egg-info/
+dist/
+build/
+
+# Type-checking / linting caches
+.mypy_cache/
+.ruff_cache/
+
+# Environment
+.env
+.venv/
+venv/
+
+# Jekyll
+_site/
+.jekyll-cache/
+.jekyll-metadata
+Gemfile.lock
+
+# OS
+.DS_Store
+Thumbs.db

01-single-responsibility/README.md

@@ -0,0 +1,66 @@
+---
+layout: default
+title: "Single Responsibility"
+nav_order: 2
+permalink: /01-single-responsibility/
+---
+
+{: .note }
+> **Language:** **English** | [O'zbek]({{ site.baseurl }}/uz/01-single-responsibility/)
+
+# Single Responsibility Principle (SRP)
+
+> A class should have only one reason to change.
+
+Each class or module should encapsulate a **single responsibility**.
+When a class handles multiple concerns (e.g. business logic, persistence, formatting), a change in any one area forces the entire class to be modified and re-tested.
+
+## Diagram
+
+<p align="center">
+  <img src="{{ site.baseurl }}/assets/01-single-responsibility.png" width="700" alt="SRP class diagram" />
+</p>
+
+## Violation
+
+In [`violation.py`](violation.py) the `Order` class handles three unrelated responsibilities:
+
+- **Price calculation** — computing the order total
+- **Discount logic** — applying business discount rules
+- **Persistence** — saving the order to a database
+
+```python
+class Order:
+    def __init__(self, items: list[Item]) -> None:
+        self.items = items
+        self.total_price = self.calculate_total()
+        self.total_price = self.apply_discount(self.total_price)
+        self.save()
+```
+
+Any change to discount rules, pricing formulas, or storage backends forces modification of this single class.
+
+## Correct
+
+In [`correct.py`](correct.py) each responsibility is extracted into its own class:
+
+| Class | Responsibility |
+|-------|---------------|
+| `Order` | Holds order data |
+| `PriceCalculator` | Computes the total price |
+| `DiscountApplier` | Applies discount rules |
+| `OrderRepository` | Handles persistence |
+
+```python
+@dataclass
+class Order:
+    items: list[Item] = field(default_factory=list)
+    total_price: float = 0.0
+
+    def finalize(self) -> None:
+        self.total_price = PriceCalculator.total(self.items)
+        self.total_price = DiscountApplier.apply(self.total_price)
+        OrderRepository.save(self)
+```
+
+Now each class has exactly **one reason to change**, and they can be tested, extended, or replaced independently.

01-single-responsibility/README.uz.md

@@ -0,0 +1,66 @@
+---
+layout: default
+title: "Single Responsibility (UZ)"
+nav_exclude: true
+permalink: /uz/01-single-responsibility/
+---
+
+{: .note }
+> **Til:** [English]({{ site.baseurl }}/01-single-responsibility/) | **O'zbek**
+
+# Single Responsibility Principle (SRP)
+
+> Har bir class faqat **bitta o'zgarish sababiga** ega bo'lishi kerak.
+
+Har bir class yoki modul **bitta vazifani** bajarishi lozim.
+Agar bitta class bir nechta vazifani bajara boshlasa (masalan, biznes-logika, ma'lumotlarni saqlash, formatlash), ulardan birortasi o'zgarganda butun class'ni qayta yozish va test qilish kerak bo'ladi.
+
+## Diagramma
+
+<p align="center">
+  <img src="{{ site.baseurl }}/assets/01-single-responsibility.png" width="700" alt="SRP class diagramma" />
+</p>
+
+## Noto'g'ri yondashuv
+
+[`violation.py`](violation.py) dagi `Order` class'i uchta turli vazifani bajaradi:
+
+- **Narxni hisoblash** — buyurtma summasini hisoblash
+- **Chegirma** — biznes-qoidalari bo'yicha chegirma qo'llash
+- **Saqlash** — buyurtmani bazaga saqlash
+
+```python
+class Order:
+    def __init__(self, items: list[Item]) -> None:
+        self.items = items
+        self.total_price = self.calculate_total()
+        self.total_price = self.apply_discount(self.total_price)
+        self.save()
+```
+
+Chegirma qoidalari, narx formulasi yoki saqlash tizimi o'zgarganda — aynan shu bitta class'ni o'zgartirish kerak bo'ladi.
+
+## To'g'ri yondashuv
+
+[`correct.py`](correct.py) dagi har bir vazifa alohida class'ga ajratilgan:
+
+| Class | Vazifasi |
+|-------|----------|
+| `Order` | Buyurtma ma'lumotlarini saqlaydi |
+| `PriceCalculator` | Umumiy narxni hisoblaydi |
+| `DiscountApplier` | Chegirma qoidalarini qo'llaydi |
+| `OrderRepository` | Bazaga saqlash bilan shug'ullanadi |
+
+```python
+@dataclass
+class Order:
+    items: list[Item] = field(default_factory=list)
+    total_price: float = 0.0
+
+    def finalize(self) -> None:
+        self.total_price = PriceCalculator.total(self.items)
+        self.total_price = DiscountApplier.apply(self.total_price)
+        OrderRepository.save(self)
+```
+
+Endi har bir class'ning **faqat bitta o'zgarish sababi** bor va ularni mustaqil ravishda test qilish, kengaytirish yoki almashtirish mumkin.

01-single-responsibility/correct.py

@@ -0,0 +1,55 @@
+"""Single Responsibility Principle -- Correct.
+
+Each class has exactly one reason to change:
+  - Order:            holds order data
+  - PriceCalculator:  pricing logic
+  - DiscountApplier:  discount rules
+  - OrderRepository:  persistence
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Item:
+    name: str
+    price: float
+    quantity: int
+
+
+class PriceCalculator:
+    @staticmethod
+    def total(items: list[Item]) -> float:
+        return sum(item.price * item.quantity for item in items)
+
+
+class DiscountApplier:
+    @staticmethod
+    def apply(total: float) -> float:
+        if total > 200:
+            return total * 0.9
+        return total
+
+
+class OrderRepository:
+    @staticmethod
+    def save(order: "Order") -> None:
+        print(f"[DB] Saving order — total: ${order.total_price:.2f}")
+
+
+@dataclass
+class Order:
+    items: list[Item] = field(default_factory=list)
+    total_price: float = 0.0
+
+    def finalize(self) -> None:
+        self.total_price = PriceCalculator.total(self.items)
+        self.total_price = DiscountApplier.apply(self.total_price)
+        OrderRepository.save(self)
+
+
+if __name__ == "__main__":
+    items = [Item("Keyboard", 75.00, 1), Item("Mouse", 50.00, 3)]
+    order = Order(items=items)
+    order.finalize()
+    print(f"Order total: ${order.total_price:.2f}")

01-single-responsibility/violation.py

@@ -0,0 +1,46 @@
+"""Single Responsibility Principle -- Violation.
+
+The Order class below handles three unrelated concerns:
+  1. Price calculation
+  2. Discount logic
+  3. Database persistence
+
+Any change to the discount rules, the pricing formula, or the storage
+backend forces a modification to this single class.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Item:
+    name: str
+    price: float
+    quantity: int
+
+
+class Order:
+    """Violates SRP: one class, three reasons to change."""
+
+    def __init__(self, items: list[Item]) -> None:
+        self.items = items
+        self.total_price = self.calculate_total()
+        self.total_price = self.apply_discount(self.total_price)
+        self.save()
+
+    def calculate_total(self) -> float:
+        return sum(item.price * item.quantity for item in self.items)
+
+    def apply_discount(self, total: float) -> float:
+        if total > 200:
+            return total * 0.9
+        return total
+
+    def save(self) -> None:
+        print(f"[DB] Saving order — total: ${self.total_price:.2f}")
+
+
+if __name__ == "__main__":
+    items = [Item("Keyboard", 75.00, 1), Item("Mouse", 50.00, 3)]
+    order = Order(items)
+    print(f"Order total: ${order.total_price:.2f}")

02-open-closed/README.md

@@ -0,0 +1,60 @@
+---
+layout: default
+title: "Open/Closed"
+nav_order: 3
+permalink: /02-open-closed/
+---
+
+{: .note }
+> **Language:** **English** | [O'zbek]({{ site.baseurl }}/uz/02-open-closed/)
+
+# Open/Closed Principle (OCP)
+
+> Software entities should be **open for extension** but **closed for modification**.
+
+You should be able to add new behavior without editing existing, tested code.
+This is typically achieved through **inheritance** and **polymorphism**.
+
+## Diagram
+
+<p align="center">
+  <img src="{{ site.baseurl }}/assets/02-open-closed.png" width="700" alt="OCP class diagram" />
+</p>
+
+## Violation
+
+In [`violation.py`](violation.py) an `AreaCalculator` uses `isinstance` checks to handle each shape type:
+
+```python
+class AreaCalculator:
+    @staticmethod
+    def calculate(shape: object) -> float:
+        if isinstance(shape, Rectangle):
+            return shape.width * shape.height
+        if isinstance(shape, Circle):
+            return math.pi * shape.radius ** 2
+        raise TypeError(f"Unknown shape: {type(shape).__name__}")
+```
+
+Adding a `Triangle` requires modifying the existing `AreaCalculator` — it is **not closed for modification**.
+
+## Correct
+
+In [`correct.py`](correct.py) a `Shape` abstract base class defines the `area()` contract.
+Each shape implements its own calculation:
+
+```python
+class Shape(ABC):
+    @abstractmethod
+    def area(self) -> float: ...
+
+class Triangle(Shape):
+    def __init__(self, base: float, height: float) -> None:
+        self.base = base
+        self.height = height
+
+    def area(self) -> float:
+        return 0.5 * self.base * self.height
+```
+
+Adding a new shape is just a new subclass — **zero changes to existing code**.