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

Rust заранее вводит множество концепций: принадлежность, заимствование, времена жизни, трейты, обработку ошибок, конкурентность, асинхронность, а также экосистему пакетов, с которыми необходимо разобраться перед тем, как что-то полезное сможет работать. Многие учащиеся пытаются решить проблему, собирая учебные материалы, но всё равно застревают перед пустым файлом main.rs. Более надёжным подходом является выбор проекта достаточно сложного, чтобы каждая из этих концепций стала задачей, которую необходимо решить, а не просто главой для чтения. В этом руководстве описаны пять таких проектов, что вы научитесь делать в каждом из них, как разработать первую версию, которую можно завершить, и как использовать помощь ИИ, чтобы он ускорил ваш процесс обучения, не заменяя вас при этом.

Почему сложный проект лучше других курсов

Курс представляет концепции в порядке, выбранном кем-то другим, при этом сложность уже устранена. Настоящий проект делает всё наоборот: вы сталкиваетесь с препятствиями, и они указывают вам, какая концепция нужна дальше. По пути вы читаете реальную документацию, принимаете архитектурные решения, о которых позже сожалеете, расшифровываете запутанные ошибки компилятора, замечаете проблемы с производительностью и учитесь, как взаимодействуют разные компоненты. Именно эти навыки пригодятся в профессиональной работе, и их трудно освоить пассивным образом.

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

Проект 1: ваш собственный терминальный агент для программирования

Ассистенты для программирования на основе ИИ в командной строке являются одним из наиболее активно развивающихся направлений средств для разработчиков. Инструменты вроде Claude Code, Codex и различные open-source аналоги позволяют разработчику сформулировать цель, после чего агент проверяет файлы, вызывает инструменты, редактирует код и докладывает об результатах, вместо того чтобы разработчик самостоятельно вводил каждую команду вручную. Упрощённая версия этого цикла отлично подходит в качестве упражнения на Rust, поскольку она одновременно затрагивает сетевые взаимодействия, процессы, файловую систему и пользовательский интерфейс.

Основной цикл довольно прост: пользователь вводит команды в терминальный интерфейс, ваша программа передаёт этот диалог языковой модели, модель может ответить запросом на использование инструмента, ваш код на Rust выполняет этот инструмент, а результат возвращается к модели для дальнейших действий.

You → Terminal UI → LLM → Tool Request → Your Rust Program → Result → LLM

Интересной частью является стрелка, идущая от модели обратно в вашу программу. Модель никогда не взаимодействует напрямую с вашим устройством; она может только задавать запросы, а ваш код решает, следует ли действовать и как это сделать. Именно в этой границе и происходит основная работа по проектированию.

Первая версия, которую можно завершить

Начните с нескольких инструментов и ничего больше:

• открыть и прочитать файл
• создать или перезаписать файл
• поиск внутри каталога
• запустить команду оболочки
• предоставить базовую информацию о проекте
• отправить результат каждого инструмента обратно в модель

Как только этот цикл будет работать полностью, расширяйте его поэтапно: сохраняйте историю разговора между вопросами и ответами, передавайте ответы по мере их получения, добавляйте проверки разрешений перед выполнением деструктивных действий, описывайте инструменты с четкими схемами, поддерживайте возможность отмены текущего шага и улучшайте отображение вывода в терминале. Проверкам разрешений следует уделять особое внимание. Агент, способный выполнять произвольные команды на вашем компьютере, должен запрашивать разрешение перед записью данных вне папки проекта или выполнением чего-либо, что он ранее не выполнял.

Чему это учит

• асинхронный Rust и HTTP-клиенты для взаимодействия с API модели
• сериализацию и десериализацию JSON для запросов, ответов и вызовов инструментов
• обработку потоковых ответов
• создание и управление дочерними процессами
• API файловой системы
• моделирование цикла агента в виде автомата состояний

Обработка ошибок в сети, при парсинге и при сбоях процессов

Дизайн интерфейса командной строки и терминала

Использование инструментов в качестве протокола

Ещё одним преимуществом является то, что проект на самом деле никогда не заканчивается. Вы можете продолжать его улучшать в течение месяцев, что делает его хорошей платформой для долгосрочных тестов. Если вы хотите узнать, как выглядит та же самая схема с точки зрения продукта и безопасности, наша статья о создании личного ИИ-агента с полученным доступом более подробно рассматривает аспекты доверия.

