[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-76134":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":9,"language":9,"languages":9,"totalLinesOfCode":9,"stars":10,"forks":11,"watchers":12,"openIssues":13,"contributorsCount":14,"subscribersCount":14,"size":14,"stars1d":15,"stars7d":16,"stars30d":17,"stars90d":14,"forks30d":14,"starsTrendScore":18,"compositeScore":19,"rankGlobal":9,"rankLanguage":9,"license":20,"archived":21,"fork":21,"defaultBranch":22,"hasWiki":23,"hasPages":21,"topics":24,"createdAt":9,"pushedAt":9,"updatedAt":25,"readmeContent":26,"aiSummary":27,"trendingCount":14,"starSnapshotCount":14,"syncStatus":28,"lastSyncTime":29,"discoverSource":30},76134,"rust-roadmap-ru","Develp10\u002Frust-roadmap-ru","Develp10","🦀 Полный roadmap по изучению Rust на русском + большой список ресурсов. Telegram: t.me\u002Frust_code",null,166,19,5,1,0,4,6,21,12,3.9,"MIT License",false,"main",true,[],"2026-06-12 02:03:40","🦀 Rust Roadmap (на русском)\n\nПолный курс по языку программирования Rust на русском языке: от первой строчки кода до асинхронности, embedded и WebAssembly. Каждый урок состоит из теории, практики и теста с ответами.\n\n📢 [t.me\u002Frust_code](https:\u002F\u002Ft.me\u002F+HelhY88sArowYjgy) — основной Telegram-канал с уроками и разбором кода для Rust-разработчиков.\n\n## 📚 О курсе\n\n- **25 уроков** — от базового синтаксиса до прикладной разработки.\n- Каждый урок построен по одной схеме: **теория с примерами → практика с задачами → тест → разбор ответов**.\n- Только **Rust 2021 \u002F 2024** — современный идиоматичный код, актуальные крейты экосистемы.\n- Без воды — только практически полезный материал.\n\n## 🗺️ Дорожная карта\n\n### Часть 1. Основы (уроки 1–8)\n\n| № | Урок | Темы |\n|---|------|------|\n| 1 | Введение в Rust | установка, cargo, hello world, структура проекта |\n| 2 | Переменные и типы | `let` \u002F `mut`, целые \u002F плавающие, `bool`, `char`, кортежи, массивы, преобразования, переполнение |\n| 3 | Управление потоком | `if` \u002F `else`, `loop`, `while`, `for`, `match`, `let-else`, loop labels |\n| 4 | Владение (ownership) | `move`, `Copy`, `Clone`, scope, `Drop`, замыкания и захват |\n| 5 | Заимствование и ссылки | `&T`, `&mut T`, NLL, reborrow, elision, времена жизни |\n| 6 | Slices, String, Vec | срезы, UTF-8, capacity, итерация по строкам |\n| 7 | Structs и enums | tuple \u002F unit-структуры, `derive`, `match` на enum, niche, builder |\n| 8 | Generics и traits | мономорфизация, `dyn` vs `impl`, trait bounds, ассоциированные типы, перегрузка операторов |\n\n### Часть 2. Углублённые темы (уроки 9–14)\n\n| № | Урок | Темы |\n|---|------|------|\n| 9 | Lifetimes | элизия, `'static`, HRTB, структуры со ссылками |\n| 10 | Обработка ошибок | `Result` \u002F `Option`, оператор `?`, `panic`, `thiserror`, `anyhow`, FFI |\n| 11 | Коллекции и итераторы | `HashMap`, `BTreeMap`, `VecDeque`, `BinaryHeap`, кастомные итераторы |\n| 12 | Умные указатели | `Box`, `Rc`, `Arc`, `RefCell`, `Mutex` \u002F `RwLock`, `OnceLock`, `Cow`, `Weak` |\n| 13 | Многопоточность | потоки, `Send` \u002F `Sync`, каналы, scoped threads |\n| 14 | Async и Tokio | `Future`, `async` \u002F `await`, рантайм tokio, `select!`, каналы |\n\n### Часть 3. Продвинутые возможности (уроки 15–19)\n\n| № | Урок | Темы |\n|---|------|------|\n| 15 | Макросы | `macro_rules!`, процедурные макросы, `derive` |\n| 16 | Тестирование | unit, integration, doc-tests, property-based |\n| 17 | Экосистема Cargo | workspaces, features, profiles, публикация |\n| 18 | Unsafe и FFI | `unsafe`, raw-указатели, `extern \"C\"`, `bindgen` |\n| 19 | Веб с axum | роутинг, extractors, middleware, JSON, state |\n\n### Часть 4. Прикладные направления (уроки 20–25)\n\n| № | Урок | Темы |\n|---|------|------|\n| 20 | Базы данных: sqlx и diesel | пулы, миграции, транзакции, repository |\n| 21 | gRPC с tonic | protobuf, streaming, interceptors, TLS |\n| 22 | Embedded и `no_std` | `core` \u002F `alloc`, `embedded-hal`, RTIC, Embassy |\n| 23 | WebAssembly | `wasm-bindgen`, `web-sys`, Yew \u002F Leptos, WASI |\n| 24 | Паттерны проектирования | newtype, builder, typestate, strategy, RAII |\n| 25 | CLI-приложения | clap, anyhow, tracing, indicatif, ratatui |\n\n## 🚀 Как учиться\n\n1. Установите Rust с [rustup.rs](https:\u002F\u002Frustup.rs) и любой редактор с поддержкой `rust-analyzer` (VS Code, Helix, Zed, RustRover).\n2. Идите по урокам последовательно: каждый следующий опирается на предыдущий.\n3. Для каждого урока: **прочитайте теорию → разберите код практики → решите задачи самостоятельно → пройдите тест и сверьтесь с ответами**.\n4. Создавайте `cargo new` песочницу под каждый урок и экспериментируйте.\n\n## 🛠️ Что понадобится\n\n- **Rust 1.75+** (`rustup update stable`).\n- **cargo** — встроенный пакетный менеджер.\n- **rust-analyzer** — LSP для подсветки и автодополнения.\n- Терминал, базовое знакомство с Git и любым другим языком (для контекста).\n\n## 📦 Полезные команды\n\n```bash\n# создать проект\ncargo new my_project\ncd my_project\n\n# собрать и запустить\ncargo run\ncargo build --release\n\n# тесты, проверки, форматирование\ncargo test\ncargo clippy\ncargo fmt\n\n# обновить зависимости\ncargo update\n```\n\n---\n\n# 📚 Полезные ресурсы\n\n## 📺 Telegram-каналы и подборки\n\n- [t.me\u002Frust_code](https:\u002F\u002Ft.me\u002F+HelhY88sArowYjgy) — основной канал по Rust на русском, уроки и разборы кода.\n- [t.me\u002Fbooks_englishhh](https:\u002F\u002Ft.me\u002Fbooks_englishhh) — англоязычные книги и материалы по Rust.\n- [t.me\u002Fai_machinelearning_big_data](https:\u002F\u002Ft.me\u002Fai_machinelearning_big_data) — AI, ML, Big Data (полезно при работе с `candle`, `burn`, `tch-rs`).\n- [Папка с обучающими ресурсами](https:\u002F\u002Ft.me\u002Faddlist\u002F8vDja6L4G_dlMjli) — большая подборка каналов для разработчиков.\n\n## 📖 Статьи на русском (must-read для глубокого понимания)\n\n- [Твой код на Rust компилируется, проходит тесты и является UB. Ты просто об этом не знаешь](https:\u002F\u002Fhabr.com\u002Fru\u002Farticles\u002F848134\u002F) — про скрытые ловушки undefined behavior в безопасном на вид Rust-коде.\n- [Как Rust обманывает процессор: тайная жизнь niche-оптимизации, drop flags и MIR](https:\u002F\u002Fhabr.com\u002Fru\u002Farticles\u002F871556\u002F) — внутренности компилятора и неожиданные оптимизации.\n- [Как Rust обманывает процессор. Часть 2: niche сквозь крейты, dropck, Pin и провенанс указателей](https:\u002F\u002Fhabr.com\u002Fru\u002Farticles\u002F873330\u002F) — продолжение про Pin, dropck и провенанс.\n\n## 📘 Официальная документация\n\n- [The Rust Book](https:\u002F\u002Fdoc.rust-lang.org\u002Fbook\u002F) — главная книга, начинать отсюда. [Русский перевод](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002F).\n- [Rust Book с интерактивными квизами](https:\u002F\u002Frust-book.cs.brown.edu\u002F) — экспериментальная версия от Brown University.\n- [Rust by Example](https:\u002F\u002Fdoc.rust-lang.org\u002Frust-by-example\u002F) — концепции через работающие примеры.\n- [The Rustonomicon](https:\u002F\u002Fdoc.rust-lang.org\u002Fnomicon\u002F) — тёмная сторона: `unsafe`, lifetimes, layout.\n- [The Rust Reference](https:\u002F\u002Fdoc.rust-lang.org\u002Freference\u002F) — формальная спецификация языка.\n- [Rust Async Book](https:\u002F\u002Frust-lang.github.io\u002Fasync-book\u002F) — асинхронность от создателей языка.\n- [Rust API Guidelines](https:\u002F\u002Frust-lang.github.io\u002Fapi-guidelines\u002F) — как проектировать идиоматичные API.\n- [std documentation](https:\u002F\u002Fdoc.rust-lang.org\u002Fstd\u002F) — стандартная библиотека (читать даже без запроса!).\n\n## 🎓 Бесплатные книги и курсы онлайн\n\n- [Rust Atomics and Locks](https:\u002F\u002Fmarabos.nl\u002Fatomics\u002F) — Mara Bos, бесплатно онлайн. Про многопоточность и memory ordering.\n- [Comprehensive Rust](https:\u002F\u002Fgoogle.github.io\u002Fcomprehensive-rust\u002F) — курс от Google, 4 дня интенсива.\n- [100 Exercises To Learn Rust](https:\u002F\u002Frust-exercises.com\u002F) — Luca Palmieri.\n- [Easy Rust](https:\u002F\u002Fdhghomon.github.io\u002Feasy_rust\u002F) — простыми словами для начинающих.\n- [Too Many Linked Lists](https:\u002F\u002Frust-unofficial.github.io\u002Ftoo-many-lists\u002F) — учим Rust через реализацию связных списков (классика!).\n- [Writing an OS in Rust](https:\u002F\u002Fos.phil-opp.com\u002F) — Philipp Oppermann, минимальная ОС с нуля.\n- [Crafting Interpreters](https:\u002F\u002Fwww.craftinginterpreters.com\u002F) — пишем интерпретатор (оригинал на Java\u002FC, есть множество Rust-портов).\n- [Zero To Production In Rust](https:\u002F\u002Fwww.zero2prod.com\u002F) — Luca Palmieri, веб-сервисы (платная, но стоит того).\n\n## 🎓 Продвинутые платные курсы \n\n- [Rust продвинутый: лайфтаймы, async, unsafe и производительность](https:\u002F\u002Fstepik.org\u002Fa\u002F285608\u002Fpay?promo=e1a7a808ed40a7be) — Внутри: async, unsafe, gRPC, lock-free, observability, Kafka, NATS, axum, tower, CI\u002FCD и канареечный деплой. 21 модуль, 84 урока, 400+ проверочных шагов.\n- [Rust полный курс разработчика! С нуля до профи\"](https:\u002F\u002Fstepik.org\u002Fa\u002F269250\u002Fpay?promo=b36f020f77bfb2d5) — 6 модулей, 50 уроков, 143 теста. Ownership, borrowing, traits, async, Tokio, Axum, макросы, WASM — всё разложено по полочкам и закреплено практикой.\n- \n## 💪 Практика и упражнения\n\n- [Rustlings](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Frustlings) — 90+ интерактивных упражнений, обязательно в начале.\n- [Exercism Rust Track](https:\u002F\u002Fexercism.org\u002Ftracks\u002Frust) — задачи с менторскими ревью.\n- [Rust Quiz](https:\u002F\u002Fdtolnay.github.io\u002Frust-quiz\u002F) — каверзные вопросы по семантике от dtolnay.\n- [Rust Playground](https:\u002F\u002Fplay.rust-lang.org\u002F) — экспериментировать без `cargo`, смотреть MIR \u002F LLVM IR \u002F ASM.\n- [Codewars](https:\u002F\u002Fwww.codewars.com\u002F) — алгоритмические ката.\n- [Advent of Code](https:\u002F\u002Fadventofcode.com\u002F) — ежегодный декабрьский марафон, отлично заходит на Rust.\n- [CodeCrafters](https:\u002F\u002Fcodecrafters.io\u002F) — пиши свой Redis \u002F Git \u002F Docker на Rust.\n\n## 📰 Блоги и новости\n\n- [This Week in Rust](https:\u002F\u002Fthis-week-in-rust.org\u002F) — еженедельный дайджест экосистемы. Подписка обязательна.\n- [Inside Rust Blog](https:\u002F\u002Fblog.rust-lang.org\u002Finside-rust\u002F) — что происходит внутри команды разработчиков.\n- [fasterthanli.me](https:\u002F\u002Ffasterthanli.me\u002F) — Amos, глубокие технические статьи.\n- [Without Boats](https:\u002F\u002Fwithout.boats\u002F) — блог одного из ключевых дизайнеров async Rust.\n- [Niko Matsakis](https:\u002F\u002Fsmallcultfollowing.com\u002Fbabysteps\u002F) — сооснователь языка, пишет про типовую систему.\n- [Manish Goregaokar](https:\u002F\u002Fmanishearth.github.io\u002F) — глубокие посты про unsafe и FFI.\n\n## 🎥 YouTube-каналы\n\n- [Jon Gjengset](https:\u002F\u002Fwww.youtube.com\u002Fc\u002FJonGjengset) — многочасовые стримы по внутренностям (Crust of Rust).\n- [No Boilerplate](https:\u002F\u002Fwww.youtube.com\u002Fc\u002FNoBoilerplate) — короткие мотивирующие видео про Rust.\n- [Logan Smith](https:\u002F\u002Fwww.youtube.com\u002F@_noisecode) — продвинутые темы доступным языком.\n- [Let's Get Rusty](https:\u002F\u002Fwww.youtube.com\u002Fc\u002FLetsGetRusty) — туториалы для начинающих.\n- [Code to the Moon](https:\u002F\u002Fwww.youtube.com\u002F@codetothemoon) — обзоры экосистемы и крейтов.\n- [chris biscardi](https:\u002F\u002Fwww.youtube.com\u002F@chrisbiscardi) — bevy, leptos, фронтенд на Rust.\n\n## 🔧 Инструменты, без которых жить нельзя\n\n- [`rust-analyzer`](https:\u002F\u002Frust-analyzer.github.io\u002F) — LSP, основа продуктивности.\n- [`cargo-edit`](https:\u002F\u002Fgithub.com\u002Fkillercup\u002Fcargo-edit) — `cargo add` \u002F `rm` \u002F `upgrade`.\n- [`cargo-watch`](https:\u002F\u002Fgithub.com\u002Fwatchexec\u002Fcargo-watch) — авто-перезапуск при изменениях.\n- [`cargo-expand`](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Fcargo-expand) — посмотреть, во что разворачиваются макросы.\n- [`cargo-nextest`](https:\u002F\u002Fnexte.st\u002F) — быстрый тест-раннер.\n- [`bacon`](https:\u002F\u002Fdystroy.org\u002Fbacon\u002F) — фоновый компилятор-watcher.\n\n## 🌐 Сообщество\n\n- [@rust_chats](https:\u002F\u002Ft.me\u002Frust_chats) — чат русскоязычных Rust-разработчиков (вопросы, помощь, обсуждение).\n- [Группа ВК «Rust IT»](https:\u002F\u002Fvk.com\u002Frust_it) — русскоязычное сообщество ВКонтакте: новости, статьи, вакансии.\n- [Rust Users Forum](https:\u002F\u002Fusers.rust-lang.org\u002F) — лучшее место для вопросов новичков.\n- [Rust Internals](https:\u002F\u002Finternals.rust-lang.org\u002F) — обсуждение развития языка.\n- [r\u002Frust](https:\u002F\u002Fwww.reddit.com\u002Fr\u002Frust\u002F) — Reddit-сообщество.\n- [Rust Discord](https:\u002F\u002Fdiscord.gg\u002Frust-lang) — официальный Discord.\n- [Rust Zulip](https:\u002F\u002Frust-lang.zulipchat.com\u002F) — где сидят разработчики компилятора.\n- [Are We X Yet?](https:\u002F\u002Fwiki.mozilla.org\u002FAreweyet) — обзоры зрелости экосистемы (Are We Web Yet?, Are We Game Yet?, Are We Async Yet?).\n\n## 🦀 Куратор-листы (awesome-lists)\n\n- [awesome-rust](https:\u002F\u002Fgithub.com\u002Frust-unofficial\u002Fawesome-rust) — главный список крейтов и проектов.\n- [Not Yet Awesome Rust](https:\u002F\u002Fgithub.com\u002Fnot-yet-awesome-rust\u002Fnot-yet-awesome-rust) — чего пока не хватает в экосистеме (повод законтрибьютить).\n- [Awesome Embedded Rust](https:\u002F\u002Fgithub.com\u002Frust-embedded\u002Fawesome-embedded-rust) — embedded.\n- [Awesome WebAssembly](https:\u002F\u002Fgithub.com\u002Fmbasso\u002Fawesome-wasm) — WASM.\n\n## 🎯 Подготовка к собеседованиям\n\n- [**Develp10\u002Frustinterviewquiestions**](https:\u002F\u002Fgithub.com\u002FDevelp10\u002Frustinterviewquiestions) — большой репозиторий вопросов с собеседований по Rust на позиции middle, senior и staff. Подходит как продолжение этого roadmap: когда базу прошли, дальше идёте сюда отрабатывать конкретные вопросы.\n\nЧто внутри:\n\n- **100 базовых вопросов с разбором** по разделам: владение и лайфтаймы, типы и трейты, конкурентность, async и runtime, unsafe и FFI, производительность, макросы, архитектура и дизайн API. Каждый ответ с кодом, типичными ошибками и пояснением, что происходит на уровне компилятора и рантайма.\n- **21 продвинутый вопрос уровня staff и expert** (GAT, HRTB, variance, Pin\u002FUnpin, Stacked Borrows, memory ordering, lock-free SPSC, custom allocators, soundness pitfalls, dropck, sealed traits, type-state).\n- **Оценки времени на подготовку** — макро-план по разделам и микро-чек на один вопрос с тремя колонками сложности: «база», «средне», «быстро».\n- **Двухнедельный план** для тех, у кого собес скоро.\n- **Подборка полезных ссылок** — официальная документация, книги (Rust Atomics and Locks, Rustonomicon), углублённое чтение (Crust of Rust, Tyler Mandry про async), инструменты (Miri, Loom, cargo-expand).\n- **Папка `tasks\u002F`** с практическими задачами уровня senior\u002Fstaff: lock-free структуры, self-referential типы в async, FFI с тензорными библиотеками, soundness кастомных коллекций.\n\n---\n\n# 🦀 Roadmap по изучению Rust: от нуля до профи\n\nЭтот путь рассчитан примерно на **6–12 месяцев** активного обучения. Каждый этап отвечает на три вопроса: **что** изучать, **где** изучать и **зачем** это нужно. Если ты совсем новичок — не перепрыгивай, порядок выбран не случайно.\n\n> 💡 **Общее правило для новичков:** прочитай тему в *The Rust Book* → прочитай её же в *Rust by Example* → реши соответствующие упражнения в *Rustlings*. Три угла зрения на одну идею закрепляют её сильно лучше, чем один источник.\n\n## Этап 0. Подготовка окружения (1–3 дня)\n\n**Что изучать:**\n\n- Установить [`rustup`](https:\u002F\u002Frustup.rs) — официальный менеджер тулчейнов. Он ставит компилятор (`rustc`), пакетный менеджер (`cargo`), форматтер (`rustfmt`), линтер (`clippy`) и позволяет переключаться между `stable` \u002F `beta` \u002F `nightly` (`rustup default stable`, `rustup toolchain install nightly`).\n- Зафиксировать версию для проекта через файл `rust-toolchain.toml` в корне репозитория — чтобы все участники и CI собирали одним и тем же компилятором.\n- **Редактор:** VS Code + расширение [rust-analyzer](https:\u002F\u002Frust-analyzer.github.io\u002F) — самая дружелюбная связка для новичков. Альтернативы: [RustRover](https:\u002F\u002Fwww.jetbrains.com\u002Frust\u002F) (бесплатен для некоммерческого использования), Helix, Zed, Neovim + LSP. Включи в `settings.json` `\"editor.formatOnSave\": true` и `\"rust-analyzer.check.command\": \"clippy\"` — будет ловить проблемы прямо в редакторе.\n- **Ежедневные команды cargo:**\n  - `cargo new` \u002F `cargo init` — создание проекта;\n  - `cargo check` — быстрая проверка типов без кодогенерации (используй пока пишешь, в 5–10 раз быстрее `build`);\n  - `cargo build` (debug) \u002F `cargo build --release` (с оптимизациями, разница в скорости часто 10–100×);\n  - `cargo run` \u002F `cargo run --release -- arg1 arg2` (всё после `--` уходит в твою программу);\n  - `cargo test` \u002F `cargo test -- --nocapture` (показывать вывод даже у прошедших тестов);\n  - `cargo doc --open` — генерирует и открывает документацию проекта со всеми зависимостями (включая stdlib);\n  - `cargo add serde --features derive` — добавить зависимость без ручной правки `Cargo.toml`;\n  - `cargo clippy -- -D warnings` — линтер; флаг превращает все варнинги в ошибки (полезно в CI).\n- **`Cargo.toml` минимум, который надо понимать:** `[dependencies]`, `[dev-dependencies]`, `[build-dependencies]`, секции `[profile.dev]` \u002F `[profile.release]`, фичи (`features = [\"derive\", \"json\"]`).\n- **Полезные cargo-расширения сразу:** `cargo install cargo-watch cargo-edit cargo-expand`. `cargo watch -x check -x test` — пересборка\u002Fтесты на сохранение файла, экономит часы.\n\n**Где изучать:**\n\n- [rustup.rs](https:\u002F\u002Frustup.rs) — установка одной командой.\n- [The Rust Book, гл. 1](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002Fch01-00-getting-started.html).\n- [The Cargo Book](https:\u002F\u002Fdoc.rust-lang.org\u002Fcargo\u002F) — особенно главы «Specifying Dependencies», «Cargo.toml format», «Profiles».\n- Шпаргалка по cargo-командам: [cheats.rs\u002F#cargo](https:\u002F\u002Fcheats.rs\u002F#cargo).\n\n**Зачем это нужно:** без рабочего окружения и правильных рефлексов (`cargo check` пока пишешь, `cargo doc --open` чтобы читать доки оффлайн, `cargo clippy` перед коммитом) Rust кажется сильно сложнее, чем есть. Один час, потраченный сейчас на настройку, экономит десятки часов на следующих этапах.\n\n**Мини-проект:** `Hello, world!`, который читает имя из `std::env::args`, валидирует, что аргумент задан (если нет — выводит usage и завершает с кодом 1), и здоровается. Бонус: добавь зависимость `anyhow` через `cargo add` и используй `anyhow::Result` как тип возврата `main`.\n\n---\n\n## Этап 1. Базовый синтаксис (2–3 недели)\n\n**Что изучать:**\n\n- **Переменные:** `let` (по умолчанию неизменяемые), `mut`, константы (`const NAME: T = ...` — всегда с типом, должны быть compile-time), `static` (живёт всю программу). Shadowing — повторное связывание имени через `let` — **идиома, а не баг**: позволяет менять тип (`let x = \"5\"; let x: u32 = x.parse()?;`).\n- **Целые типы:** `i8\u002Fi16\u002Fi32\u002Fi64\u002Fi128\u002Fisize` и `u8\u002Fu16\u002Fu32\u002Fu64\u002Fu128\u002Fusize`. `usize`\u002F`isize` зависят от платформы (32 или 64 бит) и используются для индексации. **Переполнение:** в debug-сборке — `panic`, в release — wrap (тихая обёртка). Для явного поведения — `checked_add`, `saturating_add`, `wrapping_add`, `overflowing_add`.\n- **Числовые литералы:** `1_000_000` (подчёркивания для читаемости), `0xff`, `0b1010`, `0o755`, суффиксы `100u32`, `1.5f64`.\n- **`bool`, `char`** (4-байтный Unicode scalar value, **не байт!**), кортежи `(i32, &str)`, массивы `[T; N]` (размер в типе), срезы `&[T]` \u002F `&str` (динамический размер, fat pointer).\n- **Преобразования:** `as` — низкоуровневый каст (может молча терять биты); `From`\u002F`Into` — безопасное расширение (`u32 → u64`); `TryFrom`\u002F`TryInto` — может не получиться (`i64 → i32`). Идиома: предпочитай `From`\u002F`TryFrom` вместо `as` везде, кроме horizontalных кастов внутри числовой работы.\n- **Строки:** `String` (владеющая, на куче, мутабельная) vs `&str` (срез, обычно ссылка на литерал или часть `String`). Литералы `\"...\"` имеют тип `&'static str`. **Грабли:** `String` нельзя индексировать как `s[0]` — UTF-8 переменной длины; используй `.chars()`, `.bytes()`, `.char_indices()`.\n- **Управляющие конструкции — это выражения, не операторы:**\n  ```rust\n  let max = if a > b { a } else { b };\n  let sum = loop { break 42; };\n  ```\n  `if`, `match`, `loop`, блоки `{ ... }` — все возвращают значение. Точка с запятой превращает выражение в оператор (отбрасывает значение).\n- **`match`** — главный инструмент Rust для разбора данных. Должен быть **исчерпывающим**: компилятор требует покрыть все варианты (или `_`).\n- **Функции:** возврат — последнее выражение без `;`, либо `return`. Параметры по значению переносят владение (move), по `&T` — занимают.\n- **Модули и видимость:** `mod`, `pub`, `pub(crate)`, `pub(super)`. `use crate::foo::Bar`. Файловая раскладка: `mod foo;` ищет `foo.rs` или `foo\u002Fmod.rs` (новый стиль — `foo.rs` + `foo\u002F`).\n- **Doc-комментарии:** `\u002F\u002F\u002F` для элементов, `\u002F\u002F!` для модулей\u002Fкрейтов. `cargo doc` рендерит в HTML; примеры внутри них автоматически становятся **doc-тестами** и запускаются на `cargo test`.\n\n**Где изучать:**\n\n- [The Rust Book, гл. 3–7](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002Fch03-00-common-programming-concepts.html) — основа основ. Прочитать до конца, не перепрыгивая.\n- [Rust by Example](https:\u002F\u002Fdoc.rust-lang.org\u002Frust-by-example\u002F) — параллельно с книгой, как «практический режим».\n- [Rustlings](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Frustlings) — упражнения, включая `variables`, `functions`, `primitive_types`, `vecs`, `move_semantics`, `structs`, `enums`, `strings`. Делать **все**, не пропуская.\n- [cheats.rs](https:\u002F\u002Fcheats.rs\u002F) — однострочная шпаргалка по всему синтаксису, держать открытой.\n\n**Зачем это нужно:** на этом этапе закладывается ритм работы с компилятором: пишешь → `cargo check` → читаешь ошибку → правишь. Все остальные этапы предполагают, что синтаксис у тебя уже не вызывает заминок.\n\n**Мини-проекты:** калькулятор в CLI с `+ - * \u002F`, конвертер температур °C↔°F с валидацией ввода, FizzBuzz, угадай-число (с `std::io` для ввода и `rand` для случайного числа).\n\n---\n\n## Этап 2. Владение, заимствование, времена жизни (3–4 недели) — самое важное!\n\n**Что изучать:**\n\n- **Модель памяти.** Стек (быстрый, фиксированный размер) vs куча (`Box`, `Vec`, `String` — динамический размер, аллокация дороже). Понимание, что где лежит, объясняет 90% «почему компилятор недоволен».\n- **Ownership — центральная идея языка:** у каждого значения ровно один владелец; когда владелец выходит из области видимости, вызывается `Drop`, ресурс освобождается. Без GC, без ручного `free`. Это работает для **любого ресурса**, не только памяти: файловые дескрипторы, сокеты, блокировки — всё освобождается автоматически (RAII).\n- **Move-семантика.** Присваивание или передача значения по типу, не реализующему `Copy`, **переносит** владение; использование исходной переменной после move — ошибка компиляции. Так Rust ловит use-after-free и double-free на этапе сборки.\n- **`Copy` vs `Clone`.** `Copy` — побитовое копирование, неявное (`i32`, `bool`, `char`, фиксированные массивы из `Copy`-типов). `Clone` — явная, потенциально дорогая копия (`.clone()`, всегда видно в коде). Тип не может быть `Copy`, если содержит ресурс с `Drop` (например, `String`).\n- **Заимствование.** `&T` — общая ссылка (только чтение, можно много); `&mut T` — эксклюзивная ссылка (один писатель). **Borrow checker гарантирует:** либо много читателей, либо один писатель. Это устраняет data races на этапе компиляции.\n- **Времена жизни (lifetimes).** Каждой ссылке компилятор приписывает «живёт не дольше, чем». В простых функциях лайфтаймы выводятся автоматически (**lifetime elision rules** — три правила в Rust Reference). Явная аннотация `fn longest\u003C'a>(x: &'a str, y: &'a str) -> &'a str` нужна, когда выходная ссылка зависит от нескольких входных.\n- **Особый лайфтайм `'static`** — живёт всю программу. У строковых литералов тип `&'static str`. Bound `T: 'static` означает «тип не содержит ссылок с более коротким временем жизни» (это **не** «тип живёт вечно», частая путаница).\n- **Слайсы.** `&[T]`, `&mut [T]`, `&str` — нормальная форма передачи коллекций в функции; принимай слайсы вместо `&Vec\u003CT>` \u002F `&String`. Это работает и для `Vec`, и для массивов, и для подсрезов `&v[2..5]`.\n- **NLL (Non-Lexical Lifetimes).** Современный borrow checker отслеживает использование, а не лексические скоупы. Поэтому `let r = &v; println!(\"{r}\"); v.push(1);` компилируется (последнее использование `r` — в `println!`).\n- **Что *нельзя* в safe Rust из-за ownership:** self-referential structs (структура со ссылкой на собственное поле — нужны `Pin` и продвинутые паттерны), произвольные графы со взаимными ссылками без `Rc`\u002F`Weak`, мутабельные глобалы без `Mutex`\u002F`OnceLock`. Это не баги, а сознательные ограничения.\n\n**Где изучать:**\n\n- [The Rust Book, гл. 4 (Понимание владения) и гл. 10 §3 (Lifetimes)](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002Fch04-00-understanding-ownership.html) — каноническое объяснение. Прочитать **дважды**, с интервалом в неделю.\n- [Rust by Example: Scoping rules, Borrowing, Lifetimes](https:\u002F\u002Fdoc.rust-lang.org\u002Frust-by-example\u002Fscope.html).\n- [Rustlings: `move_semantics`, `lifetimes`, `strings`](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Frustlings).\n- [Rust Book с интерактивными квизами от Brown University](https:\u002F\u002Frust-book.cs.brown.edu\u002F) — те же главы плюс квизы, ловящие типичные заблуждения именно про ownership. Сильно рекомендую.\n- [Crust of Rust: «Lifetime Annotations» (Jon Gjengset)](https:\u002F\u002Fwww.youtube.com\u002Fwatch?v=rAl-9HwD858) — когда почувствуешь готовность к более глубокому разбору.\n- The Rust Reference: [Lifetime elision](https:\u002F\u002Fdoc.rust-lang.org\u002Freference\u002Flifetime-elision.html) — формальные правила.\n\n**Зачем это нужно:** именно ownership и lifetimes делают Rust *Rust*. Почти все «почему мой код не компилируется?!» сводятся к ним. Когда щёлкнет (обычно к 3-й неделе ежедневной практики), остальной язык становится лёгким.\n\n**Типичные грабли на этом этапе:**\n\n- **«Я просто скопирую через `.clone()`».** Работает, но это анти-паттерн в горячем коде. Сначала попытайся передать ссылку.\n- **«Не могу мутировать `Vec`, пока итерирую».** Правильно: либо собрать индексы и потом изменить, либо использовать `Vec::retain` \u002F `drain_filter`.\n- **`return &local_var`** — возврат ссылки на локальную переменную. Не компилируется, и слава богу.\n\n**Мини-проекты:** функция `longest(&str, &str) -> &str` (из книги, но дописать варианты с разными лайфтаймами), парсер CSV (передача слайсов между функциями без копирования), стековый калькулятор на `Vec\u003Cf64>` с обработкой ошибок.\n\n---\n\n## Этап 3. Структуры данных и абстракции (3 недели)\n\n**Что изучать:**\n\n- **`struct`:** с именованными полями, tuple-структуры (`struct Point(f64, f64)`), unit-структуры (для маркеров и реализации трейтов). Деструктуризация: `let Point { x, y } = p;`.\n- **`enum`** — это **sum types**, а не «нумерация констант». Каждый вариант может нести данные разного типа: `enum Event { Click { x: i32, y: i32 }, Scroll(f32), Resize }`. Так моделируются «значение — одно из этих вариантов» — основной инструмент для конечных автоматов и доменных моделей.\n- **`Option\u003CT>` и `Result\u003CT, E>`** — ответ Rust на `null` и исключения. Оба — **обычные enum'ы из stdlib**, никакой магии. `Option::None` вместо `null`, `Result::Err` вместо `throw`.\n- **Pattern matching:** `match`, `if let`, `while let`, `let-else` (Rust 1.65+: `let Some(x) = opt else { return; };`). Так разбирают enum'ы и **делают невалидные состояния непредставимыми**.\n- **Exhaustive matching и `#[non_exhaustive]`.** `match` по `enum` обязан покрыть все варианты. Атрибут `#[non_exhaustive]` на публичном enum заставляет потребителей всегда писать `_ => ...` — позволяет добавлять варианты без breaking-изменений.\n- **`impl`-блоки:** методы (`&self`, `&mut self`, `self` — последний потребляет значение), ассоциированные функции (без `self`, например `String::new()`, `Vec::with_capacity(10)`).\n- **Трейты — интерфейсы Rust.** Дефолтные реализации методов; авто-вывод стандартных через `#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]`. Важные стандартные: `Debug`\u002F`Display`, `PartialEq`\u002F`Eq`, `PartialOrd`\u002F`Ord`, `Hash`, `Default`, `Iterator`, `From`\u002F`Into`.\n- **`From` \u002F `Into` \u002F `TryFrom` \u002F `TryInto`.** Реализуй `From` — `Into` появится автоматически. Идиома: всегда `impl From\u003CX> for Y`, никогда `impl Into` (orphan rule + удобство для пользователей).\n- **Дженерики:** `fn largest\u003CT: Ord>(items: &[T]) -> &T`. Trait bounds (`T: Ord`), `where`-клаузы для читаемости при многих ограничениях, `impl Trait` в позиции аргумента\u002Fвозврата (для краткости).\n- **Trait objects:** `dyn Trait`, `Box\u003Cdyn Trait>`, `&dyn Trait` — runtime-полиморфизм. **Статический диспатч** (дженерики, `impl Trait`) — компилятор делает копии под каждый тип, нет накладных расходов; **динамический** (`dyn Trait`) — vtable + указатель, удобно для гетерогенных коллекций `Vec\u003CBox\u003Cdyn Trait>>`.\n- **Object safety.** Не каждый трейт можно превратить в `dyn Trait`: запрещены generic-методы, `Self` в позиции возврата, ассоциированные константы. Если `dyn Trait` не компилируется — почти всегда нарушено object safety.\n- **Orphan rule и blanket impls.** Чтобы реализовать `Trait for Type`, либо trait, либо type должны быть из твоего крейта. Blanket impl: `impl\u003CT: Display> ToString for T` — реализация для всех подходящих типов сразу.\n- **Итераторы и замыкания.** `Iterator` — самый используемый трейт. Цепочки `.iter().filter().map().collect()` — идиоматичный Rust. Замыкания: `Fn` (читает захваты), `FnMut` (мутирует), `FnOnce` (потребляет — например, `move`-замыкание со строкой).\n- **Коллекции stdlib:** `Vec\u003CT>` (динамический массив), `HashMap\u003CK, V>` (хеш-таблица), `HashSet\u003CT>`, `BTreeMap`\u002F`BTreeSet` (упорядоченные), `VecDeque` (двухсторонняя очередь). Знай асимптотику основных операций.\n\n**Где изучать:**\n\n- [The Rust Book, гл. 5–10, 13](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002F) — структуры, enum'ы, generics, trait'ы, lifetimes (повторно), итераторы и замыкания.\n- [Rust by Example: Custom Types, Conversion, Generics, Traits, Closures, Iterators](https:\u002F\u002Fdoc.rust-lang.org\u002Frust-by-example\u002F).\n- [Rustlings: `structs`, `enums`, `options`, `error_handling`, `generics`, `traits`, `lifetimes`, `iterators`](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Frustlings).\n- [Rust API Guidelines](https:\u002F\u002Frust-lang.github.io\u002Fapi-guidelines\u002F) — чтобы сразу делать идиоматичные публичные типы.\n- [«Effective Rust»](https:\u002F\u002Fwww.lurklurk.org\u002Feffective-rust\u002F) — главы 1–8 идеально ложатся именно на этот этап.\n\n**Зачем это нужно:** struct + enum + traits + iterators — это то, как ты *моделируешь* предметную область в Rust. Когда начнёшь использовать `enum` для состояний и `Option` вместо `null`, целые классы багов исчезают на уровне типов.\n\n**Мини-проекты:** телефонная книга в CLI (потом — сохранение\u002Fзагрузка в JSON через `serde`), CLI todo-list, простой граф (`HashMap\u003CNodeId, Vec\u003CNodeId>>`) с поиском в ширину\u002Fглубину, парсер арифметических выражений через `enum Expr { Num(f64), Add(Box\u003CExpr>, Box\u003CExpr>), ... }` с интерпретатором.\n\n---\n\n## Этап 4. Обработка ошибок и тестирование (1–2 недели)\n\n**Что изучать:**\n\n- **`panic!`, `unwrap`, `expect`** — *быстрый и грязный* способ: программа падает при ошибке. Норм для прототипов, примеров из Rust Book, инвариантов «здесь по построению точно `Some`». **Не норм** для production-логики и публичных API библиотек.\n- **Идиоматичная обработка:** `Result\u003CT, E>` везде, **оператор `?`** для проброса ошибки одним символом. `?` автоматически вызывает `From`, конвертируя один тип ошибки в другой.\n- **Свои типы ошибок через [`thiserror`](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Fthiserror)** — для **библиотек**, где потребителям нужно матчить конкретные варианты:\n  ```rust\n  #[derive(thiserror::Error, Debug)]\n  pub enum MyError {\n      #[error(\"io: {0}\")]\n      Io(#[from] std::io::Error),\n      #[error(\"parse: bad value at line {line}\")]\n      Parse { line: usize },\n  }\n  ```\n- **[`anyhow`](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Fanyhow)** — для **приложений**: `anyhow::Result\u003CT>`, `anyhow!` для создания ошибки из строки, `.context(\"loading config\")` для добавления контекста. Конкурент: [`color-eyre`](https:\u002F\u002Fgithub.com\u002Feyre-rs\u002Feyre) — то же самое, но с красивым выводом и поддержкой кастомных хендлеров.\n- **Правило большого пальца:** библиотеки → `thiserror` (точные enum-ошибки); бинари \u002F приложения → `anyhow`\u002F`eyre` (контекст + цепочка причин). Не смешивай в одном крейте.\n- **Конверсии `From` \u002F `Into`** — как `?` автоматически превращает `io::Error` в `MyError`. `#[from]` в `thiserror` генерирует `impl From` за тебя.\n- **`Result::map_err`, `.context()`, `.with_context(|| ...)`** — добавление контекста к ошибке без потери исходной причины (`source` chain).\n- **Panic vs Result — когда что:** Panic — невосстановимая ошибка (битый инвариант, баг). Result — ожидаемая (файла нет, parse failed). `unwrap()` в production допустим только там, где доказать, что значение есть, проще, чем переписать код.\n- **Тестирование:**\n  - Юнит-тесты в `mod tests { #[test] fn name() { ... } }` рядом с кодом.\n  - Интеграционные — в `tests\u002F` (отдельные крейты, видят только публичный API).\n  - **Doc-тесты** — примеры в `\u002F\u002F\u002F`-комментариях запускаются как тесты на `cargo test`. Сразу и документация, и проверка.\n  - `#[should_panic(expected = \"...\")]`, `#[ignore]` (для долгих, запуск через `cargo test -- --ignored`).\n- **Property-based тестирование:** [`proptest`](https:\u002F\u002Fgithub.com\u002Fproptest-rs\u002Fproptest) или [`quickcheck`](https:\u002F\u002Fgithub.com\u002FBurntSushi\u002Fquickcheck). Вместо «проверить пару примеров» — задаёшь свойство и крейт генерирует сотни случайных входов, ищет минимальный контрпример.\n- **Snapshot-тесты:** [`insta`](https:\u002F\u002Fgithub.com\u002Fmitsuhiko\u002Finsta) — особенно удобно для сложного вывода (JSON, HTML, дерева AST). Запустил, проверил глазами, утвердил — дальше тест ловит регрессии.\n- **Бенчмарки:** [`criterion`](https:\u002F\u002Fgithub.com\u002Fbheisler\u002Fcriterion.rs) — статистически грамотные бенчи (встроенный `#[bench]` доступен только на nightly и проигрывает `criterion` по выводу и шуму).\n\n**Где изучать:**\n\n- [The Rust Book, гл. 9 (ошибки), 11 (тесты), 14 §3 (doc-тесты)](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002Fch09-00-error-handling.html).\n- [README `thiserror`](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Fthiserror) и [README `anyhow`](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Fanyhow) — короткие, прочитать оба.\n- Статья: [«Error Handling In Rust — A Deep Dive» (Luca Palmieri)](https:\u002F\u002Fwww.lpalmieri.com\u002Fposts\u002Ferror-handling-rust\u002F) — лучший разбор за один заход.\n- [«Beginner's guide to property-based testing in Rust»](https:\u002F\u002Faltsysrq.github.io\u002Fproptest-book\u002Fintro.html).\n\n**Зачем это нужно:** ошибки — это половина боевого кода. `Result + ?` делает их обработку приятной *и* явной — ты буквально не можешь молча проигнорировать ошибку. Тесты дают уверенность для рефакторинга; без них любое нетривиальное изменение страшно.\n\n**Мини-проект:** CLI-утилита для валидации конфигов (JSON\u002FTOML) — читает, парсит, возвращает список ошибок с номерами строк. Свой тип ошибки через `thiserror`, интеграционный тест на `tests\u002F`, doc-тесты на публичные функции, `proptest` на парсер.\n\n---\n\n## Этап 5. Умные указатели и интериор-мутабельность (2 недели)\n\n**Что изучать:**\n\n- **`Box\u003CT>`** — аллокация на куче. Нужен, когда тип имеет известный размер на компиляции, но ты хочешь его на куче. Классика — рекурсивные типы:\n  ```rust\n  enum List { Cons(i32, Box\u003CList>), Nil }\n  ```\n  Без `Box` рекурсивный enum имел бы бесконечный размер. Также используется для `Box\u003Cdyn Trait>` и для возврата больших значений без копирования стека.\n- **`Rc\u003CT>`** — *Reference Counted*, разделяемое владение **в одном потоке**. Несколько владельцев, освобождается, когда последний уходит. `Rc::clone(&rc)` — дешёвая операция (инкремент счётчика), не глубокое копирование.\n- **`Arc\u003CT>`** — *Atomic Reference Counted*, потокобезопасная версия `Rc`. Чуть медленнее из-за атомарных операций. Используй ровно тогда, когда данные пересекают границу потоков.\n- **Циклические ссылки и `Weak\u003CT>`.** `Rc`\u002F`Arc` **не освобождает** циклы — это утечка памяти (не UB, но плохо). Для деревьев с обратными ссылками (parent ← child) используй `Weak` для одного направления; `Weak::upgrade()` возвращает `Option\u003CRc\u003CT>>`.\n- **Интериор-мутабельность.** Как менять данные через `&T` (общую ссылку). Обычное правило Rust говорит «нельзя» — эти типы являются спасательными люками с runtime-проверкой:\n  - **`Cell\u003CT>`** — для `Copy`-типов, `get`\u002F`set` по значению, без borrow. Очень дёшево, но только для `Copy`.\n  - **`RefCell\u003CT>`** — runtime-проверка borrow (`borrow()` \u002F `borrow_mut()`); один поток. **Грабли:** `borrow_mut` panics, если уже есть активный borrow — это runtime-аналог borrow checker'а.\n  - **`Mutex\u003CT>`** — потокобезопасный, блокирует. `mutex.lock().unwrap()` — `unwrap` потому что lock возвращает `Result` (poisoning при панике в другом потоке).\n  - **`RwLock\u003CT>`** — много читателей или один писатель, потокобезопасно. На сильной contention может страдать от writer starvation — для горячих структур иногда лучше [`parking_lot::RwLock`](https:\u002F\u002Fgithub.com\u002FAmanieu\u002Fparking_lot) или `Mutex`.\n  - **`OnceLock\u003CT>`** (stable с 1.70) \u002F **`OnceCell\u003CT>`** (одно-поточная) — записать один раз, читать многократно. Идеальная замена `lazy_static!` для глобалов.\n  - **`LazyLock\u003CT>`** (stable с 1.80) \u002F **`LazyCell\u003CT>`** — ленивая инициализация при первом доступе. Современная замена `once_cell::Lazy`.\n- **`Cow\u003C'_, T>`** (Clone-On-Write) — `Cow::Borrowed(&str)` или `Cow::Owned(String)`. Полезно для функций, которые **обычно** не модифицируют вход, но иногда должны (например, нормализация строк).\n- **`Pin\u003CT>`** — гарантия, что значение не сдвинется в памяти. Нужен для self-referential типов (typically — для async-future). На этом этапе достаточно знать, что он существует и зачем; глубокое погружение — на этапе 13.\n- **Drop, RAII, drop order.** Поля структуры дропаются в порядке объявления. `std::mem::drop(x)` — явный ранний дроп. Не реализуй `Drop` ради привычки — большинству типов он не нужен.\n- **Когда что выбирать (шпаргалка):**\n  - один владелец на стеке → обычное значение;\n  - один владелец на куче → `Box\u003CT>`;\n  - несколько владельцев в потоке → `Rc\u003CT>`;\n  - несколько владельцев между потоками → `Arc\u003CT>`;\n  - мутация через общую ссылку, один поток → `RefCell` (или `Cell` для `Copy`);\n  - мутация между потоками → `Mutex` \u002F `RwLock` \u002F атомики.\n\n**Где изучать:**\n\n- [The Rust Book, гл. 15 (умные указатели), гл. 16 (overlap с многопоточностью)](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002Fch15-00-smart-pointers.html).\n- [Rust by Example: Box, Rc, Cell\u002FRefCell](https:\u002F\u002Fdoc.rust-lang.org\u002Frust-by-example\u002Fstd\u002Fbox.html).\n- Классика: [«Learn Rust With Entirely Too Many Linked Lists»](https:\u002F\u002Frust-unofficial.github.io\u002Ftoo-many-lists\u002F) — реализуем 6 связных списков, каждый учит свой умный указатель. *Тот самый* туториал на этот этап, обязательно.\n- [docs.rs\u002Fonce_cell](https:\u002F\u002Fdocs.rs\u002Fonce_cell\u002F) — переходное чтение перед `OnceLock`\u002F`LazyLock` из stdlib.\n\n**Зачем это нужно:** без умных указателей Rust ощущается зажатым («как мне это пошарить?!»). С ними понимаешь, *почему* обычные правила Rust такие строгие — они дают статические гарантии, а эти типы — аккуратно подписанные исключения с явной runtime-стоимостью.\n\n**Мини-проект:** двусвязный список (`Rc` + `RefCell` + `Weak`) или дерево, где дети знают родителя; кэш с `OnceLock` для ленивого вычисления тяжёлых констант.\n\n---\n\n## Этап 6. Многопоточность (2–3 недели)\n\n**Что изучать:**\n\n- **`std::thread::spawn`** — создаёт OS-поток. Замыкание захватывает данные; без `move` Rust не даст захватить переменные с лайфтаймом (нет гарантий, что они переживут поток).\n- **`std::thread::scope`** (stable с 1.63) — **scoped threads**. Позволяет потокам безопасно заимствовать данные из родителя; scope ждёт завершения всех порождённых потоков. Современный дефолт для параллельной обработки локальных данных.\n- **`Send` и `Sync`** — два маркерных трейта, на которых строится thread safety:\n  - `T: Send` — значение можно **передать** в другой поток.\n  - `T: Sync` — на значение можно **сослаться** из другого потока (`&T: Send`).\n  - `Rc` — **не** `Send` (счётчик не атомарный); `Arc` — `Send`. Компилятор не даст пошарить `Rc` между потоками — гарантия, не предупреждение.\n- **Разделяемое состояние:** `Arc\u003CMutex\u003CT>>`, `Arc\u003CRwLock\u003CT>>` — каноническая обёртка для shared mutable state. Стандартные `Mutex`\u002F`RwLock` на Linux реализованы через futex и разумно быстры; для интенсивно конкурируемых случаев — [`parking_lot`](https:\u002F\u002Fgithub.com\u002FAmanieu\u002Fparking_lot) (короче, быстрее, без poisoning).\n- **Каналы (message passing).** Идиома Rust: «не шарьте память, передавайте сообщения».\n  - `std::sync::mpsc` — multi-producer single-consumer, в stdlib.\n  - [`crossbeam-channel`](https:\u002F\u002Fgithub.com\u002Fcrossbeam-rs\u002Fcrossbeam) — быстрее, поддерживает `select`, bounded\u002Funbounded.\n  - [`flume`](https:\u002F\u002Fgithub.com\u002Fzesterer\u002Fflume) — современная альтернатива `mpsc` с async-API.\n- **Атомики:** `AtomicUsize`, `AtomicBool`, `AtomicPtr` — целочисленные операции без блокировок. **Memory ordering** (`Relaxed`, `Acquire`, `Release`, `AcqRel`, `SeqCst`) — глубокая тема; **новичкам** хватит правила «если не уверен — `SeqCst`, не теряя в корректности; оптимизировать упорядочения — после освоения этапов 13–14».\n- **Параллельные итераторы — [`rayon`](https:\u002F\u002Fgithub.com\u002Frayon-rs\u002Frayon).** `v.par_iter().map(...).sum()` — прозрачное распараллеливание data-parallel вычислений на work-stealing thread pool. Чаще всего этого достаточно: не надо вручную поднимать потоки.\n- **Условные переменные и барьеры:** `Condvar`, `Barrier` — низкоуровневая синхронизация. На практике редки; обычно лучше канал.\n- **Деадлоки.** Rust **не защищает** от deadlocks (защищает только от data races). Правило: всегда захватывай мьютексы в одном порядке; не вызывай чужой код, держа lock; используй `tokio::sync::Mutex` или `parking_lot::Mutex` без poisoning, если poisoning не нужен.\n- **`thread_local!`** — данные, локальные для потока. Полезно для thread-local буферов и счётчиков.\n\n**Где изучать:**\n\n- [The Rust Book, гл. 16 (Бесстрашная многопоточность)](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002Fch16-00-concurrency.html).\n- [Rust Atomics and Locks (Mara Bos)](https:\u002F\u002Fmarabos.nl\u002Fatomics\u002F) — бесплатно онлайн, *та самая* книга по теме. Читать после главы Rust Book — в этой книге плотный практический разбор атомиков с нуля и реализация `Mutex` своими руками.\n- [README `rayon`](https:\u002F\u002Fgithub.com\u002Frayon-rs\u002Frayon) и [его docs](https:\u002F\u002Fdocs.rs\u002Frayon\u002F) — короткие, сразу полезные.\n- [«Crust of Rust: Atomics and Memory Ordering» (Jon Gjengset)](https:\u002F\u002Fwww.youtube.com\u002Fwatch?v=rMGWeSjctlY).\n\n**Зачем это нужно:** многопоточность — место, где большинство языков пропускают баги (data races, dangling references). Rust ловит data races на компиляции через `Send`\u002F`Sync` — это настоящая суперсила, ради которой многие выбирают язык.\n\n**Мини-проект:** параллельный word-counter (`rayon::par_iter` + объединение через `fold`\u002F`reduce`); thread-pool с очередью задач через `crossbeam-channel`; параллельный обработчик изображений (поток-производитель читает с диска, пул-потребителей применяет фильтр).\n\n---\n\n## Этап 7. Асинхронное программирование (3–4 недели)\n\n**Что изучать:**\n\n- **Трейт `Future`** — async-кирпичик Rust. Future — это *стейт-машина*, которую рантайм опрашивает (`poll`) до готовности. Ключевое: **future ничего не делает, пока ты не сделаешь `.await` или не отдашь его рантайму** (`tokio::spawn`). Это отличается от JS-промисов, которые исполняются eager.\n- **Синтаксис `async fn` и `.await`.** `async fn foo() -> T` — это `fn foo() -> impl Future\u003COutput = T>`. `.await` приостанавливает выполнение, возвращая контроль рантайму, до готовности future.\n- **Рантаймы.** В 95% случаев — [`tokio`](https:\u002F\u002Ftokio.rs\u002F) (де-факто стандарт; многопоточный планировщик, богатая экосистема). Альтернативы: [`async-std`](https:\u002F\u002Fasync.rs\u002F) (API ближе к stdlib, развитие замедлилось), [`smol`](https:\u002F\u002Fgithub.com\u002Fsmol-rs\u002Fsmol) (минималистичный). Не смешивай рантаймы в одном бинаре.\n- **`tokio::main`:**\n  ```rust\n  #[tokio::main]\n  async fn main() -> anyhow::Result\u003C()> { ... }\n  ```\n  Под капотом — `Builder` для рантайма; для production-сервисов часто пишут конфигурацию рантайма вручную.\n- **`tokio::spawn` vs `tokio::task::spawn_blocking`.** `spawn` — для async-задач (требует `Send + 'static` от future). `spawn_blocking` — переносит **синхронную** работу в отдельный thread pool, чтобы не заморозить async-планировщик. Любая блокирующая операция (`std::fs`, тяжёлый CPU-кранч, синхронный SDK) обязана идти через `spawn_blocking`.\n- **Стримы (`futures::Stream`, `tokio_stream`)** — асинхронные итераторы. `while let Some(x) = stream.next().await { ... }`. Backpressure обрабатывается естественно через `.await`.\n- **`tokio::select!`** — гонка нескольких future; первый завершившийся выигрывает, остальные **отменяются**. Это источник тонких багов «cancellation safety»: если внутри ветки была накопленная работа без `.await`-точек до commit'а — она теряется. Читай документацию `select!` целиком, не по диагонали.\n- **`JoinSet`** (`tokio::task::JoinSet`) — динамический набор задач, можно `spawn` новые в процессе и `join_next().await` для забора результатов. Современный способ организовать «обработать N запросов параллельно с лимитом».\n- **`Send + 'static` ловушки.** Future, передаваемая в `spawn`, должна быть `Send + 'static`. Если внутри держится `Rc` или non-`Send`-тип через `.await` — компилятор объяснит, но сообщение бывает длинное. Обычное лекарство: заменить `Rc` на `Arc`, либо вытащить non-`Send` за пределы `.await`.\n- **Async-сеть и HTTP:** TCP\u002FUDP через `tokio::net`; HTTP-клиент [`reqwest`](https:\u002F\u002Fgithub.com\u002Fseanmonstar\u002Freqwest); сервер — [`axum`](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Faxum) (на `tokio` + `tower`) или [`actix-web`](https:\u002F\u002Factix.rs\u002F).\n- **Каналы для async:** `tokio::sync::mpsc` \u002F `oneshot` \u002F `broadcast` \u002F `watch` — каждая со своим назначением. `oneshot` — для «отправить один ответ»; `watch` — для «последнее значение видно всем».\n- **Async-Mutex.** `tokio::sync::Mutex` нужен только если lock держится **через `.await`**. В остальных случаях — `std::sync::Mutex` или `parking_lot::Mutex` быстрее (нет async-overhead).\n- **Логирование и диагностика:** [`tracing`](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Ftracing) + `tracing-subscriber` — стандарт для async; spans корректно прослеживаются через task'и. [`tokio-console`](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Fconsole) — интерактивный отладчик задач (вид процессов в `top`, но для tokio).\n\n**Где изучать:**\n\n- [The Rust Book, гл. 17 (Async и await — в новых редакциях)](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002F) — вводное.\n- [Asynchronous Programming in Rust](https:\u002F\u002Frust-lang.github.io\u002Fasync-book\u002F) — официальная книга по async.\n- [Tokio Tutorial](https:\u002F\u002Ftokio.rs\u002Ftokio\u002Ftutorial) — пошаговое создание Mini-Redis.\n- Видео: [«The What and How of Futures and async\u002Fawait in Rust» (Jon Gjengset)](https:\u002F\u002Fwww.youtube.com\u002Fwatch?v=9_3krAQtD2k).\n- [Alice Ryhl — «Actors with Tokio»](https:\u002F\u002Fryhl.io\u002Fblog\u002Factors-with-tokio\u002F) и «Shared mutable state in Rust» — короткие практические заметки от core-разработчика `tokio`.\n\n**Зачем это нужно:** большинство production-Rust сервисов — async (web-бэкенды, прокси, сетевые тулзы, БД-клиенты). Поверхностного знания tokio мало: cancellation safety, `Send`-ловушки и `spawn_blocking` регулярно ломают код тех, кто ими не озаботился.\n\n**Мини-проекты:** многопоточный TCP-эхо-сервер (`tokio::net::TcpListener`); HTTP-агрегатор, который параллельно опрашивает 10 API через `reqwest` + `JoinSet` и собирает ответы; mini-Redis (TCP + RESP-протокол + `HashMap` под `Mutex`).\n\n---\n\n## Этап 8. Макросы и метапрограммирование (2 недели)\n\n**Что изучать:**\n\n- **Декларативные макросы — `macro_rules!`.** Pattern-match по токенам, разворачиваются в код. Ты уже пользуешься: `println!`, `vec!`, `assert_eq!`, `format!` — это они.\n  - Фрагменты: `expr`, `ident`, `ty`, `pat`, `block`, `stmt`, `path`, `tt` (token tree), `item`. Не путай — каждый позволяет ровно своё.\n  - Повторители: `$( ... ),*` — ноль или больше через запятую; `$( ... )+` — один или больше.\n  - **Гигиена.** `macro_rules!` гигиеничен по умолчанию: имена, объявленные внутри макроса, не пересекаются с внешними. Это не `#define` из C.\n- **Процедурные макросы** — три вида:\n  - **derive** (`#[derive(MyTrait)]`) — добавляет реализацию трейта;\n  - **атрибутные** (`#[my_attribute] fn ...`) — преобразуют элемент целиком (используется в `#[tokio::main]`, `#[tracing::instrument]`);\n  - **функциональные** (`my_macro!(...)`) — выглядят как обычные макросы, но работают с любыми токенами.\n  Живут в **отдельном крейте** с `proc-macro = true` в `Cargo.toml`.\n- **Тройка для проц-макросов:**\n  - [`syn`](https:\u002F\u002Fdocs.rs\u002Fsyn) — парсит входящие токены в AST Rust;\n  - [`quote`](https:\u002F\u002Fdocs.rs\u002Fquote) — генерирует Rust по шаблону (`quote! { fn #name() {} }`);\n  - [`proc-macro2`](https:\u002F\u002Fdocs.rs\u002Fproc-macro2) — стабильная обёртка над нестабильным `proc_macro` API; нужна, чтобы код проц-макроса можно было юнит-тестировать без `rustc`.\n- **[`darling`](https:\u002F\u002Fgithub.com\u002FTedDriggs\u002Fdarling)** — высокоуровневая обёртка над `syn` для парсинга атрибутов `#[my_macro(field = \"value\", flag)]`. Сильно сокращает derive-макрос.\n- **[`trybuild`](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Ftrybuild)** — тестирование, что неправильное использование макроса даёт ожидаемое сообщение об ошибке. Стандарт для проверки UI proc-макросов.\n- **`cargo expand`** (из `cargo install cargo-expand`) — посмотреть, во что разворачивается макрос. Незаменимо при отладке. Работает и для `macro_rules!`, и для `derive`.\n- **Когда стоит писать макрос:** когда устранение бойлерплейта реально окупает усложнение чтения. Часто лучше **функция или дженерик**, а не макрос.\n\n**Где изучать:**\n\n- [The Rust Book, гл. 19 §6 (Макросы)](https:\u002F\u002Fdoc.rust-lang.ru\u002Fbook\u002Fch19-06-macros.html) — мягкое введение.\n- [The Little Book of Rust Macros](https:\u002F\u002Fveykril.github.io\u002Ftlborm\u002F) — исчерпывающий справочник по `macro_rules!`, читать целиком.\n- [`proc-macro-workshop` от David Tolnay](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Fproc-macro-workshop) — упражнения, через которые проходят все, кто всерьёз пишет проц-макросы. Материал на 1–2 выходных.\n- Документация [`syn`](https:\u002F\u002Fdocs.rs\u002Fsyn) и [`quote`](https:\u002F\u002Fdocs.rs\u002Fquote) с примерами.\n\n**Зачем это нужно:** даже если своих макросов писать не будешь, чтение чужих и понимание, что генерируется при `#[derive(Serialize, Deserialize)]` или `#[tokio::main]`, делает экосистему прозрачной. И сокращает «магия Rust» до «это вот такой код, я могу его прочитать через `cargo expand`».\n\n**Мини-проект:** свой `derive(Builder)` — для `struct User { name: String, age: u32 }` сгенерировать `UserBuilder` с цепочечными сеттерами и методом `build() -> Result\u003CUser, _>`. Это упражнение #2 из `proc-macro-workshop`.\n\n---\n\n## Этап 9. Unsafe Rust и FFI (2 недели)\n\n**Что изучать:**\n\n- **Что реально открывает `unsafe`** (всего пять «суперсил»): разыменование сырых указателей; вызов `unsafe`-функций; доступ\u002Fизменение мутабельных `static`; реализация `unsafe`-трейтов; доступ к полям `union`. **Всё.** `unsafe` *не* отключает borrow checker и *не* делает Rust C-подобным — он просто говорит «здесь я беру на себя инварианты, которые компилятор не может проверить».\n- **Контракт безопасности.** Каждая `unsafe fn` обязана иметь блок `\u002F\u002F\u002F # Safety` в doc-комментарии, перечисляющий инварианты вызывающего. Это **часть API**, а не пожелание.\n- **Сырые указатели:** `*const T`, `*mut T`. Не имеют гарантий лайфтайма, могут быть null, могут указывать на освобождённую память. Создание сырого указателя — safe; разыменование — unsafe.\n- **`MaybeUninit\u003CT>`** — корректный способ работать с неинициализированной памятью. `mem::uninitialized()` deprecated и UB. Паттерн: `let mut x = MaybeUninit::\u003CT>::uninit(); ptr::write(x.as_mut_ptr(), value); let x = unsafe { x.assume_init() };`.\n- **`mem::transmute`** — почти всегда **не то**, что нужно. Крайний случай. Сначала смотри `as`, `From`\u002F`Into`, `bytemuck`\u002F`zerocopy`.\n- **Strict Provenance API** (стабилизируется): `ptr.addr()`, `ptr::with_addr`, `expose_addr`. Аккуратная работа с указателями как с числами; устраняет класс UB при оптимизациях.\n- **FFI с C:**\n  - `extern \"C\" fn` для функций, видимых из C;\n  - `#[repr(C)]` для структур, чья раскладка должна совпадать с C;\n  - [`bindgen`](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Frust-bindgen) — генерирует Rust-биндинги по C-хедерам;\n  - [`cbindgen`](https:\u002F\u002Fgithub.com\u002Fmozilla\u002Fcbindgen) — наоборот, генерирует C-хедер по Rust-API;\n  - [`cxx`](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Fcxx) — безопасный мост Rust↔C++ с генерацией биндингов через декларацию типов.\n- **Атрибуты layout:** `#[repr(C)]` (как в C), `#[repr(transparent)]` (как у внутреннего поля — для newtype-обёрток без overhead), `#[repr(packed)]` (без выравнивания — осторожно: ссылки на packed-поля недопустимы), `#[repr(u8)]` для enum-discriminant.\n- **Panic через границу FFI — UB.** Оборачивай экспортируемые функции в `std::panic::catch_unwind`, превращая панику в код ошибки.\n- **Miri** — интерпретатор Rust, который ловит UB в твоём `unsafe`-коде (use-after-free, неинициализированные чтения, выход за границу, нарушение алиасинга). Прогоняй критичные тесты через `cargo +nightly miri test`. Это самый дешёвый способ найти ошибку `unsafe`.\n- **AddressSanitizer \u002F ThreadSanitizer \u002F MemorySanitizer \u002F LeakSanitizer** через nightly: `RUSTFLAGS=\"-Z sanitizer=address\" cargo +nightly test`. Дополняет Miri (ловит то, что Miri не моделирует, например, реальные heap corruption).\n\n**Где изучать:**\n\n- [The Rustonomicon](https:\u002F\u002Fdoc.rust-lang.org\u002Fnomicon\u002F) — *главная* книга про unsafe. Читать после уверенного safe Rust. Особое внимание главам про aliasing, variance, drop check.\n- [The Rust Reference: Unsafety](https:\u002F\u002Fdoc.rust-lang.org\u002Freference\u002Funsafety.html) — формальный справочник.\n- [«Learn Rust the Dangerous Way»](https:\u002F\u002Fcliffle.com\u002Fp\u002Fdangerust\u002F) — пошаговый перенос C-программы в `unsafe` Rust, потом — итеративная замена на safe.\n- [Документация `bindgen`](https:\u002F\u002Frust-lang.github.io\u002Frust-bindgen\u002F) и [`cxx`](https:\u002F\u002Fcxx.rs\u002F).\n- [Miri README](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Fmiri).\n\n**Зачем это нужно:** `unsafe` нужен на стыке с C-библиотеками, для нестандартных структур данных (свои аллокаторы, lock-free очереди), для перформанс-критичного кода (zero-copy парсеры, FFI без копирования). 99% Rust-кода — safe; `unsafe` — это инструмент, к которому подходят с осторожностью и доказательством корректности.\n\n**Мини-проект:** написать **safe**-обёртку над небольшой C-библиотекой (например, [`libsodium`](https:\u002F\u002Flibsodium.org\u002F) или `zlib`) через `bindgen`, валидируя инварианты на границе и закрывая `unsafe` блоком `#![deny(unsafe_op_in_unsafe_fn)]`. Прогон тестов под Miri.\n\n---\n\n## Этап 10. Экосистема и реальные проекты\n\n**Что изучать — по доменам:**\n\n- **Веб-бэкенды.** [`axum`](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Faxum) — рекомендую как дефолт (`tokio` + `tower`, отличная типизация, активная разработка); [`actix-web`](https:\u002F\u002Factix.rs\u002F) (зрелый, очень быстрый); [`rocket`](https:\u002F\u002Frocket.rs\u002F) (приятный декларативный API); [`poem`](https:\u002F\u002Fgithub.com\u002Fpoem-web\u002Fpoem). HTTP-крейты под капотом: [`hyper`](https:\u002F\u002Fgithub.com\u002Fhyperium\u002Fhyper), [`tower`](https:\u002F\u002Fgithub.com\u002Ftower-rs\u002Ftower) (composable middleware: rate-limiting, retry, timeout, load shedding), [`tower-http`](https:\u002F\u002Fgithub.com\u002Ftower-rs\u002Ftower-http) (CORS, compression, tracing, auth).\n- **Базы данных.** [`sqlx`](https:\u002F\u002Fgithub.com\u002Flaunchbadge\u002Fsqlx) — async, **проверка SQL на компиляции** (макрос `query!` ходит в живую БД во время сборки), современный дефолт; [`diesel`](https:\u002F\u002Fdiesel.rs\u002F) (sync ORM с сильной типизацией и миграциями); [`sea-orm`](https:\u002F\u002Fwww.sea-ql.org\u002FSeaORM\u002F) (async ORM, ближе к ActiveRecord); [`redis`](https:\u002F\u002Fgithub.com\u002Fredis-rs\u002Fredis-rs); [`mongodb`](https:\u002F\u002Fgithub.com\u002Fmongodb\u002Fmongo-rust-driver). Миграции — `sqlx-cli`, `diesel migration`, [`refinery`](https:\u002F\u002Fgithub.com\u002Frust-db\u002Frefinery).\n- **Сериализация.** [`serde`](https:\u002F\u002Fserde.rs\u002F) — *тот самый* фреймворк, де-факто стандарт. Поддерживает JSON ([`serde_json`](https:\u002F\u002Fgithub.com\u002Fserde-rs\u002Fjson)), YAML ([`serde_yaml`](https:\u002F\u002Fgithub.com\u002Fdtolnay\u002Fserde-yaml)), TOML ([`toml`](https:\u002F\u002Fgithub.com\u002Ftoml-rs\u002Ftoml)), MessagePack, [`bincode`](https:\u002F\u002Fgithub.com\u002Fbincode-org\u002Fbincode), [`postcard`](https:\u002F\u002Fgithub.com\u002Fjamesmunns\u002Fpostcard) (для embedded), [`prost`](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Fprost) и [`protobuf`](https:\u002F\u002Fgithub.com\u002Fstepancheg\u002Frust-protobuf) (Protocol Buffers).\n- **CLI.** [`clap`](https:\u002F\u002Fgithub.com\u002Fclap-rs\u002Fclap) (парсинг аргументов, derive-API, генерация completions для bash\u002Fzsh\u002Ffish), [`structopt`](https:\u002F\u002Fgithub.com\u002FTeXitoi\u002Fstructopt) (исторический предок `clap` derive — теперь не нужен, всё в `clap v4`), [`dialoguer`](https:\u002F\u002Fgithub.com\u002Fconsole-rs\u002Fdialoguer) (интерактивные промпты), [`indicatif`](https:\u002F\u002Fgithub.com\u002Fconsole-rs\u002Findicatif) (прогресс-бары), [`console`](https:\u002F\u002Fgithub.com\u002Fconsole-rs\u002Fconsole) (цвета, стили в терминале).\n- **Логирование и трассировка.** [`tracing`](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Ftracing) + `tracing-subscriber` — современный дефолт (структурированные логи, spans, OpenTelemetry-интеграция). Старый [`log`](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Flog) ещё жив и хорош для библиотек (нейтральный фасад). Не путай: `tracing` для приложений, `log` для библиотек, которые не хотят форсить выбор системы логирования.\n- **Конфигурация:** [`config`](https:\u002F\u002Fgithub.com\u002Fmehcode\u002Fconfig-rs) (слои: файл + env + override), [`figment`](https:\u002F\u002Fgithub.com\u002FSergioBenitez\u002FFigment) (от автора Rocket, гибче). Загрузка `.env` — [`dotenvy`](https:\u002F\u002Fgithub.com\u002Fallan2\u002Fdotenvy) (форк `dotenv`, который не поддерживается).\n- **HTTP-клиент.** [`reqwest`](https:\u002F\u002Fgithub.com\u002Fseanmonstar\u002Freqwest) — дефолт (async, JSON, мультипарт, прокси). Альтернативы: [`ureq`](https:\u002F\u002Fgithub.com\u002Falgesten\u002Fureq) (sync, минимум зависимостей), [`hyper`](https:\u002F\u002Fgithub.com\u002Fhyperium\u002Fhyper) (низкий уровень, под нестандартные задачи).\n- **WebSockets:** [`tokio-tungstenite`](https:\u002F\u002Fgithub.com\u002Fsnapview\u002Ftokio-tungstenite), сервер на `axum` через `axum::extract::WebSocketUpgrade`.\n- **gRPC:** [`tonic`](https:\u002F\u002Fgithub.com\u002Fhyperium\u002Ftonic) — async-gRPC на `tokio` + `prost`.\n- **CLI-утилиты для разработчиков:** `cargo-edit`, `cargo-watch`, `cargo-expand`, `cargo-outdated`, `cargo-audit` (CVE), `cargo-deny` (банлисты лицензий и крейтов), `cargo-nextest` (быстрый тест-раннер, в 2–3 раза быстрее `cargo test` на больших проектах), `cargo-llvm-cov` (покрытие кода).\n- **Дата\u002Fвремя:** [`chrono`](https:\u002F\u002Fgithub.com\u002Fchronotope\u002Fchrono) (классика, много API), [`time`](https:\u002F\u002Fgithub.com\u002Ftime-rs\u002Ftime) (современнее, с `no_std`), [`jiff`](https:\u002F\u002Fgithub.com\u002FBurntSushi\u002Fjiff) (новый, с правильной работой с таймзонами от автора `ripgrep`).\n- **Регулярки и парсинг:** [`regex`](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Fregex), [`nom`](https:\u002F\u002Fgithub.com\u002Frust-bakery\u002Fnom) (комбинаторный парсер), [`winnow`](https:\u002F\u002Fgithub.com\u002Fwinnow-rs\u002Fwinnow) (наследник `nom` v8 с переписанным API), [`pest`](https:\u002F\u002Fgithub.com\u002Fpest-parser\u002Fpest) (PEG, грамматика отдельным файлом).\n- **Шаблонизаторы:** [`askama`](https:\u002F\u002Fgithub.com\u002Fdjc\u002Faskama) (compile-time, типобезопасен), [`tera`](https:\u002F\u002Fgithub.com\u002FKeats\u002Ftera) (runtime, как Jinja2), [`maud`](https:\u002F\u002Fgithub.com\u002Flambda-fairy\u002Fmaud) (HTML как макрос Rust).\n\n**Где изучать:**\n\n- [Awesome Rust](https:\u002F\u002Fgithub.com\u002Frust-unofficial\u002Fawesome-rust) — каталог крейтов и проектов.\n- [lib.rs](https:\u002F\u002Flib.rs\u002F) — альтернатива crates.io с более удобной навигацией и категоризацией.\n- [«Zero To Production In Rust» (Luca Palmieri)](https:\u002F\u002Fwww.zero2prod.com\u002F) — *лучшая* книга по практическому веб-бэкенду на Rust (`actix-web` + `sqlx` + `tracing` + Docker). Если делаешь web — must-read.\n- [«Rust for Rustaceans» (Jon Gjengset)](https:\u002F\u002Fnostarch.com\u002Frust-rustaceans) — для перехода с уверенного среднего на продвинутый.\n- Официальная документация каждого крейта на [docs.rs](https:\u002F\u002Fdocs.rs\u002F).\n\n**Зачем это нужно:** одно дело — знать язык, другое — собрать рабочий сервис. Этот этап превращает «я могу написать функцию» в «я могу выкатить REST-API в Docker с миграциями БД, логами в JSON и метриками в Prometheus».\n\n**Мини-проект:** REST-API на `axum` + `sqlx` + Postgres с миграциями, аутентификацией (JWT через `jsonwebtoken`), `tracing` для логов, `tower-http` для CORS\u002Fcompression, тестами в `tests\u002F` и Dockerfile на multi-stage. **Это** — шипуемый проект уровня джуна-мидла.\n\n---\n\n## Этап 11. Уровень профи (4–8 недель и далее)\n\n**Что изучать:**\n\n- **Профилирование на уровне CPU и памяти.** Снятие flamegraph'ов, поиск горячих точек, анализ кеш-промахов и аллокаций. Инструменты: `perf` + [cargo-flamegraph](https:\u002F\u002Fgithub.com\u002Fflamegraph-rs\u002Fflamegraph) (Linux), [Instruments](https:\u002F\u002Fdeveloper.apple.com\u002Fxcode\u002F) (macOS), [`samply`](https:\u002F\u002Fgithub.com\u002Fmstange\u002Fsamply) (кросс-платформенно), [`heaptrack`](https:\u002F\u002Fgithub.com\u002FKDE\u002Fheaptrack), [`dhat`](https:\u002F\u002Fdocs.rs\u002Fdhat\u002F).\n- **Микрооптимизации и low-level perf.** SIMD через `std::simd` (nightly) или `std::arch` (stable), хинты `#[inline]` \u002F `#[cold]`, struct-of-arrays vs array-of-structs, cache-friendly layout, выравнивание (`#[repr(C, align(64))]`).\n- **Fuzz-тестирование и property-based.** [`cargo-fuzz`](https:\u002F\u002Fgithub.com\u002Frust-fuzz\u002Fcargo-fuzz) (libFuzzer), [`afl.rs`](https:\u002F\u002Fgithub.com\u002Frust-fuzz\u002Fafl.rs); property-based — [`proptest`](https:\u002F\u002Fgithub.com\u002Fproptest-rs\u002Fproptest), [`quickcheck`](https:\u002F\u002Fgithub.com\u002FBurntSushi\u002Fquickcheck), снапшот-тесты — [`insta`](https:\u002F\u002Fgithub.com\u002Fmitsuhiko\u002Finsta).\n- **Чтение исходников зрелых крейтов** по нарастающей сложности: `itertools` → `serde` → `tokio` → `hyper` → `rustc`. Это самый быстрый путь от среднего уровня к продвинутому.\n- **Open-source-вклад.** Бери `E-easy` \u002F `good-first-issue` в любом популярном крейте. Ревью от мейнтейнеров — лучший ускоритель роста.\n- **Публикация своего крейта на [crates.io](https:\u002F\u002Fcrates.io):** хорошие доки, CI на GitHub Actions, [семвер](https:\u002F\u002Fsemver.org\u002F), [`cargo-semver-checks`](https:\u002F\u002Fgithub.com\u002Fobi1kenobi\u002Fcargo-semver-checks) перед каждым релизом.\n- **Nightly-фичи и RFC-процесс.** Читай [Inside Rust Blog](https:\u002F\u002Fblog.rust-lang.org\u002Finside-rust\u002F), [`rust-lang\u002Frfcs`](https:\u002F\u002Fgithub.com\u002Frust-lang\u002Frfcs), подпишись на [This Week in Rust](https:\u002F\u002Fthis-week-in-rust.org\u002F).\n\n**Где изучать:**\n\n- The Rust Performance Book — \u003Chttps:\u002F\u002Fnnethercote.github.io\u002Fperf-book\u002F>\n- «Writing High-Performance Rust» (видеосерия Logan Smith и [fasterthanli.me](https:\u002F\u002Ffasterthanli.me\u002F)).\n- Зеркала лекций по `rustc` от разработчиков компилятора на YouTube.\n- Канал [@rust_code](https:\u002F\u002Ft.me\u002F+HelhY88sArowYjgy) — разборы кода и идиом, по которым удобно сверяться.\n\n**Зачем это нужно:** на этом уровне ты перестаёшь *учить Rust* и начинаешь *думать на Rust*. Лучшие инженеры публикуют библиотеки, которыми пользуются другие, шлют фиксы апстрим и понимают компромиссы дизайнеров языка.\n\n**Мини-проект:**\n\n- Возьми любой свой крейт уровня этапа 10, прогоняй его через `cargo-fuzz`, `proptest`, `criterion` — найди и почини хотя бы одну реальную проблему.\n- Сделай PR в популярный крейт (например, `tokio`, `serde`, `clap`, `reqwest`) — пусть даже небольшой фикс доки или теста.\n\n---\n\n# 🚀 Расширение roadmap: продвинутые темы\n\n> Этапы ниже не обязательно идти строго по порядку — выбирай ту ветку, которая ближе к твоей предметной области (web, embedded, ML, gamedev, distributed systems). Но все они опираются на уверенное прохождение этапов 1–11.\n\n## Этап 12. Продвинутая типовая система\n\n**Что изучать:**\n\n- **HRTB (Higher-Ranked Trait Bounds, `for\u003C'a>`)** и **GAT (Generic Associated Types)** — позволяют выражать «лайфтайм-семейства» и абстракции, которые на обычных дженериках просто не записываются (например, лениво возвращающиеся итераторы со ссылками на собственные данные).\n- **Associated types vs дженерики.** Когда выбирать `type Item;` (одна реализация на тип), а когда `\u003CT>` (много реализаций для одного типа). Рассмотри это на примерах `Iterator` и `Add\u003CT>`.\n- **`PhantomData`, zero-sized types, type-level состояния.** Кодируй состояния протокола в типах (`Builder\u003CUnbuilt>` → `Builder\u003CBuilt>`), чтобы неправильное использование становилось ошибкой компиляции. Это паттерн **typestate**.\n- **Sealed traits** — закрытые расширяемые API: только модуль-владелец может реализовать трейт у новых типов, потребители — нет.\n- **Newtype-паттерн** (`struct UserId(u64);`) — разные типы для разных смыслов без рантайм-стоимости. Защищает от смешивания `UserId` и `OrderId`.\n- **Variance:** covariance, contravariance, invariance. Почему `&mut T` инвариантен, а `&T` ковариантен.\n- **Auto-traits, negative impls (`!Send`, `!Sync`), `?Sized`, DST** (dynamically sized types).\n\n**Где изучать:**\n\n- The Rustonomicon — \u003Chttps:\u002F\u002Fdoc.rust-lang.org\u002Fnomicon\u002F> (главы про variance и DST).\n- The Rust Reference — \u003Chttps:\u002F\u002Fdoc.rust-lang.org\u002Freference\u002F> (раздел про trait bounds).\n- Серия [«Pretty State Machine Patterns in Rust»](https:\u002F\u002Fhoverbear.org\u002Fblog\u002Frust-state-machine-pattern\u002F) — про typestate.\n- Jon Gjengset, плейлист «Crust of Rust» на YouTube — лучший разбор GAT, HRTB и subtyping на практике.\n\n**Зачем это нужно:** даёт инструменты для «компилятор-как-теорема» подхода: API становятся такими, что неправильное использование в принципе невозможно. Это отличает middle от senior'а в Rust.\n\n**Мини-проект:**\n\n- Спроектируй type-state API для конечного автомата (HTTP-парсер, протокол хендшейка) — пусть некорректные переходы становятся ошибкой компиляции.\n- Реализуй sealed trait для расширяемого API.\n\n## Этап 13. Глубокая работа с асинхронностью\n\n**Что изучать:**\n\n- **Внутренности `Future`:** `Poll::Ready` \u002F `Poll::Pending`, `Pin`, `Unpin`, self-referential типы и почему они вообще нужны.\n- **Устройство async-рантайма:** reactor (epoll\u002Fkqueue\u002Fio_uring), executor, waker, task scheduling. Прочитай минимальный executor (например, [`futures::executor`](https:\u002F\u002Fdocs.rs\u002Ffutures\u002Flatest\u002Ffutures\u002Fexecutor\u002Findex.html)) от и до.\n- **Cooperative scheduling** и проблема блокирующих вызовов в async. Когда нужен `tokio::task::spawn_blocking`, `LocalSet`, `JoinSet`.\n- **Cancellation safety** и почему `tokio::select!` опасен, если не понимать его. Что значит «фьючи могут быть брошены в любой await-точке».\n- **Структурированная конкурентность.** [`tokio-util`](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Ftokio), [`async-scoped`](https:\u002F\u002Fgithub.com\u002Frmanoka\u002Fasync-scoped), `JoinSet`. Идея: ни одна задача не переживает свой scope.\n- **Backpressure в стримах** (`futures::Stream`, `tokio_stream`). Как не перегрузить медленного потребителя.\n- **`async fn` в трейтах** (стабильны с 1.75) и `#[async_trait]` — когда нужен какой.\n- **Отладка async:** [`tokio-console`](https:\u002F\u002Fgithub.com\u002Ftokio-rs\u002Fconsole), `tracing` spans, `tokio::time::pause()` для детерминированных тестов.\n\n**Где изучать:**\n\n- «Asynchronous Programming in Rust» — \u003Chttps:\u002F\u002Frust-lang.github.io\u002Fasync-book\u002F>\n- Tokio Tutorial — \u003Chttps:\u002F\u002Ftokio.rs\u002Ftokio\u002Ftutorial>\n- Серия Alice Ryhl «Actors with Tokio» и «Shared mutable state in Rust».\n- [Without.Boats](https:\u002F\u002Fwithout.boats\u002F) — блог одного из дизайнеров async\u002Fawait.\n\n**Зачем это нужно:** большинство production-Rust проектов — async (web, сеть, БД). Поверхностного знания tokio мало: cancellation safety и Pin регулярно ломают код тех, кто их не понял.\n\n**Мини-проект:**\n\n- Напиши свой простейший async-executor на базе `futures::task::Waker` — поймёшь, как всё устроено внутри.\n- Реализуй mini-Redis (TCP-сервер с pub\u002Fsub) на чистом `tokio`, добавь `tracing` и `tokio-console`.\n\n## Этап 14. Производительность и низкий уровень\n\n**Что изучать:**\n\n- **Cache-friendly структуры, false sharing, padding.** Почему `Vec\u003CStruct>` часто медленнее, чем struct-of-arrays.\n- **SoA vs AoS** (struct of arrays) — выбор раскладки, который часто доминирует в перформансе горячих циклов.\n- **Branch prediction**, хинты `std::hint::likely` \u002F `unlikely`, `black_box` для бенчмарков.\n- **SIMD:** `std::simd` (nightly, переносимый), `std::arch` (stable, платформенные интринсики), крейт [`wide`](https:\u002F\u002Fgithub.com\u002FLokathor\u002Fwide) и [`pulp`](https:\u002F\u002Fgithub.com\u002Fsarah-quin","该项目提供了一个全面的Rust编程语言学习路线图，包括从基础语法到高级应用的25个课程。每个课程都遵循理论讲解、实践练习、测试和答案解析的结构，涵盖了Rust 2021\u002F2024版本的现代编码实践。内容涉及所有权、生命周期、错误处理、异步编程等核心概念以及数据库交互、gRPC服务开发、嵌入式系统和WebAssembly等实际应用场景。适合希望系统性地掌握Rust语言及其在不同领域应用的开发者学习使用。",2,"2026-06-11 03:54:37","CREATED_QUERY"]