AI-ассистенты кодирования 1
▼
Использует GitHub Copilot для написания базового Rust-кода: автодополнение функций, генерация struct-определений с derive-макросами. Понимает когда Copilot-подсказки нарушают ownership-правила и корректирует предложенный код.
Применяет Copilot для ускорения Rust-разработки: генерация impl-блоков для трейтов, написание unit-тестов через #[test], работа с error handling (thiserror/anyhow). Критически проверяет предложения на корректность lifetime-аннотаций и async-паттернов.
Оптимизирует использование Copilot в Rust-проектах: настройка workspace-контекста для точных подсказок, генерация сложных generic-конструкций и macro_rules. Проводит review AI-предложений на предмет unsafe-корректности, performance-импликаций и идиоматичности Rust-кода.
Определяет политику использования AI-ассистентов в Rust-разработке: guidelines для Copilot с учётом license compliance (cargo-deny), ограничения на генерацию unsafe-кода. Внедряет best practices для code review AI-generated Rust-кода с фокусом на memory safety и security.
Code Review 1
▼
Участвует в code review Rust-проектов: проверяет базовую корректность ownership и borrowing, читаемость кода и соответствие clippy-рекомендациям. Учится давать конструктивные комментарии и понимать feedback от старших разработчиков.
Проводит эффективные code review Rust-кода: проверяет корректность error handling, идиоматичность (clippy suggestions), правильность async/await паттернов. Оценивает тестовое покрытие, документацию через rustdoc и соответствие архитектурным паттернам проекта.
Проводит глубокий code review Rust-сервисов: анализ unsafe-блоков на soundness, оценка performance-импликаций (аллокации, клонирования, lock contention). Проверяет архитектурные решения, API-дизайн с учётом backward compatibility и корректность concurrent-кода.
Определяет стандарты code review для Rust-платформы: обязательные чеклисты (unsafe audit, dependency review, API design), SLA на review time. Менторит команду в review-практиках, фокусируясь на Rust-специфичных аспектах: lifetime correctness, trait design и error propagation.
Distributed Tracing 1
▼
Интегрирует OpenTelemetry в Rust-сервисы через opentelemetry-rust SDK: базовая настройка tracer-а, отправка traces через OTLP-exporter. Понимает концепции spans, trace context и связывание трейсов с tracing крейтом через tracing-opentelemetry.
Настраивает OpenTelemetry для Rust-микросервисов: автоматическая инструментация HTTP через tower-middleware, distributed tracing с context propagation (W3C TraceContext). Конфигурирует OTLP-экспорт в Jaeger/Tempo, настраивает sampling strategies и span attributes.
Проектирует observability-архитектуру на OpenTelemetry для Rust-сервисов: unified traces/metrics/logs через OTel SDK, custom instrumentation для бизнес-операций. Оптимизирует overhead через tail-based sampling, настраивает OTel Collector pipeline и интегрирует с service map визуализацией.
Определяет стандарты OpenTelemetry для Rust-платформы: обязательная инструментация для всех сервисов, shared otel-крейт с auto-configuration. Разрабатывает semantic conventions для бизнес-доменов, настраивает OTel Collector fleet и определяет data pipeline для traces/metrics.
Git и workflow 1
▼
Использует Git для Rust-проектов: понимание .gitignore для target/ и Cargo.lock стратегии (коммитить для бинарей, игнорировать для библиотек). Работает с ветками, создаёт PR и разрешает базовые merge-конфликты в Cargo.toml.
Применяет продвинутые Git-практики для Rust-разработки: interactive rebase для чистой истории, git bisect для поиска регрессий с cargo test. Настраивает pre-commit hooks с cargo fmt и clippy, управляет workspace-зависимостями через Cargo.lock.
Проектирует Git-workflow для Rust-проектов: trunk-based development с feature flags, monorepo-стратегии для workspace с selective CI. Настраивает git-субмодули для shared-крейтов, оптимизирует .gitattributes для больших бинарных файлов и внедряет conventional commits.
Определяет Git-стандарты для Rust-команд: branching-стратегия, PR-шаблоны с чеклистами (clippy, tests, docs), CODEOWNERS для критических крейтов. Разрабатывает автоматизацию через GitHub Actions: auto-labeling по изменённым крейтам, dependency updates через Dependabot/Renovate.
gRPC 1
▼
Реализует базовые gRPC-сервисы на Rust через tonic, определяя .proto-файлы и используя автогенерацию Rust-кода через prost. Понимает структуру Protobuf-сообщений, unary RPC-вызовы и маппинг proto-типов на Rust-структуры.
Разрабатывает gRPC-сервисы на tonic с server/client streaming, interceptors для аутентификации и метаданными запросов. Настраивает tonic-build для кодогенерации, реализует error mapping через tonic::Status и подключает reflection-сервис для grpcurl.
Проектирует gRPC-архитектуру Rust-сервисов: bidirectional streaming для real-time данных, health-checking через tonic-health, load balancing с tower. Оптимизирует сериализацию через prost с custom-кодеками и реализует graceful shutdown для streaming-соединений.
Определяет стандарты gRPC-коммуникации для Rust-платформы: schema registry для .proto-файлов, backwards-compatible эволюция сообщений, shared-крейты с сгенерированным кодом. Разрабатывает middleware-стек на tower для tracing, metrics и circuit breaking в gRPC-вызовах.
REST API 1
▼
Реализует базовые REST-эндпоинты на Actix-web или Axum, используя extractors для парсинга запросов и serde для JSON-сериализации. Понимает HTTP-методы, статус-коды и структуру маршрутизации в Rust web-фреймворках.
Разрабатывает REST API на Axum/Actix-web с middleware-слоями (tower layers), валидацией через validator крейт и структурированными ответами ошибок. Реализует пагинацию, фильтрацию и HATEOAS-ссылки с типобезопасными response-структурами.
Проектирует REST API Rust-сервисов с учётом идемпотентности, rate limiting через tower-governor и content negotiation. Реализует hypermedia-driven API, настраивает CORS через tower-http и обеспечивает backward compatibility с версионированием через Accept-заголовки.
Определяет стандарты REST API для Rust-платформы: единый error-handling через thiserror/anyhow, общий middleware-стек на tower, OpenAPI-генерация через utoipa. Разрабатывает shared-крейты с типами запросов/ответов и автоматическую валидацию контрактов в CI.
Unit-тестирование 1
▼
Понимает основы юнит-тестирования в Rust: атрибут #[test], assert-макросы, тестовые блоки на уровне модулей. Следует командным конвенциям организации тестов, использования cargo test и структуры интеграционных тестов в директории tests/.
Пишет unit-тесты для Rust-модулей через #[cfg(test)] с организацией в mod tests, используя assert_eq!/assert! и #[should_panic]. Применяет mockall для мокирования trait-зависимостей и test fixtures через rstest для параметризованных тестов.
Разрабатывает стратегию unit-тестирования Rust-сервисов: тестирование async-кода через #[tokio::test], snapshot-тесты через insta, coverage через cargo-tarpaulin. Реализует test utilities крейт с builders для доменных объектов и in-memory реализациями trait-зависимостей.
Определяет стандарты unit-тестирования для Rust-платформы: минимальное покрытие через cargo-tarpaulin в CI, обязательные тесты для public API крейтов. Разрабатывает testing-infrastructure крейт с mock-серверами, test containers и стандартными fixture-паттернами для команд.
Алгоритмы и структуры данных 2
▼
Понимает основы Алгоритмы и сложность на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно применяет алгоритмическое мышление в Rust: выбирает итератор-based алгоритмы для zero-copy обработки, понимает влияние модели владения на дизайн алгоритмов, оценивает паттерны конкурентных алгоритмов с атомиками и каналами. Анализирует сложность обработки данных в системном Rust-коде.
Применяет алгоритмическую экспертизу в Rust-разработке: проектирование zero-copy алгоритмов для высокопроизводительной обработки данных, SIMD-оптимизированные алгоритмы для вычислительных нагрузок, lock-free конкурентные алгоритмы с использованием атомиков. Проектирует memory-efficient алгоритмы, используя модель владения Rust для предсказуемой производительности.
Проектирует алгоритмические решения для высоконагруженных Rust-сервисов, применяя zero-cost abstractions и итераторные цепочки. Анализирует сложность с учётом особенностей аллокатора и кеш-линий процессора, профилируя через criterion и flamegraph.
Понимает основы Структуры данных на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно выбирает подходящие структуры данных в Rust: Vec vs VecDeque для последовательных данных, HashMap vs BTreeMap для поиска по ключу, Arc<Mutex> vs каналы для разделяемого состояния. Понимает компромиссы между паттернами владения и семантикой заимствования структур данных.
Выбирает оптимальные структуры данных для Rust-приложений: BTreeMap для cache-friendly упорядоченного доступа, arena allocators для графовых структур, crossbeam-очереди для lock-free конкурентных паттернов. Оптимизирует layout памяти с использованием repr(C) и packed structs. Проектирует zero-copy структуры данных с правильными lifetime bounds и Pin-семантикой.
Разрабатывает специализированные структуры данных на Rust с учётом ownership-модели, используя типы из std::collections и внешние крейты (im, dashmap). Обеспечивает lock-free доступ через crossbeam и атомарные типы для конкурентных сценариев.
Аутентификация и авторизация 1
▼
Реализует базовую JWT-аутентификацию в Rust-сервисах через jsonwebtoken крейт: валидация токенов, извлечение claims через serde-десериализацию. Настраивает middleware для проверки Authorization-заголовка в Axum/Actix-web и понимает структуру JWT.
Разрабатывает аутентификацию и авторизацию для Rust-сервисов: JWT с RS256 через jsonwebtoken, OAuth2-интеграция через oauth2-rs крейт. Реализует refresh token flow, role-based access control через custom extractors в Axum и token blacklisting через Redis.
Проектирует identity-архитектуру Rust-микросервисов: OIDC-интеграция с Keycloak/Auth0, token propagation между сервисами, RBAC/ABAC через casbin-rs. Реализует token introspection middleware, JWK rotation через JWKS-эндпоинты и audit logging аутентификационных событий.
Определяет стандарты аутентификации для Rust-платформы: единый auth-middleware крейт, стандарты token lifetime и rotation, integration с IdP. Разрабатывает authorization-framework с policy-as-code через OPA-интеграцию и автоматическое тестирование security policies.
Безопасность приложений 1
▼
Понимает основные OWASP-уязвимости в контексте Rust-сервисов: SQL-инъекции (предотвращаются параметризованными запросами SQLx), XSS (экранирование через askama/tera). Применяет базовые практики безопасности, используя преимущества type-safety Rust.
Защищает Rust-сервисы от OWASP Top 10: CSRF через double-submit cookies, SSRF через валидацию URL, broken authentication через argon2-хеширование. Настраивает security-заголовки через tower-http middleware и реализует rate limiting через governor.
Проектирует защиту Rust-сервисов от сложных атак: deserialization-уязвимости в serde (deny_unknown_fields), timing attacks через constant_time_eq, supply chain через cargo-vet. Проводит threat modeling и внедряет SAST через cargo-audit и cargo-deny в CI-пайплайн.
Определяет стандарты безопасности для Rust-платформы: обязательный cargo-audit/cargo-deny в CI, security review для unsafe-блоков, dependency-vetting через cargo-vet. Разрабатывает security-middleware стек и внедряет автоматизированное penetration testing.
Веб-фреймворки 1
▼
Использует Rust Web Frameworks на базовом уровне в actix-web/axum. Выполняет простые задачи по готовым шаблонам. Понимает базовые концепции и следует принятым в команде практикам.
Самостоятельно реализует задачи с Rust Web Frameworks в actix-web/axum. Понимает внутреннее устройство и оптимизирует производительность. Пишет тесты с помощью cargo test.
Проектирует решения на основе Rust Web Frameworks для production-систем. Оптимизирует производительность и масштабируемость. Выбирает между альтернативными подходами. Менторит команду.
Определяет архитектурные решения по Rust Web Frameworks на уровне продукта. Формирует стандарты. Проводит design review и определяет технический roadmap.
Интеграционное тестирование 1
▼
Понимает основы интеграционного тестирования Rust-сервисов. Пишет простые тесты проверки HTTP-эндпоинтов с actix-test или axum::test и взаимодействий с БД. Следует принятым в команде стандартам валидации интеграций асинхронных сервисов.
Пишет интеграционные тесты для Rust-сервисов в tests/ директории, используя testcontainers-rs для PostgreSQL/Redis и reqwest для HTTP-тестирования. Настраивает test harness с одноразовыми базами данных и автоматической очисткой через Drop trait.
Разрабатывает интеграционное тестирование Rust-микросервисов: end-to-end через docker-compose, contract testing через pact-rust, тестирование gRPC через tonic-mock. Настраивает CI с параллельными test suites и изолированными окружениями через testcontainers.
Определяет стандарты интеграционного тестирования Rust-платформы: обязательные contract-тесты между сервисами, shared test infrastructure крейт. Разрабатывает staging-environment с автоматическим деплоем для integration test suites и chaos-тестирование через toxiproxy.
Кэширование 2
▼
Использует Redis на базовом уровне в actix-web/axum. Выполняет простые задачи по готовым шаблонам. Понимает базовые концепции и следует принятым в команде практикам.
Самостоятельно реализует задачи с Redis в actix-web/axum. Понимает внутреннее устройство и оптимизирует производительность. Пишет тесты с помощью cargo test.
Интегрирует Redis в Rust-сервисы через крейт redis с поддержкой connection pooling (deadpool-redis) и async-команд на Tokio. Реализует кеширование с TTL, pub/sub для инвалидации и сериализацию данных через serde_json/bincode для оптимальной производительности.
Проектирует слой кеширования Redis для Rust-микросервисов: cluster-конфигурации, Lua-скрипты через redis::Script, distributed locks с Redlock-алгоритмом. Разрабатывает типобезопасные абстракции кеша с generic trait Cache<K,V> и автоматической сериализацией через serde.
Использует Стратегии кэширования на базовом уровне в actix-web/axum. Выполняет простые задачи по готовым шаблонам. Понимает базовые концепции и следует принятым в команде практикам.
Самостоятельно реализует задачи с Стратегии кэширования в actix-web/axum. Понимает внутреннее устройство и оптимизирует производительность. Пишет тесты с помощью cargo test.
Реализует стратегии кеширования в Rust-сервисах: in-memory через moka/cached с TTL и LRU-политиками, HTTP-кеширование через tower-http middleware. Применяет cache-aside паттерн с типобезопасными wrapper-структурами и обработкой cache stampede через probabilistic early expiration.
Проектирует multi-level кеш-архитектуру для Rust-сервисов: L1 (thread-local), L2 (shared moka), L3 (Redis) с write-through/write-behind стратегиями. Разрабатывает generic cache trait с поддержкой инвалидации, warming и мониторинга hit-rate через метрики Prometheus.
Многопоточность и конкурентность 2
▼
Понимает основы Асинхронное программирование на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно применяет асинхронное программирование в Rust: runtime tokio/async-std, композиция Future с async/await, pinning и управление lifetime в async-контекстах. Понимает компромиссы между sync и async Rust, порождение задач vs структурированная конкурентность.
Проектирует async-архитектуры в Rust: настройка runtime tokio, кастомные реализации Future, паттерны async trait и стратегии pinning. Менторит команду по оптимизации производительности async Rust и выбору границ sync/async.
Проектирует сложные асинхронные системы на Tokio/async-std с управлением backpressure, graceful shutdown и structured concurrency. Настраивает runtime (work-stealing, current-thread), управляет spawn-стратегиями и отлаживает async-код через tokio-console.
Понимает основы Многопоточное программирование на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно применяет многопоточность в Rust: система трейтов Send/Sync для гарантий потокобезопасности, Arc<Mutex> для разделяемого состояния, рантайм tokio для async-конкурентности, crossbeam для lock-free структур данных. Обосновывает преимущества модели ownership Rust для конкурентного кода на ревью.
Обладает глубокой экспертизой в конкурентности Rust: проектирует zero-cost конкурентные абстракции, используя систему ownership, внедряет custom async-рантаймы и lock-free структуры данных, оптимизирует тюнинг рантайма tokio для высокопроизводительных сервисов. Менторит команду по продвинутым паттернам конкурентности Rust для системного программирования.
Проектирует многопоточные Rust-системы с гарантиями Send/Sync, используя Arc<Mutex>, RwLock и каналы crossbeam. Применяет Rayon для data-parallelism, настраивает thread pools и профилирует contention через flamegraph и perf.
Моделирование данных 2
▼
Создаёт базовые миграции для Rust-проектов через refinery или sqlx migrate, понимая принципы версионирования схемы. Пишет идемпотентные UP/DOWN миграции, добавляет таблицы и колонки с правильными типами данных и constraints.
Самостоятельно проектирует схемы и оптимизирует запросы с Миграции БД. Понимает индексирование и планы выполнения запросов. Использует diesel/sea-orm эффективно.
Разрабатывает сложные миграции для Rust-сервисов: zero-downtime ALTER через добавление nullable-колонок, backfill-скрипты на Rust через SQLx, разделение миграций на deploy-safe и post-deploy. Обеспечивает backward compatibility между версиями схемы и приложения.
Проектирует стратегию миграций для Rust-микросервисной платформы: единый инструмент (refinery vs sqlx migrate vs diesel_migrations), тестирование миграций в CI. Разрабатывает workflow для координации schema-изменений между командами с автоматической проверкой обратной совместимости.
Проектирует простые модели данных для Rust-приложений, создавая struct-определения с derive(sqlx::FromRow) или Diesel-схемами. Понимает маппинг между Rust-типами и PostgreSQL, использует Option<T> для nullable-полей и enum-типы через sqlx::Type.
Самостоятельно проектирует схемы и оптимизирует запросы с Проектирование схем данных. Понимает индексирование и планы выполнения запросов. Использует diesel/sea-orm эффективно.
Разрабатывает доменные модели данных для Rust-сервисов с разделением на persistence и domain layers. Применяет newtype-паттерны для ID-типов (UserId(Uuid)), JSONB для гибких атрибутов через serde, и проектирует нормализованные схемы с учётом query-паттернов.
Проектирует модели данных для Rust-микросервисной платформы: bounded contexts с отдельными схемами, event-sourcing через append-only таблицы. Разрабатывает shared-библиотеки доменных типов (domain-primitives крейт) и стандарты сериализации через serde для межсервисного обмена.
Облачные провайдеры 1
▼
Использует базовые AWS-сервисы для Rust-приложений: EC2/ECS для деплоя, S3 через aws-sdk-s3, RDS PostgreSQL. Понимает IAM-роли, security groups и настраивает AWS CLI для локальной разработки с aws-sdk-rust.
Интегрирует AWS-сервисы в Rust через aws-sdk: SQS/SNS для messaging, DynamoDB через serde-интеграцию, Lambda через cargo-lambda. Настраивает ECS Fargate для Rust-контейнеров с task definitions, service discovery и CloudWatch логированием через tracing.
Проектирует AWS-инфраструктуру для Rust-сервисов: EKS с Karpenter, ElastiCache Redis, Aurora PostgreSQL. Оптимизирует Lambda cold start для Rust (minimal runtime, AL2023), реализует infrastructure-as-code через CDK/Terraform и настраивает VPC-архитектуру.
Определяет AWS-архитектуру Rust-платформы: multi-account стратегия, PrivateLink для сервисов, cost optimization через Graviton (ARM compilation). Разрабатывает Terraform-модули для стандартизированного провижининга и внедряет FinOps-практики с автоматическим cost-alerting.
ООП и паттерны проектирования 2
▼
Понимает основы Паттерны проектирования на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно применяет паттерны проектирования для Rust: стратегия и посетитель на основе trait, builder для сложного конструирования структур, паттерн newtype для типобезопасности, паттерн конечного автомата с enum. Обосновывает Rust-специфичный выбор паттернов с учётом ownership и lifetimes.
Обладает глубокой экспертизой в паттернах проектирования для Rust: проектирует zero-cost абстракции с trait objects и generics, внедряет типобезопасные конечные автоматы и паттерны builder, оптимизирует использование паттернов с учётом ownership и borrow checker. Менторит команду по Rust-идиоматичным паттернам для системного программирования.
Адаптирует классические паттерны под Rust ownership-модель: Builder через consuming self, Strategy через trait objects (Box<dyn Trait>), Observer через каналы Tokio. Формирует библиотеку идиоматических паттернов команды, включая typestate pattern и newtype idiom.
Понимает основы Принципы ООП и SOLID на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно применяет принципы SOLID в Rust: полиморфизм на основе trait вместо наследования, единственная ответственность в дизайне модулей/крейтов, инверсия зависимостей через trait objects и дженерики. Понимает Rust-специфичные ООП-компромиссы — композиция вместо наследования, правила когерентности trait, zero-cost абстракции.
Применяет принципы SOLID в trait-based дизайне Rust: interface segregation с сфокусированными traits, dependency inversion через trait bounds и дженерики, single responsibility в организации модулей. Проектирует чистые Rust-архитектуры с использованием trait objects для рантайм-полиморфизма, associated types для compile-time абстракции и newtype pattern для доменного моделирования.
Трансформирует ООП-подходы в идиоматический Rust: composition over inheritance через trait composition, полиморфизм через enum dispatch и trait objects. Определяет стандарты использования generics с trait bounds vs dynamic dispatch для команды.
Оптимизация 2
▼
Измеряет латентность Rust-сервисов через базовые метрики: response time через tracing, P50/P95/P99 через prometheus histograms. Понимает источники латентности (сетевые вызовы, DB-запросы) и применяет базовые оптимизации (connection pooling, индексы).
Оптимизирует латентность Rust-сервисов: минимизация аллокаций через stack-based буферы (SmallVec, ArrayVec), async I/O без блокирующих операций. Профилирует через tokio-console для анализа task scheduling, оптимизирует сериализацию через zero-copy (bytes, rkyv).
Проектирует low-latency архитектуру на Rust: pre-allocated buffers через object pools, TCP tuning (TCP_NODELAY, SO_REUSEPORT), io_uring через tokio-uring. Применяет lock-free структуры данных (crossbeam), CPU pinning для Tokio-рантайма и оптимизирует GC-free работу с памятью.
Определяет стандарты оптимизации латентности для Rust-платформы: SLO-based performance budgets, обязательные latency-бенчмарки в CI. Разрабатывает архитектурные guidelines для latency-sensitive сервисов: pre-warming, connection pooling стратегии и async-паттерны для минимального overhead.
Измеряет пропускную способность Rust-сервисов через базовое нагрузочное тестирование (wrk, hey) и метрики RPS. Понимает связь между concurrency и throughput в Tokio-runtime и применяет базовые оптимизации (batch processing, connection pooling).
Оптимизирует throughput Rust-сервисов: настройка Tokio worker threads, batch-обработка через Stream API, connection multiplexing. Применяет Rayon для CPU-параллелизма, оптимизирует сериализацию через simd-json и настраивает backpressure через bounded channels.
Проектирует high-throughput архитектуру на Rust: pipeline-паттерны через async streams, partition-based parallelism, zero-copy I/O через splice/sendfile. Оптимизирует runtime: multi-runtime стратегии (IO-runtime + CPU-runtime), custom task schedulers и memory-mapped I/O.
Определяет стандарты throughput-оптимизации для Rust-платформы: capacity planning на основе бенчмарков, автоматизированное нагрузочное тестирование в CI через k6/gatling. Разрабатывает архитектурные guidelines для high-throughput сервисов и стандарты horizontal scaling.
Оптимизация БД 2
▼
Создаёт базовые индексы PostgreSQL для Rust-приложений, понимая связь между типами запросов в SQLx/Diesel и необходимыми индексами. Использует EXPLAIN для анализа планов запросов и добавляет B-tree индексы для часто используемых WHERE-условий.
Самостоятельно проектирует схемы и оптимизирует запросы с Индексирование БД. Понимает индексирование и планы выполнения запросов. Использует diesel/sea-orm эффективно.
Проектирует стратегию индексирования для Rust-сервисов: partial индексы для фильтрованных запросов, GIN для JSONB-полей (сериализованных через serde), covering индексы для часто запрашиваемых наборов колонок. Анализирует производительность через pg_stat_user_indexes и criterion-бенчмарки.
Разрабатывает стандарты индексирования PostgreSQL для Rust-платформы: автоматизация анализа через custom CLI-утилиты на Rust, мониторинг неиспользуемых индексов. Определяет стратегии индексирования для высоконагруженных таблиц с учётом write amplification и VACUUM-процессов.
Оптимизирует простые SQL-запросы в Rust-приложениях, анализируя EXPLAIN-вывод и избегая N+1 проблем при загрузке связанных данных. Использует batch-запросы через SQLx query_as вместо циклических вызовов и добавляет пагинацию через LIMIT/OFFSET.
Самостоятельно проектирует схемы и оптимизирует запросы с Оптимизация запросов. Понимает индексирование и планы выполнения запросов. Использует diesel/sea-orm эффективно.
Оптимизирует сложные PostgreSQL-запросы в Rust-сервисах: CTE для читаемости, window functions, lateral joins. Профилирует время выполнения через tracing-интеграцию SQLx, применяет prepared statements и оптимизирует десериализацию результатов через zero-copy где возможно.
Проектирует стратегию оптимизации запросов для Rust-платформы: query builder-абстракции с автоматическим EXPLAIN-логированием, materialized views для агрегаций. Разрабатывает custom SQLx middleware для трейсинга медленных запросов и автоматического алертинга.
Очереди сообщений 1
▼
Использует Apache Kafka на базовом уровне в actix-web/axum. Выполняет простые задачи по готовым шаблонам. Понимает базовые концепции и следует принятым в команде практикам.
Самостоятельно реализует задачи с Apache Kafka в actix-web/axum. Понимает внутреннее устройство и оптимизирует производительность. Пишет тесты с помощью cargo test.
Реализует интеграцию с Kafka через rdkafka (librdkafka binding) в Rust-сервисах, настраивая продюсеры и консьюмеры с serde-сериализацией. Обеспечивает exactly-once семантику, обрабатывает ошибки через Result<T,E> и управляет offset-коммитами в асинхронном Tokio-рантайме.
Проектирует event-driven архитектуру Rust-сервисов с Kafka: схемы Avro/Protobuf через prost, consumer groups с graceful shutdown, dead letter queues. Разрабатывает абстракции над rdkafka с типобезопасными message envelopes и автоматической десериализацией через serde.
Реляционные БД 1
▼
Выполняет базовые CRUD-операции с PostgreSQL из Rust через SQLx или Diesel, используя типобезопасные запросы с compile-time проверкой. Понимает маппинг Rust-типов на SQL-типы (String->TEXT, i32->INTEGER) и работает с пулом соединений через sqlx::PgPool.
Самостоятельно проектирует схемы и оптимизирует запросы с PostgreSQL. Понимает индексирование и планы выполнения запросов. Использует diesel/sea-orm эффективно.
Разрабатывает сложные PostgreSQL-запросы в Rust-сервисах с использованием SQLx макросов (sqlx::query_as!) для compile-time валидации SQL. Настраивает connection pooling через deadpool-postgres, реализует транзакции с правильной обработкой ошибок и JSONB-операции через serde.
Проектирует слой доступа к PostgreSQL для Rust-платформы: выбор между Diesel (compile-time DSL) и SQLx (raw SQL с проверкой), стратегии миграций через refinery. Разрабатывает абстракции репозиториев с generic trait Repository<T> и оптимизирует connection pool-настройки под Tokio-runtime.
Сети 1
▼
Понимает базовые сетевые концепции для бэкенд-сервисов на Rust — программирование TCP/UDP сокетов, HTTP/HTTPS через hyper/reqwest и разрешение DNS. Следует рекомендациям команды по настройке TLS в Rust-сервисах и отладке проблем подключения с сетевыми примитивами tokio.
Работает с сетевыми протоколами в Rust-сервисах: TLS через rustls/native-tls, HTTP/2 через hyper, WebSocket через tokio-tungstenite. Настраивает connection pooling, таймауты и retry-логику в reqwest/hyper-клиентах с учётом backpressure.
Проектирует сетевую архитектуру Rust-микросервисов: service mesh интеграция, mTLS между сервисами через rustls, custom протоколы на Tokio. Оптимизирует сетевую производительность: TCP-настройки (SO_REUSEPORT, TCP_NODELAY), epoll/io_uring через tokio-uring.
Системы типов 2
▼
Понимает основы Дженерики и параметрический полиморфизм на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Реализует дженерики Rust с trait bounds: пишет generic-функции и структуры с where-клаузами и множественными trait bounds. Понимает мономорфизацию и её влияние на размер бинарника vs производительность. Применяет lifetime-параметры в generic-контекстах ('a), комбинирует дженерики с trait objects (dyn Trait) при необходимости динамической диспетчеризации. Использует PhantomData для zero-cost type-level маркеров.
Проектирует продвинутые generic-архитектуры Rust: реализует GATs (Generic Associated Types) для lending iterators и async trait паттернов. Строит generic type-state машины с zero-runtime-cost переходами, обеспечиваемыми системой типов. Применяет const generics для compile-time валидированных размерностей и буферов. Проектирует generic trait-иерархии с supertraits и blanket implementations, оптимизирует сложность trait bounds для поддержания разумного времени компиляции в больших generic-кодовых базах.
Проектирует обобщённые API с комплексными trait bounds, используя where-клаузы, associated types и GAT (Generic Associated Types). Разрабатывает generic middleware-слои для tower-сервисов и типизированные builder-паттерны с compile-time валидацией.
Понимает основы Типобезопасность и системы типов на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно применяет систему типов Rust для бэкенд-сервисов — использует ownership и borrowing для безопасности памяти, enum с ассоциированными данными для стейт-машин и trait bounds для обобщённых абстракций сервисов. Понимает компромиссы между динамической диспетчеризацией и мономорфизацией. Объясняет коллегам аннотации lifetime и программирование на уровне типов.
Обладает глубокой экспертизой в системе типов Rust — проектирует zero-cost абстракции с ассоциированными типами и GAT, кодирует бизнес-инварианты через newtype-паттерны и typestate-программирование, использует const generics для вычислений на этапе компиляции. Архитектурирует типобезопасные слои асинхронных сервисов с tower middleware. Менторит команду по продвинутым паттернам lifetime, аудиту unsafe-кода и генерации типов на основе макросов.
Проектирует API с максимальной типобезопасностью: newtype-паттерны для доменных типов, phantom types для compile-time инвариантов, exhaustive enums вместо строковых констант. Внедряет typestate pattern для гарантии корректности протоколов на уровне типов.
Управление API 3
▼
Понимает rate limiting в Rust: знает tower::limit::RateLimit для tower-based сервисов, умеет применить middleware через tower layer. Понимает как Rust ownership model помогает в thread-safe rate limiting без data races.
Реализует rate limiting в Rust-сервисах: создает custom Tower layer для per-key rate limiting, использует governor crate для flexible rate limiting algorithms, реализует distributed limiting через Redis с fred/deadpool-redis. Оптимизирует через atomic operations для lock-free counting.
Проектирует rate limiting для высоконагруженных Rust-сервисов: реализует zero-allocation rate limiter через lock-free data structures, настраивает multi-tier limiting с sub-microsecond overhead. Проектирует adaptive throttling на основе system metrics (CPU, memory, event loop lag).
Стандартизирует rate limiting для Rust-платформы: создает internal crate с pluggable backends и configuration, проектирует rate limiting proxy для multi-protocol support (HTTP, gRPC, WebSocket). Определяет fairness algorithms для resource allocation.
Документирует REST API Rust-сервисов через utoipa-атрибуты (#[utoipa::path]) на эндпоинтах Axum/Actix-web. Описывает request/response-схемы через derive(ToSchema) и генерирует Swagger UI через utoipa-swagger-ui middleware.
Разрабатывает комплексную API-документацию для Rust-сервисов: OpenAPI 3.0 через utoipa с examples, описание аутентификации (SecurityScheme), группировка по тегам. Настраивает автоматическую генерацию документации в CI и публикацию через Swagger UI/Redoc.
Проектирует стратегию API-документации для Rust-сервисов: автотесты на соответствие спецификации через spectral, changelog-генерация при изменениях proto/OpenAPI. Реализует documentation-as-code подход с rustdoc для внутренних API и utoipa для публичных.
Определяет стандарты документирования API для Rust-платформы: обязательные utoipa-аннотации в code review, автоматическая публикация в developer portal. Разрабатывает CI-проверки полноты документации и примеров для каждого эндпоинта с интеграцией в cargo test.
Понимает принципы версионирования API в Rust-сервисах: URL-based (/v1/, /v2/), header-based подходы. Реализует базовое версионирование через раздельные route-модули в Axum/Actix-web и поддерживает совместимость при добавлении новых полей через Option<T>.
Реализует версионирование API в Rust-сервисах через Axum-middleware или Actix-web guards, поддерживая несколько версий одновременно. Применяет serde с #[serde(default)] и #[serde(skip_serializing_if)] для backward-compatible эволюции JSON-схем.
Проектирует стратегию версионирования для Rust-микросервисов: content negotiation через Accept-заголовки, версионирование Protobuf-схем через reserved fields. Реализует adapter-слои между версиями API с compile-time проверкой через From/Into трейты.
Определяет стандарты версионирования API для Rust-платформы: semantic versioning для gRPC-контрактов, автоматическое обнаружение breaking changes в CI. Разрабатывает deprecation-workflow с sunset-заголовками и метриками использования устаревших версий.
Управление памятью 2
▼
Понимает основы Профилирование памяти на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно использует DHAT, heaptrack и Valgrind/Massif для профилирования памяти Rust-приложений. Понимает, как паттерны владения и семантика borrow checker влияют на аллокации, и выбирает стратегии профилирования соответственно.
Обладает глубокой экспертизой в профилировании памяти Rust через DHAT, heaptrack и Massif. Оптимизирует паттерны аллокаций через семантику владения, устраняет лишнее использование кучи и настраивает borrow-checker-совместимые дизайны для продакшн-нагрузок.
Профилирует потребление памяти Rust-сервисов через Valgrind/DHAT, jemalloc-статистику и custom allocator wrappers. Анализирует паттерны аллокаций через tracing-allocator, выявляет утечки через Rc-циклы и оптимизирует layout структур через repr(C) и field reordering.
Понимает основы Управление памятью на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Эффективно применяет модель владения Rust: понимает семантику перемещения, правила заимствования и аннотации времени жизни. Правильно использует Box, Rc, Arc для паттернов heap-аллокации. Работает с interior mutability через RefCell и Mutex. Понимает компромиссы stack vs heap аллокации и когда использовать ссылки vs владеемые значения.
Проектирует паттерны zero-cost абстракций в Rust: кастомные аллокаторы для arena-систем, lock-free структуры данных и эффективные layout-ы памяти для cache-friendly доступа. Безопасно реализует unsafe-код когда производительность требует обхода borrow checker. Оптимизирует memory footprint через уменьшение размера enum, bitfield-ы и компактные представления данных. Менторит команду по продвинутым паттернам владения и управлению lifetime.
Проектирует системы с оптимальным использованием ownership-модели Rust: минимизация клонирований через lifetime annotations, Cow для lazy copying, Arc для shared ownership. Определяет стандарты команды по работе с Box, Rc, Pin и управлению lifetime-аннотациями.
Чистый код и рефакторинг 1
▼
Понимает основы Качество кода и рефакторинг на базовом уровне. Применяет простые концепции в рабочих задачах с использованием Rust. Следует рекомендациям senior-разработчиков при решении задач.
Самостоятельно применяет практики качества кода в Rust-разработке. Пишет чистый код с ясной семантикой владения, правильными типами ошибок и эргономичными API. Понимает компромиссы между сложностью дженериков и удобством API. Ревьюит код на использование unsafe, корректность lifetime и ясность дизайна trait.
Проектирует стандарты качества кода для Rust-проектов: конфигурации линтов Clippy, политики ревью unsafe-кода, гайдлайны паттернов владения. Рефакторит сложные иерархии lifetime и реализации trait для ясности. Устанавливает практики ревью для безопасности памяти, zero-cost абстракций и гигиены макросов.
Внедряет комплексную систему качества Rust-кода: строгие clippy-линты (#![deny(clippy::all)]), rustfmt-конфигурацию, cargo-audit для зависимостей. Настраивает CI-пайплайны с MSRV-проверками, miri для undefined behavior и cargo-deny для лицензий.