Что знаешь об invention requirements и quality attributes?

Functional Requirements и Quality Attributes (Non-Functional Requirements)

Это фундаментальные понятия системного анализа и архитектуры. Они определяют что система должна делать и как хорошо она это должна делать.

Функциональные требования (Functional Requirements)

Определение: что система ДОЛЖНА ДЕЛАТЬ

Это конкретные функции и возможности:

# Примеры функциональных требований для интернет-магазина:

functional_requirements = [
    "Пользователь может просматривать товары",
    "Пользователь может добавлять товары в корзину",
    "Система должна рассчитывать скидки на основе количества",
    "Пользователь может оплатить заказ через Stripe",
    "Система отправляет email подтверждение",
    "Администратор может управлять инвентарем",
    "Система отслеживает историю заказов"
]

В коде — это основная логика:

class OrderService:
    def create_order(self, user_id: int, items: list) -> Order:
        """Функциональное требование: пользователь может создать заказ"""
        total = self.calculate_total(items)
        discount = self.apply_discount(items)
        order = Order(
            user_id=user_id,
            items=items,
            total=total - discount
        )
        db.session.add(order)
        return order
    
    def apply_discount(self, items: list) -> float:
        """Функциональное требование: система рассчитывает скидки"""
        total_quantity = sum(item.quantity for item in items)
        if total_quantity > 10:
            return sum(item.price for item in items) * 0.1  # 10% скидка
        return 0

Quality Attributes / Non-Functional Requirements (NFR)

Определение: КАК ХОРОШО система делает то, что делает

Это атрибуты качества системы:

quality_attributes = {
    "Performance": {
        "description": "Скорость обработки",
        "example": "API должен ответить за < 200ms",
        "metric": "Response time"
    },
    "Reliability": {
        "description": "Надёжность, доступность",
        "example": "99.9% uptime (SLA)",
        "metric": "Mean Time Between Failures"
    },
    "Scalability": {
        "description": "Способность расти",
        "example": "Поддерживать 10k concurrent users",
        "metric": "Max throughput"
    },
    "Maintainability": {
        "description": "Удобство поддержки кода",
        "example": "Code coverage > 80%, clean code",
        "metric": "Time to fix bug"
    },
    "Security": {
        "description": "Безопасность",
        "example": "Все пароли хешированы (bcrypt)",
        "metric": "Security incidents"
    },
    "Usability": {
        "description": "Удобство использования",
        "example": "UI должен быть интуитивным",
        "metric": "User satisfaction"
    },
    "Testability": {
        "description": "Тестируемость",
        "example": "Unit tests, integration tests",
        "metric": "Code coverage"
    }
}

Примеры в практике

Функциональное требование:

# Система должна обновлять баланс пользователя
def update_user_balance(user_id: int, amount: float):
    user = db.get_user(user_id)
    user.balance += amount
    db.save(user)

Quality Attribute (Performance):

# Это обновление должно выполниться за < 100ms
# Как мы это обеспечиваем?

@cache.cached(timeout=300)  # Кэширование
def update_user_balance(user_id: int, amount: float):
    # Используем index на user_id
    user = db.query(User).filter(User.id == user_id).first()
    
    # Транзакция для консистентности
    with db.session.begin_nested():
        user.balance += amount
        db.save(user)
    
    return user

Таблица сравнения

Почему Quality Attributes важнее

Много разработчиков фокусируются только на функциональности, но качественные атрибуты определяют успех системы в production:

# Плохой дизайн с functional требованиями
def get_all_users():
    """Функциональное требование: получить всех пользователей"""
    return db.query(User).all()  # Работает! Но...

# 100k пользователей → OOM ошибка
# Нарушает: Performance, Scalability

# Хороший дизайн
def get_users_paginated(page: int, limit: int = 20):
    """Функциональное требование + Quality Attributes"""
    return db.query(User)\
        .offset((page - 1) * limit)\
        .limit(limit)\
        .all()

# Теперь масштабируется, O(1) память

Архитектурные решения driven by Quality Attributes

Requirement: "Система должна поддерживать 100k concurrent requests"

# Это quality attribute (Scalability) требует:

# 1. Asynchronous processing
from fastapi import FastAPI
from starlette.concurrency import iterate_in_threadpool

app = FastAPI()

@app.post("/process")
async def process(data: dict):
    # Async — позволяет обрабатывать много одновременно
    result = await expensive_computation(data)
    return result

# 2. Caching
from cachetools import TTLCache

cache = TTLCache(maxsize=1000, ttl=300)

# 3. Database optimization
# - Индексы
# - Connection pooling
# - Query optimization

# 4. Load balancing
# - Nginx в frontend
# - Multiple server instances
# - Redis for sessions

# 5. Monitoring
# - Track response times
# - Track errors
# - Alert on SLA violation

Документирование требований

Профессиональный подход:

# requirements.md

## Functional Requirements

FR-001: User Registration
- Пользователь должен создать аккаунт
- Email должен быть уникальный
- Пароль должен быть > 8 символов

FR-002: Order Creation
- Пользователь может создать заказ
- Система проверяет наличие товара

## Non-Functional Requirements

NFR-001: Performance
- Все API endpoints должны ответить за < 200ms (p95)
- Страницы должны загружаться за < 2 сек

NFR-002: Reliability
- System uptime: 99.9%
- RTO (Recovery Time Objective): < 1 hour
- RPO (Recovery Point Objective): < 5 minutes

NFR-003: Security
- Все пароли хешированы bcrypt
- Все API endpoints требуют authentication
- SQL injection protection через parameterized queries

NFR-004: Scalability
- Поддерживать 10k concurrent users
- Handle 1000 requests/second

Практический совет

# Когда разработчик говорит: "Это работает!"
# Спроси: "А скорость? Безопасность? Может ли это масштабироваться?"

# Лучше вопросы:
questions = [
    "Какой целевой response time?",
    "Сколько пользователей одновременно?",
    "Какие SLA требуются?",
    "Какие security требования?",
    "Нужно ли масштабировать горизонтально?",
    "Как быстро должен выполняться batch процесс?"
]

Вывод

Functional Requirements — это ЧТО нужно построить Quality Attributes — это КАК ХОрошо нужно построить

Оба одинаково важны для успеха системы. Опытные архитекторы всегда начинают с quality attributes и строят архитектуру под них, а не пытаются добавить их потом (дорого и сложно).