Rust очень любят, но что в нём особенного?
Авторизуйтесь
Rust очень любят, но что в нём особенного?
Rust оказывается самым любимым языком по версии StackOverflow шесть лет подряд. В чём его секрет? Короткий ответ — Rust избавлен от болевых точек, которые есть во многих современных языках программирования.
Мы рассмотрим несколько примеров того, как Rust справляется с проблемами других языков и его недостатки, которые тоже присутствуют.
Наследник динамически типизированных языков
Споры между программистами, которые предпочитают динамическую типизацию статической, вероятно, будут продолжаться еще десятилетия, но трудно спорить о преимуществах статических типов.
Развитие таких языков, как TypeScript и наличие таких возможностей, как аннотации типов в Python, свидетельствуют о том, что люди разочаровались в текущем состоянии динамической типизации.
Статически типизированные языки позволяют использовать ограничения на данные и их поведение, проверяемые компилятором, что снижает когнитивные издержки и недопонимание.
Однако не все способы статической типизации эквивалентны. Многие статически типизированные языки поддерживают концепцию NULL.
Это значит, что любое значение может отсутствовать, таким образом создавая второй возможный тип для каждого типа. Как Haskell и некоторые другие современные языки программирования, Rust реализует эту возможность с помощью типа optional, и компилятор требует, чтобы вы указывали case None.
Это предотвращает возникновение ошибки: TypeError: Cannot read property ‘foo’ of null во время выполнения программы, вместо этого ошибка появляется ещё во время компиляции, и вы можете устранить её до того, как пользователь ее увидит. Вот пример функции для приветствия кого-либо независимо от того, знаем мы его имя или нет; если бы мы забыли случай None в match или попытались использовать имя так, как если бы оно было всегда присутствующим строковым значением, компилятор выдал бы ошибку.
Статическая типизация в Rust делает все возможное, чтобы не мешать программисту, при этом обеспечивая поддержку. Некоторые языки со статической типизацией ложатся большой нагрузкой на программиста, требуя многократного повторения типа переменной, что препятствует удобочитаемости и рефакторингу. Другие статически типизированные языки допускают вывод типа во всей программе.
Хотя это удобно в начале разработки, снижается способность компилятора предоставлять полезную информацию об ошибках, в случае несовпадения типов. Rust учится на обоих этих стилях и требует, чтобы элементы верхнего уровня, такие как аргументы функций и константы, имели явные типы, позволяя при этом выводить типы внутри тел функций. В этом примере компилятор Rust может определить тип дважды, 2 и 1, поскольку параметр val и возвращаемый тип объявлены как 32-разрядные целые числа со знаком.
Наследник языков со сборщиком мусора
Одним из самых больших преимуществ использования системного языка программирования является возможность контролировать низкоуровневые детали.
Rust позволяет выбирать между хранением данных в стеке или в куче и во время компиляции определяет что память больше не нужна и может быть очищена. Это позволяет эффективно использовать память. Tilde — один из первых пользователей Rust в своем продукте Skylight, обнаружил, что им удалось сократить использование памяти с 5 ГБ до 50 МБ, переписав некоторые конечные точки HTTP на Java в Rust. Такая экономия становится особенно значимой, когда облачные провайдеры меняют цены на дополнительную память.
Без необходимости постоянной работы сборщика мусора проекты Rust хорошо подходят для использования в качестве библиотек другими языками программирования через интерфейсы с внешними функциями. Это позволяет существующим проектам заменять критически важные для производительности части быстрым кодом на Rust без рисков для безопасности памяти, присущих другим системным языкам программирования. Некоторые проекты даже были постепенно переписаны в Rust с использованием этих методов.
Обладая прямым доступом к оборудованию и памяти, Rust является идеальным языком для разработки встраиваемых и bare-metal систем. Вы можете писать код чрезвычайно низкого уровня, например ядра операционной системы или приложения для микроконтроллеров. Основные типы и функции Rust, а также переиспользуемый библиотечный код отлично работают в этих особенно сложных средах.
Наследник языков системного программирования
Большинство людей рассматривают Rust как альтернативу таким языкам системного программирования, как Си или C++. Самое большое преимущество Rust — это проверка заимствований. Это часть компилятора, ответственная за то, чтобы ссылки не переживали данные, на которые они ссылаются, это помогает устранить целые классы ошибок, вызванных небезопасным использованием памяти.
В отличие от многих существующих языков системного программирования, Rust не требует, чтобы вы проводили все свое время, погружаясь в мельчайшие детали. Rust стремится иметь как можно больше абстракций с нулевой стоимостью — абстракций, которые столь же эффективны, как и эквивалентный рукописный код. В этом примере мы покажем, как итераторы, основная абстракция Rust, могут быть использованы для краткого создания вектора, содержащего первые десять квадратных чисел:
В тех случаях когда безопасного Rust недостаточно мы можете использовать небезопасный Rust. Это даёт дополнительные возможности, однако вы сами должны следить за тем, что код безопасен. Этот код затем может быть заключен в абстракции более высокого уровня, которые гарантируют, что все виды использования абстракции безопасны.
Использование небезопасного Rust должно быть обдуманным решением, поскольку его правильное использование требует столько же размышлений и осторожности, как и в любом другом языке, в котором вы несете ответственность за предотвращение неопределенного поведения. Сведение к минимуму небезопасного кода — лучший способ свести к минимуму возможности сбоев и уязвимостей из-за небезопасности памяти.
Языки системного программирования подразумевают, что они будут эффективно существовать вечно. В то время как некоторые современные разработки не требуют такого срока службы, многие компании хотят знать, что их фундаментальная база кода будет пригодна для использования в обозримом будущем. Rust признает это и принял сознательные дизайнерские решения, касающиеся обратной совместимости и стабильности; это язык, разработанный на ближайшие 40 лет.
Экосистема Rust
Rust больше, чем спецификация языка и компилятор; многие аспекты создания и поддержки программного обеспечения промышленного качества рассматриваются как объекты первого класса. С помощью rustup можно установить несколько параллельных цепочек инструментов Rust и управлять ими. Rust поставляются с Cargo — инструментом командной строки для управления зависимостями, запуска тестов, создания документации и многого другого. Поскольку зависимости, тесты и документация доступны по умолчанию, их использование широко распространено. crates.io — это сайт сообщества для обмена и поиска библиотек Rust. Любая библиотека, опубликованная в crates.io будет иметь свою документацию на docs.rs.
Кроме встроенных инструментов, коммьюнити Rust создало множество средств разработки. Бенчмаркинг, анализ и тестирование на основе свойств — все это легко легко использовать в проектах. Дополнительные линты компилятора доступны в Clippy, а автоматическое форматирование обеспечивается rustfmt. Поддержка IDE хороша и с каждым днем становится всё более эффективной.
Rust имеет яркое, гостеприимное сообщество. Существует несколько официальных и неофициальных способов получить помощь, таких как чат, форум, сабреддит Rust и, конечно же, Stack Overflow. У Rust есть кодекс поведения, который соблюдается потрясающей командой модераторов, поэтому официальные порталы и большинство неофициальных располагают к себе.
В оффлайне Rust проводит множество конференций по всему миру, таких как RustConf, Rust Belt Rust, RustFest, Rust Latam, RustCon Asia и другие.
Не всё так просто
Сильная система типов Rust и акцент на безопасность памяти — все это происходит во время компиляции — означают, что при компиляции кода чрезвычайно часто возникают ошибки. Это может быть неприятным для программистов, не привыкших к такому самоуверенному языку программирования. Тем не менее, разработчики Rust потратили большое количество времени на работу над улучшением сообщений об ошибках, чтобы убедиться, что они понятны и применимы.
Особенно часто можно услышать, как кто-то жалуется, что он «борется с проверкой заимствований». Хотя эти ошибки могут обескураживать, важно признать, что каждое из выявленных мест потенциально могло привести к ошибкам и потенциальным уязвимостям.
В этом примере мы создаем изменяемую строку, содержащую имя, затем берем ссылку на первые три байта имени. Мы пытаемся изменить строку, очистив ее. Теперь ссылки на действительные данные и их разыменование могут привести к неопределенному поведению, поэтому компилятор останавливает нас:
К счастью, сообщение об ошибке включает в себя наш код и изо всех сил пытается объяснить проблему, указывая точные места.
Прототипирование в Rust может быть сложными из-за его статически типизированной природы и из-за того, что Rust требует покрытия 100% условий. Крайние случаи должны быть описаны, даже если программист еще не знает, что там должно быть. На ранних стадиях разработки эти крайние случаи часто можно устранить, вызвав сбой программы, а затем можно добавить строгую обработку ошибок на более позднем этапе. Это другой рабочий процесс, он встречается в таких языках, как Ruby, где разработчики часто пробуют код в REPL, а затем переносят его в прототип, вообще не рассматривая случаи ошибок.
Rust все еще относительно новый язык, а это значит, что некоторые нужные библиотеки могут быть ещё недоступны. Положительным моментом является то, что есть много плодородной почвы для разработки этих необходимых библиотек, возможно, даже с использованием последних достижений в соответствующих областях компьютерных наук. Благодаря этому и возможностям Rust некоторые библиотеки Rust, такие как regex, являются лучшими в своем классе на любом языке.
Хотя Rust твердо привержен стабильности и обратной совместимости, это не означает, что язык доработан. Конкретная проблема может не решаться функциями языка, которые облегчили бы ее выражение или, возможно, даже позволили бы ее выразить. Например, в Rust асинхронные фьючерсы существуют уже более трех лет, но стабильная поддержка async/await появилась не так давно.
Rust — молодой и дерзкий язык программирования
Говорят, что это одновременно C++ и Haskell.
Первая версия языка Rust появилась в 2010 году, и он сразу занял третью строчку в списке любимых языков разработчиков на StackOverflow. Год спустя Rust возглавил этот список и держался там несколько лет. Давайте посмотрим, почему этот язык стал таким популярным, в чём его особенности и почему вокруг него много споров.
В чём идея языка Rust
Автору языка нравилась скорость работы и всемогущество языка C++ и надёжность Haskell. Он поставил перед собой задачу совместить оба этих подхода в одном языке, и за несколько лет он собрал первую версию языка Rust.
Rust позиционируется как компилируемый системный мультипарадигмальный язык высокого уровня. Сейчас поясним, что это значит.
👉 Компилируемый язык означает, что готовая программа — это отдельный файл, который можно запустить на любом компьютере с нужной операционной системой. Для запуска не нужно устанавливать среду разработки и компилятор, достаточно, чтобы скомпилированная версия подходила к вашему компьютеру.
👉 Системный — это когда на языке пишут программы для работы системы в целом. Это могут быть операционные системы, драйверы и служебные утилиты. Обычные программы тоже можно писать на Rust — от калькулятора до системы управления базами данных. Системный язык позволяет писать очень быстрые программы, которые используют все возможности железа.
👉 Мультипарадигмальный значит, что в языке сочетаются несколько парадигм программирования. В случае Rust это ООП, процедурное и функциональное программирование. Причём, ООП в Rust пришло из C++, а функциональное — из Haskell. Программист может сам выбирать, в каком стиле он будет писать код, или совмещать разные подходы в разных элементах программы.
Синтаксис и код
За основу синтаксиса в Rust взят синтаксис из C и C++.Например, классический «Привет, мир!» на Rust выглядит так:
fn main() <
println!(«Hello, world!»);
>
Если вы знакомы с подобным синтаксисом, то сможете быстро начать писать и на Rust. Другое дело, что в Rust есть свои особенности:
let x = if new_game() < 4 >
else if reload() < 3 >
else
Последнее разберём подробно. При такой записи переменная x будет равна четырём, если функция new_game() вернёт значение true. Если этого не случится, компилятор вызовет функцию reload() и проверит, что получилось. Если true, то x примет значение 3, а если и это не сработает — то x станет равным 0.
Ещё в Rust есть сравнение переменной с образцом. В зависимости от того, с каким образцом совпало значение переменной, выполнится та или иная функция:
Главная особенность программ на Rust
Несмотря на синтаксис, похожий на C, главную особенность программ на Rust разработчики взяли из Haskell, и звучит она так:
Если программа на Rust скомпилировалась и не упала во время запуска, то она будет работать до тех пор, пока вы сами её не остановите.
Это значит, что программы на Rust почти так же надёжны, как программы на Haskell. Почти — потому что если программист использует «небезопасный» блок unsafe, который даёт ему прямой доступ к памяти, то в теории это иногда может привести к сбоям. Но даже с такими блоками Rust старается справляться сам и падает только в безнадёжных случаях.
Плюсы и минусы языка
Когда язык совмещает в себе несколько разных подходов из других языков, он получает большинство преимуществ каждого из них:
Минусы в основном связаны со скоростью развития языка. Так как Rust развивается очень быстро, то часто бывает так, что код из старой версии не работает в новой версии. Ещё к минусам можно добавить:
Что написано на Rust
Чаще всего Rust используют в тех проектах, где нужна стабильность и надёжность при высокой нагрузке и общее быстродействие программы.
На практике Rust подходит для разработки ОС, веб-серверов, системных программ мониторинга, веб-движков, а также для создания масштабируемых частей фронтенда и бэкенда. Например, вот самые известные проекты, где Rust был основным языком программирования:
Опровергаем четыре стереотипа о языке программирования Rust
Язык программирования Rust, начатый как хобби-проект, а впоследствии поддерживаемый корпорацией Mozilla, позволяет обычным программистам писать одновременно и безопасные, и быстрые системы: от калькуляторов до высоконагруженных серверов.
За своё относительно короткое время существования данный язык уже успел обрасти стереотипами, четыре из которых я попытаюсь опровергнуть ниже. Могу пропустить некоторые моменты, дискуссии в комментариях приветствуются.
1. Rust — сложный язык программирования
Сложность языка программирования обуславливается наличием большого числа несогласованных между собой синтаксических конструкций. Яркий пример — C++ и C#, ведь для абсолютного большинства программистов C++ является сложнейшим языком, коим не является C#, несмотря на большое количество синтаксических элементов. Rust довольно однороден, т.к. изначально был спроектирован с оглядкой на ошибки прошлого, а все нововведения вводятся исключительно при условии согласования с уже имеющимися.
Данный стереотип восходит своими корнями к концепции времён жизни ссылок (lifetimes), позволяющей на уровне семантики языка описывать гарантии действительности используемых ссылок. Синтаксис лайфтаймов выглядит сперва странным:
Но на деле синтаксис объявления лайфтайма довольно прост — это всего лишь идентификатор, перед которым следует апостроф. Лайфтайм ‘static означает, что ссылка является действительной на протяжении всего времени исполнения программы.
Что такое «действительность ссылки»? Если ссылка действительна, то она поддаётся разыменованию без паники, ошибки сегментации и прочих прелестей. Например, в функции main() указатель something становится недействительным, т.к. все автоматические переменные функции produce_something() очищаются после её вызова:
Семантически лайфтайм может быть задан посредством других лайфтаймов. Например, эта функция требует того, чтобы ссылка foo не стала недействительной до недействительности ссылки bar :
Конструкция выше применяется крайне редко, чаще всего одного лишь указания лайфтайма достаточно. Лайфтаймы — это элегантная абстракция, дающая возможность программистам быть уверенными в действительности собственных ссылок как в контексте однопоточных, так и многопоточных систем. Сложность лайфтаймов сильно переоценена.
Изучающих Rust также пугают концепции заимствования и владения (которые существовали и до создания Rust). Как и с лайфтаймами, концепции заимствования и владения лаконично вписываются в общую картину: заимствование — это взятие ссылки на значение, а владение — это связь идентификатора переменной с её значением.
Если один поток имеет иммутабельную ссылку на переменную, а другой поток имеет мутабельную, то второй может изменить значение, вызвав состояние гонки. Данная ситуация недопустима в безопасном языке, вследствие чего команда Rust определила два простых правила:
2. Rust — ещё один «убийца C/C++»
Ключевая фраза — «ещё один». На данный момент Rust — единственный язык программирования, обладающий одновременно активным сообществом и характеристиками, позволяющими ему решать задачи, решаемые языками C/C++. Синтаксис и семантика позволяют с лёгкостью изъясняться на разных уровнях абстракции — от инструкций SIMD до управления веб-серверами.
Данный стереотип возник вследствие языков Vala, Zig, Golang и подобных. Как было сказано выше, у этих языков либо слишком маленькое сообщество, либо они теоретически и практически не смогут работать на всех системах, на которых способны работать C/C++. У Vala и Zig маленькое сообщество, а Golang берёт курс на вытеснение интерпретируемых языков и не может работать на системах с критической нехваткой ресурсов, т.к. поставляется с дополнительной средой выполнения (например, сборщик мусора).
Очевидно, что языки C/C++ будут жить ещё очень много лет из-за накопленного за десятилетия кода и программистов, пишущих на них, но Rust имеет все шансы потеснить их, как это когда-то сделала Java.
3. Unsafe губит все гарантии, предоставляемые Rust
Unsafe, в действительности, — это подмножество языка Rust, разрешающее совершать лишь четыре операции, запрещённые в «безопасном» Rust. Borrow-checker не перестаёт работать, по-прежнему нельзя двум переменным обладать тем же значением и так далее. Запрещены лишь:
Потенциально небезопасный блок кода может быть инкапсулирован в безопасный блок, т.к. компилятор предполагает, что программист не сомневается в его правильности. Смысл потенциально небезопасного блока кода в том, что при его неправильном использовании поведение программы не определено.
Данный стереотип можно встретить в несколько иной трактовке: «Rust станет популярным лишь тогда, когда его сделают полностью небезопасным». И снова неверно, т.к. не все гарантии, предоставляемые Rust, могут работать в полностью небезопасном коде. Концепция Rust теряется при отсутствии гарантий безопасности.
И ещё одна трактовка: «Unsafe не работает, потому что любая программа на Rust использует небезопасные библиотеки на Си». Это заблуждение аналогично следующему: «Безопасность Java не работает, потому что любая прикладная программа исполняется на ОС, которая может содержать UB».
Дело в том, что если библиотека на Си не содержит UB, то она ни в коем случае не породит UB в использующим её коде на Rust. Существуют некоторые «оговорки», например, «UB может возникнуть как следствие неправильного использования безопасной библиотеки на Си», но если обобщить, то библиотека не является безопасной. Смотреть на определение UB из Википедии:
Другими словами, спецификация не определяет поведение языка (библиотеки, микросхемы) в любых возможных ситуациях, а говорит: «при условии А результат операции Б не определён».
4. Rust никогда не обгонит C/C++ по скорости
Утверждение безосновательное. В теории, программа, написанная на языке Rust, может быть оптимизирована столь же хорошо, как и аналогичная программа на C/C++. В некоторых синтетических тестах производительности Rust даже обгоняет GCC C:
Что касается тестов производительности на реальных задачах, то можно отметить замеры производительности RapidJSON и serde_json. serde_json парсит DOM медленнее, чем это делает RapidJSON, но при сериализации/десериализации структур serde_json обогнал RapidJSON (DOM) как на GCC, так и на CLANG:
Также можно отметить библиотеку Rustls, обогнавшую знаменитую OpenSSL практически во всех тестах (на 10% быстрее при установке соединения на сервере и на 20%-40% быстрее на клиенте, на 10%-20% быстрее при восстановлении соединения на сервере и на 30%-70% быстрее на клиенте).
По сути, когда мы сравниваем производительность Rust, скомпилированного стандартным компилятором rustc, с производительностью C/C++ кода, скомпилированного посредством CLANG, то мы сравниваем качество сгенерированного LLVM IR. В один случаях он может быть более подвержен оптимизациям, в других — менее.
На данном этапе своего развития компилятор rustc ещё не научился генерировать минимальный набор инструкций в сравнении с GCC/CLANG, что, теоретически, может замедлить выполнение программы на пару процентов. Рассмотрим два аналогичных примера кода на Rust и на C CLANG:
rustc сгенерировал больше инструкций, чем CLANG, хотя под капотом одна технология — LLVM. Это недоработка компилятора rustc, но никак не ограничение самого языка Rust, т.к. нет никаких фундаментальных препятствий сгенерировать меньший набор инструкций (как это делает CLANG).
Заключение
Rust не лишён недостатков, таких как сложности реализации некоторых структур данных, временная сырость экосистемы (которая с каждым годом всё нивелируется) и так далее. Надеюсь, что язык займёт свою нишу в современном программировании. Обсуждения — в комментариях.
Языковое замещение, или Почему Rust сменяет C
Rust — амбициозный проект компании Mozilla, язык программирования, который по задумке создателей должен стать следующей ступенью эволюции C и C++.
В компании Evrone язык Rust применяется на многих проектах, и наши инженеры накопили большую экспертизу в этом направлении. В публикации мы расскажем об особенностях Rust.
За годы существования этих языков многие неприятные базовые вещи, вроде ошибок сегментации, ручного управления памятью, повышенных рисков допустить утечку памяти и непредсказуемого поведения компилятора, в полной мере так и не исключены. Rust призван избавить от этих недостатков, в то же время обеспечив более высокую производительность и безопасность.
Работу над Rust начал в 2006 году энтузиаст Грэйдон Хор. В 2009-м проектом заинтересовалась Mozilla, и уже спустя год был дан публичный анонс нового языка программирования.
Альфа-версия Rust появилась в 2012 году. Через год авторы браузерного движка Servo на базе этого языка сообщили, что их детище получило поддержку Samsung. Благодаря этому удалось портировать код движка на ARM-архитектуру.
Версия Rust 1.0 была представлена в мае 2015 года. В том же году язык занял третье место в опросе Stack Overflow о любимых инструментах разработчиков. Начиная с 2016 года Rust регулярно возглавляет этот список.
Данный язык поддерживает основные парадигмы программирования: объектно ориентированное, параллельное, функциональное и процедурное. Rust универсален и подходит для решения различных задач: разработки операционных систем, программ общего назначения, веб-серверов и клиентов, систем мониторинга серверов, разработки инфраструктуры, приложений для мониторинга системы, блокчейн-сетей, игровых и браузерных движков.
Rust создавался в первую очередь как язык системного программирования. Он предоставляет достаточно возможностей для управления памятью и защиты от уязвимостей, чтобы стать востребованным инструментом для разработки операционных систем и ключевых приложений. Главная проблема языка — низкая поддержка со стороны производителей «железа», предпочитающих использовать для работы именно С/С++.
Системы на базе распределенного реестра должны уметь быстро обрабатывать запросы внутри сети при минимальной нагрузке на устройство. Инструментарий С++ отлично справляется с этой задачей (именно на нем работают блокчейны Bitcoin и Ethereum), а посему разработка инфраструктуры с использованием Rust окажется еще эффективнее.
Уже сейчас Rust может использоваться для полноценного создания веб-проектов, инструментарий языка позволяет создать и фронт-энд, и бэк-энд. Клиентская часть реализуется, например, на вдохновленном React и Angular фреймворке Yew. Простая разработка веб-серверов на Rust возможна благодаря actix-web — очень производительному фреймворку, поддерживающему WebSockets, TLS и HTTP/2.0. Также доступны другие инструменты: rocket, conduit, gotham, pencil.
Нейросети на Rust выглядят интересной перспективой. Быстрая работа, низкоуровневый контроль памяти с использованием высокоуровневых абстракций могут помочь Rust API стать более востребованным инструментом. Но пока машинное обучение на данном языке программирования остается областью экспериментов. Экосистеме Rust не хватает готовых, протестированных и надежных библиотек для создания нейросетей, не уступающих по возможностям аналогам на Python.
С++ почти 40 лет доминировал среди других языков, успел стать промышленным стандартом и по праву удерживает это звание по сей день. Rust стремительно развивается, дорабатывается и старается решать существенные недостатки С++ и других языков программирования.
Среди проектов, в которых компания Evrone использует Rust, можно отметить крупную ERP-систему сети ресторанов. В ней на Rust реализуется микросервис, который выдает пользователю информацию о ближайшем заведении. Также интересна реализация на Rust в нашем собственном сервисе непрерывной интеграции Vexor. На этом языке сделана диспетчеризация задач, шедулинг их выполнения и агент, управляющий изоляцией запущенных задач на рабочих машинах, автоматический закупщик мощностей и системы логирования.
Разработка с использованием Rust через несколько лет может стать гораздо более востребованной, а в отдаленной перспективе и вовсе потеснить нынешних лидеров.
