План изучения Rust

Профиль обучения

• Исходный уровень: опытный разработчик.
• Основной опыт: Kotlin / Java.
• Цель: комплексное освоение Rust --- от базового синтаксиса до системного программирования, многопоточности, асинхронности и низкоуровневых механизмов.
• Формат: углублённое изучение с подробным разбором внутренних механизмов.
• Ориентировочная продолжительность: 5--7 месяцев.
• Ориентировочная нагрузка: 6--8 часов в неделю.

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

Цели программы

В ходе обучения:

• освоим модель владения и заимствования Rust;
• разберём систему типов, generics, traits и lifetimes;
• научимся проектировать безопасные и идиоматичные API;
• изучим управление памятью и ресурсами;
• освоим многопоточность и асинхронное программирование;
• разберём границы Safe Rust и Unsafe Rust;
• изучим системное программирование, FFI и взаимодействие с ОС;
• научимся анализировать производительность, аллокации и машинный код;
• сформируем навык самостоятельной работы с официальной документацией и исходным кодом библиотек.

Принципы обучения

1. Основой программы станет официальная документация Rust.
2. The Rust Programming Language (The Book) будет задавать основной маршрут изучения.
3. The Rust Reference будет использоваться для проверки точной семантики языка.
4. Документация стандартной библиотеки будет использоваться при изучении API и контрактов типов.
5. Cargo Book, Rustonomicon и Async Book будут подключаться по мере необходимости.
6. Практические задания будут сопровождать каждый модуль.
7. Решения будут проходить разбор и code review.
8. Сравнения с Kotlin и Java будут использоваться там, где они помогут понять различия моделей исполнения, типов и управления ресурсами.
9. Будем различать гарантии языка, возможности стандартной библиотеки и возможности сторонних crates.
10. Unsafe Rust будет изучаться после освоения безопасных механизмов и критериев soundness.

Рекомендуемое распределение времени

• 30% --- теория и чтение официальной документации;
• 45% --- упражнения и разработка;
• 25% --- анализ поведения компилятора, эксперименты и code review.

Программа по модулям

Модуль 1. Фундамент Rust

Ориентировочная продолжительность: 1--2 недели.

Цель: освоим инструментарий Rust, структуру проектов и базовую семантику языка.

Занятия:

1. Устройство Rust toolchain: rustup, rustc, Cargo, linker и LLVM.
2. Crates, packages, modules и workspaces.
3. Компиляция и модель выполнения программы; debug и release profiles.
4. Переменные, mutability, shadowing и базовые типы.
5. Функции, выражения, statements и управление потоком.
6. Tuples, arrays, slices и базовый pattern matching.

Практический результат: создадим CLI-утилиту с обработкой аргументов, файлов и структурированного вывода.

Основная документация: - The Book --- Getting Started - The Book --- Common Programming Concepts - The Cargo Book

Модуль 2. Ownership и Borrowing

Ориентировочная продолжительность: 2--3 недели.

Цель: сформируем точную ментальную модель владения, перемещения значений и заимствования.

Занятия:

1. Правила Ownership и область видимости значений.
2. Move semantics, Copy и Clone.
3. Borrowing и shared references.
4. Mutable references и правила эксклюзивного доступа.
5. Borrow checker и Non-Lexical Lifetimes (NLL).
6. Возврат ссылок, временные значения и ограничения времени жизни.
7. Освобождение ресурсов и связь ownership с Drop.

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

Основная документация: - The Book --- Understanding Ownership - The Reference --- Destructors - The Reference --- Expressions

Модуль 3. Система типов и обработка ошибок

Ориентировочная продолжительность: 1--2 недели.

Цель: научимся выражать ограничения и состояния программы средствами типовой системы.

Занятия:

1. Struct, Enum и способы моделирования данных.
2. Pattern matching и exhaustive matching.
3. Option<T> и Result<T, E>.
4. Оператор ? и распространение ошибок.
5. Пользовательские типы ошибок и композиция ошибок.
6. Newtype pattern и проектирование типов, исключающих некорректные состояния.

Практический результат: разработаем библиотеку для разбора конфигурации с явной моделью ошибок.

Основная документация: - The Book --- Enums and Pattern Matching - The Book --- Error Handling - Standard Library --- Result

Модуль 4. Generics, Traits и Lifetimes

Ориентировочная продолжительность: 3--4 недели.

Цель: освоим систему абстракций Rust и научимся проектировать обобщённые API.

Занятия:

1. Generic types и ограничения типов.
2. Определение и реализация traits.
3. Trait bounds, associated types и default implementations.
4. Static dispatch, dynamic dispatch и monomorphization.
5. impl Trait, dyn Trait и trait objects.
6. Dyn compatibility и ограничения динамической диспетчеризации.
7. Lifetime annotations и lifetime elision.
8. Lifetime bounds и 'static.
9. Variance, subtyping и более сложные случаи взаимодействия lifetimes.

