Путь к Team Lead: Python-разработка и управление

Фундамент: углубленный Python, принципы ООП и паттерны проектирования

Приветствую на курсе. Твоя цель — стать Team Lead в кратчайшие сроки. Это амбициозная задача, требующая смены мышления. Если Junior думает «как заставить это работать», то Team Lead думает «как это будет жить, масштабироваться и поддерживаться через год».

В этой статье мы укрепим твой технический фундамент. Мы не будем учить синтаксис if-else, мы разберем то, на чем сыпятся на собеседованиях и в архитектуре реальных проектов.

Углубленный Python: что под капотом?

Чтобы управлять командой Python-разработчиков, ты должен понимать язык глубже, чем просто написание скриптов. Ошибки в понимании работы памяти и структур данных приводят к «плавающим» багам, которые убивают недели разработки.

Управление памятью и изменяемость

В Python все является объектом. Но ключевое различие, которое ты обязан помнить, — это mutable (изменяемые) и immutable (неизменяемые) типы данных.

• Immutable: int, float, str, tuple, frozenset. При попытке изменения создается новый объект.
• Mutable: list, dict, set, пользовательские классы. Изменяются in-place (на месте).

Классическая ловушка, которую ты будешь ловить на код-ревью у своих джунов — изменяемые аргументы по умолчанию.

# ПЛОХО: список создается один раз при определении функции
def add_item(item, items=[]):
    items.append(item)
    return items

