Кого можно назвать middle-разработчиком

Кого можно назвать middle-разработчиком

Middle (Mid-level) разработчик — это разработчик, который может самостоятельно решать стандартные задачи, понимает архитектуру системы и может помогать juniors. Это промежуточный уровень между junior и senior.

Основные признаки middle-разработчика

1. Опыт и знания

Требуемый опыт:

• 2-5 лет профессиональной разработки на Python
• Понимание основных паттернов и best practices
• Знание типичных ошибок и как их избежать
• Знакомство с инструментами: Git, Docker, CI/CD

# Middle может написать чистый, структурированный код
from dataclasses import dataclass
from abc import ABC, abstractmethod
from typing import Protocol

class Repository(ABC):
    @abstractmethod
    async def get_by_id(self, id: int):
        pass

@dataclass
class UserService:
    """Сервис для работы с пользователями"""
    repository: Repository
    
    async def get_user(self, user_id: int):
        """Получить пользователя по ID"""
        user = await self.repository.get_by_id(user_id)
        if not user:
            raise ValueError(f"User {user_id} not found")
        return user

2. Способность решать задачи самостоятельно

Middle может:

• Разбить задачу на подзадачи без помощи
• Выбрать подходящие инструменты и технологии
• Написать тесты для своего кода
• Провести code review
• Общаться с product manager о деталях
• Оценить сложность задачи (estimate)

Junior:

# Написал функцию, но забыл тесты и документацию
def process_user(user):
    user['age'] = int(user['age'])
    return user

Middle:

@dataclass
class User:
    name: str
    age: int
    
    def validate(self) -> bool:
        """Валидация пользователя"""
        return 0 < self.age < 150

def test_user_validation():
    user = User("John", 30)
    assert user.validate() is True
    
    invalid_user = User("Jane", 200)
    assert invalid_user.validate() is False

3. Понимание архитектуры

Middle понимает:

• Слои приложения (presentation, business logic, data)
• Как работает database (индексы, N+1 problem, транзакции)
• SOLID, DRY, KISS принципы
• Когда использовать кэш, когда использовать queue
• Как масштабировать систему

# Middle видит N+1 проблему
# Плохо: N+1 query problem
users = session.query(User).all()
for user in users:
    print(user.profile.bio)  # Отдельный query для каждого пользователя!

# Хорошо: Middle использует eager loading
users = session.query(User).options(joinedload(User.profile)).all()
for user in users:
    print(user.profile.bio)  # Всё загружено в одном query

4. Коммуникация

Middle разработчик:

• Может объяснить свой код коллегам
• Задаёт правильные вопросы при неясных требованиях
• Участвует в обсуждении архитектуры
• Может наставлять juniors
• Пишет понятные commit messages и PR описания

# Junior commit message
git commit -m "fix"

# Middle commit message
git commit -m "Fix N+1 query in user list endpoint

Optimized database query by adding joinedload for user profile.
Reduces queries from 1+N to 1.

Fixes #123"

5. Внимание к качеству

Middle пишет:

• Код с покрытием тестами > 80%
• Документацию (docstrings, README)
• Code reviews для других
• Рефакторит старый код

# Middle пишет документированный код
class PaymentProcessor:
    """Обработчик платежей.
    
    Поддерживает несколько платёжных систем: Stripe, PayPal.
    Обрабатывает retry и ошибки.
    """
    
    async def process_payment(
        self,
        amount: Decimal,
        user_id: int,
        method: PaymentMethod
    ) -> PaymentResult:
        """Обработать платёж.
        
        Args:
            amount: Сумма в рублях
            user_id: ID пользователя
            method: Метод оплаты (stripe, paypal)
        
        Returns:
            PaymentResult с статусом и ID транзакции
        
        Raises:
            PaymentError: Если платёж не прошёл
        """
        pass

Сравнение уровней разработчиков

Практический пример: решение одной задачи

Задача: Реализовать API для получения списка заказов пользователя

Junior подход:

@app.get("/orders")
def get_orders(user_id: int):
    # Простой query, может быть N+1
    orders = db.query(Order).filter(Order.user_id == user_id).all()
    return orders  # Может быть 1000 заказов без пагинации

Middle подход:

from typing import Optional
from pydantic import BaseModel

class OrderResponse(BaseModel):
    id: int
    total: Decimal
    status: str
    created_at: datetime

@app.get("/users/{user_id}/orders", response_model=list[OrderResponse])
async def get_user_orders(
    user_id: int,
    skip: int = 0,
    limit: int = 20,
    db: Session = Depends(get_db)
) -> list[OrderResponse]:
    """Получить заказы пользователя с пагинацией"""
    
    # Проверяем, что пользователь существует
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    
    # Оптимизированный query с пагинацией
    orders = db.query(Order)\
        .filter(Order.user_id == user_id)\
        .options(joinedload(Order.items))  # Избегаем N+1\
        .order_by(Order.created_at.desc())\
        .offset(skip)\
        .limit(limit)\
        .all()
    
    return [OrderResponse.from_orm(o) for o in orders]

Senior подход:

# Добавляет кэширование, документацию, мониторинг
from functools import lru_cache
from prometheus_client import Counter

order_requests = Counter('order_requests_total', 'Total order requests')

@app.get("/users/{user_id}/orders")
@cache.cached(timeout=300, key_prefix='orders')  # Кэшируем результаты
async def get_user_orders(
    user_id: int,
    skip: int = 0,
    limit: int = 20,
    db: Session = Depends(get_db)
):
    """Получить заказы пользователя.
    
    Кэшируется 5 минут. Поддерживает пагинацию.
    """
    order_requests.inc()  # Метрика для мониторинга
    
    # Использует service layer
    orders = await order_service.get_user_orders(
        user_id=user_id,
        skip=skip,
        limit=limit
    )
    
    return orders

Как стать middle

1. Изучай architecture

   • SOLID, Design Patterns, Clean Architecture
   • Как работают БД, кэш, очереди

2. Пиши больше кода

   • Выполняй боевые задачи в реальных проектах
   • Занимайся рефакторингом

3. Читай код других

   • Code reviews
   • Open source проекты
   • Best practices

4. Общайся с коллегами

   • Обсуждай архитектуру
   • Помогай juniors
   • Спрашивай у seniors

5. Тестируй

   • Пиши юнит и интеграционные тесты
   • Понимай разницу между типами тестов

Вывод

Middle-разработчик — это тот, кто:

• Самостоятельно решает стандартные задачи
• Пишет качественный, тестируемый код
• Понимает архитектуру и scalability
• Может помогать juniors
• Участвует в обсуждении технических решений
• Думает не только о том, как это работает, но и почему это работает