Практический результат: спроектируем универсальную библиотеку с generics, traits, associated types и продуманным публичным API.

Основная документация: - The Book --- Generics, Traits, and Lifetimes - The Reference --- Trait Bounds - The Reference --- Trait Objects

Модуль 5. Коллекции, итераторы и функциональные возможности

Ориентировочная продолжительность: 1--2 недели.

Цель: освоим стандартные структуры данных и композицию операций над последовательностями.

Занятия:

1. Vec, VecDeque, HashMap и HashSet.
2. String, str и slices.
3. Итераторы, IntoIterator и Iterator.
4. Iterator adapters, ленивые вычисления и collect.
5. Closures и трейты Fn, FnMut, FnOnce.
6. FromIterator, преобразования и zero-cost abstractions.

Практический результат: реализуем потоковую обработку наборов данных с контролем аллокаций и промежуточных копирований.

Основная документация: - The Book --- Common Collections - The Book --- Iterators - Standard Library

Модуль 6. Управление памятью и ресурсами

Ориентировочная продолжительность: 2--3 недели.

Цель: научимся выбирать подходящую модель владения и управлять разделяемым доступом.

Занятия:

1. Drop, RAII и детерминированное освобождение ресурсов.
2. Box<T> и владение данными в куче.
3. Rc<T> и Arc<T>: разделяемое владение.
4. Cell<T> и RefCell<T>: interior mutability.
5. Mutex<T> и RwLock<T>.
6. Циклы ссылок и Weak<T>.
7. Runtime borrow checking и его отличия от compile-time borrow checking.
8. Pin и Unpin: первоначальная модель и области применения.

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

Основная документация: - The Book --- Smart Pointers - Standard Library --- std::rc - Standard Library --- std::sync

Модуль 7. Cargo, организация приложений и тестирование

Ориентировочная продолжительность: 1--2 недели.

Цель: научимся организовывать проекты и поддерживать библиотеки и приложения.

Занятия:

1. Packages, crates и workspaces.
2. Modules, visibility и организация публичного API.
3. Dependencies, версии и Cargo.lock.
4. Cargo features и conditional compilation.
5. Build scripts и конфигурация сборки.
6. Unit tests, integration tests и documentation tests.
7. Документирование API и подготовка библиотеки к публикации.
8. Основы benchmarking.

Практический результат: создадим workspace с несколькими crates, тестами, документацией и разделёнными публичными интерфейсами.

Основная документация: - The Cargo Book - The Book --- Writing Automated Tests - The Book --- Managing Growing Projects

Модуль 8. Concurrency и multithreading

Ориентировочная продолжительность: 2--3 недели.

Цель: освоим безопасное параллельное выполнение и синхронизацию общего состояния.

Занятия:

1. Threads и модель выполнения потоков.
2. Message passing и channels.
3. Shared state concurrency.
4. Send и Sync.
5. Mutex, RwLock и atomic types.
6. Memory ordering и основы модели памяти.
7. Scoped threads и передача заимствованных данных между потоками.
8. Deadlocks, data races и стратегии синхронизации.

Практический результат: разработаем многопоточный TCP-сервер и пул рабочих потоков.

Основная документация: - The Book --- Fearless Concurrency - The Reference --- Memory Model - Standard Library --- std::thread

Модуль 9. Асинхронное программирование

Ориентировочная продолжительность: 3--4 недели.

Цель: разберём внутреннюю механику async Rust и научимся строить асинхронные приложения.

Занятия:

1. Future и модель асинхронного вычисления.
2. async / await и преобразование в state machines.
3. Polling, Context и Waker.
4. Pin, Unpin и самоссылочные структуры.
5. Executors и async runtimes.
6. Tokio: tasks, scheduling и управление задачами.
7. Cancellation, select и композиция futures.
8. Async channels и взаимодействие задач.
9. Async traits и ограничения асинхронных интерфейсов.

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

Основная документация: - The Book --- Asynchronous Programming - The Async Book - Tokio Documentation

Модуль 10. Unsafe Rust и FFI

Ориентировочная продолжительность: 2--3 недели.

Цель: научимся работать с низкоуровневыми возможностями языка и строить безопасные абстракции над небезопасными операциями.

Занятия:

1. Raw pointers и указательная арифметика.
2. Unsafe blocks и unsafe functions.
3. Unsafe traits и safety contracts.
4. Undefined Behavior и правила aliasing.
5. Soundness и безопасные абстракции.
6. FFI, C ABI и repr(C).
7. Memory layout и работа с неинициализированной памятью.
8. Взаимодействие с библиотеками на C и C++.

Практический результат: реализуем небольшой FFI-модуль и безопасную обёртку над низкоуровневым API.

