Язык Rust и почему его надо съесть


Содержание

Фичи Rust, которых не хватает в C

Перевод статьи Федерико Мена-Кинтеро, который, наряду с Мигелем де Икаса, основал проект GNOME — широко используемую, свободную графическую среду, в основном для систем GNU/Linux. Перед этим он некоторое время поддерживал GIMP. Сейчас Федерико активно развивает библиотеку librsvg с использованием языка программирования Rust. По его мнению, разработка достигла момента, когда портирование некоторых крупных компонент с C на Rust выглядит более лёгкой задачей, чем просто добавление аксессоров к ним. Федерико часто приходится переключаться с C на Rust и обратно, и в статье он рассказывает, почему считает C очень и очень примитивным языком для современного ПО.

Своего рода элегия по C

Я влюбился в язык программирования C около 24-ёх лет назад. Я выучил основы, прочитав испанский перевод второго издания «Языка программирования C» Кернигана/Ритчи (K&R). До этого я писал на Turbo Pascal в довольно низкоуровневой манере — с указателями и ручным выделением памяти. После него C казался освежающим и мощным.

К&R — это отличная книга благодаря стилю изложения и лаконичности программирования. Эта книга даже учит, как реализовать простые функции malloc/free , что крайне поучительно. Даже такие низкоуровневые конструкции, которые выглядят как часть языка, могут быть реализованы на самом языке!

В последующие годы я хорошо освоил C. Это простой язык с небольшой стандартной библиотекой. Наверное, это был идеальный язык для реализации ядер Unix в 20 000 строк кода или около того.

GIMP и GTK+ научили меня тому, как использовать модный объектно-ориентированный подход в C. GNOME показал, как поддерживать крупномасштабные проекты, написанные на C. Стало казаться, что 20 000 строк C кода — это проект, который можно практически полностью понять за пару недель.

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

Опыт использования C

Положительный

  • Чтение исходного кода проекта POV-Ray впервые и изучение того, как использовать объектно-ориентированный подход и наследование в чистом C;
  • Чтение исходного кода проекта GTK+ и изучение читаемого, поддерживаемого и чистого стиля написания кода на C;
  • Чтение исходного кода проекта SIOD, а также ранних исходников проекта Guile и понимание того, как интерпретатор Scheme может быть написан на C;
  • Написание первых версий Eye of Gnome и доработка системы микротайлового рендеринга.

Негативный

  • Работа в команде Evolution, когда программа постоянно падала. Мы были вынуждены приобрести машину с Solaris на борту, чтобы иметь возможность купить Purify; в те времена Valgrind-а еще не существовало;
  • Отладка взаимных блокировок потоков в gnome-vfs;
  • Безуспешная отладка Mesa;
  • Когда мне передали исходники первых версий Nautilus-share, я увидел, что free() вообще не используется;
  • Попытки рефакторинга кода, о стратегии управления памятью которого я не имел понятия;
  • Попытка сделать библиотеку из кода, кишащего глобальными переменными, и в котором ни одна функция не помечена как static .

Фичи Rust, которых не хватает в C

Автоматическое управление ресурсами

Один из первых блог-постов, которые я прочитал о Rust, назывался «В Rust вам никогда не придётся закрывать сокет». Rust заимствует у C++ идеи об идиоме RAII (Resource Acquisition Is Initialization, получение ресурса есть инициализация) и умных указателях, добавляет принцип единоличного владения для значений и предоставляет механизм автоматического, детерминированного управления ресурсами в очень изящной упаковке.

  • Автоматическое: не нужно вызывать free() вручную. Память освободится, файлы закроются, мьютексы разблокируются, когда переменные выйдут из зоны видимости. Если вам нужно написать обёртку для стороннего ресурса, то всё, что нужно сделать, это реализовать типаж Drop. Обёрнутый ресурс ощущается как часть языка, потому что вам не приходится нянчиться с его временем жизни вручную;
  • Детерминированное: ресурсы создаются (память выделяется и инициализируется, файлы открываются и т. д.) и уничтожаются, когда выходят из зоны видимости. Никакой сборки мусора: ресурсы действительно освобождаются, когда вы закрываете скобку. Вы начинаете видеть время жизни данных в своей программе как дерево вызовов функций.

После того, как постоянно забываешь освобождать/закрывать/уничтожать объекты в C, или, ещё хуже, пытаешься понять, где в чужом коде забыли сделать что-то из этого (или ошибочно сделали дважды)… я просто больше этого не хочу.

Дженерики

Vec — это действительно вектор, размер элементов которого равен размеру объекта типа T . Это не массив указателей на объекты, память для которых выделялась отдельно. Он специально компилируется в код, который может работать только с объектами типа T .

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

Типажи — это больше, чем просто интерфейсы

Rust — это не Java-подобный объектно-ориентированный язык, подробнее об этом можно прочитать в open-source книге «The Rust Programming Language». Вместо этого в нём есть типажи, которые поначалу похожи на интерфейсы в Java, — простой способ осуществления динамического переключения (dynamic dispatch), так что если объект реализует Drawable , то можно предположить, что у него есть метод draw() .

Однако типажи — это более мощный инструмент. Одной из отличительных особенностей типажей можно считать ассоциированные типы (associated types). Например, Rust предоставляет типаж Iterator , который вы можете реализовать:

Это означает, что всякий раз, когда вы реализуете этот типаж для какого-либо объекта, поддерживающего итерирование, вы также указываете тип Item для значений, которые он выдаёт. Если вы вызываете next() и элементы ещё остались, вы получите Some(ТипВашегоЭлемента) . Когда у вашего итератора закончатся элементы, он вернет None .

Ассоциированные типы могут ссылаться на другие типажи.

