На пути к Rust 1.0

Автор оригинала: Niko Matsakis
  • Перевод
Эта статья — перевод первого поста в официальном блоге языка программирования Rust, разрабатываемого Mozilla. Первая стабильная версия Rust совсем не за горами (предварительный прогноз — конец этого/начало следующего года), и авторы языка собираются опубликовать несколько вводных статей о том, что же такое особенное Rust предлагает.

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




Rust 1.0 уже в пути! Мы определились со списком фич и плотно заняты их реализацией. Наш план — выпустить бета-версию 1.0 в конце года. Если всё будет в порядке, то релиз 1.0 состоится вскоре после беты. Будущие версии в ветке 1.x будут обратно совместимыми, то есть существующий код будет ими компилироваться без изменений (естественно, за исключением багов в компиляторе).

Естественно, релиз 1.0 не означает только лишь стабилизацию («ваш код продожит компилироваться»); для нас он значит, что язык стал таким, каким мы хотим его видеть. Если ещё точнее, что он минимален. На данный момент язык выстроен вокруг простых базовых концепций, которые мы называем владением (ownership) и заимствованием (borrowing) (подробнее о них далее). Применяя эти концепции, всё остальное мы смогли вынести в библиотеки. Это очень здорово, потому что вы сами сможете написать аналогичные библиотеки. Из-за этого мы уверены, что Rust не только достигнет своих первоначальных целей, но и пойдёт дальше, применяясь в таких задачах, какие мы даже себе не представляли.



Путь к Rust 1.0


Rust прошёл длинный путь в своём развитии. Если вы не следили за ним некоторое время, то, скорее всего, удивитесь, насколько за последний год мы его упростили. Один из самых выдающихся замечательных примеров — это указатели. Долгое время в Rust были встроены несколько видов указателей, обозначающихся специальными символами. Их больше нет, и в языке остались только ссылочные типы, &T и &mut T. Кроме того, мы смогли объединить и упростить многие другие элементы языка, например, замыкания, которые были ранее представлены во многих формах. Многое продолжает меняться и до сих пор.

Ключом ко всему этому послужило целенаправленное использование основополагающих идей: владения (данными; ownership) и заимствования (borrowing). Сначала мы ввели понятие владения данными в качестве эффективного и безопасного способа передачи данных между задачами (потоками), но с течением времени мы поняли, что за счёт этого же самого механизма мы можем вынести самые разные элементы языка в библиотеки. Получившуюся в результате архитектуру не только проще изучить; она гораздо «ближе к железу», чем мы в принципе могли ожидать. Все конструкции языка Rust непосредственно отображаются на машинные операции, и Rust не требуется специальная среда выполнения или внешние зависимости. В самом минимальном его варианте на Rust можно даже написать ядро операционной системы.

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

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

Что ещё осталось сделать


Мы уже далеко продвинулись, но перед первым релизом ещё многое предстоит сделать. Вот список больших изменений, над которыми мы в данный момент работаем:

  1. Типы с динамическим размером (Dynamically sized types). Это расширение системы типов даст возможность единообразно работать с типами, размер которых неизвестен во время компиляции — такими, как массивы. При помощи DST пользователи языка смогут создавать собственные «умные» указатели, которые будут способны содержать массивы объектов. Nicholas Cameron не так давно проделал большую часть необходимой работы.
  2. Unboxed-замыкания (Unboxed closures). Новый дизайн замыканий объединяет замыкания и объектные типы. Большая часть этой спецификации уже реализована.
  3. Ассоциированные типы (Associated types). Мы переводим наш механизм трейтов на использование ассоциированых типов, что сильно сократит количество ти́повых переменных, ранее необходимых для создания действительно обобщённых библиотек. Patrick Walton уже сделал предварительный вариант реализации ассоциированных типов.
  4. Where-условия (Where clauses). Мы хотим добавить новую гибкую форму задания ограничений на ти́повые переменные — where-условия. Patrick Walton уже добавил базовую поддержку в синтаксисе, а я сделал оставшуюся функциональность в отдельной ветке, которая скоро будет интегрирована в проект.
  5. Множественная диспетчеризация трейтов (Multidispatch traits). Мы собираемся расширить возможности трейтов так, чтобы компилятор мог выбирать конкретную реализацию трейта на основании нескольких типов сразу. Прототип уже есть в моей ветке.
  6. Деструкторы (Destructors). Мы хотим улучшить семантику деструкторов так, чтобы они не требовали предварительного обнуления памяти. Как следствие, время компиляции уменьшится, а скорость выполнения уже скомпилированного кода повысится. Felix Klock проанализировал, что для этого необходимо, и сейчас занят реализацией.
  7. Легковесные потоки (Green threading). Мы удалим поддержку легковесных потоков из стандартной библиотеки и перенесём её в отдельный пакет. Благодаря этому модель потоков Rust станет ближе к модели операционной системы, что, в свою очередь, приведёт к более эффективным программам. Aaron Turon написал RFC и уже собирается приступить к работе над этим.


