Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Приложение G - Как создаётся Rust и «Nightly Rust»

Это приложение рассказывает о том, как создаётся Rust и как это влияет на вас как на разработчика Rust.

Стабильность без застоя

Как язык, Rust очень заботится о стабильности вашего кода. Мы хотим, чтобы Rust был прочным фундаментом, на котором можно строить, и если бы всё постоянно менялось, это было бы невозможно. В то же время, если мы не можем экспериментировать с новыми возможностями, мы можем не обнаружить важные недостатки до их выпуска, когда мы уже не сможем ничего изменить.

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

Ту-ту! Каналы выпуска и поезда

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

  • Nightly
  • Beta
  • Stable

Большинство разработчиков Rust в основном используют стабильный канал, но те, кто хочет опробовать экспериментальные новые возможности, могут использовать nightly или beta.

Вот пример того, как работает процесс разработки и выпуска: предположим, что команда Rust работает над выпуском Rust 1.5. Этот выпуск состоялся в декабре 2015 года, но он даст нам реалистичные номера версий. В Rust добавляется новая возможность: новый коммит попадает в основную ветку. Каждую ночь создаётся новая nightly-версия Rust. Каждый день — день выпуска, и эти выпуски создаются нашей инфраструктурой выпуска автоматически. Таким образом, по мере течения времени наши выпуски выглядят так, раз в ночь:

nightly: * - - * - - *

Каждые шесть недель наступает время готовить новый выпуск! Ветка beta репозитория Rust ответвляется от основной ветки, используемой nightly. Теперь есть два выпуска:

nightly: * - - * - - *
                     |
beta:                *

Большинство пользователей Rust не используют beta-выпуски активно, но тестируют против beta в своей CI-системе, чтобы помочь Rust обнаружить возможные регрессии. Тем временем nightly-выпуск всё ещё выходит каждую ночь:

nightly: * - - * - - * - - * - - *
                     |
beta:                *

Допустим, обнаружена регрессия. Хорошо, что у нас было время протестировать beta-выпуск до того, как регрессия просочилась в стабильный выпуск! Исправление применяется к основной ветке, так что nightly исправляется, а затем исправление переносится в ветку beta, и создаётся новый beta-выпуск:

nightly: * - - * - - * - - * - - * - - *
                     |
beta:                * - - - - - - - - *

Через шесть недель после создания первой beta наступает время стабильного выпуска! Ветка stable создаётся из ветки beta:

nightly: * - - * - - * - - * - - * - - * - * - *
                     |
beta:                * - - - - - - - - *
                                       |
stable:                                *

Ура! Rust 1.5 готов! Однако мы забыли одну вещь: поскольку прошло шесть недель, нам также нужна новая beta следующей версии Rust, 1.6. Поэтому после того, как stable ответвляется от beta, следующая версия beta снова ответвляется от nightly:

nightly: * - - * - - * - - * - - * - - * - * - *
                     |                         |
beta:                * - - - - - - - - *       *
                                       |
stable:                                *

Это называется «моделью поездов», потому что каждые шесть недель выпуск «отправляется со станции», но всё ещё должен пройти путь через beta-канал, прежде чем прибудет как стабильный выпуск.

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

Благодаря этому процессу вы всегда можете проверить следующую сборку Rust и убедиться сами, что обновиться легко: если beta-выпуск не работает как ожидалось, вы можете сообщить об этом команде, и это будет исправлено до того, как произойдёт следующий стабильный выпуск! Поломки в beta-выпуске относительно редки, но rustc всё ещё является программным обеспечением, и ошибки существуют.

Время поддержки

Проект Rust поддерживает самую последнюю стабильную версию. Когда выпускается новая стабильная версия, старая версия достигает конца своего жизненного цикла (EOL). Это означает, что каждая версия поддерживается в течение шести недель.

Нестабильные возможности

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

Если вы используете beta- или stable-выпуск Rust, вы не можете использовать никакие флаги возможностей. Это ключ, который позволяет нам получить практическое использование новых возможностей до того, как мы объявим их стабильными навсегда. Те, кто хочет включить передовой край, могут это сделать, а те, кто хочет прочного опыта, могут оставаться на stable и знать, что их код не сломается. Стабильность без застоя.

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

Rustup и роль Rust Nightly

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

$ rustup toolchain install nightly

Вы также можете увидеть все toolchain'ы (выпуски Rust и связанные компоненты), которые у вас установлены, с помощью rustup. Вот пример на компьютере с Windows одного из ваших авторов:

> rustup toolchain list
stable-x86_64-pc-windows-msvc (default)
beta-x86_64-pc-windows-msvc
nightly-x86_64-pc-windows-msvc

Как видите, stable toolchain является по умолчанию. Большинство пользователей Rust используют stable большую часть времени. Вы можете захотеть использовать stable большую часть времени, но использовать nightly для конкретного проекта, потому что вам важна передовая возможность. Для этого вы можете использовать rustup override в директории этого проекта, чтобы установить nightly toolchain как тот, который rustup должен использовать, когда вы находитесь в этой директории:

$ cd ~/projects/needs-nightly
$ rustup override set nightly

Теперь каждый раз, когда вы вызываете rustc или cargo внутри ~/projects/needs-nightly, rustup будет убеждаться, что вы используете nightly Rust, а не ваш по умолчанию stable Rust. Это удобно, когда у вас много проектов на Rust!

Процесс RFC и команды

Итак, как вы узнаёте об этих новых возможностях? Модель разработки Rust следует процессу Request For Comments (RFC). Если вы хотите улучшения в Rust, вы можете написать предложение, называемое RFC.

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

Если возможность принята, в репозитории Rust открывается issue, и кто-то может её реализовать. Человек, который её реализует, вполне может не быть человеком, который изначально предложил возможность! Когда реализация готова, она попадает в основную ветку за флагом возможности, как мы обсуждали в разделе «Нестабильные возможности».

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