Например, в Rust вы можете использовать циклы for со всем, что реализует типаж IntoIterator :

Когда реализуете этот типаж, вы должны указать и тип элементов, которые будет выдавать ваш итератор, и сам тип IntoIter , который реализует типаж Iterator и хранит состояние вашего итератора.

Таким образом, вы можете построить настоящую сеть типов, которые ссылаются друг на друга. Вы можете написать типаж, который говорит: «Я могу сделать foo и bar, но только если вы дадите мне тип, который умеет делать вот это и это».

Срезы

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

Современные инструменты для управления зависимостями

Вместо того, чтобы

  • Запускать pkg-config руками или через Autotools-макрос;
  • Сражаться с include-путями в заголовочных файлах…
  • … и библиотечных файлах;
  • И, по сути, полагаться на то, что пользователь гарантирует установку верных версий библиотек,

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

Не нужно сражаться с зависимостями. Оно просто работает, когда вы набираете cargo build .

Тесты

В C очень сложно покрывать код тестами по нескольким причинам:

  • Внутренние функции часто помечены как static . Это означает, что они не могут быть вызваны вне файла, в котором эта функция определена. Тестовая программа вынуждена либо #include -ить содержимое исходника, в котором функция объявлена, либо использовать #ifdef , чтобы убирать static только при тестировании;
  • Вам придётся плясать с бубном вокруг вашего Makefile, чтобы слинковать тестовую программу с определённой частью зависимостей основной или с какой-то частью оставшейся программы;
  • Вам придётся выбрать фреймворк для тестирования. Вам придётся зарегистрировать свои тесты в фреймворке для тестирования. Вам придётся изучить этот фреймворк.

В Rust вы пишете

в любом месте программы или библиотеки, и, когда вы набираете cargo test , ОНО ПРОСТО, *****, РАБОТАЕТ. Этот код линкуется только в тестовый исполняемый файл. Не нужно ничего компилировать дважды вручную, писать Makefile-магию или разбираться, как вытащить внутренние функции для тестирования.

Для меня это одна из главных киллер-фич языка.

Документация с тестами

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

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

Гигиеничные макросы

В Rust особые гигиеничные макросы, позволяющие избежать проблем, при которых во время разворачивания C макросов происходит непреднамеренное затенение идентификаторов в коде. Вам больше не нужно писать макросы, заключая все символы в скобки, чтобы max(5 + 3, 4) работал правильно.

Никакого неявного приведения типов

Все эти баги, которые появляются в C из-за непреднамеренного приведения int к short или к char и т. п. — в Rust их нет. Вы должны приводить типы явно.

Никакого целочисленного переполнения

Этим всё сказано.

Как правило, никакого неопределённого поведения в безопасном режиме

В Rust, если что-то вызывает неопределенное поведение в «безопасном режиме» (всё, что написано вне блоков unsafe <> ), это расценивается как баг самого языка. Например, можно сделать побитовый сдвиг отрицательного целого числа вправо и произойдёт именно то, что вы ожидаете.

Сопоставление с образцом

Знаете, как gcc выдает предупреждение, если вы используете switch() с перечислением (enum), но обработаете не все варианты? Это детский сад по сравнению с Rust.

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

match работает на строках. ВЫ МОЖЕТЕ МАТЧИТЬ ГРЁБАНЫЕ СТРОКИ.


Вы же знаете, насколько такое плохо читается?

my_func(true, false, false)

Как насчет того, чтобы вместо этого использовать сопоставление с образцом на аргументах функции:

Стандартная полезная обработка ошибок

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

#[derive(Debug)]

Если вы пишете новый тип (скажем, структуру с кучей полей), то можно написать #[derive(Debug)] , и Rust будет знать, как автоматически напечатать содержимое этого типа для отладки. Больше не нужно руками писать специальную функцию, которую затем придётся вызывать из gdb, только для того, чтобы посмотреть содержимое полей пользовательского типа.

Замыкания

Вам больше не придётся передавать указатели на функцию и user_data вручную.

Заключение

Я пока не попробовал «fearless concurrency», где компилятор может предотвращать гонки данных в многопоточном коде. Я полагаю, что это в корне меняет положение дел для людей, которые пишут параллельный код на регулярной основе.

C — это старый язык с примитивными конструкциями и примитивными инструментами. Он хорошо подходил для небольших однопроцессорных Unix-ядер, которые работали в доверенных, академических средах. Но для современного программного обеспечения он больше не подходит.

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; что же происходит там?

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

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

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

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

Цукерберг рекомендует:  Оператор сравнения - IF A=B Then...

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

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

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

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

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

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

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

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

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

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

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

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

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

Потому, что прикладуху можно хоть на 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-программы могут быть скомпилированы, как библиотеки, и могут быть включены в другие программы.

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

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

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

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

Заключение

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

rustycrate.ru
Русскоязычный сайт о языке программирования Rust

26 Марта 2020 • оригинал: Aleksey Kladov • перевод: Александр Андреев • руководства • поддержите на Patreon

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

Пишем простой веб сервис на языке программирования Rust

15 Июня 2020 • оригинал: Daniel Welch • перевод: Александр Андреев • обучение • поддержите на Patreon

Я новичок в языке Rust, но он быстро становится моим любимым языком программирования. Хотя написание небольших проектов на Rust обычно менее эргономично и занимает больше времени ( по крайней мере , со мной за рулём), это бросает вызов тому , как я думаю о дизайне программы. Мои бои с компилятором становятся менее частыми , после того как я узнаю что-то новое.

