Rust очень любят, но что в нём особенного?

Rust оказывается самым любимым языком по версии StackOverflow шесть лет подряд. В чём его секрет? Короткий ответ — Rust избавлен от болевых точек, которые есть во многих современных языках программирования.

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

Наследник динамически типизированных языков

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

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

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

Однако не все способы статической типизации  эквивалентны. Многие статически типизированные языки поддерживают концепцию NULL.

Это значит, что любое значение может отсутствовать, таким образом создавая второй возможный тип для каждого типа. Как Haskell и некоторые другие современные языки программирования, Rust реализует эту возможность с помощью типа optional, и компилятор требует, чтобы вы указывали case None.

Это предотвращает возникновение ошибки: TypeError: Cannot read property ‘foo’ of null во время выполнения программы, вместо этого ошибка появляется ещё во время компиляции, и вы можете устранить её до того, как пользователь ее увидит. Вот пример функции для приветствия кого-либо независимо от того, знаем мы его имя или нет; если бы мы забыли случай None в match или попытались использовать имя так, как если бы оно было всегда присутствующим строковым значением, компилятор выдал бы ошибку.

			fn greet_user(name: Option) {
    match name {
        Some(name) => println!("Hello there, {}!", name),
        None => println!("Well howdy, stranger!"),
    }
}
		

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

Хотя это удобно в начале разработки, снижается способность компилятора предоставлять полезную информацию об ошибках, в случае несовпадения типов. Rust учится на обоих этих стилях и требует, чтобы элементы верхнего уровня, такие как аргументы функций и константы, имели явные типы, позволяя при этом выводить типы внутри тел функций. В этом примере компилятор Rust может определить тип дважды, 2 и 1, поскольку параметр val и возвращаемый тип объявлены как 32-разрядные целые числа со знаком.

			fn simple_math(val: i32) -> i32 {
    let twice = val * 2;
    twice - 1
}
		

Наследник языков со сборщиком мусора

Одним из самых больших преимуществ использования системного языка программирования является возможность контролировать низкоуровневые детали.

Rust позволяет выбирать между хранением данных в стеке или в куче и во время компиляции определяет что память больше не нужна и может быть очищена. Это позволяет эффективно использовать память. Tilde — один из первых пользователей Rust в своем продукте Skylight, обнаружил, что им удалось сократить использование памяти с 5 ГБ до 50 МБ, переписав некоторые конечные точки HTTP на Java в Rust. Такая экономия становится особенно значимой, когда облачные провайдеры меняют цены на дополнительную память.

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

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

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

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

Подробнее о фичах Rust, которых не хватает в Си.

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

			let squares: Vec<_> = (0..10).map(|i| i * i).collect();
		

В тех случаях когда безопасного 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 потратили большое количество времени на работу над улучшением сообщений об ошибках, чтобы убедиться, что они понятны и применимы.

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

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

			fn no_mutable_aliasing() {
    let mut name = String::from("Vivian");
    let nickname = &name[..3];
    name.clear();
    println!("Hello there, {}!", nickname);
}
		

			error[E0502]: cannot borrow `name` as mutable because it is also borrowed as immutable
 --> a.rs:4:5
  |
3 |     let nickname = &name[..3];
  |                     ---- immutable borrow occurs here
4 |     name.clear();
  |     ^^^^^^^^^^^^ mutable borrow occurs here
5 |     println!("Hello there, {}!", nickname);
  |                                  -------- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
		

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

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

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

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

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

[ab id=”123″ group=”control”][/ab][ab id=”123″ group=”test”]А вам нравится Rust?[/ab]