Определите, что вы оптимизируете

Прежде чем писать любой код, будьте честны относительно своей цели. Изучение Rust, создание проекта для портфолио, разработка инструмента, который будет использоваться ежедневно, эксперименты с ИИ и подготовка к работе в области системного программирования — всё это приводит к разным решениям. Проект для портфолио требует совершенства; ежедневный инструмент — надежности; учебный проект — готовности преодолевать трудности.

Если приоритетом является обучение, не позволяйте ассистенту генерировать весь кодовый базис. Удаление раздражающих частей также устраняет значительную часть понимания, которое они могли бы дать. Просить ассистента объяснить ошибку проверки заимствований или прояснить непонятный раздел документации — это нормально. Делегировать проектирование до того, как вы поймете систему, — нет. Проект, который требует трех дней для понимания, обычно учит гораздо большему, чем проект, созданный за три часа.

Проект 2: десктопное приложение с Tauri

Rust известен благодаря серверам, инструментам командной строки и коду низкого уровня, но он также является хорошим выбором для десктопного программного обеспечения. Tauri сочетает веб-интерфейс с бэкендом на Rust, что позволяет создавать приложения, похожие на современное десктопное программное обеспечение по внешнему виду и ощущениям, при этом ключевая логика выполняется на Rust. Если вы сравниваете Tauri с другими вариантами, наш обзор JavaScript-десктопных фреймворков показывает преимущества и недостатки каждого из них.

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

Сама идея имеет меньшее значение, чем согласованность между веб-интерфейсом и нативным бэкендом. Каждая кнопка в интерфейсе в конечном итоге превращается в запрос через этот разделитель, и именно качественная разработка такого интерфейса является ключевым уроком. Разумной первой целью будет реализация одного командного элемента на языке Rust, вызываемого с фронтенда и выполняющего то, что браузер не может сделать самостоятельно, например, чтение списка файлов в папке.

Чему это учит

• структурирование приложения на Rust с использованием нескольких слоев

взаимодействие между фронтендом и Rust

упаковка и распространение десктопных приложений

локальное хранилище

потоки и фоновые задачи, обеспечивающие отзывчивость интерфейса

операции с файловой системой

запрос к внешним API и сервисам

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

обработка ошибок с отображением полезных сообщений в интерфейсе

аспекты безопасности для нативного приложения, отображающего веб-контент

Общий урок заключается в том, что разработка программного обеспечения становится гораздо сложнее, когда оно работает с реальной операционной системой. Чтение файла — это одна строка кода. Однако безопасная обработка файлов, четкое сообщение об ошибках, поддержание отзывчивости при медленных операциях и одинаковое поведение на разных устройствах — это совершенно другая проблема, и именно опыт решения этой проблемы имеет большую ценность.

Проект 3: игра в жанре защиты башен на Bevy

Игра — один из немногих проектов, способных заставить забыть о том, что вы учитесь. Она также является требовательным «учителем», поскольку на каждой кадре должны одновременно работать множество систем: объекты, ввод от игрока, физика, рендеринг, синхронизация времени, переходы между состояниями, а также ограничения по производительности, которые объединяют всё это воедино.

Bevy отлично подходит для тех, кто изучает Rust, поскольку основан на системе Entity Component System (ECS). Вместо крупных объектов, объединяющих всё поведение, энтити — это лишь идентификаторы с привязанными к ним компонентами, а системы — это функции, которые выполняются для каждого энтитета с определённым набором компонентов. Проектиль может иметь координаты положения, скорость и значение урона; система движения обновляет все параметры, связанные с положением и скоростью, а система столкновений обрабатывает всё, что причиняет урон. Такой переход от объектов к данным и функциям — одна из самых ценных концепций, которые могут дать вам Rust и Bevy.

Почему именно жанр защиты башен

В этом жанре количество энтитетов быстро растёт, и именно это делает его полезным для обучения. Одна карта может включать:

• сотни врагов одновременно
• множество башен с разным поведением

снаряды в полете

системы здоровья и урона

поиск пути

волны атакующих

улучшения

несколько типов врагов