Я работаю над дополнением zigbee2mqtt Hass.io, это расширение Домашний помощник для платформы домашней автоматизации. Надстройка опирается на библиотеку zigbee2mqtt . zigbee2mqtt довольно новый проект, который быстро развивается и ещё не имеет опубликованных релизов. Дополнения на Hass.io распространяются в виде Docker-контейнеров и zigbee2mqtt просто использует самую свежую ветку master базовой библиотеки при сборке контейнера. При таком подходе возникла проблема: когда новые коммиты были перенесены в zigbee2mqtt , пользователи дополнения не могли обновиться до последней версии , пока контейнер дополнения не был собран ( что происходит автоматически в Travis CI только тогда , когда коммиты были перенесены в репозиторий add-on). Мне нужен был способ запускать сборку на Travis всякий раз , когда библиотека была изменена на Github. Почему бы не реализовать это на языке Rust?

В этом посте я пройдусь по созданию простого веб-сервиса в Rust с помощью actix-web , который принимает входящие сообщения Github webhook и запускает сборку Travis CI через Travis API V3 .

Что такое Tokio и Async IO и зачем это нужно?

29 Января 2020 • оригинал: Manish Goregaokar • перевод: bmusin • обучение • поддержите на Patreon

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

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

  • Что это такое — Async I/O?
  • Что такое корутины ( coroutines)?
  • Что такое легковесные потоки ( lightweight threads)?

