Rust с нуля бесплатно: начинаем четвёртый курс программирования на Shanraq.org

Мы начали разрабатывать четвёртый бесплатный курс Shanraq.org —
«Rust с нуля». До него появились курсы по Go, Python и SQL. Теперь к
ним добавляется язык, который заметно отличается от предыдущих трёх.

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

Это не курс «Rust за семь дней» и не набор готовых фрагментов кода для
копирования. Мы хотим построить спокойный путь от первой программы к
пониманию того, почему Rust устроен именно так.

Курс будет бесплатным. Читать уроки можно без обязательной регистрации и
в собственном темпе.

Открыть бесплатные курсы
Shanraq.org

Что такое Rust и зачем его изучать

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

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

Центральное понятие здесь — ownership, или владение. У значения
есть владелец. Когда владелец перестаёт существовать, соответствующие
ресурсы освобождаются. Передача значения, временное заимствование и
изменение данных подчиняются правилам, которые компилятор проверяет до
запуска программы.

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

Почему мы выбрали Rust

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

Rust учит понимать, что происходит с данными

Начинающий программист довольно быстро привыкает писать:

let name = String::from("Shanraq");

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

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

Многие проблемы обнаруживаются ещё при компиляции

Компилятор Rust довольно строгий. Это иногда раздражает даже опытных
разработчиков, а новичка — тем более. Но у этой строгости есть
практическая цель.

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

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

Rust нужен не только для учебных задач

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

Интерес разработчиков к языку остаётся высоким. В Stack Overflow
Developer Survey 2025 Rust снова оказался самым высоко оцениваемым
языком в категории Admired: 72% разработчиков, работавших с ним, хотели
продолжить его использовать.

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

Почему не начать сразу с официальной книги Rust

Начать можно. Официальная книга The Rust Programming Language, которую
разработчики обычно называют просто The Book, — один из основных
источников по языку. Мы сами будем постоянно сверяться с официальной
документацией.

Но есть важная деталь: авторы Rust Book предполагают, что читатель уже
немного знаком с программированием. Книга не ставит своей задачей
подробно объяснять с самого начала, что такое программа и как рассуждать
при её создании.

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

Чему будем учиться

Начнём с установки Rust, первой программы, компиляции, rustc и Cargo.
Затем разберём переменные, типы, функции, условия и циклы — базовые
элементы, без которых невозможно двигаться дальше.

После этого постепенно перейдём к особенностям, ради которых Rust
действительно стоит изучать: владению и перемещению значений, ссылкам и
заимствованию, изменяемым ссылкам и срезам. Затем появятся структуры,
перечисления, Option, Result, match, коллекции, строки, модули и
обработка ошибок.

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

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

Cargo — с самого начала

Отдельно будем учиться работать с Cargo — стандартной системой сборки
и менеджером пакетов Rust. Cargo создаёт структуру проекта, собирает и
запускает программу, выполняет тесты и управляет зависимостями.

Например:

cargo new hello_rust
cd hello_rust
cargo run

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

Не запоминать запреты, а понимать правила

Одна из опасностей при изучении Rust — превратить ownership в набор
механических рецептов: «здесь поставьте &», «здесь добавьте mut»,
«здесь сделайте .clone() — и ошибка исчезнет».

Так можно заставить программу компилироваться, но сам Rust при этом
останется непонятным.

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

Особенно осторожно будем относиться к .clone(). Клонирование иногда
действительно необходимо. Но если начинающий разработчик добавляет
.clone() всякий раз, когда компилятор жалуется на владение, он
устраняет сообщение об ошибке, не устраняя непонимание причины.

Как будут устроены уроки

Мы сохраняем подход, который используем в других курсах Shanraq. Сначала
читатель увидит небольшую работающую программу и результат её работы.
Затем разберёт код по частям и свяжет новую тему с уже знакомыми
понятиями.

В конце урока будет компактная карта, по которой можно восстановить
содержание. После разбора нужно будет закрыть объяснение и ответить на
несколько вопросов своими словами. Только затем появится самостоятельное
задание.

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

Ошибка компилятора — тоже часть урока

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

Например, передадим значение функции, а затем попробуем использовать его
снова. Посмотрим сообщение компилятора, разберём его, исправим программу
одним способом, затем другим и сравним решения.

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

Rust после Go, Python и SQL

Четыре курса Shanraq не должны повторять друг друга. У каждого своя
задача.

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

Поэтому вопрос «что лучше — Go, Python или Rust?» поставлен
неправильно. Всё зависит от задачи. Для быстрого исследования данных
часто удобнее Python. Для простого и понятного серверного сервиса
хорошим выбором может быть Go. Для работы с данными в реляционной базе
нужен SQL. А когда важно глубже понимать управление памятью,
безопасность и производительность, появляется Rust.

Эти языки в наших курсах не соперничают друг с другом. Это разные
инструменты и разные способы научиться думать о программах.

Можно ли изучать Rust первым языком

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

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

Однако прохождение предыдущих курсов не будет обязательным условием.
Если какое-то понятие необходимо для понимания текущего урока, мы должны
объяснить его в самом курсе или дать понятную ссылку на дополнительный
материал. Фраза «вы это должны уже знать» — плохое объяснение.

Бесплатно означает бесплатно

Здесь ничего не меняется по сравнению с другими курсами Shanraq. Читать
уроки можно бесплатно, для этого не нужна обязательная регистрация. Нет
нескольких вводных уроков, после которых появляется платёжная форма, и
нет платного «продвинутого уровня», куда переносится самая полезная
часть материала.

Мы также не обещаем сделать из человека Rust-разработчика за месяц. Есть
открытый учебный материал, компьютер и столько времени, сколько
понадобится конкретному человеку. Если один читатель пройдёт урок за
вечер, а другой будет разбираться неделю — оба учатся нормально.

Курс пока создаётся

Это важно сказать сразу: курс Rust ещё не закончен. Мы только начали его
разработку и будем публиковать уроки постепенно.

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

Курс должен улучшаться не потому, что автор считает его хорошим, а
потому, что читатели действительно могут по нему учиться.

Что будет дальше

Rust стал четвёртым направлением бесплатных курсов Shanraq.org. Сейчас
образовательная траектория выглядит так:

Go — программирование и веб-разработка;
Python — программирование и работа с данными;
SQL — базы данных;
Rust — системное мышление, безопасность памяти и
производительность.

Дальше мы планируем развивать Data Science, Machine Learning и другие
направления. Но не хотим превращать это в гонку за количеством курсов.
Лучше один законченный маршрут, по которому человек действительно дошёл
до работающего проекта, чем десять каталогов по пять вводных уроков.

Поэтому Rust тоже будем строить постепенно — от первой программы:

fn main() {
    println!("Hello, world!");
}

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

С этого для нас и начинается знание языка.

Посмотреть бесплатные курсы
Shanraq.org

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

Источники

SEO title: Rust с нуля — бесплатный курс для начинающих |
Shanraq.org

Meta description: Бесплатный курс Rust для начинающих: установка,
Cargo, типы, ownership, borrowing, структуры, Result, traits, lifetimes
и многопоточность. Учитесь с нуля в своём темпе.

Slug: rust-s-nulya-besplatnyi-kurs