Что касается библиотек, то сейчас мы проходимся по libstd, отмечая отдельные её части как стабильные и нестабильные. Вы можете следить за нашим прогрессом здесь. Учтите, что многие «нестабильные» определения на самом деле будут изменяться минимально, например, они могут слегка сменить имя для лучшего соответствия принятым соглашениям.

Cargo и экосистема библиотек


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

Встречайте Cargo, пакетный менеджер Rust. Cargo в последнее время очень быстро развивается и уже вполне функционален. К релизу Rust 1.0 мы также планируем запустить центральный репозиторий пакетов, благодаря чему создавать и распространять библиотеки (которые мы называем «ящиками» — «crates») будет очень просто. И конечно, Cargo и сервер с репозиторием оба написаны на Rust.

Процесс релизов


Промежуточные версии Rust долгое время выходили точно по графику, и мы не планируем от этого отказываться. Однако, как только у нас появятся стабильные релизы, мы построим вокруг них дополнительную инфраструктуру. Мы хотим воспользоваться системой «каналов», которая применяется многими проектами, такими, как Firefox, Chrome и Ember.js.

Главная идея заключается в наличии трёх каналов: Nightly, Beta и Stable. Nightly-канал включает нестабильные фичи и библиотеки, которые могут изменяться без сохранения обратной совместимости. Каждые шесть недель мы будем создавать новую ветку, Beta. В неё больше не будут вноситься изменения, ломающие совместимость, поэтому если вы используете Beta или Stable, вы можете быть уверенными, что ваш код продолжит компилироваться без изменений. В это же время уже существующая Beta-ветка станет Stable-релизом. Мы ожидаем, что пользователи языка будут тестировать свой код под Beta-веткой, а готовые программы собирать с помощью Stable. Ваше тестирование Beta-версией поможет нам узнать заранее, что мы сломали что-то, что вы используете.

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

Перспектива


Во многом выпуск Rust 1.0 — не конец, а только начало. Естественно, мы планируем развивать язык и в дальнейшем: у нас есть множество идей, и некоторые из них уже запланированы к реализации. Но больше всего я жду не результатов работы команды Rust; я считаю, что устойчивая основа позволит сообществу Rust и его экосистеме развиваться и расти ещё быстрее, чем сейчас. Не могу дождаться того, что из этого выйдет.
AdBlock похитил этот баннер, но баннеры не зубы — отрастут

Подробнее
Реклама