Что такое футуры? ( futures)?


  • Как они сочетаются между собой?
  • Rust: скачиваем ленту и парсим JSON

    22 Января 2020 • оригинал: Florian Gilcher • перевод: bmusin • обучение • поддержите на Patreon

    Я покажу вам , как написать небольшую программу , которая скачивает ленту ( feed) в формате JSON, парсит и выводит список заметок на консоль в форматированном виде.

    У нас все вылилось в очень лаконичный код. Как? Смотрите под катом.

    Небезопасные абстракции

    08 Января 2020 • оригинал: Niko Matsakis • перевод: bmusin • обучение • поддержите на Patreon

    Ключевое слово unsafe является неотъемлемой частью дизайна языка Rust. Для тех кто не знаком с ним: unsafe — это ключевое слово , которое, говоря простым языком , является способом обойти проверку типов ( type checking) Rust’а.

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

    Все же , по моему мнению , unsafe не является недостатком. На самом деле он является важной частью языка. unsafe выполняет роль некоторого выходного клапана — это значит то , что мы можем использовать систему типов в простых случаях, однако позволяя использовать всевозможные хитрые приёмы , которые вы хотите использовать в вашем коде. Мы только требуем , чтобы вы скрывали эти ваши приёмы ( unsafe код) за безопасными внешними абстракциями.

    Данная заметка представляет ключевое слово unsafe и идею ограниченной « небезопасности». Фактически это предвестник заметки, которую я надеюсь написать чуть позже. Она обсуждает модель памяти Rust, которая указывает , что можно , а что нельзя делать в unsafe коде.

    Как публиковать свои пакеты на Crates.io

    17 Декабря 2020 • Михаил Панков • обучение • поддержите на Patreon

    Как зарегистрироваться на crates.io, опубликовать свою библиотеку, подключить её в другой проект , и как управлять версиями пакета на crates.io.

    Цукерберг рекомендует:  Вакансии ОТР 2000

    Это цикл статей:

    Rust: str vs String

    13 Октября 2020 • оригинал: Ameya • перевод: Norman Ritchie • обучение • поддержите на Patreon

    Будучи новичком в Rust, я запутывался в различных способах представления строк. В книге о языке Rust есть глава « References and Borrowing», в которой используется три различных типа строковых переменных в примерах: String , &String и &str .

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

    Как настроить сборку и тестирование для Open Source проекта на Rust под Windows с помощью AppVeyor

    20 Августа 2020 • Михаил Панков • обучение • поддержите на Patreon

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

    Это цикл статей:

    • Как настроить сборку и тестирование для Open Source проекта на Rust под Linux с помощью Travis
    • Как настроить сборку и тестирование для Open Source проекта на Rust под Windows с помощью AppVeyor ( эта статья)

    Как настроить сборку и тестирование для Open Source проекта на Rust под Linux с помощью Travis

    30 Июля 2020 • Михаил Панков • обучение • поддержите на Patreon

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

    Это цикл статей:

    • Как настроить сборку и тестирование для Open Source проекта на Rust под Linux с помощью Travis ( эта статья)
    • Как настроить сборку и тестирование для Open Source проекта на Rust под Windows с помощью AppVeyor

    Есть ли ООП в Rust?

    11 Июня 2020 • Михаил Панков • обучение • поддержите на Patreon

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

    В этой статье мы рассмотрим , как программировать на Rust в ООП-стиле. Мы будем делать это на примере: построим иерархию классов в учебной задаче.

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

    Решаем систему логических уравнений на Rust

    17 Мая 2020 • Павел Никитин • руководства • поддержите на Patreon

    Язык программирования Rust сосредоточен на безопасности , скорости и параллелизме. Давайте проверим , насколько Rust быстрый в сравнении с другими компилируемыми языками программирования C и Vala в решении системы логических уравнений. Для этого реализуем алгоритм решения интересной головоломки Lights Off на языках

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

    Передача намерений

    12 Апреля 2020 • оригинал: Jasper ‘jaheba’ Schulz • перевод: Илья Богданов • обучение • поддержите на Patreon

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

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

    Изменение размера изображения с учётом содержимого

    18 Марта 2020 • оригинал: Martin Hafskjold Thoresen • перевод: Gexon • руководства • поддержите на Patreon

    Изменение размера изображения с учётом содержимого ( Content Aware Image Resize), жидкое растяжение ( liqu > ( retargeting) или вырезание шва ( seam carving) относятся к методу изменения размера изображения , где можно вставлять или удалять швы, или наименее важные пути , для уменьшения или наращивания изображения. Об этой идее я узнал из ролика на YouTube, от Shai Av >, естественно на языке Rust :)

    Для подопытной картинки , я поискал по запросу [1] «sample image» , и нашёл её [2]:

    Прекрасные конечные автоматы на Rust

    14 Марта 2020 • оригинал: Andrew ‘hoverbear’ Hobden • перевод: Илья Богданов • обучение • поддержите на Patreon

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

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

    Один интересный шаблон , часто применяемый к таким проблемам — « Конечный автомат». Предлагаю потратить немного времени , чтобы понять , что именно имеется ввиду под этим словосочетанием , и почему же это так интересно.

    Графическое описание владения и заимствования в Rust

    17 Февраля 2020 • оригинал: Phil Ruffwind • перевод: Шерзод Муталов • обучение • поддержите на Patreon

    Ниже представлено графическое описание перемещения , копирования и заимствования в языке программирования Rust. В основном , эти понятия специфичны только для Rust и часто являются камнем преткновения для новичков.

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

    Числа Пеано на системе типов Rust

    20 Сентября 2020 • Fedor Logachev • обучение • поддержите на Patreon

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

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

    Если верить википедии « Аксио́мы Пеа́но — одна из систем аксиом для натуральных чисел , введённая в XIX веке итальянским математиком Джузеппе Пеано.»

    Нас интересуют две из них — с помощью которых можно ввести и использовать натуральные числа:

    • 1 является натуральным числом
    • Число , следующее за натуральным , тоже является натуральным.

    Дословно запишем на rust с помощью:

    Nat — это либо ноль , либо следующее натуральное число.

    futures-rs: асинхронщина на Rust

    16 Сентября 2020 • оригинал: Alex Crichton • перевод: Арсен Галимов • обучение • поддержите на Patreon

    Замечание: проект futures-rs был реорганизован и многие вещи были переименованы. Где возможно , ссылки были обновлены.


    Начинаем работу с futures

    Этот документ поможет вам изучить контейнер для языка программирования Rust — futures , который обеспечивает реализацию futures и потоков с нулевой стоимостью. Futures доступны во многих других языках программирования , таких как C++ , Java , и Scala , и контейнер futures черпает вдохновение из библиотек этих языков. Однако он отличается эргономичностью , а также придерживается философии абстракций с нулевой стоимостью , присущей Rust, а именно: для создания и композиции futures не требуется выделений памяти , а для Task , управляющего ими , нужна только одна аллокация. Futures должны стать основой асинхронного компонуемого высокопроизводительного ввода/вывода в Rust, и ранние замеры производительности показывают , что простой HTTP сервер , построенный на futures, действительно быстр.

    Эта документация разделена на несколько разделов:

    • « Здравствуй , мир!»;
    • типаж future;
    • типаж Stream ;
    • конкретные futures и поток ( Stream );
    • возвращение futures;
    • Task и future;
    • локальные данные задачи.

    Futures нулевой стоимости в Rust

    12 Августа 2020 • оригинал: Aaron Turon • перевод: Сергей Ефремов • обучение • поддержите на Patreon

    Замечание: проект futures-rs был реорганизован и многие вещи были переименованы. Где возможно , ссылки были обновлены.

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

    Нам бы хотелось чего-нибудь более высокоуровневого , с лучшей эргономикой , но чтобы оно обладало хорошей компонуемостью, поддерживая экосистему асинхронных абстракций , работающих вместе. Звучит очень знакомо: ту же цель преследовало внедрение futures ( или promises) во многие языки, поддерживающие синтаксический сахар в виде async/await на вершине.

    Мифы и легенды о переполнении целых чисел в Rust

    25 Июля 2020 • оригинал: Huon Wilson • перевод: Станислав Ткач • обучение • поддержите на Patreon

    Примитивные целочисленные типы , поддерживаемые процессорами , являются ограниченным приближением к бесконечному набору целых чисел , которыми мы привыкли оперировать в реальной жизни. Это ограниченное представление не всегда совпадает с « реальными» числами , например 255_u8 + 1 == 0 . Зачастую программист забывает об этой разнице, что легко может приводить к багам.

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

    Введение в Iron

    13 Июля 2020 • Арсен Галимов aka « Loo Maclin» • обучение • поддержите на Patreon

    Немного об Iron

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

    Философия

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

    • « промежуточные» типажи — используются для реализации сквозного функционала в обработке запросов;
    • модификаторы — используются для изменения запросов и ответов наиболее эргономичным способом.

    С базовой частью модификаторов и промежуточных типажей вы познакомитесь в ходе статьи.

    Создание проекта

    Для начала создадим проект с помощью Cargo, используя команду:

    Язык программирования Rust

    Первый раздел книги рассказывает о том, как начать работать с Rust и его инструментами. Сначала мы установим Rust, затем напишем классическую программу «Привет, мир!» и, наконец, поговорим о Cargo, который представляет собой систему сборки и менеджер пакетов в Rust.

    Установка Rust

    Первым шагом к использованию Rust является его установка. В этой главе нам понадобится интернет-соединение для выполнения команд, с помощью которых мы загрузим Rust из Интернета.

    Мы воспользуемся несколькими командами в терминале, и они все будут начинаться с $ . Вам не нужно вводить $ : этот символ используется только для того, чтобы обозначить начало каждой команды. В Интернете можно увидеть множество руководств и примеров, которые следуют этому правилу: $ обозначает команды, которые выполняются с правами обычного пользователя, и # — команды, которые выполняются с правами администратора.

    Поддерживаемые платформы

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

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

    Первый уровень

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

    • Автоматические тесты обеспечивают тестирование этих платформ.
    • Изменения, принятые в ветку master репозитория rust-lang/rust , прошли тестирование.
    • Для этих платформ предоставляются официальные пакеты.
    • Доступна документация о том, как собрать и использовать платформу.
    Target std rustc cargo notes
    x86_64-pc-windows-msvc 64-bit MSVC (Windows 7+)
    i686-pc-windows-gnu 32-bit MinGW (Windows 7+)
    x86_64-pc-windows-gnu 64-bit MinGW (Windows 7+)
    i686-apple-darwin 32-bit OSX (10.7+, Lion+)
    x86_64-apple-darwin 64-bit OSX (10.7+, Lion+)
    i686-unknown-linux-gnu 32-bit Linux (2.6.18+)
    x86_64-unknown-linux-gnu 64-bit Linux (2.6.18+)

    Второй уровень

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

    • Настроена автоматическая сборка, но тестирования не происходит.
    • Изменения, принятые в ветку master репозитория rust-lang/rust , собираются для этих платформ. Имейте в виду, что для некоторых платформ собирается только стандартная библиотека, но для остальных настроена полная раскрутка компилятора (bootstraping).
    • Для этих платформ предоставляются официальные пакеты.
    Target std rustc cargo notes
    i686-pc-windows-msvc 32-bit MSVC (Windows 7+)

    Третий уровень

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

    Target std rustc cargo notes
    x86_64-unknown-linux-musl 64-bit Linux with MUSL
    arm-linux-androideabi ARM Android
    i686-linux-android 32-bit x86 Android
    aarch64-linux-android ARM64 Android
    arm-unknown-linux-gnueabi ARM Linux (2.6.18+)
    arm-unknown-linux-gnueabihf ARM Linux (2.6.18+)
    aarch64-unknown-linux-gnu ARM64 Linux (2.6.18+)
    mips-unknown-linux-gnu MIPS Linux (2.6.18+)
    mipsel-unknown-linux-gnu MIPS (LE) Linux (2.6.18+)
    powerpc-unknown-linux-gnu PowerPC Linux (2.6.18+)
    i386-apple-ios 32-bit x86 iOS
    x86_64-apple-ios 64-bit x86 iOS
    armv7-apple-ios ARM iOS
    armv7s-apple-ios ARM iOS
    aarch64-apple-ios ARM64 iOS
    i686-unknown-freebsd 32-bit FreeBSD
    x86_64-unknown-freebsd 64-bit FreeBSD
    x86_64-unknown-openbsd 64-bit OpenBSD
    x86_64-unknown-netbsd 64-bit NetBSD
    x86_64-unknown-bitrig 64-bit Bitrig
    x86_64-unknown-dragonfly 64-bit DragonFlyBSD
    x86_64-rumprun-netbsd 64-bit NetBSD Rump Kernel
    i686-pc-windows-msvc (XP) Windows XP support
    x86_64-pc-windows-msvc (XP) Windows XP support

    Имейте в виду, что данная таблица со временем может быть дополнена: это не исчерпывающий набор платформ третьего уровня!

    Установка на Linux или Mac

    Если вы используете Linux или Mac, то всё, что вам нужно сделать, — это ввести следующую команду в консоль:

    Эта команда загрузит скрипт и начнёт установку. Если всё пройдёт успешно, то вы увидите следующий текст:

    Нажмите y для подтверждения и следуйте дальнейшим подсказкам.

    Установка на Windows

    Если вы используете Windows, то скачайте подходящий установщик.

    Удаление

    Удалить Rust так же просто, как и установить его. На Linux или Mac нужно просто запустить скрипт удаления:

    Если вы использовали установщик Windows, то просто повторно запустите .msi , который предложит вам возможность удаления.

    Решение проблем

    Если у вас установлен Rust, то можно открыть терминал и ввести:

    Вы должны увидеть версию, хеш коммита и дату коммита.

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

    Если нет и вы пользователь Windows, то убедитесь в том, что Rust прописан в вашей системной переменной %PATH%. Если это не так, то запустите установщик снова, выберите «Change» на странице «Change, repair, or remove installation» и убедитесь, что «Add to PATH» указывает на локальный жёсткий диск.

    Существует несколько мест, где вы можете получить помощь. Самый простой вариант — канал #rust на irc.mozilla.org, к которому вы можете подключиться через Mibbit. Нажмите на эту ссылку, и вы будете общаться в чате с другими Rustaceans (это дурашливое прозвище, которым мы себя называем), и мы поможем вам. Другие полезные ресурсы, посвящённые Rust: форум пользователей и Stack Overflow. Русскоязычные ресурсы: сайт сообщества, форум, Stack Overflow.

    Установщик также устанавливает документацию, которая доступна без подключения к сети. На UNIX системах она располагается в директории /usr/local/share/doc/rust . В Windows используется директория share/doc , относительно того, куда вы установили Rust.

    Привет, мир!

    Теперь, когда вы установили Rust, давайте напишем первую программу на Rust. Традиционно при изучении нового языка программирования первая написанная программа просто выводит на экран «Привет, мир!», и мы следуем этой традиции.

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

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

    Создание проекта

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

    Если вы используете Windows и не используете PowerShell,

    может не работать. Обратитесь к документации вашей оболочки для уточнения деталей.

    Написание и запуск программы на Rust

    Теперь создадим новый файл для кода программы. Назовём наш файл main.rs. Файлы с исходным кодом на Rust всегда имеют расширение .rs. Если вы хотите использовать в имени вашего файла больше одного слова, разделяйте их подчёркиванием; например hello_world.rs, а не helloworld.rs.

    Теперь откройте только что созданный файл main.rs и добавьте в него следующий код:


    Сохраните файл и вернитесь к вашему окну терминала. На Linux или OSX введите следующие команды:

    На Windows просто замените main на main.exe . Вне зависимости от вашей ОС вы должны увидеть строку Привет, мир! в терминале. Поздравляем! Вы написали первую программу на Rust. Теперь вы Rust-разработчик! Добро пожаловать!

    Анатомия программ на Rust

    Теперь давайте детально разберёмся, что происходит в программе «Привет, мир!». Вот первый кусочек головоломки:

    Эти строки объявляют «функцию» в Rust. Функция main особенна: это начало каждой программы на Rust. Первая строка говорит: «Мы объявляем функцию, именуемую main , которая не получает параметров и ничего не возвращает». Если бы мы хотели передать в функцию параметры, то указали бы их в скобках ( ( и ) ). Поскольку нам не надо ничего возвращать из этой функции, мы можем опустить указание типа возвращаемого значения. Мы вернёмся к этому позже.

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

    Теперь эта строка:

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

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

    Идём дальше. «Привет, мир!» — это «строка». Строки — это удивительно сложная тема для системного языка программирования. Это статически расположенная в памяти строка. Мы передаём строку в качестве аргумента в println! , который выводит строки на экран. Достаточно просто!

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

    Компиляция и запуск это отдельные шаги

    В разделе «Написание и запуск программы на Rust» мы рассмотрели, как запустить только что созданную программу. Теперь мы разберём каждый шаг по отдельности.

    Перед запуском программы её нужно скомпилировать. Вы можете воспользоваться компилятором Rust с помощью команды rustc и передать ваш файл, как показано здесь:

    Если раньше вы программировали на С или С++, то заметите, что это напоминает gcc или clang . После успешной компиляции Rust создаст двоичный исполняемый файл. На Linux или OSX вы можете убедиться в этом с помощью команды ls :

    У нас есть два файла: файл с нашим исходным кодом, имеющий расширение .rs , и исполняемый файл ( main.exe в Windows, main в остальных случаях). Все, что осталось сделать, — это запустить main или main.exe :

    Мы вывели наш текст «Привет, мир!» в окне терминала.

    Если раньше вы использовали динамические языки программирования вроде Ruby, Python или JavaScript, то, возможно, разделение компиляции и запуска покажется вам странным. Rust — это язык, на котором программы компилируются перед исполнением. Это означает, что вы можете собрать программу, дать её кому-то ещё, и ему не нужно устанавливать Rust для запуска этой программы. Если вы передадите кому-нибудь .rb , .py или .js файл, им понадобится интерпретатор Ruby, Python или JavaScript, чтобы скомпилировать и запустить вашу программу (это делается одной командой). В мире языков программирования много компромиссов, и Rust сделал свой выбор.

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

    Привет, Cargo!

    Cargo — это система сборки и пакетный менеджер для Rust, и Rustaceans используют его для управления своими проектами на Rust. Cargo заботится о трёх вещах: сборка кода, загрузка библиотек, от которых зависит ваш код, и сборка этих библиотек. Библиотеки, которые нужны вашему коду, мы называем «зависимостями» («dependencies»), поскольку ваш код зависит от них.

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

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

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

    Переход на Cargo

    Давайте переведём наш проект «Привет, мир!» на использование Cargo. Для перехода на Cargo нужно сделать три вещи:

    1. Расположить файл с исходным кодом в правильной директории.
    2. Избавиться от старого исполняемого файла ( main.exe или main ) и сделать новый.
    3. Создать конфигурационный файл для Cargo.

    Давайте сделаем это!

    Создание нового исполняемого файла и директории с исходным кодом

    Для начала вернитесь к вашему терминалу, перейдите в вашу директорию hello_world и введите следующие команды:

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

    Теперь скопируйте main.rs в директорию src и удалите скомпилированный файл, который вы создали с помощью rustc .

    Отметим, что поскольку мы создаём исполняемый файл, то мы используем main.rs . Если бы мы хотели создать библиотеку, то мы использовали бы lib.rs. Cargo использует это соглашение для успешной компиляции вашего проекта, но вы можете это изменить, если захотите.

    Создание конфигурационного файла

    Теперь создайте новый файл внутри директории hello_world и назовите его Cargo.toml .

    Убедитесь в том, что имя правильное: вам нужна заглавная C ! В противном случае Cargo не найдёт конфигурационный файл.

    Это файл в формате TOML (Tom’s Obvious, Minimal Language). TOML — это аналог INI, но с некоторыми дополнениями, и он используется в конфигурационных файлах для Cargo.

    Поместите в данный файл следующие строки:

    Первая строка, [package] , говорит о том, что следующие параметры отвечают за настройку пакета. Когда нам понадобится добавить больше информации в этот файл, мы создадим другие разделы, но сейчас нам достаточно настроек пакета.

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

    После того как вы добавили эту информацию в Cargo.toml, сохраните изменения. На этом создание конфигурационного файла завершено.

    Сборка и запуск Cargo проекта

    Теперь, после создания файла Cargo.toml в корневой директории, мы готовы приступить к сборке и запуску нашего проекта. Чтобы сделать это, введите следующие команды:

    Та-да! Мы собрали наш проект, вызвав cargo build , и запустили его с помощью ./target/debug/hello_world . Мы можем сделать это в один шаг, используя cargo run :

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

    На первый взгляд это кажется сложнее, по сравнению с более простым использованием rustc , но давайте подумаем о будущем: если в нашем проекте будет больше одного файла, мы должны будем вызывать rustc для каждого из них и передавать кучу параметров, чтобы собрать их вместе. С Cargo, когда наш проект вырастет, нам понадобится вызвать только команду cargo build , и она всё сделает за нас.

    Сборка релизной версии

    Когда вы закончите работать над проектом и он окончательно будет готов к релизу, используйте команду cargo build —release для компиляции вашего проекта с оптимизацией. Эти оптимизации делают ваш код на Rust быстрее, но требуют больше времени на компиляцию. Именно из-за этого существует два разных способа: один для разработки, другой для сборки финальной версии, которую вы отдадите пользователям.

    Также вы должны были заметить, что Cargo создал новый файл: Cargo.lock .

    Этот файл используется Cargo для отслеживания зависимостей в вашем приложении. Прямо сейчас у нас нет ни одной, поэтому этот файл немного пустоват. Вам не нужно редактировать этот файл самостоятельно, Cargo сам с ним разберётся.

    Вот и все! Мы успешно собрали hello_world с помощью Cargo.

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

    Простой способ создать новый Cargo проект

    Вам не нужно повторять вышеприведённые шаги каждый раз, когда вы хотите создать новый проект! Cargo может создать директорию проекта, в которой вы сразу сможете приступить к разработке.

    Чтобы создать новый проект с помощью Cargo, нужно ввести команду cargo new :

    Мы указываем аргумент —bin , так как хотим создать исполняемую программу. Если мы не укажем этот аргумент, то Cargo создаст проект для библиотеки. Исполняемые файлы часто называют бинарниками (поскольку обычно они находятся в /usr/bin , если вы используете Unix систему).

    Cargo сгенерировал два файла и одну директорию: Cargo.toml и директорию src с файлом main.rs. Они должны выглядеть так же, как те, что мы создали ранее.

    Этого достаточно для того, чтобы начать. Открыв Cargo.toml , вы должны увидеть следующее:

    Cargo наполнил этот файл значениями по умолчанию на основании переданных аргументов и глобальной конфигурации git . Также он инициализировал директорию hello_world как git репозиторий.

    Вот что должно быть внутри src/main.rs :

    Cargo создал «Hello World!» для нас, и вы уже можете приступить к программированию!

    У Cargo есть собственное руководство, в котором про него рассказано более детально.

    Заключение

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

    У вас есть два пути: погрузиться в изучение реального проекта, открыв раздел «Изучение Rust», или начать с самого низа и постепенно продвигаться наверх, начав с раздела «Синтаксис и семантика». Программисты, имеющие опыт работы с системными языками, вероятно, предпочтут «Изучение Rust», в то время как программисты, имеющие опыт работы с динамическими языками, скорее всего, захотят пойти по второму пути. Разные люди учатся по-разному! Выберите то, что подходит именно вам.

    7 причин, по которым Rust — самый захватывающий новый язык программирования

    1 min

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

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

    Что такое ржавчина?

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


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

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

    Конечно, есть языки, которые легче изучать (но опять же Python не для всех

    4 причины, почему Python не является языком программирования для вас

    4 причины, почему Python не является языком программирования для вас
    Язык программирования Python чрезвычайно популярен, но вот несколько причин, по которым вы можете избежать Python.
    Прочитайте больше

    ) так зачем учить Rust?

    1. Ржавчина особенная

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

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

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

    2. Груз все делает

    Rust использует менеджер пакетов под названием Cargo. Подобно NPM в JavaScript или Ruby Gems, Cargo собирает и компилирует все необходимое для вашего проекта. Для создания нового проекта в Rust вы используете Cargo. Вы также будете использовать его для проверки кода на наличие ошибок, компиляции и сборки, а также для управления своими зависимостями.

    Каждый новый проект Rust имеет Cargo.toml файл, который содержит детали проекта и зависимости. Каждый раз, когда вы проверяете или создаете свой проект, Cargo использует файл Cargo.toml для упаковки всего, что нужно проекту.

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

    3. Ржавчина быстро

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

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

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

    4. Rust для веб-разработки

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

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

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

    5. Разработчики любят Rust

    Все виды разработчиков любят Rust, и это видно. Это был самый любимый язык в 2020, 2020 и 2020 годах в опросе разработчиков Stack Overflow. Все, включая веб-разработчиков, создателей музыки, разработчиков игр и программистов встроенного оборудования, говорят о том, как это идеально подходит для их дисциплины.

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

    6. Rust сделает вас лучшим программистом

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

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

    Как научиться программировать на С с помощью этого начинающего проекта

    Как научиться программировать на С с помощью этого начинающего проекта
    Хотите начать программирование, но не уверены в C? Попробуйте это руководство для начинающих, чтобы проверить, подходит ли вам этот язык.
    Прочитайте больше

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

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

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

    7. Книга

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

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

    Язык программирования Rust — это не книга по основам кодирования как таковая, но процесс изучения того, как работает язык, отражает вашу собственную практику.

    Стоит ли учиться ржавчине?

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

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

    6 причин, почему Python — язык программирования будущего

    6 причин, почему Python — язык программирования будущего
    Хотите узнать или расширить свои навыки программирования? Вот почему Python — лучший язык программирования для изучения в этом году.
    Прочитайте больше

    ,

    Узнайте больше о: Программирование, Rust.

    Как превратить скрипты Bash в интерактивные приложения с помощью AppleScript

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

    Аналитическая компания RedMonk опубликовала рейтинг языков программирования за третий квартал 2020 года: Rust занял в нем 23 место.

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

    О языке

    Rust – процедурный язык программирования, поддерживающий различные стили написания кода. Разработчик Грэйдон Хор начал создавать язык в 2006 году, и спустя три года к проекту подключилась Mozilla. В 2010 году Rust презентовали на конференции Mozilla Summit. В этом же году разработку перевели на компилятор, написанный на Rust. Компилятор использовал универсальную систему анализа и трансформации программ LLVM в качестве базы данных.

    Первая стабильная версия языка вышла в 2015 году. После релиза альфа-версии Rust подвергся правкам – внутри компилятора оставили только готовые возможности, которые не будут изменяться. Все остальное перенесли в экспериментальный раздел.

    В основе языка Грэйдон Хор заложил такие понятия как:

    • Безопасность. Rust содержит ряд ограничений для программиста, которые включены по умолчанию. Для их отключения в блоках и функциях требуется метка «unsafe».
    • Скорость. Язык сопоставим по скорости с другим языком программирования C++, что дает явный ряд преимуществ для программиста.
    • Параллелизм. Система может выполнять несколько вычислений одновременно, вместе с этим они могут взаимодействовать друг с другом.
    • Краткость. Первые ключевые слова в Rust укладывались в пять символов. Но позднее это ограничение сняли.

    Пример одного из первых кодов на Rust

    Однако Rust не лишен и минусов, самые яркие из них:

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

    Впрочем, язык регулярно модернизируется и дополняется: его обновления выходят раз в 6 недель.

    Сравнение Rust с C++

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

    • Обращение к удаленной памяти. В C++ из-за удаления переменной может возникнуть целый ряд проблем. Подобные осложнения невозможны в Rust, так как в нем нет команд для удаления памяти. Компилятор наследника сообщит, что написанный код содержит ошибку, а компилятор С++ выведет результат без удаленных значений, даже не сообщив о проблеме.
    • Точка с запятой. Добавив в код лишнюю точку с запятой, вы вызовете ошибку в С++, тогда как в Rust тело цикла заключается в фигурные скобки.
    • Небезопасный код. В Rust есть метка «unsafe», которая изолирует основной код от небезопасного. В будущем, при просмотре кода это позволяет сузить поиск уязвимостей.

    Именно на C++ был реализован Firefox: этот капризный язык требовал повышенного внимания к деталям. В противном случае ошибки оборачивались серьезными уязвимостями. Rust был призван справиться с этой проблемой.

    Перспективы

    В рейтинге RedMonk за третий квартал 2020 года язык программирования от Mozilla стабильно занимает 23 место. Эксперты полагают, что улучшение позиций ему не грозит. Несмотря на это, в августе 2020 года создатели выпустили обновленный Rust 1.28.

    После релиза Rust в 2015 году, по данным площадки Stack Overflow, с ним хотели ознакомиться 74% разработчиков. Однако уже в 2020 году он переместился на первое место: 79% пользователей назвали Rust любимым языком программирования и изъявили желание продолжить работу с ним. Первое место по этому параметру Rust занял и в 2020 году.

    Stack Overflow — популярная система вопросов и ответов о программировании, разработанная в 2008 году.

    Рейтинг любимых языков программирования по версии Stack Overflow-2020

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

    Переход на Cargo

    Перепишем наш проект «Hello, world» с использованием Cargo.

    Создаём новый проект:

    , где опция –bin указывает, что мы хотим создать исполняемую программу (бинарник), а не библиотеку. После этого создается папка hw2, со следующей структурой:

    В src лежит шаблон исходного кода с именем main.rs и таким кодом:

    Файл Cargo.toml — это конфигурационный файл нашего проекта:

    Теперь собираем проект с помощью команды:

    Если нет ошибок, запускаем нашу программу:

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

    Язык программирования Rust

    Добро пожаловать! Эта книга обучает основным принципам работы с языком программирования Rust. Rust — это системный язык программирования, внимание которого сосредоточено на трёх задачах: безопасность, скорость и параллелизм. Он решает эти задачи без сборщика мусора, что делает его полезным в ряде случаев, когда использование других языков было бы нецелесообразно: при встраивании в другие языки, при написании программ с особыми пространственными и временными требованиями, при написании низкоуровневого кода, такого как драйверы устройств и операционные системы. Во время компиляции Rust делает ряд проверок безопасности. За счёт этого не возникает накладных расходов во время выполнения приложения и устраняются все гонки данных. Это даёт Rust преимущество над другими языками программирования, имеющими аналогичную направленность. Rust также направлен на достижение «абстракции с нулевой стоимостью». Хотя некоторые из этих абстракций и ведут себя как в языках высокого уровня, но даже тогда Rust по-прежнему обеспечивает точный контроль, как делал бы язык низкого уровня.

    Книга «Язык программирования Rust» делится на восемь разделов. Это введение является первым из них. Затем идут:

    • C чего начать — Настройка компьютера для разработки на Rust.
    • Изучение Rust — Обучение программированию на Rust на примере небольших проектов.
    • Синтаксис и семантика — Каждое понятие Rust разбивается на небольшие кусочки.
    • Эффективное использование Rust — Понятия более высокого уровня для написания качественного кода на Rust.
    • Нестабильные возможности Rust — Передовые возможности, которые пока не добавлены в стабильную сборку.
    • Глоссарий — Ссылки на термины, используемые в книге.
    • Библиография — Литература, которая оказала влияние на Rust.

    После прочтения этого введения, в зависимости от ваших предпочтений, вы можете продолжить дальнейшее изучение либо в направлении «Изучение Rust», либо в направлении «Синтаксис и семантика». Если вы предпочитаете изучить язык на примере реального проекта, лучшим выбором будет раздел «Изучение Rust». Раздел «Синтаксис и семантика» подойдёт тем, кто предпочитает тщательно изучить каждое понятие языка отдельно, перед тем как двигаться дальше. Большое количество перекрёстных ссылок соединяет эти части воедино.

    Содействие

    Исходные файлы, из которых генерируется оригинал этой книги, могут быть найдены на GitHub.

    Цукерберг рекомендует:  Photoshop - web дизайндруг
    Понравилась статья? Поделиться с друзьями:
    Все языки программирования для начинающих