Основная документация: - The Book --- Unsafe Rust - The Rustonomicon - The Reference --- External Blocks

Модуль 11. Системное программирование

Ориентировочная продолжительность: 2--3 недели.

Цель: применим Rust для задач, в которых он особенно интересен: взаимодействия с ОС, сетями, устройствами и системными ресурсами.

Занятия:

1. Работа с файлами и файловой системой.
2. Processes, signals и системные вызовы.
3. TCP, UDP и sockets.
4. Бинарные протоколы и сериализация.
5. OS abstractions и platform-specific code.
6. Memory-mapped files.
7. Взаимодействие с устройствами и транспортными интерфейсами.
8. Основы Embedded Rust и no_std.

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

Основная документация: - Standard Library - Rust Embedded Book - The Rust Reference

Модуль 12. Углублённое изучение языка и производительности

Ориентировочная продолжительность: 2--3 недели.

Цель: изучим внутренние механизмы компиляции и научимся обоснованно оптимизировать программы.

Занятия:

1. Declarative macros.
2. Procedural macros.
3. Monomorphization и особенности генерации кода.
4. Layout типов и представление данных в памяти.
5. LLVM, оптимизации компилятора и машинный код.
6. Inlining, codegen units и профили сборки.
7. Profiling, benchmarking и анализ аллокаций.
8. Оптимизация без нарушения корректности и безопасности.
9. Дополнительное знакомство с no_std, no_main и внутренним устройством компилятора.

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

Основная документация: - The Rust Reference --- Macros - The Rust Compiler Development Guide - Cargo Profiles

Сквозной практический проект

В качестве проекта, который будет развиваться вместе с программой, разработаем Device Communication Framework --- библиотеку для взаимодействия с внешними устройствами через различные транспортные механизмы.

Постепенно сформируем следующие компоненты:

• Device API --- общий интерфейс взаимодействия с устройствами;
• Device Connector --- управление подключениями, состоянием и переподключением;
• USB Transport --- транспортный слой USB;
• TCP Transport --- сетевой транспорт;
• Bluetooth Transport --- транспорт Bluetooth.

По мере изучения языка будем последовательно применять:

• ownership --- для управления подключениями и ресурсами;
• traits --- для транспортных абстракций;
• generics и associated types --- для проектирования API;
• lifetimes --- для работы со ссылками и буферами;
• RAII и Drop --- для освобождения ресурсов;
• Send и Sync --- для многопоточного взаимодействия;
• async --- для обработки нескольких подключений;
• Unsafe и FFI --- для низкоуровневого взаимодействия с системными API.

Архитектура не будет считаться заранее определённой. Будем проектировать её по мере изучения языка, сравнивать варианты и аргументировать выбранные решения.

Контроль усвоения материала

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

Для каждой ключевой темы проверим пять уровней:

1. Понимание: сможем сформулировать концепцию и объяснить её назначение.
2. Применение: реализуем решение самостоятельно.
3. Анализ: объясним поведение компилятора и причины ограничений.
4. Проектирование: выберем подходящую абстракцию и обоснуем API.
5. Критическая оценка: сравним альтернативы, компромиссы и ограничения.

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

Формат занятий

Каждое полноценное занятие будет включать:

1. Контекст и постановку задачи.
2. Теоретическое объяснение.
3. Ссылки на конкретные разделы официальной документации.
4. Сопоставление с Kotlin/Java, когда оно будет полезно.
5. Разбор механики языка, типов, памяти и runtime.
6. Примеры корректных и некорректных решений.
7. Самостоятельное практическое задание.
8. Разбор решения и code review.

Для каждого модуля и полноценного занятия будем формировать отдельный Markdown-конспект с теорией, ссылками, примерами и практическими заданиями. Обычные ответы на вопросы и уточнения не будут автоматически оформляться в отдельные файлы.

Критерии завершения программы

По итогам обучения сможем:

• самостоятельно разрабатывать библиотеки и приложения на Rust;
• понимать и обосновывать решения borrow checker;
• проектировать API с использованием ownership, traits и lifetimes;
• работать с многопоточностью и асинхронностью;
• понимать границы Safe и Unsafe Rust;
• взаимодействовать с системными API и использовать FFI;
• анализировать производительность, аллокации и машинный код;
• читать техническую документацию и исходный код библиотек без постоянной посторонней помощи.

Основные официальные источники

• The Rust Programming Language
• The Rust Reference
• Rust Standard Library
• The Cargo Book
• The Rustonomicon
• The Async Book
• Rustlings
• Rust Compiler Development Guide
• Rust Embedded Book

---

Первое занятие: устройство Rust toolchain и модель выполнения программы. Начнём с rustup, rustc, Cargo, linker, LLVM, структуры crate и различий между debug и release profiles.