# ХОРОШО: список создается каждый раз при вызове
def add_item_correct(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

Алгоритмическая сложность структур данных

Тимлид отвечает за производительность. Ты должен интуитивно понимать, когда использовать list, а когда set. Это описывается через «O-большое».

Поиск элемента в списке (list) выполняется перебором, поэтому его сложность:

$$O(n)$$

где $n$ — количество элементов в списке, а $O$ — верхняя граница времени выполнения. Чем больше список, тем дольше поиск.

Поиск в хеш-таблице (set или dict) работает иначе:

$$O(1)$$

где $1$ означает константное время. Время поиска практически не зависит от количества элементов (при отсутствии коллизий).

«Преждевременная оптимизация — корень всех зол, но выбор неправильной структуры данных — это не оптимизация, а ошибка проектирования».

Объектно-Ориентированное Программирование (ООП)

Ты наверняка знаешь про инкапсуляцию, наследование и полиморфизм. Давай копнем глубже, туда, где возникают реальные проблемы архитектуры.

MRO (Method Resolution Order)

В Python поддерживается множественное наследование. Главная проблема здесь — «Ромбовидное наследование» (Diamond Problem). Как Python понимает, чей метод вызывать, если класс наследуется от двух родителей, имеющих общего предка?

Python использует алгоритм линеаризации C3. Ты можешь посмотреть порядок разрешения методов через атрибут __mro__.

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

Важно: Если ты строишь сложную иерархию наследования, ты, скорее всего, делаешь что-то не так. Предпочитай композицию наследованию.

SOLID принципы

Это библия для проектирования гибких систем. Как Тимлид, ты будешь использовать их для аргументации на код-ревью.

1. S — SRP (Single Responsibility Principle): У класса должна быть только одна причина для изменения. Не смешивай логику сохранения в БД и отправку email в одном классе.
2. O — OCP (Open/Closed Principle): Программные сущности должны быть открыты для расширения, но закрыты для модификации. Используй наследование или стратегии, чтобы менять поведение, не переписывая старый код.
3. L — LSP (Liskov Substitution Principle): Наследники должны безболезненно заменять родителей. Если ты наследуешься от класса Bird, но твой Penguin кидает ошибку в методе fly(), ты нарушил LSP.
4. I — ISP (Interface Segregation Principle): Много специализированных интерфейсов лучше, чем один универсальный. В Python это реализуется через абстрактные базовые классы (abc).
5. D — DIP (Dependency Inversion Principle): Зависимости должны строиться на абстракциях, а не на деталях. Модули верхних уровней не должны зависеть от модулей нижних уровней.

Паттерны проектирования

Не нужно зубрить все 23 паттерна GoF. В Python многие из них встроены в язык (например, Итератор или Декоратор). Но есть те, которые критически важны для структуры backend-приложений.

Singleton (Одиночка)

Гарантирует, что у класса есть только один экземпляр. Часто используется для подключений к БД или логгеров.

Нюанс Python: Модуль в Python — это уже Singleton. Если тебе нужен глобальный объект, просто создай его в модуле и импортируй.

Factory Method (Фабричный метод)

Позволяет создавать объекты, не указывая точный класс создаваемого объекта. Полезно, когда логика создания сложная или зависит от конфигурации.

Strategy (Стратегия)

Позволяет выбирать алгоритм поведения на лету. В Python это часто реализуется просто передачей функции как аргумента.

# Пример паттерна Стратегия через функции
def pay_by_card(amount):
    print(f"Оплата картой: {amount}")

def pay_by_crypto(amount):
    print(f"Оплата криптой: {amount}")

def process_payment(amount, strategy):
    strategy(amount)

process_payment(100, pay_by_card)

Архитектура и структура проекта

Тимлид задает стандарты. Если каждый разработчик будет создавать папки как хочет, проект превратится в хаос.

Стандартная структура

Для большинства веб-сервисов (Django/FastAPI/Flask) придерживайся такой структуры:

• src/ (или название проекта) — исходный код.
  • core/ — базовые настройки, конфиги, исключения.
  • api/ — ручки (endpoints), схемы данных (Pydantic).
  • services/ — бизнес-логика.
  • db/ — модели БД и миграции.
  • utils/ — вспомогательные функции.
• tests/ — тесты (зеркалят структуру src).
• docs/ — документация.
• .env.example — пример переменных окружения.
• requirements.txt / pyproject.toml — зависимости.
• Dockerfile / docker-compose.yml — контейнеризация.

Чистая Архитектура (Clean Architecture)

Чтобы проект жил долго, разделяй его на слои. Зависимости должны идти строго снаружи внутрь.

1. Domain (Сущности): Самая важная бизнес-логика. Не зависит ни от чего (ни от БД, ни от фреймворка).
2. Application (Use Cases): Сценарии работы приложения. Оперирует сущностями.
3. Infrastructure: Реализация работы с БД, внешними API, отправка писем.

Соблюдение этого правила позволяет тебе легко сменить базу данных с PostgreSQL на MongoDB или фреймворк с Flask на FastAPI, не переписывая бизнес-логику.

Заключение

Твоя задача как Тимлида — не писать код быстрее всех, а создавать среду, где код пишется качественно и предсказуемо. Знание того, как работает память, понимание сложности алгоритмов ($O(n)$ vs $O(1)$), соблюдение SOLID и чистая архитектура — это инструменты, которые позволят тебе строить надежные системы.

В следующей статье мы перейдем к процессам разработки: Git Flow, Code Review и CI/CD.

Архитектура ПО: проектирование структуры проекта, микросервисы и Clean Architecture

Приветствую, будущий Team Lead. В прошлой лекции мы разобрали фундамент Python и ООП. Теперь пришло время подняться на уровень выше. Если Junior пишет код, то Team Lead проектирует системы.

Архитектура — это не просто красивые диаграммы. Это решения, которые трудно (и дорого) менять впоследствии. Твоя задача — построить систему так, чтобы через год, когда бизнес-требования изменятся, твоя команда не захотела уволиться всем составом.

Сегодня мы разберем вечный спор «Монолит против Микросервисов», углубимся в реализацию Clean Architecture и научимся считать надежность системы.

Монолит vs Микросервисы: Эволюция, а не выбор

На собеседованиях часто спрашивают: «Что лучше?». Правильный ответ Team Lead'а: «Зависит от контекста». Давай разберем этот контекст.

Монолитная архитектура

Монолит — это когда весь твой код, бизнес-логика, работа с базой данных и API живут в одном процессе и деплоятся как единое целое.

Плюсы:

• Простота разработки: Все лежит в одном репозитории, IDE видит все ссылки.
• Простота деплоя: Один Docker-контейнер, одна база данных.
• Скорость: Вызовы функций внутри памяти работают мгновенно, в отличие от сетевых запросов.

Минусы:

• Сложность масштабирования: Если нагружен только модуль оплаты, тебе придется масштабировать весь монолит.
• Единая точка отказа: Ошибка в одном модуле может положить весь сервис.

Микросервисная архитектура

Это подход, при котором приложение разбивается на небольшие, независимые сервисы, общающиеся через сеть (обычно HTTP/REST или gRPC).

Главное правило: Не начинай проект с микросервисов, если у тебя нет на это веских причин. Микросервисы — это решение организационных проблем (когда 50 человек не могут коммитить в один репозиторий), а не технических.

«Не делайте микросервисы, пока вы не стали слишком большими, чтобы быть монолитом». — Мартин Фаулер (Martin Fowler), автор книг по архитектуре ПО.

Модульный монолит (Modular Monolith)

Это «золотая середина», к которой ты должен стремиться на старте. Ты пишешь код в одном репозитории, но жестко разделяешь его на модули (Users, Billing, Catalog). Модули общаются только через публичные интерфейсы. Если один модуль разрастется, ты легко вынесешь его в отдельный микросервис.

Clean Architecture: Погружение в детали

В прошлой статье мы коснулись слоев. Теперь давай посмотрим, как это выглядит в коде и почему Dependency Rule (Правило зависимостей) — это закон.

Правило зависимостей

Стрелки зависимостей всегда смотрят внутрь. Внешние круги знают о внутренних, внутренние ничего не знают о внешних.

1. Entities (Сущности): Это твои бизнес-объекты. Например, класс Order. Он не знает, что существует база данных SQL или API. Он содержит только правила бизнеса (например, «нельзя оформить заказ с отрицательной суммой»).
2. Use Cases (Сценарии): Это действия. Например, CreateOrderUseCase. Он берет данные, создает сущность Order, проверяет ее и передает дальше. Он все еще не знает, как и куда сохранится заказ.
3. Interface Adapters (Адаптеры): Здесь живут контроллеры (в Django/FastAPI это views или endpoints) и репозитории. Задача репозитория — перевести объекты базы данных (ORM) в чистые сущности и обратно.
4. Frameworks & Drivers: Самый внешний слой. Здесь находится Flask, FastAPI, PostgreSQL, React. Это детали, которые должны быть легко заменяемы.

Пример инверсии зависимостей (DIP) в Python

Чтобы слой Use Cases мог сохранять данные, не зная о базе данных, мы используем абстракции (интерфейсы).

from abc import ABC, abstractmethod
from dataclasses import dataclass

# --- Domain Layer (Entities) ---
@dataclass
class User:
    id: int
    username: str

# --- Application Layer (Use Cases) ---
# Интерфейс, который объявляет, ЧТО нужно сделать, но не КАК
class UserRepository(ABC):
    @abstractmethod
    def save(self, user: User):
        pass

class CreateUserUseCase:
    def __init__(self, repo: UserRepository):
        self.repo = repo  # Зависим от абстракции, а не от SQL

    def execute(self, username: str):
        user = User(id=1, username=username)
        self.repo.save(user)
        return user

# --- Infrastructure Layer ---
# Реализация деталей
class SqlAlchemyUserRepository(UserRepository):
    def save(self, user: User):
        print(f"INSERT INTO users VALUES ({user.id}, '{user.username}')")

# --- Main ---
repo = SqlAlchemyUserRepository()
use_case = CreateUserUseCase(repo)
use_case.execute("team_lead_alex")

Благодаря этому коду, ты можешь заменить SqlAlchemyUserRepository на MongoUserRepository или MockUserRepository (для тестов), не меняя ни строчки в бизнес-логике CreateUserUseCase.

Проектирование надежности и доступности

Тимлид должен уметь говорить с бизнесом на языке цифр. Когда бизнес спрашивает «Почему мы лежим?», ты должен оперировать метриками.

SLA, SLO, SLI

• SLI (Service Level Indicator): Что мы измеряем (например, время ответа или процент ошибок).
• SLO (Service Level Objective): Цель, к которой стремимся (например, 99.9% запросов успешны).
• SLA (Service Level Agreement): Юридический договор с клиентом (если мы не выполним SLO, мы вернем деньги).

Формула доступности (Availability)

Как посчитать доступность твоего сервиса? Используем формулу:

$$A = \frac{MTBF}{MTBF + MTTR}$$

Где:

• $A$ — Доступность (Availability), вероятность того, что система работает в произвольный момент времени.
• $MTBF$ (Mean Time Between Failures) — Среднее время между сбоями. Чем оно больше, тем надежнее система.
• $MTTR$ (Mean Time To Repair) — Среднее время восстановления после сбоя. Чем оно меньше, тем быстрее команда чинит баги.

Пример: Если твой сервис падает раз в 100 часов ($MTBF = 100$), а чините вы его 1 час ($MTTR = 1$), то доступность:

$$A = \frac{100}{100 + 1} \approx 0.99$$

То есть 99%. Чтобы получить «три девятки» (99.9%), тебе нужно либо увеличить время между сбоями до 1000 часов, либо научиться чинить сервис за 6 минут.

CAP-теорема

При проектировании распределенных систем (микросервисов) ты столкнешься с фундаментальным ограничением. CAP-теорема гласит, что распределенная система может обеспечить только два из трех свойств:

1. C (Consistency) — Согласованность: Все узлы видят одни и те же данные одновременно.
2. A (Availability) — Доступность: Каждый запрос получает ответ (успех или ошибка), даже если часть узлов упала.
3. P (Partition Tolerance) — Устойчивость к разделению: Система продолжает работать, даже если связь между узлами пропала.

В реальности, так как сеть ненадежна, $P$ (Partition Tolerance) обязательно. Поэтому выбор всегда стоит между CP (согласованность + устойчивость) и AP (доступность + устойчивость).

• CP-системы (например, банковские транзакции): Если связь пропала, мы лучше вернем ошибку, чем покажем неверный баланс.
• AP-системы (например, лента соцсети): Если связь пропала, мы лучше покажем старые посты, чем ошибку 500.

Структура проекта для Team Lead

Хаос в файлах = хаос в голове. Твоя задача — утвердить структуру, понятную любому новичку.

Рекомендуемая структура Python-проекта

my_project/
├── src/                  # Весь исходный код
│   ├── domain/           # Сущности (Entities)
│   │   └── models.py
│   ├── application/      # Use Cases
│   │   └── services.py
│   ├── infrastructure/   # Работа с БД, внешними API
│   │   ├── db/
│   │   └── api_clients/
│   └── presentation/     # API (FastAPI/Flask)
│       └── routers/
├── tests/                # Тесты (Unit, Integration, E2E)
├── alembic/              # Миграции БД
├── docker/               # Dockerfiles
├── pyproject.toml        # Зависимости (Poetry/PDM)
└── README.md             # Документация по запуску

Использование src (src-layout) предотвращает ошибки импорта, когда Python случайно импортирует папку проекта как пакет.

Заключение

Архитектура — это искусство компромиссов. Монолит проще, но микросервисы масштабируемее. Clean Architecture требует больше кода, но спасает при смене фреймворков. Высокая доступность требует денег.

Как Team Lead, ты должен принимать эти решения осознанно, опираясь на требования бизнеса, а не на хайп. В следующей статье мы разберем процессы, которые заставят эту архитектуру жить: CI/CD, Code Review и Git Flow.

Культура кода: CI/CD, стратегии тестирования и проведение Code Review

Приветствую. Мы уже заложили фундамент знания Python и спроектировали чистую архитектуру. Но даже идеальная архитектура рассыплется в прах, если процесс доставки кода (delivery) построен на «честном слове» и ручном копировании файлов на сервер.

Твоя задача как Team Lead — превратить написание кода в конвейер. Ты должен исключить человеческий фактор там, где это возможно, и усилить его там, где это необходимо. Сегодня мы говорим о том, как код попадает в продакшн, как гарантировать его качество и как проводить Code Review так, чтобы команда росла, а не выгорала.

CI/CD: Автоматизация как религия

CI/CD (Continuous Integration / Continuous Delivery & Deployment) — это не просто набор скриптов. Это методология, позволяющая внедрять изменения часто и надежно.

Continuous Integration (Непрерывная интеграция)

Суть CI проста: разработчики должны сливать (merge) код в основную ветку как можно чаще (минимум раз в день). Каждое слияние запускает автоматическую сборку и тестирование.

Зачем это Тимлиду? Это спасает от «Integration Hell» (Ада интеграции), когда две недели разработки заканчиваются тремя днями попыток соединить код Васи и Пети.

Continuous Delivery vs Deployment

• Continuous Delivery (Непрерывная доставка): Код автоматически проходит все стадии проверок и готов к релизу в любой момент. Но кнопку «Deploy to Production» нажимает человек.
• Continuous Deployment (Непрерывное развертывание): Если тесты прошли, код летит к пользователям автоматически. Без участия человека.

Анатомия пайплайна (Pipeline)

В Python-мире стандартом де-факто стали GitHub Actions или GitLab CI. Типичный конфиг .gitlab-ci.yml или workflow выглядит так:

1. Lint: Проверка стиля (Black, Flake8, Ruff). Если код некрасивый — тесты даже не запускаем.
2. Test: Запуск pytest.
3. Build: Сборка Docker-образа.
4. Deploy: Обновление сервиса в Kubernetes или на сервере.

# Пример простого workflow для GitHub Actions
name: Python CI

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'
    - name: Install dependencies
      run: |
        pip install poetry
        poetry install
    - name: Lint with Ruff
      run: poetry run ruff check .
    - name: Test with pytest
      run: poetry run pytest

Стратегии тестирования

«У нас нет времени на тесты» — это фраза Junior-разработчика. Team Lead знает: время, сэкономленное на тестах, будет потрачено на тушение пожаров в продакшене с коэффициентом x10.

Пирамида тестирования

Майк Кон предложил концепцию пирамиды, которая идеально ложится на Python-разработку.

1. Unit Tests (Модульные тесты): Основание пирамиды. Их должно быть 70-80%. Они проверяют одну функцию или класс в изоляции. В Python для этого используют pytest.
2. Integration Tests (Интеграционные тесты): Середина пирамиды. Проверяют, как модули взаимодействуют друг с другом (например, сервис + база данных). Здесь мы поднимаем тестовую БД в Docker-контейнере.
3. E2E Tests (End-to-End): Верхушка. Эмуляция действий реального пользователя (например, через Selenium или Playwright). Они медленные и хрупкие.

Mocking: Искусство имитации

В модульных тестах мы не должны делать реальные запросы к API банка или слать письма. Мы используем «моки» (mocks).

from unittest.mock import Mock, patch

# Функция, которую тестируем
def get_user_data(api_client, user_id):
    return api_client.get(f"/users/{user_id}")

# Тест
def test_get_user_data():
    # Создаем фейковый клиент
    mock_client = Mock()
    mock_client.get.return_value = {"id": 1, "name": "Lead"}

    result = get_user_data(mock_client, 1)

    assert result["name"] == "Lead"
    # Проверяем, что метод был вызван с правильным аргументом
    mock_client.get.assert_called_once_with("/users/1")

Code Coverage (Покрытие кода)

Метрика, которую любят менеджеры, но с которой нужно быть осторожным. Она рассчитывается по формуле:

$$C = \frac{L_{executed}}{L_{total}} \times 100\%$$

Где:

• $C$ — процент покрытия кода тестами (Code Coverage).
• $L_{executed}$ — количество строк кода, выполненных во время прогона тестов.
• $L_{total}$ — общее количество строк кода в проекте.

Важно: 100% покрытие не гарантирует отсутствие багов. Оно лишь гарантирует, что каждая строка была выполнена. Стремись к 80-90%, но не делай из этого культ.

Code Review: Больше, чем поиск ошибок

Code Review (CR) — это главный инструмент обмена знаниями в команде. Если ты, как Тимлид, молча мержишь код или пишешь только «ок», ты убиваешь культуру.

Что должен проверять робот, а что — человек?

Самая частая ошибка: тратить время на споры о запятых и отступах. Это должны делать линтеры (автоматические проверяльщики).

• Робот (CI): PEP8, неиспользуемые импорты, типизация (Mypy), сложность кода, покрытие тестами.
• Человек (Reviewer): Архитектура, понятность, безопасность, соответствие бизнес-задаче.

Чек-лист Тимлида на ревью

Когда ты смотришь Merge Request (Pull Request) своего сотрудника, задавай себе вопросы:

1. Понятность: Смогу ли я или другой разработчик понять этот код через полгода без автора?
2. Архитектура: Не нарушает ли этот код слои Clean Architecture? Не протекает ли логика БД в контроллеры?
3. Безопасность: Нет ли SQL-инъекций (если используется сырой SQL) или передачи паролей в логах?
4. Дублирование: Не написан ли велосипед, который уже есть в utils?

Психология Code Review

Ты критикуешь код, а не человека. Это фундаментальное правило.

• Плохо: «Ты написал бред в функции calculate_tax. Переделай».
• Хорошо: «В функции calculate_tax логика кажется сложной для восприятия. Может быть, стоит вынести расчет НДС в отдельный метод или использовать паттерн Стратегия? Что думаешь?»

Используй вопросы вместо приказов. Это заставляет разработчика думать, а не слепо исполнять.

Git Flow и стратегии ветвления

Чтобы CI/CD работал, нужен порядок в Git.

Trunk Based Development

Современный стандарт для быстрых команд. Есть одна главная ветка (main или master). Разработчики создают короткоживущие ветки (feature-branches), которые живут 1-2 дня, и вливают их в main.

Плюсы: Минимум конфликтов при слиянии, быстрый Time-to-Market.

Git Flow

Классическая, более сложная схема. Есть ветки develop, release, master, hotfix.

Когда использовать: В Enterprise-проектах с жесткими релизными циклами (например, релиз раз в месяц), где стабильность важнее скорости.

Заключение

Культура кода — это то, что отличает профессиональную разработку от хакатона. Настроив CI/CD, внедрив пирамиду тестирования и наладив здоровое Code Review, ты освободишь себе время для стратегических задач. Ты перестанешь быть «нянькой», проверяющей отступы, и станешь архитектором процессов.

В следующей, заключительной технической статье, мы поговорим о базах данных: оптимизации SQL, индексах и транзакциях.

Управление командой: делегирование, менторство, найм и разрешение конфликтов

Приветствую, коллега. Мы прошли долгий путь: от углубленного Python и алгоритмической сложности до микросервисной архитектуры и CI/CD пайплайнов. Ты научился управлять кодом и серверами. Теперь настало время самого сложного испытания — управления людьми.

Многие разработчики, становясь Team Lead, попадают в ловушку: они продолжают писать код 80% времени, а управлению уделяют остаточное внимание. Это путь к выгоранию и стагнации команды. Твоя задача — сменить парадигму с «я делаю круто» на «моя команда делает круто».

В этой статье мы разберем четыре столпа управления: как отдавать задачи (делегирование), как растить сотрудников (менторство), как собирать команду (найм) и что делать, когда все идет не по плану (конфликты).

Делегирование: искусство не делать все самому

Главный страх новоиспеченного лида: «Если я поручу это Джуну, он будет делать это три дня, а я сделаю за час. Лучше сделаю сам». Это ошибка. Если ты делаешь задачу сам, ты блокируешь рост сотрудника и становишься «бутылочным горлышком».

Ситуационное руководство

Нельзя делегировать всем одинаково. Используй модель ситуационного лидерства Херси-Бланшара. Стиль управления зависит от двух факторов: компетентности сотрудника и его мотивации.

1. Директивный стиль (Junior): «Делай А, потом Б, результат покажи мне». Четкие инструкции, жесткий контроль.
2. Наставнический стиль (Middle-): «Давай обсудим, как лучше сделать». Ты продаешь идею, объясняешь «почему».
3. Поддерживающий стиль (Middle+): «Какое решение ты предлагаешь?». Сотрудник знает «как», но ему нужна уверенность.
4. Делегирующий стиль (Senior): «Вот цель, действуй». Максимальная свобода.

Математика коммуникаций

Почему нельзя просто нанять 50 человек и работать в 50 раз быстрее? Потому что с ростом команды количество связей растет нелинейно. Это описывается формулой количества коммуникационных каналов:

$$C = \frac{N(N-1)}{2}$$

Где:

• $C$ — количество каналов коммуникации (связей между людьми).
• $N$ — количество людей в команде.

Если у тебя в команде 5 человек, то каналов $10$. Если 10 человек — каналов уже $45$. Сложность коммуникации растет квадратично. Именно поэтому делегирование — это способ снизить нагрузку на центральный узел (на тебя).

Менторство и Bus Factor

Твоя цель как лида — стать ненужным. Звучит парадоксально, но идеальный Team Lead может уйти в отпуск на две недели, и процессы не встанут.

Bus Factor (Фактор автобуса)

Это минимальное количество участников команды, после потери которых (условно «сбил автобус» или просто уволились) проект остановится. Если только ты знаешь, как деплоить продакшн, твой Bus Factor = 1. Это катастрофа.

Как повышать Bus Factor:

• Code Review: Не просто поиск багов, а обмен знаниями.
• Парное программирование: Садись с джуном и пишите сложный модуль вместе.
• Документация: Если это не записано, этого не существует.

План развития сотрудника (PDP)

Менторство — это не ответы на вопросы «почему упал тест». Это системная работа над ростом инженера. Раз в полгода составляй PDP (Personal Development Plan).

Пример целей для Python-разработчика:

• Hard Skills: Изучить asyncio и внедрить его в сервис уведомлений.
• Soft Skills: Провести техническую презентацию для команды.

Найм: фильтр на входе

Найм — это продажа в обе стороны. Ты продаешь компанию, кандидат продает свои навыки. Ошибка найма стоит дорого: по статистике, замена сотрудника обходится в 3-6 его месячных окладов.

Воронка найма

Не пытайся найти «идеального» кандидата. Строй процесс как воронку.

1. Скрининг резюме: Отсеиваем неадекватность.
2. HR-скрининг: Проверка на soft skills и мотивацию.
3. Техническое интервью: Проверка hard skills.
4. Финальное интервью (Bar Raising): Проверка на культурное соответствие (culture fit).

Что спрашивать Python-разработчика?

Не проси писать сортировку пузырьком на листочке. Спрашивай то, что реально нужно в работе.

• Вместо: «Перечисли все методы списка».

• Спроси: «У нас есть список из 10 миллионов объектов. Как оптимизировать потребление памяти?» (Ожидаемый ответ: использование генераторов, __slots__ или переход на numpy/pandas в зависимости от контекста).

• Вместо: «Что такое GIL?».

• Спроси: «У нас CPU-bound задача, сервис тормозит. Помогут ли потоки (threads)? Почему? Что делать?» (Ожидаемый ответ: потоки не помогут из-за GIL, нужно использовать multiprocessing или выносить логику в отдельный сервис на Go/C++).

«Нанимай медленно, увольняй быстро». — Старая управленческая мудрость.

Разрешение конфликтов

Конфликты неизбежны. Если в команде нет споров, значит, людям все равно (или они боятся говорить). Конфликты бывают конструктивные (по поводу идей) и деструктивные (переход на личности).

Алгоритм ненасильственного общения (NVC)

Когда на код-ревью разгорается холивар или два сеньора не могут поделить архитектуру, вмешайся, используя технику Маршалла Розенберга.

1. Наблюдение (Факты): «Ты второй раз за неделю переносишь дедлайн по задаче X» (без оценки «ты ленивый»).
2. Чувства: «Меня это тревожит, так как мы рискуем релизом».
3. Потребность: «Мне нужна предсказуемость в планировании».
4. Просьба: «Давай обсудим, что блокирует работу и как мы можем это исправить?».

Правило «No Asshole Rule»

Даже если разработчик — гений, знающий наизусть исходники CPython, но он токсичен, унижает джунов и саботирует решения — увольняй. Токсичность заразна. Один «гениальный мудак» снижает эффективность всей команды на 30-40%.

One-on-One (1:1)

Это твой главный инструмент. Регулярные встречи (раз в неделю или две) с каждым членом команды по 30 минут.

О чем говорить:

• Не о статусе задач (для этого есть Daily Standup).
• О мотивации, проблемах, выгорании, развитии.
• «Что я как менеджер могу сделать, чтобы тебе работалось комфортнее?»

Заключение

Стать Team Lead — это значит принять ответственность не только за код, но и за судьбы людей. Твой код теперь — это процессы. Твои баги — это конфликты и увольнения.

Ты изучил технический фундамент, архитектуру, процессы CI/CD и теперь основы управления людьми. Это база, на которой строится карьера успешного технического лидера. Впереди тебя ждет практика. Удачи на этом пути!

Курс завершен. Теперь ты обладаешь картой местности, но идти по ней тебе придется самостоятельно.

Процессы и планирование: Agile, оценка задач и работа с техдолгом

Приветствую. Мы уже обсудили архитектуру, качество кода и управление людьми. Казалось бы, у тебя есть все инструменты: команда нанята, CI/CD настроен, микросервисы спроектированы. Но почему-то релизы задерживаются, бизнес недоволен, а разработчики жалуются на «говнокод».

Проблема кроется в процессах. Твоя задача как Team Lead — превратить хаотичный поток задач в предсказуемый конвейер ценности. Ты больше не просто пишешь код, ты управляешь временем и ожиданиями.

В этой статье мы разберем, как выбрать методологию (и не стать ее рабом), как оценивать задачи (когда сроки горят) и как продать бизнесу идею рефакторинга.

Agile: Философия, а не набор ритуалов

Многие джуниоры думают, что Agile — это когда мы стоим по утрам в кругу (Daily Standup) и клеим стикеры. Это карго-культ. Agile — это гибкость и готовность к изменениям.

Scrum vs Kanban: Что выбрать?

Как Тимлид, ты должен выбрать фреймворк, подходящий под задачи твоей команды.

Scrum идеально подходит для продуктовой разработки, где нужно регулярно поставлять новые фичи.

• Ритм: Работа делится на спринты (обычно 2 недели).
• Роли: Product Owner, Scrum Master, Команда.
• Артефакты: Бэклог продукта, Бэклог спринта, Инкремент.
• Плюс: Предсказуемость. Бизнес знает, что в конце спринта будет демо.
• Минус: Жесткость. Если в середине спринта прилетает срочная задача, процесс ломается.

Kanban лучше работает для команд поддержки, эксплуатации или SRE, где поток задач непредсказуем.

• Ритм: Непрерывный поток.
• Главное правило: WIP Limits (Work In Progress). Ограничение количества задач, находящихся в работе одновременно.
• Плюс: Гибкость. Взял задачу — сделал — взял следующую.
• Минус: Сложно прогнозировать долгосрочные сроки.

«Agile не решает ваши проблемы, он их выявляет».

Оценка задач: Искусство предсказания

«Сколько времени это займет?» — самый страшный вопрос для разработчика. Твоя задача — научить команду давать оценки, в которые можно верить.

Почему мы оцениваем в Story Points, а не в часах?

Оценка в часах почти всегда ошибочна. Люди плохо оценивают время, но хорошо сравнивают сложности.

Story Point (SP) — это абстрактная мера сложности, объема и риска.

• Задача на 1 SP — это «поменять текст на кнопке».
• Задача на 5 SP — это «сделать форму логина».
• Задача на 13 SP — это «интегрировать платежную систему».

Мы используем числа Фибоначчи (1, 2, 3, 5, 8, 13, 21), чтобы подчеркнуть: чем больше задача, тем выше неопределенность. Разница между 1 и 2 часами понятна, а разница между 40 и 42 часами — нет.

Planning Poker

Это техника коллективной оценки. Вся команда собирается, читает задачу и одновременно показывает карточку с оценкой.

Зачем это нужно Тимлиду? Если Senior оценил задачу в 2 SP, а Junior в 8 SP — это сигнал. Либо Джун чего-то не знает (и Сеньор должен объяснить), либо Сеньор не заметил подводных камней (и Джун спас спринт). Это инструмент синхронизации понимания задачи.

PERT: Научный подход к оценке

Если бизнес требует точных сроков в часах/днях, используй метод PERT (Program Evaluation and Review Technique). Он учитывает риски.

Формула оценки времени:

$$E = \frac{O + 4M + P}{6}$$

Где:

• $E$ (Expected time) — ожидаемое время выполнения задачи.
• $O$ (Optimistic time) — оптимистичное время (если все пойдет идеально).
• $M$ (Most likely time) — наиболее вероятное время.
• $P$ (Pessimistic time) — пессимистичное время (если все сломается).

Пример: Ты думаешь, что сделаешь API за 5 дней ($M=5$). Если повезет — за 3 ($O=3$). Если упадет сервер — за 15 ($P=15$).

$$E = \frac{3 + 4 \cdot 5 + 15}{6} = \frac{3 + 20 + 15}{6} = \frac{38}{6} \approx 6.33$$

Твоя оценка для бизнеса — 6.5 дней, а не 5. Это защищает команду от переработок.

Приоритизация: Что делать в первую очередь?

Бэклог всегда бесконечен. Ресурсы всегда ограничены. Как выбрать, что делать?

Метод RICE

Это фреймворк скоринга задач, который помогает убрать эмоции из планирования.

$$Score = \frac{R \cdot I \cdot C}{E}$$

Где:

• $Score$ — итоговый балл приоритета.
• $R$ (Reach) — охват. Скольких пользователей затронет фича за период? (например, 1000 человек).
• $I$ (Impact) — влияние. Насколько это улучшит опыт? (3 — массово, 2 — сильно, 1 — заметно, 0.5 — слабо).
• $C$ (Confidence) — уверенность в оценке. (100% — есть метрики, 80% — есть тесты, 50% — интуиция).
• $E$ (Effort) — трудозатраты. Обычно в «человеко-месяцах» или Story Points.

Задача с высоким $Score$ идет в работу первой. Если у задачи огромный Impact, но и гигантский Effort, ее приоритет может быть ниже, чем у маленькой, но быстрой задачи (Quick Win).

Технический долг: Кредит, который придется гасить

Технический долг — это метафора, придуманная Уордом Каннингемом. Когда мы пишем код быстро и «грязно», чтобы успеть к релизу, мы берем кредит. Мы получаем время сейчас, но будем платить «проценты» потом в виде сложной поддержки и багов.

Виды техдолга

1. Преднамеренный: «Мы знаем, что это костыль, но релиз завтра. Мы перепишем это в следующем спринте». Это нормально, если долг возвращают.
2. Непреднамеренный (случайный): Команда написала плохой код, потому что не знала, как сделать лучше (нехватка компетенций). Это лечится обучением и Code Review.
3. Бит-рот (Bit rot): Код был хорошим 5 лет назад, но технологии ушли вперед, и теперь он устарел.

Стратегии борьбы с техдолгом

Бизнес никогда не даст тебе задачу «Рефакторинг ради красоты». Ты должен продавать это через риски и деньги.

1. Правило бойскаута: «Оставь место стоянки чище, чем оно было до тебя». Если ты зашел в модуль поправить баг — поправь и стиль кода рядом. Не переписывай все, делай маленькие улучшения.
2. Квота 20%: Договорись с бизнесом, что 20% времени в спринте команда тратит на технические задачи. Это «налог на надежность».
3. Технические спринты: Раз в квартал устраивайте спринт, где нет продуктовых задач. Обновляйте библиотеки, переходите на новые версии Python, чистите базу данных.

Работа с рисками и Bus Factor

В прошлой статье мы упоминали Bus Factor. В планировании это критически важно. Не ставь критические задачи на человека, у которого Bus Factor = 1, перед его отпуском.

Матрица компетенций

Составь таблицу, где строки — это технологии/модули проекта, а столбцы — разработчики.

Модуль	Junior	Middle	Team Lead
Billing	0	1	3
Auth	1	2	2
Frontend	0	0	1

• 0 — не знает.
• 1 — может поправить баг с подсказкой.
• 2 — может пилить фичи самостоятельно.
• 3 — эксперт, может учить других.

Твоя задача как лида — видеть «нули» и «единицы» в критических зонах и планировать задачи так, чтобы люди обучались (Cross-training).

Заключение

Процессы — это скелет твоего проекта. Agile дает гибкость, Story Points дают относительную точность, PERT страхует от оптимизма, а RICE помогает делать то, что действительно важно.

Но помни: процессы для людей, а не люди для процессов. Если какой-то ритуал мешает команде работать — меняй его. Ты теперь Team Lead, и у тебя есть на это право.

В следующей статье мы подведем итоги курса и поговорим о том, как развиваться дальше в роли технического лидера.