На таком масштабе правильность уже не является единственным вопросом. Начинаешь задумываться о том, сколько работы выполняет игра на каждой кадровой процедуре. Этот вопрос естественным образом приводит к анализу производительности, структуре данных, планированию выполнения операций, использованию памяти и выбору алгоритмов, которые не теряют эффективности при увеличении объема данных. Хорошей первой целью является создание ситуации, когда один враг движется по фиксированному маршруту, а одна башня стреляет в него; всё остальное можно добавлять по мере стабилизации этого цикла.

Чему это учит

• как структурирована система Entity Component System
• игровой цикл и тайминг кадров
• реагирование на события
• управление состоянием между меню, уровнями и окончанием игры
• анализ производительности
• проектирование, ориентированное на данные
• управление ресурсами
• основы отрисовки
• обработка входных данных
• оптимизация

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

Проект 4: встраиваемое устройство с машинным обучением на устройстве

Именно в условиях ограниченного оборудования Rust становится ещё более интересным инструментом: ограниченная память, малый объём энергии и ограниченное время работы процессора. Вместо ноутбука целесообразно использовать микроконтроллер или небольшое периферийное устройство.

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

• температуре
• влажности
• уровне освещённости
• движении
• звуке
• других показателях датчиков

Кроме того, вы можете добавить компактную модель машинного обучения для выполнения одной конкретной задачи: выявления аномалий, распознавания жестов или прослушивания слова-активатора. Модель должна быть простой; настоящая сложность заключается в адаптации всего под ограниченные характеристики оборудования.

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

Почему Rust в встраиваемых системах кажется иным

Приложения для настольных ПК располагают полной стандартной библиотекой, большим объемом памяти, быстрым процессором и операционной системой, которая обрабатывает множество низкоуровневых деталей. В встраиваемом программировании большая часть этого уходит, и появляется новый набор проблем:

• no_std в Rust, при котором стандартная библиотека недоступна
• работа в условиях строгих ограничений по объему памяти
• интерфейсы с оборудованием

прерывания

поведение в реальном времени

драйверы устройств

взаимодействие с периферийными устройствами

межсистемная компиляция

инструменты и экосистема, связанные с конкретными микроконтроллерами

Это один из наиболее ясных примеров того, почему Rust важен не только для обычных приложений. Необходимо понимать, что на самом деле делает машина, поскольку здесь нет ничего, что можно было бы скрыть. Работа с встраиваемыми системами также связывает Rust с робототехникой, автомобильными системами, промышленным оборудованием и другими сферами, требующими мощного оборудования.

Проект 5: адаптивный балансировщик нагрузки

Для разработчиков бэкенда обычный CRUD API редко требует значительного развития навыков. Вот построение инфраструктуры — это уже так. Хорошим примером может служить балансировщик нагрузки: он находится между клиентами и пулом бэкенд-серверов, и для каждого входящего запроса определяет, какой из серверов должен им заняться, вместо того чтобы направлять всю нагрузку на одну машину.

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

┌─────────────┐
                │   Clients   │
                └──────┬──────┘
                       │
                       ▼
              ┌─────────────────┐
              │  Rust Load      │
              │    Balancer     │
              └───────┬─────────┘
                  ┌───┴───┐
                  ▼       ▼
             ┌────────┐ ┌────────┐
             │Worker 1│ │Worker 2│
             └────────┘ └────────┘

Этапы развития от примитивного к адаптивному решению

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

• измеряйте время отклика и уровень ошибок для каждого сервера-рабочего
• обнаруживайте неисправные серверы и прекращайте направление к ним запросов
• устанавливайте лимиты на количество подключений

попробуйте альтернативные стратегии маршрутизации и сравните их в условиях нагрузки

В конечном итоге балансировщик может скорректировать свою работу в соответствии с реальными условиями трафика, вместо того чтобы следовать фиксированным правилам.

Где возникают трудности

Представьте, что один из работников внезапно замедляет работу. Стоит ли продолжать направлять туда новые запросы? Почти наверняка нет. Ещё сложнее, когда несколько работников одновременно начинают работать хуже по разным причинам: у одного перегрузка, у другого нестабильное сетевое соединение, у третьего происходит сбор мусора. Ваша система должна наблюдать за происходящим и быстро принимать решения, не становясь при этом самой узкой горлышком. Для решения этих задач необходимо знать:

• конкурентность
• основы сетевых технологий
• TCP и HTTP
• обратное прокси-шардинг
• проверки работоспособности и таймауты
• пулы соединений с работниками
• сбор метрик
• равномерное распределение нагрузки
• нагрузка из-за занятости всех рабочих процессов
• грамотное управление сбоями
• подход к распределенным системам

