Rust — всё по этой теме для программистов

Оглавление (нажмите, чтобы открыть):

[Rust] Расскажите о своём опыте программирования на Rust

05.09.2020, 08:47

[Rust] Обсуждение возможностей и предстоящей роли языка Rust
Psilon, чем он тебя так привлек? И почему именно «убийца плюсов»? Если напишешь развернутый ответ.

[Rust] Как привязывать WinAPI-функции к коду на Rust?
Может кто-нить дать код, КАК привязывать вин апишные функции к растовскому коду (на примере.

[Rust] Time
Подскажите как узнать время в Rust. //Rust extern crate time; fn main() < let now =.

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

Подключение библиотеки в Rust lang
хочу подключить библиотеку glfw в проекте rust. я сделал как здесь получился следующий код .

06.09.2020, 10:23 2

Только изучал. Читал книгу http://rurust.github.io/rust_book_ru/, решал задачки из книжки и на https://www.codewars.com/.
Язык вобрал много интересных идей из других языков. Для безопасного управления памятью у него оригинальный подход через концепцию владения — то есть не сборщик мусора как в C# и не ручное управление памятью как в Delphi.
Но то что называется «экосистема» у него гораздо меньше — меньше репозиториев с готовыми решениями, меньше сообществ, разделов на форумах, чатов, статей по сравнению даже с Delphi, не говоря уже о C#.
До недавнего времени его новые версии не всегда были совместимыми со старым кодом. Сейчас, это, вроде бы, прекратилось.

Язык в значительной степени функциональный.

В целом он мне понравился, если не считать закидоново взятых из D.
Пока коммерчески не перспективен.

08.09.2020, 21:35 3

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

Научиться на нем писать гораздо легче, если есть опыт на Delphi, чем после C#. Еще был бы крайне полезным опыт Haskell, но это не обязательно, а только желательно. Есть очень много пишущих на Rust программистов, которые ни черта не смыслят в Haskell, и им это особо не мешает (даже не мешает флудить в интернетах).

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

Есть такой человек Степан Кольцов. Так вот, он в видосиках на YouTube заявляет, что Rust — одновременно быстрый и безопасный. То есть, быстрый как Си и безопасный как Java. Здесь я с ним согласен.

Программист — это звучит гордо

Знаниями нужно делиться, иначе они протухают.

Страницы

понедельник, 16 ноября 2015 г.

Профилирование в Rust

Стоит отметить, что описанные инструменты не специфичны для Rust, а вполне применимы для широкого спектра языков. Но при этом я сразу оговорюсь, что речь будет идти о Linux инструментарии, что из этого портировано на другие ОС я не изучал.

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

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

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

Ещё один интересный подход демонстрирует valgrind, он по сути реализует виртуальную машину, внутри которой запускается исследуемая программа. Таким образом профилировщик отлавливает все выделения памяти, вызовы функций и т.п. собирая максимально полную информацию о работе приложения. Накопленные данные позволяют потом всесторонне анализировать время выполнения функций, ошибки выделения памяти, выход за границы массивов и т.п. Правда стоит отметить большой минус подхода — скорость работы приложения замедляется на пару порядков. Если будет время я попробую поиграться с ним и написать что получилось. А пока пропускаем.

И теперь о теме сегодняшнего разговора — о статических профилировщиках. Они работают существенно быстрее предыдущего способа, а так же ради них не нужно менять код, как в случае с gprof, правда и информации дают они не так что бы очень много, например утечки памяти с их помощью не найти. Работают они следующим образом: с заданной периодичностью, обычно довольно высокой (типично около 1000 раз в секунду) приложение останавливается и считываются различные его характеристики. В нашем случае это будут — текущая исполняемая функция и по возможности её call stack. Всё это сохраняется и приложение продолжает работу. Если «погонять» приложение в таком режиме достаточно долго, то с определённой долей уверенности, можно считать, что чем чаще «попадалась» нам функция, тем больше её реальное время исполнения. Самыми известными представителями являются oprofile и perf. С последним мы сегодня и будем играться.

Стоит отметить, что точность таких замеров является не 100%. Самые быстрые и редкие функции легко могут вообще не попасть в собранную статистику, но поскольку целью является выявление самых медленных и часто выполняемых, то отсечение всех остальных, нам даже на руку.

Приступим. Всяких разных способов анализа у perf много, подробно про все можно почитать в их wiki, я же буду собирать статистику через «perf record» и потом строить из неё красивые интерактивные графики через FlameGraph. Поэтому те кто хочет повторить у себя нечто подобное — установите perf и скачайте stackcollapse-perf.pl и flamegraph.pl из репозитория FlameGraph по ссылке выше. Ну и конечно же понадобится скомпилированное приложение на rust, я буду использовать свой rust-software-render.

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

Про параметры для конфига можно почитать на сайте cargo. Тут выбран нулевой уровень оптимизации, их всего четыре: 0,1,2,3. На нулевом сохраняются все имена функций и разбирать результаты одно удовольствие, но при этом результаты очень далеки от тех, что будут в release сборке, а следовательно и узкие места в последней могут быть совсем иными. На 3-м уровне напротив от исходных функций мало что остаётся и понять там что-то становится сложно. Обычно рекомендуют выбирать 1-й, но ниже я покажу результаты для всех уровней.

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

В результате мы получим svg файл, с динамическим содержанием, где можно посмотреть информацию по каждому блоку или рассмотреть его более детально. К сожалению вставить в блог его не получилось, поэтому я буду ниже вставлять лишь статическую картинку, а рядом прикладывать ссылку на исходный svg файл, который можно скачать и посмотреть в просмотрщике, который его поддерживает. Лично у меня локальные svg файлы хорошо открывает Firefox. Что бы было представление о возможностях я покажу gif с демонстрацией:

Почему язык Rust обречён на успех

«Проект Rust хорош настолько, насколько это возможно, а его сообщество ещё лучше», — пишет о мультипарадигмальном компилируемом языке программирования, разработанном компанией Mozilla, вице-президент мобильного подразделения Adobe Мэт Эсэй (Matt Asay).

Некоторые open source-сообщества, кажется, вдохновляются цитатой из «Ада» Данте: «Оставь надежду, всяк сюда входящий».

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

Но это не касается сообщества Rust. Начавшийся как амбициозный побочный проект сотрудника компании Mozilla, язык программирования Rust обещает совместить возможности контроля низкоуровневых языков с гибкостью высокоуровневых языков. Или, как пишет Сердар Егулалп (Serdar Yegulalp), «наибольшие планы Mozilla в отношении Rust, исходя из рекламы этого языка как средства достижения скорости без ущерба для безопасности, по-видимому, включают не только нативные приложения вроде веб-браузера, но также и целые операционные системы».

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

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

Будущее строится на Rust

Новые приложения всё чаще требуют новых подходов к разработке. Это одна из причин, по которым язык программирования Go от Google оказался весьма успешным. Это же может стать причиной и радужного будущего для Rust. Аналитик RedMonk Стивен О’Грейди (Stephen O’Grady) обращает внимание: «Случайные наблюдения, которые я производил некоторое время, говорят о пробуждении интереса разработчиков из разных областей».

Отчасти это из-за безопасности. Как полагает Дэвид Херман (David Herman), ведущий разработчик Mozilla, «Rust может предложить нечто уникальное, чего не предлагал ни один язык раньше: это та степень безопасности, которую языки типа С и С++ никогда не имели. В них есть вещи, которые делают системное программирование пугающим и которых нет в Rust».

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

Как объясняет Херман, «Rust имеет много функций и удобств, которые делают его практически высокоуровневым языком, несмотря даже на то, что вы делаете такие вещи, как, например, ручное управление памятью, которое можно сделать на С++. Но Rust имеет и множество абстракций, которые не дадут застрять лишь на управлении памятью».

Словом, «низкоуровневый контроль и высокоуровневая безопасность». Это мощное сочетание, которое обещает дать разработчикам гораздо больше контроля над производительностью без бремени обучения С/С++ и без риска ошибок.

Уютное сообщество

Хотя подзаголовок звучит просто, процесс обучения и приобретения опыта в Rust таковым не является.

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

Один из комментаторов (JArcane) делится подробностями:

«Программируя на Rust, я все ещё чувствуют себя глупым. Я все еще думаю «Ой, дурак, ты же должен это знать». Я еще стесняюсь того, что не знаю чего-то или не могу додуматься до этого сам. Когда я читаю книги, общий их тон звучит так: «Да, это сложновато, но не волнуйтесь, если у вас не вышло с первого раза. Со временем у вас получится». Когда я спрашиваю о чём-то на канале, я получаю быстрые и полезные ответы, причём зачастую более широкие, чем были сами вопросы: что, как и почему. И это словно подтверждение тому, что каждый такой вопрос –– это возможность научить, ожидаемый случай, а вовсе не повод для перепалки в надежде, что позже поможет кто-то другой».

Как говорят, «основной посыл в литературе, сообщениях компилятора, на канале IRC звучит так: «Мы понимаем».

Это очень существенно отличается от сообщества Linux, где, например, Линус Торвальдс может поприветствовать участника словами «Ты несёшь полную чушь».

Или от писем Говарда Чу, ведущего архитектора OpenLDAP: «Если вы напишете в этой рассылке и ваше сообщение будет сочтено офтопиком или окажется недостаточно исследованным, то вы будете выруганы, осмеяны и унижены. Это касается и глупых вопросов».

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

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

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

Rust — язык системного или прикладного программирования?

Почему создатели языка так упирают на systems programming? По-моему, при тех фичах, которые уже наличествуют в языке, богатстве стандартной библиотеки и легкости создания биндингов как минимум к С, он вполне может стать и языком для прикладухи, это у него получится уж точно не хуже С++.

Мастер Йода рекомендует:  Информация по трафику от AMP Stories в Google Search Console

Порог входа высокий.

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

У Си++ накоплена куча библиотек, которые из других языков использовать от «сложно» до «почти никак».

И то, и другое же.

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

Потому, что прикладуху можно хоть на Petooh писать, а ты попробуй на bare-metal уровень выйти.

А ты попробуй на нем писать. Его borrow checker — это не серебрянная пуля, избавляющая от GC, под него гораздо сложнее программировать, чем под язык с GC.

Это «язык изотерического программирования». Проще говоря, новый диалект lisp-а с более разнообразными скобочками.

runtime zero cost

это у него получится уж точно не хуже С++.

«Все» (особенно тут) кричат, что С++ для этого не подходит.

Ну а так никто не запрещает ведь. Правда подозреваю, что с ГЦ писать слегка попроще, чем на расте.

Почему создатели языка так упирают на systems programming?

Наверное, ещё потому, что ничего другого кроме С/С++ и нет в этом плане?

У С++, пожалуй, выше.

хватит уже пинать это мертворожденное монструозное говнецо в инкубаторе

У Си++ накоплена куча библиотек, которые из других языков использовать от «сложно» до «почти никак».

У Си накоплено еще больше, в чем проблема использовать их?

У Си++ накоплена куча библиотек, которые из других языков использовать от «сложно» до «почти никак».

У Си накоплено еще больше

И они все доступны из Си++ гораздо проще, чем из Rust.

Надо писать привязки.

хватит уже пинать это мертворожденное монструозное говнецо в инкубаторе

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

Кстати, я еще помню, когда на заглавной странице висел хипстерский хелловорлд с многопоточностью и функциональной обработкой списков, а тут смотрю — теперь там ява какая-то.

Из примера на глагне убрать бы лишние кейворды fn и непонятное в 2015 году let.

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

Rust — новый язык программирования: Часть 1. Общее описание, характеристики и свойства

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

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

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

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

Характеристики системы типов данных: static , nominal , linear , algebraic , locally inferred (локально выводимые).

Безопасная работа с памятью обеспечивается отстутствием null-указателей или «висящих» указателей, также исключено переполнение буферов.

Обобщённая настраиваемая параметризация типов с использованием классов типов.

Обработка исключений выполняется без восстановления состояния, без «обратной раскрутки» (unwinding), с изоляцией (обрабатываемой) задачи.

Модель памяти: необязательный к применению сборщик мусора (GC), локальный относительно одной задачи, безопасные типы указателей с анализом их области видимости.

Компилятор и все вспомогательные инструментальные средства публикуются под двойной лицензией: MIT / Apache 2.

2. Краткая история

Rust начинался, как личный проект разработчика компании Mozilla Грэйдона Хоара (Graydon Hoare) в 2006 году. Компания заинтересовалась разработкой в 2009 г. и взяла проект под свою опеку. В 2010 г. основной акцент разработки был перенесён на создание компилятора rustc, который мог бы компилировать себя сам (до этого компилятор для сборки Rust был написан на языке OCaml), в это же время впервые была опубликована информация о новом языке программирования Rust. И уже в 2011 г. задача самокомпиляции была успешно решена. В качестве бэкэнда rustc использует LLVM.

В январе 2012 г. был представлен первый альфа-релиз компилятора Rust. На момент написания данной статьи текущей являлась версия 0.6, выпущенная в апреле 2013 г. Грэйдон Хоар и компания Mozilla планируют представить первую стабильную версию языка в конце 2013 года.

3. Основные концепции Rust

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

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

  • Определение типов по предположению — в объявлениях локальных переменных указание типа не является обязательным.
  • Безопасное параллельное выполнение, основанное на задачах (task)— так называемые «лёгкие» задачи (lightweight tasks) в Rust не используют память совместно, вместо этого они обмениваются сообщениями.
  • Эффективные и гибкие замыкания обеспечивают выполнение итераций и других управляющих конструкций.

Сравнение с шаблоном (match) в перечислимых типах Rust (это более мощная версия перечислений enum в С, похожая на алгебраические типы данных в функциональных языках) является компактным и выразительным способом кодирования логики программы.

Полиморфизм — в Rust имеются функции с параметрами-типами, а также типы данных, классы типов и интерфейсы в объектно-ориентированном стиле.

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

Rust выбирает второй подход к обеспечению безопасности. Ряд функциональных возможностей, присутствующих в языках типа C, и остающихся, несмотря ни на что, в уделяющих большее внимание безопасности языках типа Java, запрещены или по крайней мере серьёзно ограничены в Rust. Эти потери в значительной степени компенсируются другими функциональными средствами языка, и упомянутые выше потенциально опасные возможности становятся ненужными. Один из аспектов такого подхода очевиден: Rust старается генерировать ошибки компиляции в тех ситуациях, где использование прочих языков приводит к ошибкам времени выполнения (или аварийным завершениям программ). Это не только снижает накладные расходы во время выполнения, но и должно сократить количество обращений клиентов-заказчиков в службы поддержки.

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

Развивая идею модуля System в языке Modula-2 (этот модуль обеспечивает доступ к так называемой «функциональности низкого уровня»), Rust позволяет объявлять функции и блоки кода, как «небезопасные» (unsafe). В области такого небезопасного кода не применяется большинство ограничений, которые как раз и делают Rust безопасным языком. Это можно рассматривать как признание неудачи при создании действительно безопасного языка, но такое умозаключение будет чрезмерно упрощённым, если не сказать примитивным. С теоретической точки зрения теорема Гёделя о неполноте позволяет высказать предположение о том, что любой язык программирования, достаточно богатый возможностями для того, чтобы выразить всё, что хочет сказать программист, обладает вместе с тем и полным спектром свойств, из-за которых его невозможно считать «безопасным». Невозможность абсолютной безопасности подтверждается и практикой.

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

4. Безопасность по умолчанию

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

Многие языки программирования используют ключевые слова const (C, C++, Go) или final (Java) для объявления того, что некоторое имя, один раз связанное, всегда будет ссылаться на одно и то же значение (фактически таким образом объявляется константа). Rust использует противоположный подход: связывания неизменяемы по умолчанию, а чтобы объявить переменную изменяемой, обязательно требуется наличие ключевого слова mut. Таким образом, после объявления

любые изменения значения phi будут запрещены, а объявление

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

Для некоторых структур данных свойство изменяемости/неизменяемости наследуется через ссылки, а для элементов структур и через родительские структуры, поэтому если неизменяемая ссылка связана с определёнными объектами, то компилятор проследит за тем, чтобы весь объект в целом оставался неизменяемым.

5. Демонстрационный пример

Для того, чтобы получить общее представление о синтаксисе и внешнем виде кода на языке Rust предлагается небольшая простая программа в листинге 1.

Листинг 1. Демонстрационный пример кода Rust

В приведённом выше примере для каждого имени name создаётся так называемая задача (task), и все эти задачи выполняются параллельно. Если скомпилировать и несколько раз запустить эту программу, то можно заметить, что всякий раз последовательность вывода строк немного изменяется (проявление параллельности выполнения задач), иногда создавая иллюзию более или менее осмысленного обмена репликами перечисленных в листинге «персонажей».

6. С чего начать

В настоящее время компилятор Rust можно самостоятельно собрать и установить из tar-архива в различных дистрибутивах Linux. Следует отметить, что поскольку компилятор Rust написан на самом Rust, сборка производится посредством уже предварительно скомпилированной текущей версии данного компилятора (созданной на предыдущей стадии разработки), поэтому потребуется постоянное Интернет-соединение на время компиляции и установки (при этом текущая операционная система должна обеспечивать выполнение бинарных файлов компилятора).

После завершения процесса установки в локальном каталоге /usr/local/bin будут размещены следующие программы:

  • rustc— компилятор языка Rust
  • rustdoc— инструмент для создания документации к API
  • rustpkg— менеджер пакетов Rust
  • rusti— интерпретатор Rust, обеспечивающий цикл REPL
  • rust— инструмент, который работает и как единый унифицированный интерфейс для всех перечисленных выше программ, и как средство выполнения нескольких общих сценариев командной строки.

6.1. Первая программа. Компиляция

По соглашению файлам с исходным кодом программ на языке Rust присваиваются расширения .rs. Допустим, что имеется файл hello.rs, содержащий исходный код, приведённый в листинге 2.

Листинг 2. Самая простая программа на языке Rust

Если компилятор Rust был установлен правильно, то запуск команды

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

Компилятор Rust при обнаружении ошибки старается выдать как можно больше полезной информации. Если в код листинга 2 намеренно внести ошибку (например, вместо io::println вписать имя какой-нибудь несуществующей функции), то при попытке компиляции сообщения об ошибках будут выглядеть приблизительно так, как показано в листинге 3.

Листинг 3. Попытка компиляции программы с ошибками

В самой простой форме исходный код программы на языке Rust представляет собой текстовый файл с расширением .rs, в котором содержатся определения некоторых типов данных и функций. Если в таком файле имеется функция main , то он может быть скомпилирован в выполняемый файл. По правилам Rust не допускается наличие кода, для которого отстутствует объявление (declaration) на самом верхнем уровне структуры файла, то есть, все инструкции программы обязательно должны быть записаны внутри тела функции. Кроме того, Rust-программы могут быть скомпилированы, как библиотеки, и могут быть включены в другие программы.

Мастер Йода рекомендует:  Использование сессий в PHP

6.2. Использование инструментального средства rust

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

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

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

Заключение

Rust позиционируется, как универсальный и надёжный язык программирования, и компания Mozilla предлагает его в качестве основного средства web-разработки. Пожалуй, впервые в языке программирования главное внимание уделено безопасности и однозначности применяемых средств, а не «трюкам и уловкам». В следующих четырёх статьях (с 2 по 5) будет рассматриваться основной синтаксис Rust.

Хочу начать изучать Rust. С чего начать, где взять базу?

Всем привет!
Дело в том, что я JavaScript разработчик. Но меня очень заинтересовал язык Rust, я начал знакомиться с статьями про Rust, но там много непонятных терминов. Возможно есть какая-то общая литература без сильной завязки на языке (Не хочу учить плюсы, чтобы учить Rust)?

  • Вопрос задан более трёх лет назад
  • 14850 просмотров

Содержание:
1 Установка Rust
2 Hello, world!
3 Hello, Cargo!
4 Объявление переменных
5 Условные операторы
6 Функции
7 Комментарии в коде
8 Составные типы данных
9 Оператор Match
10 Циклы
11 Строки
12 Массивы
13 Стандартный ввод
14 Игра угадайка
15 Ящики и модули
16 Тестирование кода
17 Указатели
18 Паттерны
19 Синтаксис методов
20 Замыкания(closures)
21 Итераторы
22 Дженерики(Generics) — похоже на шаблоны в С++
23 Трейты(Traits) — куски кода
24 Задания
25 Макросы
26 Небезопасный код
27 Заключение

Языковое замещение, или Почему Rust сменяет C

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

В компании Evrone язык Rust применяется на многих проектах, и наши инженеры накопили большую экспертизу в этом направлении. В публикации мы расскажем об особенностях Rust.

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

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

История Rust

Работу над Rust начал в 2006 году энтузиаст Грэйдон Хор. В 2009-м проектом заинтересовалась Mozilla, и уже спустя год был дан публичный анонс нового языка программирования.

Альфа-версия Rust появилась в 2012 году. Через год авторы браузерного движка Servo на базе этого языка сообщили, что их детище получило поддержку Samsung. Благодаря этому удалось портировать код движка на ARM-архитектуру.

Версия Rust 1.0 была представлена в мае 2015 года. В том же году язык занял третье место в опросе Stack Overflow о любимых инструментах разработчиков. Начиная с 2020 года Rust регулярно возглавляет этот список.

Плюсы и минусы Rust

  • Единый компилятор от разработчиков Rust со встроенным менеджером и сборщиком пакетов, системой тестов и генератором документации.
  • Безопасная работа с памятью, не допускающая ошибок сегментации.
  • Возможность применять абстракции, облегчающие ручное управление памятью.
  • Для многих ошибок во время компиляции приводятся варианты исправления, ошибки в шаблонах понятны и лаконичны.
  • Указатели можно использовать только в небезопасном коде, в безопасном коде применяются исключительно ссылки на гарантированно существующие объекты.
  • Хорошо совместим с Mac и Unix-подобными системами.
  • Отсутствие классов и наследования, что затрудняет написание кода в объектно ориентированной парадигме.
  • Очень строгий компилятор кода, иногда чересчур сильно контролирующий обращения к памяти.

Сфера применения Rust

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

Операционные системы и программное обеспечение

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

  • Redox, Unix-подобная операционная система, базирующаяся на микроядре. Основная часть ПО для этой ОС также написана на Rust.
  • Servo, браузерный движок с поддержкой многопоточности.
  • Система микровиртуализации, созданная преимущественно под serverless окружения Firecracker.

Применение Rust в разработке Blockchain

Системы на базе распределенного реестра должны уметь быстро обрабатывать запросы внутри сети при минимальной нагрузке на устройство. Инструментарий С++ отлично справляется с этой задачей (именно на нем работают блокчейны Bitcoin и Ethereum), а посему разработка инфраструктуры с использованием Rust окажется еще эффективнее.

  • https://www.parity.io/ — альтернативный клиент Ethereum и Bitcoin.
  • https://polkadot.network/ — гетерогенные блокчейн-сети.
  • Exonum, фреймворк для создания блокчейн-проектов.
  • MaidSafe, распределенная система хранения и обработки данных.
  • Solana, платформа для создания блокчейн-приложений.

Разработка веб-серверов на Rust

Уже сейчас Rust может использоваться для полноценного создания веб-проектов, инструментарий языка позволяет создать и фронт-энд, и бэк-энд. Клиентская часть реализуется, например, на вдохновленном React и Angular фреймворке Yew. Простая разработка веб-серверов на Rust возможна благодаря actix-web — очень производительному фреймворку, поддерживающему WebSockets, TLS и HTTP/2.0. Также доступны другие инструменты: rocket, conduit, gotham, pencil.

  • Dropbox, облачное хранилище.
  • OpenDNS, веб-сервис, позволяющий использовать общедоступные DNS-серверы.
  • Coursera, образовательный портал, основанный профессорами информатики Стэнфордского университета.

Машинное обучение на Rust

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

Будущее Rust

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

Среди проектов, в которых компания Evrone использует Rust, можно отметить крупную ERP-систему сети ресторанов. В ней на Rust реализуется микросервис, который выдает пользователю информацию о ближайшем заведении. Также интересна реализация на Rust в нашем собственном сервисе непрерывной интеграции Vexor. На этом языке сделана диспетчеризация задач, шедулинг их выполнения и агент, управляющий изоляцией запущенных задач на рабочих машинах, автоматический закупщик мощностей и системы логирования.

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

Rust: начинаем работать с новым языком программирования от специалистов компании Mozilla

Оригинал: Rust: Get started with Mozilla’s new language
Автор: Mike Saunders
Дата публикации: 13 августа 2020 г.
Перевод: А.Панин
Дата перевода: 3 сентября 2020 г.

Несмотря на то, что компания Mozilla широко известна главным образом благодаря своему веб-браузеру Firefox, еще одним из ее продуктов является отличный язык программирования, который стоит испытать в работе.

Для чего это нужно?

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

Нужен ли миру еще один язык программирования? Ведь уже существуют такие языки программирования, как C, C++, C#, Objective C, Swift, Java, Perl, Python, Ruby, Go, а также сотни других менее известных языков программирования с значительным количеством пользователей. Это достаточно для удовлетворения запросов каждого из разработчиков, не так ли? Ну, специалисты компании Mozilla считают иначе и именно поэтому в течение пяти последних лет занимались, помимо прочего, разработкой Rust, чрезвычайно быстрого языка для системного программирования, позволяющего предотвратить практически все ошибки сегментирования и гарантирующего потокобезопасность. Другими словами, данный язык программирования позволяет разрабатывать программное обеспечение, работающее так же быстро, как и программное обеспечение, разработанное с использованием языка C, при этом лишенное проблем, присущих последнему.

Rust проектировался как мультипарадигменный язык программирования, следовательно он может использоваться для процедурного, функционального и объектно-ориентированного программирования. Он не позволяет использовать нулевые и некорректные указатели, что делает его более безопасным при работе с памятью, чем C, а также позволяет использовать набор оптимизированных библиотек времени исполнения для обработки ввода-вывода, управления программными потоками и выполнения других операций. Rust является относительно новым языком программирования, ведь его версия 1.0 была выпущена в мае 2015 года, но при этом он разрабатывался более пяти лет. Исходя из вышесказанного, уже сейчас стоит выучить, по крайней мере, его основы, так как в будущем он наверняка станет достойным конкурентом таких языков программирования, как C и C++.

Компилятор Rust может быть доступен из репозитория пакетов программного обеспечения вашего дистрибутива, но ввиду того, что язык программирования постоянно дорабатывается, имеет смысл загрузить новейшие бинарные файлы с веб-сайта проекта www.rust-lang.org . Вам нужно будет всего лишь загрузить файл сценария rustup.sh и выполнить его на своей машине аналогичным образом:

(В рамках данной команды утилита wget используется для загрузки файла сценария и передачи его содержимого посредством потока стандартного вывода исполняемому файлу командной оболочки для последующего исполнения.) По истечении нескольких минут, компилятор Rust будет установлен в вашу систему и вы сможете использовать команду rustc для компиляции программ. Давайте начнем с классического примера — сохраните данный код в файле с именем hello.rs:

Многие текстовые редакторы могут подсвечивать синтаксические конструкции языка программирования Rust, причем Vim не является исключением (вам понадобятся файлы из репозитория по адресу https://github.com/rust-lang/rust.vim ).

Уже сейчас вы могли обратить внимание на то, что синтаксис рассматриваемого языка программирования очень похож на синтаксис таких языков, как C/C++, ведь в обоих случаях для выделения комментариев используются два слэша, блоки кода обрамляются фигурными скобками, а аргументы функций — круглыми скобками. Также следует помнить о том, что для объявления функций используется ключевое слово fn , причем каждая программа должна иметь функцию main() . Восклицательный знак после имени функции println в данном случае указывает на то, что используется макрос (по сути, это удобная обертка над функцией print из библиотеки времени исполнения Rust).

Для компиляции программы следует просто выполнить команду:

В результате в директории с файлом исходного кода программы должен появиться бинарный файл с именем hello , для исполнения которого достаточно выполнить команду ./hello . Но если вы обратите внимание на размер этого файла, вы будете в некоторой степени шокированы: он будет превышать 800 КБ. И все это нужно для работы такой простой программы? Ну, по умолчанию компилятор Rust осуществляет статическое связывание большей части библиотек времени исполнения с программой, поэтому вы можете скопировать бинарный файл в систему, в которой не установлено библиотек времени исполнения Rust и запустить его без каких-либо проблем. Однако, вы также можете сообщить компилятору о необходимости выполнения оптимизаций и динамического связывания:

Теперь вы получите бинарный файл более приемлемого размера, равного 8 КБ, но в случае использования утилиты ldd вы обнаружите, что для корректной работы программы требуется наличие в системе динамической библиотеки libstd- .so .

Синтаксис языка программирования

Теперь, когда мы можем компилировать и запускать программы на Rust, я предлагаю разобраться с синтаксисом данного языка программирования и особо выделить его отличия от синтаксиса таких языков программирования, как C, C++ и других аналогичных:

Если вы привыкли работать с языками C/C++, вы можете подумать, что данный код является каким-то странным, но он вполне логичен. Давайте начнем рассмотрение с функции main() : в первой строке let мы объявляем 32-битную целочисленную переменную a и присваиваем ей начальное значение 5. Мы могли бы пропустить указание типа переменной (i32 является стандартным типом переменных), а также не присваивать ей начальное значение, причем в этом случае она содержала бы нулевое значение. Обратите внимание на то, что при объявлении переменной и присваивании ей определенного значения таким же образом, как в случае переменной a из примера, вы не сможете впоследствии изменить ее значение, поэтому при компиляции следующего фрагмента кода будет сгенерировано сообщение об ошибке:

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

Для чего же это нужно? Это ведь лишняя работа, не так ли? Ну, по сути это действительно так, но, с другой стороны, данная особенность языка программирования помогает разрабатывать безопасные программы. Вы должны делать изменяемыми лишь те переменные, значения которых действительно должны изменяться. Rust заставляет вас быть настолько многословным, насколько это необходимо для максимально точного описания принципа работы программы: в строке выше приведено объявление знаковой целочисленной переменной a размером ровно в 32 бита с возможностью изменения ее значения в будущем.

Далее мы вызываем нашу функцию doubler с переменной a в качестве аргумента и сохраняем возвращаемое значение в переменной b . Обратите внимание на объявление функции doubler , которое находится в начале кода программы: в нем указывается тип параметра функции (i32) и тип возвращаемого значения (i32) после символов ->. Также несложно заметить, что в рамках функции выполняется единственная операция x * 2 , после которой даже не следует символа точки с запятой, как в обычном блоке кода на языке Rust; что же происходит там?

Мастер Йода рекомендует:  Краткое руководство по Web Storage

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

Вернемся в функцию main() , в которой мы использовали макрос println!() для вывода результата; обратите внимание на методику подстановки значения переменной с помощью последовательности символов <> . Наконец, в примере демонстрируется чрезвычайно полезное ключевое слово «match» языка программирования Rust, которое позволяет значительно сократить объем кода в том случае, если вам необходимо выполнить большое количество операций if/else. В данном случае 1 … 10 является объявлением диапазона значений (от 1 до 10 включительно), а символ подчеркивания ( _ ) соответствует всем остальным значениям.

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

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

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

В результате будет осуществлен вывод значения третьего элемента кортежа x , то есть, строки «Hello» . Как и в случае с обычными массивами, которые также поддерживаются в Rust, нумерация элементов кортежей начинается с нуля. Вы можете использовать кортежи для возврата нескольких значений из функции:

В данном случае функция с именем switch() принимает кортеж с двумя 32-битными целочисленными значениями и сохраняет их в переменной input . При этом она также возвращает кортеж с двумя целочисленными значениями. В рамках данной функции используется простое выражение, позволяющее поменять местами элементы кортежа и вернуть получившийся кортеж.

В рамках функции main() создается кортеж с именем x , содержащий значения 10 и 50, а также кортеж с именем y , содержащий значения, которые были возвращены после вызова функции switch() . Далее осуществляется простой вывод значений кортежа на экран ( 50, 10 ).

Совет: Если вам не терпится самостоятельно разобраться с возможностями Rust, рекомендуем начать с чтения официальной документации, расположенной по адресу https://doc.rust-lang.org/book .

Это было краткое описание синтаксиса и возможностей языка программирования Rust; если вы желаете узнать больше о данном языке программирования из специальной серии статей, дайте нам знать об этом!

Почему язык Rust обречён на успех

«Проект Rust хорош настолько, насколько это возможно, а его сообщество ещё лучше», — пишет о мультипарадигмальном компилируемом языке программирования, разработанном компанией Mozilla, вице-президент мобильного подразделения Adobe Мэт Эсэй (Matt Asay).

Некоторые open source-сообщества, кажется, вдохновляются цитатой из «Ада» Данте: «Оставь надежду, всяк сюда входящий».

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

Но это не касается сообщества Rust. Начавшийся как амбициозный побочный проект сотрудника компании Mozilla, язык программирования Rust обещает совместить возможности контроля низкоуровневых языков с гибкостью высокоуровневых языков. Или, как пишет Сердар Егулалп (Serdar Yegulalp), «наибольшие планы Mozilla в отношении Rust, исходя из рекламы этого языка как средства достижения скорости без ущерба для безопасности, по-видимому, включают не только нативные приложения вроде веб-браузера, но также и целые операционные системы».

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

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

Будущее строится на Rust

Новые приложения всё чаще требуют новых подходов к разработке. Это одна из причин, по которым язык программирования Go от Google оказался весьма успешным. Это же может стать причиной и радужного будущего для Rust. Аналитик RedMonk Стивен О’Грейди (Stephen O’Grady) обращает внимание: «Случайные наблюдения, которые я производил некоторое время, говорят о пробуждении интереса разработчиков из разных областей».

Отчасти это из-за безопасности. Как полагает Дэвид Херман (David Herman), ведущий разработчик Mozilla, «Rust может предложить нечто уникальное, чего не предлагал ни один язык раньше: это та степень безопасности, которую языки типа С и С++ никогда не имели. В них есть вещи, которые делают системное программирование пугающим и которых нет в Rust».

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

Как объясняет Херман, «Rust имеет много функций и удобств, которые делают его практически высокоуровневым языком, несмотря даже на то, что вы делаете такие вещи, как, например, ручное управление памятью, которое можно сделать на С++. Но Rust имеет и множество абстракций, которые не дадут застрять лишь на управлении памятью».

Словом, «низкоуровневый контроль и высокоуровневая безопасность». Это мощное сочетание, которое обещает дать разработчикам гораздо больше контроля над производительностью без бремени обучения С/С++ и без риска ошибок.

Уютное сообщество

Хотя подзаголовок звучит просто, процесс обучения и приобретения опыта в Rust таковым не является.

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

Один из комментаторов (JArcane) делится подробностями:

«Программируя на Rust, я все ещё чувствуют себя глупым. Я все еще думаю «Ой, дурак, ты же должен это знать». Я еще стесняюсь того, что не знаю чего-то или не могу додуматься до этого сам. Когда я читаю книги, общий их тон звучит так: «Да, это сложновато, но не волнуйтесь, если у вас не вышло с первого раза. Со временем у вас получится». Когда я спрашиваю о чём-то на канале, я получаю быстрые и полезные ответы, причём зачастую более широкие, чем были сами вопросы: что, как и почему. И это словно подтверждение тому, что каждый такой вопрос –– это возможность научить, ожидаемый случай, а вовсе не повод для перепалки в надежде, что позже поможет кто-то другой».

Как говорят, «основной посыл в литературе, сообщениях компилятора, на канале IRC звучит так: «Мы понимаем».

Это очень существенно отличается от сообщества Linux, где, например, Линус Торвальдс может поприветствовать участника словами «Ты несёшь полную чушь».

Или от писем Говарда Чу, ведущего архитектора OpenLDAP: «Если вы напишете в этой рассылке и ваше сообщение будет сочтено офтопиком или окажется недостаточно исследованным, то вы будете выруганы, осмеяны и унижены. Это касается и глупых вопросов».

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

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

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

Научный метод

Будущее само не придет

Разбор критики Rust

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

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

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

Инструменты разработки для Rust уже есть: поддержка в виде плагина к IDEA, пакетная система и репозиторий пакетов тоже присутствуют, чего в C++ нет и не будет ещё долго. В качестве некоторых «саксес сторис», хоть язык и молодой, можно указать использование в Dropbox и разработку Habitat (другие применения можно посмотреть здесь: https://www.rust-lang.org/en-US/friends.html).

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

Проблема курицы и яйца. Очень редко эту проблему удается успешно решить (условно тут можно привести в пример Go и Scala), в основном благодаря вложению времени и денег со стороны некоторой крупной компании (Google, Typesafe), по каким-то своим соображениям заинтересованных в популяризации языка.

Как показывает практика проблемы «курицы и яйца» не существует. Множество языков не имеющих за плечами поддержки крупных корпораций достигло высокого уровня распространенности и популярности. Можно вспомнить C, C++, Python, Scala, Ruby, PHP, Perl, Clojure, Lua, — в принципе, десяток набрать можно. То есть примерно половина из наиболее распространенных языков именно такие. Если язык имеет определенные преимущества и область применения, то он зачастую находит своего пользователя.

Rust действительно безопасный, но, к сожалению, далеко не быстрый. По скорости на момент написания этих строк Rust сравним с Java, Go и Haskell.

Стоит ли сравнивать Rust c Java, Go и Haskell — отдельный вопрос к автору, но даже если сравнить, то все немного не так. Rust требует примерно в 4 раза меньше ОЗУ для того, чтобы работать с той же скоростью, что и языки со сборкой мусора. Rust быстрее Go, Java и Haskell. Можно ли новый язык с такими характеристиками назвать «далеко не быстрым»? Думаю нет. Иначе бы Swift пришлось назвать откровенным тормозом, что по факту не так.

до тех пор в плане компромисса скорости и безопасности он не намного интереснее Scala или Go

Даже если опустить то, что перечисленные языки не предназначены для системной разработки, все равно это утверждение вызывает много вопросов. Автор пытается сказать, что Rust такой же медленный как Go и имеет такой же уровень безопасности? Это не так. Может быть он быстрее Go, но менее безопасный или медленнее Go, но более безопасный? Все эти утверждения ложны.

Ок, но тогда получается, что Rust вообще не нужен, потому что я могу написать 90% кода на Go, а 10% на Си.

Здесь хотелось бы понять по какому критерию автор оценивает результат, потому что в результате такого подхода он получит требования к ОЗУ и задержки на сборку мусора от Go, проблемы с безопасностью от C да ещё и сложности с интеграцией и сборкой такой конструкции под разные платформы.

С одной стороны, это неплохо, когда программист задумывается о том, где лежат переменные, в стеке или куче, и могут или не могут с ними одновременно работать несколько потоков. Но с другой, представьте, что вы пишите программу, и оказалось, что переменная должна жить не в стеке, а в куче. Вы переписываете все, чтобы использовался Box. Потому вы понимаете, что на самом деле нужен Rc или Arc. Снова переписываете. А потом еще раз переписываете на обычную переменную в стеке.

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

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

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

И да, никто не будет транслировать Rust в JavaScript

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

Смарт поинтеры, если что, далеко не бесплатны и не приводят к предсказуемому времени сборки мусора.

Опять же, весьма странное высказывание для статьи о том, что Rust не заменит C++, в этой области у них нет различий. Я бы даже сказал, что зная размеры иерархий можно вполне точно предсказать сколько времени займет их освобождение, что невозможно в случае со сборкой мусора, конечно если это не единственный объект в памяти.

Добавить комментарий