Комментарии 16

    –3
    ИХМО, язык перегружен возможностями. Использовать его как «высокоуровневый ассемблер» — тяжело (я пробовал) — при адаптации перетащишь половину стандартной библиотеки, отображение структур языка на память определно хуже, чем в C; в прикладном программировании управляемые динамические языки типа Python выигрывают по всем значимым параметрам: проще, быстрее, мощнее. Остается только один сегмент — высокопроизводительные вычисления. Хотя язык типа Rust я ждал очень давно, результат подозрительно похож на C++ по перегруженности и запутанности.
      +5
      ИМХО, запутанность Rust при мереходе с C/C++ скорее в смене философии — непривычно делается, иногда сложнее, много явных преобразований и тп. А вот запутанность C++ — знаешь как сделать вроде и даже компилируется, но нужно самому аккуратно обходить все способы отстрелить себе ногу. После некоторого привыкания писать на Rust вроде бы проще, чем на C++ — меньше нужно держать в голове. Но, вероятно, всё это слишком субъективно.
        +10
        Гарантии времени компиляции корректной работы с памятью и отсутствия гонок — это мечта. C++ и Rust похожи принципом нулевых накладных расходов на неиспользуемые возможности, что хорошо. Вот только лучше бы он транслировался в С++ (как MoonScript транслируется в Lua), потому что иначе он вряд ли выживет в нише, где очень сильны позиции C++. С другой стороны, языку C++ 30 лет и, возможно, подходит время начать с нуля, учитывая развитие IT и удачные идеи из других языков.

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

        Не всегда этот выигрыш окупается, когда нужно сделать шаг влево или вправо. К тому же, «проще, быстрее, мощнее» будет то, с чем есть много опыта. Лично у меня написание простого кода на Qt и Python занимает примерно одинаковое время. Ещё замечаю печальную закономерность, что графические программы на Python (PyQt), пусть не падают, но периодически виснут и не хотят работать как следует (взять хотя бы последние версии Electrum). Скриптовые языки дают расслабиться и разработчики закрывают глаза на такие вещи и качество ПО снижается. Честно говоря, я пользуюсь ровно двумя пакетами, написанными на Python, к качеству кода которых у меня нет нареканий: mercurial и fail2ban.

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

        Возвращаюсь к Rust. Хочется верить, что там, где в Python будет периодическая ругань и глюки в GUI, а в С++ будет сегфолт (что лучше), в Rust будет ошибка компиляции (что ещё лучше).
          +6
          в прикладном программировании управляемые динамические языки типа Python выигрывают по всем значимым параметрам: проще, быстрее, мощнее

          то-то Apple для прикладной разработки вместо динамического Objective-C выкатила Swift со строгой статической типизацией и относительно сложной системой типов, некоторые идеи которого почерпнуты в том числе и из Rust.
          +3
          У меня мощное дежавю… habrahabr.ru/post/237059/

          Имхо, не стоит настолько похожие тексты постить с разницей меньше чем сутки.
            +5
            Та статья — немного странная компиляция из этой и ещё откуда-то, а эта — перевод оригинала.
              +4
              Да и качество перевода разное.
              Оригинал:
              Dynamically sized types

              Там:
              Динамически типы изменяемого размера

              Тут:
              Типы с динамическим размером
            –3
            Rust — мощный, и как только он доживет до беты, ему будет необходимы такие крутые чуваки, как TJ Holowaychuk. Поддержка и продвижение Mozilla или нашего родного Яндекса — это конечно жирный плюс для языка, но Rust будет нужен простой популяризатор из народа, глядя на которого другие программисты будут понимать, что на Rust и правда можно писать, даже если ты не большая компания.
              +3
              Думать своей головой Головайчуки (pun not intended) программистов отучили?
                +2
                А при чем тут думать головой или не думать? Только вот не надо говорить, что в мире IT не играет роль авторитет конкретных личностей. В свое время когда Кармак впрягался за OpenGL многие программисты которые стояли перед выбором использовать DirectX или OpenGL склонялись к выбору последнего, и часто тут решающим фактором было то, что отцы тоже его используют.
                Git стал популярен только из-за того, что его сделал Линус, а потом появился Github. Не будь хотя бы одного их этого — все бы юзали какой-нибудь Mercurial или чего доброго SVN.
                Так и TJ заработав себе авторитет в node.js заставил других программистов со стороны взглянуть на ноду серьезнее. В последствии, как мы знаем, TJ ушел в Go, и тем самым тоже обратил взгляды многих на этот язык.
                Можно сколько угодно думать своей головой, но популярность языка или платформы коррелирует между качеством исполнения и тем, кто этим вообще пользуется.
              +1
              Мне одному кажется, что Rust — это, по сути, калька с Object Caml?
                +2
                Rust — не функциональный и не объектно-ориентированный язык, без карринга, глобального вывода типов и сборки мусора. Хотя, конечно, Rust ближе к OCaml чем к Haskell. С другой стороны, система типов Rust не имеет аналогов — других языков, основанных на понятии владения и заимствования, фактически, нет (Cyclone близок, но он скорее исследовательский язык, чем практический). Да, Rust вдохновлялся OCaml, но это совершенно разные языки.
                  +1
                  Не калька.
                  Rust ориентирован на разработку с минимальным использованием GC. OCaml ориентирован на использование GC.
                  В OCaml своя, похожая на классическую, объектная система (которой мало кто пользуется, за ненадобностью). Rust использует классы типов, которые в API активно применяются.
                  +1
                  > библиотеки (которые мы называем «ящиками» — «crates»)

                  Сленг — это, конечно, прикольно для комьюнити, но как же напрягает, когда только начинаешь разбираться. Такую головную боль вызывают все эти весёлые названия. Назвали бы проще, «packages» — и люди были бы им благодарны.
                    +1
                    Да, «crates» так называются ещё с очень старой версии языка, когда был ещё первый Cargo. Но это, наверное, единственный такой термин. Даже «borrowed pointers» теперь называются просто ссылками.
                    А термин «package» уже занят — так называются пакеты Cargo. В пакете может быть много ящиков :) — максимум одна библиотека и много выполняемых бинарников.
                      0
                      > Сленг — это, конечно, прикольно для комьюнити, но как же напрягает, когда только начинаешь разбираться.

                      Согласен. Может через 20 лет, когда Rust основательно «проржавеет» это и будет восприниматься нормально, а пока выглядит несерьезно и только отталкивает от языка.

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

                    Самое читаемое