Вы можете экспериментировать с политикой маршрутизации с использованием ИИ, но рассматривайте это строго как эксперимент. Критически важная инфраструктура никогда не должна слепо полагаться на решения модели, и всегда должен существовать детерминистический запасной вариант. Сам по себе ИИ ничего не добавляет; цель — оценить, действительно ли он улучшает систему по сравнению с простой, хорошо понятной стратегией.

Что общего у этих проектов

Общим элементом является не синтаксис, а сложность, которой невозможно избежать.

Учебное пособие может показать, как работает Arc<Mutex<T>>; проект заставляет понять, почему вообще требуется синхронизация общего состояния, обычно после того, как компилятор откажется позволить делиться им безопасно. Асинхронные функции легко объяснить на бумаге; реальное приложение показывает, что происходит, когда взаимодействуют несколько задач, когда запрос отменяется на полпути или когда прерывается сетевое соединение. Книга может объяснить концепцию владения ресурсами; проект заставляет разрабатывать структуры, в которых у каждого ресурса есть правильный владелец и он освобождается в подходящее время. Именно это различие и составляет разницу между знанием языка и умением создавать на нём программное обеспечение.

Выберите проект, который немного сложен

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

Такое ощущение — хороший знак. Ожидайте, что вам придётся читать много документации, ломать код, неправильно интерпретировать API, писать абстракции, которые оказываются неудачными и приходится заменять их, а также неоднократно спорить с компилятором. Через несколько дней то, что казалось невозможным, станет понятным. Такой опыт очень трудно воспроизвести, просто посмотрев ещё один учебный материал.

Использование ИИ без передачи обучения на аутсорс

То, как вы используете помощь ИИ, может повлиять на то, насколько проект поможет вам учиться, больше любого другого фактора. Современные ассистенты действительно полезны: они объясняют сообщения об ошибках, сокращают длинную документацию, предлагают подходы и помогают разбираться с багами. Важно не путать использование ИИ в качестве инструмента и его применение вместо понимания.

Для проекта, ориентированного на обучение, эффективная дисциплина выглядит следующим образом:

• самостоятельно написать первую версию
• прочитать соответствующую документацию перед тем, как просить о помощи
• попытаться решить каждую проблему самостоятельно, прежде чем запрашивать решение
• когда застрянете, попросите объяснение, а не готовый код
• самостоятельно внедрите исправление, даже если теперь знаете, как оно должно выглядеть
• убедитесь, что можете объяснить каждую важную часть системы без поиска информации

Всё это не означает избегания ИИ. Это значит убедиться, что именно вы осуществляете мышление.

Соответствие проекта вашим целям

Позвольте тому типу инженера, которым вы хотите стать, направлять ваш выбор:

• ИИ и инструменты для разработчиков: создайте агента для кодирования в терминале
• Десктопное программное обеспечение: создайте приложение на Tauri
• Игры и производительность: создайте игру в жанре защиты башен на Bevy
• Робототехника, аппаратное обеспечение или работа на низком уровне: создайте встраиваемое устройство
• Инфраструктура бэкенда и распределённые системы: адаптивный балансировщик нагрузки

Какой бы вариант вы ни выбрали, не стремитесь к совершенству. Сначала запустите самую простую рабочую версию, а затем вносите улучшения.

Основные выводы

• Выбирайте проекты, сложность которых вынуждает вас работать с конкурентным доступом, асинхронностью и обработкой ошибок на практике, а не просто читать об этом в теории.
• Определите минимальную первую цель для каждого проекта и постепенно расширяйте её; рабочий простой цикл научит большему, чем амбициозный дизайн, который так и не будет реализован.
• Заранее решите, занимаетесь ли вы обучением, созданием проектов в портфолио или выпуском инструмента, поскольку каждая цель требует разных подходов.
• Используйте ИИ для объяснений, а не для написания кода, поскольку цель — обучение, и сохраняйте детерминистичные решения там, где модель принимает решения в реальной системе.
• Цикл создания, нарушения работоспособности, исследования, перепроектирования и оптимизации — вот откуда приходит наибольшее понимание Rust, и неделя работы в этом цикле может принести больше пользы, чем многие часы пассивного изучения по учебникам.