Что пишут на rust

Rust

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

«IT-специалист с нуля» наш лучший курс для старта в IT

Язык используют такие крупные компании, как VK, Twitter и Dropbox, а также Mozilla, создатель известного браузера Firefox. Движок браузера написан на Rust.

Кроме Mozilla язык помогают развивать Google, Huawei, Microsoft и AWS. Rust бесплатный, у него открытый исходный код, поэтому сообщество разработчиков тоже может вносить вклад в развитие языка.

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

Название читается как «раст», изредка также произносят «руст». Это не совсем верное произношение, но так тоже говорят.

Профессия / 8 месяцев
IT-специалист с нуля

Попробуйте 9 профессий за 2 месяца и выберите подходящую вам

Где применяется язык Rust

Rust создавали как язык общего назначения. Это значит, что его можно применять в разных сферах — он подойдет для многого и не имеет какой-то жесткой направленности. Но особенности Rust сделали его идеальным вариантом для нагруженных систем: более лаконичным, чем Java, и более безопасным, чем C++.

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

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

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

Прикладные программы. Десктопное программное обеспечение тоже можно писать на Rust. Это доказывает пример Mozilla Firefox — браузера, движок которого написан на этом языке. Язык позволяет быстро и эффективно обрабатывать данные и отрисовывать страницы, ведь при создании разработчики делали упор в том числе на создание браузеров. Пока что программ на Rust не так много, но у этого направления большие перспективы.

Операционные системы. Rust — мощный язык, на котором можно с нуля написать ОС. Но на такое мало кто решается. А вот в уже известных операционных системах его вполне используют. Например, некоторые компоненты операционной системы Windows написаны на Rust. Есть и более специфические проекты — ОС для устройств «умного дома» Tock и Unix-подобная система Redox.

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

Курс для новичков «IT-специалист
с нуля» – разберемся, какая профессия вам подходит, и поможем вам ее освоить

В чем особенности языка Rust

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

Вот как выглядит этот язык изнутри. Некоторые его особенности похожи на C++, но есть и изменения — они как раз направлены на повышение безопасности и удобства в работе.

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

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

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

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

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

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

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

• выделение памяти вручную, как в C++ и похожих языках. Это позволяет гибко работать с памятью и ее потреблением, но взамен делает разработку сложнее и повышает риск ошибки. Можно забыть очистить память или допустить ее утечку.
• автоматические выделение и очистка памяти, как в C# или Java. Память для переменных выделяется автоматически, а когда она перестает быть нужна — очищается с помощью специального «сборщика мусора». Писать код на таких языках проще, но встроенные системы часто оказываются неэффективными в плане использования памяти.

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

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

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

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

Преимущества Rust

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

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

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

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

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

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

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

Универсальность. Rust прекрасно работает с высокими уровнями абстракции. Поэтому разработчик может не думать о низкоуровневых «железных» вещах, если не хочет. Но одновременно с этим язык дает разработчику доступ к более низким уровням: «железу», процессам, памяти. Это делает Rust универсальным, подходящим и для низкоуровневого, и для высокоуровневого программирования.

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

Недостатки Rust

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

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

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

Как начать изучать язык Rust

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

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

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

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

Если вы хотите узнать больше о разработке — записывайтесь на курсы! Мы поможем определиться с профессией и стать востребованным специалистом.

IT-специалист с нуля

Наш лучший курс для старта в IT. За 2 месяца вы пробуете себя в девяти разных профессиях: мобильной и веб-разработке, тестировании, аналитике и даже Data Science — выберите подходящую и сразу освойте ее.

Статьи по теме:

Рассказываем об особенностях Rust и прогнозируем его будущее

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

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

Что особенного в Rust?

• Лаконичный синтаксис с ключевиками, похож на синтаксис C.
• Кодовый анализатор, помогающий не допускать утечек памяти и не совершать ошибок при работе с многопоточностью.
• Самостоятельное управление расположением данных в памяти (используя указатели).
• Нет garbage collection.
• Мощная статистическая типизация.

История языка

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

Первый альфа-релиз языка состоялся в 2012. На Rust был разработан Servo, движок для веб-браузеров. В 2013 к работе над Servo присоединился Samsung, в результате чего код Servo был портирован на ARM-архитектуру.

Rust 1.0 вышел в 2015. В свой первый год Rust взял бронзу в голосовании «Любимый язык программирования» на портале Stack Overflow. Все последующие годы Rust занимает только первое место.

Преимущества и недостатки

• без проблем работает на Unix и Mac;
• есть абстракции, которые существенно упрощают регулирование памяти вручную;
• надёжная система взаимодействия с памятью, исключающая ошибки сегментации;
• автоматическое представление способов исправить ошибки при компиляции;
• компилятор содержит сборщик и менеджер пакетов, инструменты для тестирования и создания документации;
• в безопасном коде нет возможности применять указатели (только ссылки на 100% реальные объекты);
• доступное описание ошибок в шаблонах.

• Компилятор слишком строго фиксирует вызовы к памяти;
• Нет типичных для ООП-стиля наследования и классов.

Где нужен Rust?

Код на Rust соответствует четырём главным концепциям в программировании: процедурное, параллельное, функциональное и ООП. Поэтому Rust — разносторонний язык, который можно применять во многих сферах. Например:

• программирование клиентских приложений и веб-серверов;
• blockchain;
• создание собственных ОС;
• написание программ и приложений по мониторингу систем и серверов;
• разработка ПО общего назначения;
• создание инфраструктуры;
• написание движков для браузеров и игр.

ПО и операционки

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

• многопоточный движок для браузера Servo;
• гипервизор Firecracker, разработанный в основном под бессерверную архитектуру;
• микроядерная ОС Redox.

Rust и блокчейн-проекты

Одно из важнейших требований блокчейн-сетей — высокая скорость работы внутри сети при низком уровне нагрузки серверов. Многие блокчейны (например Ethereum или Bitcoin) используют для реализации таких условий функционал C++. Учитывая сказанное выше, создание инфраструктуры на Rust будет более результативным. Вот примеры использования в blockchain:

• сервис для разработки блокчейн-проектов Solana;
• фреймворк для тех же целей Exonum;
• неофициальный клиент для Ethereum и Bitcoin — Parity.io;
• децентрализованная платформа хранения и работы с информацией MaidSafe;
• гетерогенные blockchain-сети polkadot.network.

Rust и web-приложения

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

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

Rust и нейросети

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

Что будет с Rust дальше?

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

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

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

Rust с каждым днём используют всё чаще. На него сделали ставки такие компании как Microsoft, Amazon. Также Rust включили в список языков для разработки ядра Linux, а Google — выпустила свою ОС Fuchsia, которая в большой степени написана на Rust.

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

Мультипарадигменный компилируемый язык программирования общего назначения Rust, на котором чаще всего пишут хакеры, набирает популярность. Об этом говорится в исследовании, результаты которого обнародованы в начале августа 2023 года рабочей группой Rust Survey Working Group и независимой некоммерческой организацией Rust Foundation.

Опрос проведен в декабре 2022 года среди пользователей по всему миру, включая Россию. В исследовании приняли участие более 9400 респондентов, а на все вопросы смогли ответить 82% участников (76% годом ранее). Зафиксирован значительный рост числа людей, которые просматривали опрос, но не участвовали в нем: с 16 457 в 2021 году до 25 581 в 2022-м, то есть, более чем на 55%.

Использование Rust в работе

Говорится, что свыше 90% респондентов идентифицировали себя в качестве пользователей Rust. Из них 47% применяют данный язык программирования ежедневно, что на 4% больше, чем в 2021 году. Около трети опрошенных (30%) могут писать на Rust простые программы, 27% — создавать готовый к использованию код. Примерно 42% респондентов говорят о своем высоком уровне владения Rust. Среди тех, кто отказался от Rust, 30% в качестве основной причины назвали сложность языка. На это же обстоятельство указали 26% тех, кто не использует Rust в работе.

В отчете отмечается, что существует несколько факторов, способствующих росту популярности Rust в профессиональной среде. Это возможность создавать программное обеспечение без ошибок (86%), высокая эффективность языка (84%) и безопасность (69%). Из тех респондентов, которые применяют Rust в работе, 72% сообщили, что язык помог их командам достичь поставленных целей (на 4% больше, чем в 2021 году). Около 75% участников опроса заявили, что планируют продолжать использовать Rust в своих будущих проектах. [1]

Rust 1.72

24 августа 2023 года стало известно о том, что опубликован релиз языка программирования общего назначения Rust 1.72, основанного проектом Mozilla, но ныне развиваемого под покровительством независимой некоммерческой организации Rust Foundation. Язык сфокусирован на безопасной работе с памятью и предоставляет средства для достижения оптимального параллелизма выполнения заданий, при этом обходясь без использования сборщика мусора и runtime (runtime сводится к базовой инициализации и сопровождению стандартной библиотеки).

Youtube-канал chris biscardi

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

Безопасная работа с памятью обеспечивается в Rust во время компиляции через проверку ссылок, отслеживание владения объектами, учёт времени жизни объектов (области видимости) и оценку корректности доступа к памяти во время выполнения кода. Rust также предоставляет средства для защиты от целочисленных переполнений, требует обязательной инициализации значений переменных перед использованием, лучше обрабатывает ошибки в стандартной библиотеке, применяет концепцию неизменяемости (immutable) ссылок и переменных по умолчанию, предлагает сильную статическую типизацию для минимизации логических ошибок. Ранкинг TAdviser100: Крупнейшие ИТ-компании в России 2023

• В сообщениях об ошибках обеспечено отображение сведений об элементах, отключённых через атрибуты условной компиляции «cfg», позволяющие активировать выполнение Rust-кода в зависимости от наличия поддержки определённых возможностей crate или запуска на отдельных платформах. Ранее, элементы, отключённые через cfg, были не видны компилятору, но теперь компилятор запоминает их имена и условия скрытия, и отображает эту информацию в сообщениях об ошибках, что, например, позволяет понять, что какая-то функция недоступна из-за отключения определённых feature-свойств в crate.
• Убраны ограничения на время вычисления выражений const. Ранее, для предотвращения зацикливаний во время компиляции, Rust ограничивал максимальное число выражений, выполняемых в процессе вычисления констант. Данная особенность приводила к выводу ошибок при компиляции кода, не вписывающегося в ограничения, поэтому в данном выпуске решено заменить жёсткие ограничения на вывод предупреждения, информирующего о длительно выполняемых вычислениях констант. Также по умолчанию применена lint-проверка const_eval_long_running, выявляющая зацикливания.
• В компилятор rustc перенесена серия lint-проверок из Clippy: undropped_manually_drops, invalid_utf8_in_unchecked, invalid_nan_comparisons и invalid_reference_casting.
• В разряд стабильных переведена порция API, в том числе стабилизированы методы и реализации типажей:

impl Sync for mpsc::Sender
impl TryFrom for &str
String::leak

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

CStr::from_bytes_with_nul
CStr::to_bytes
CStr::to_bytes_with_nul
CStr::to_str

• Реализован третий уровень поддержки для платформ loongarch64-unknown-none. Третий уровень подразумевает базовую поддержку, но без автоматизированного тестирования, публикации официальных сборок и проверки возможности сборки кода.
• В будущем выпуске Rust 1.76 планируется прекратить поддержку платформ Windows 7, 8 и 8.1, и сделать Windows 10 минимальной версией как для самого компилятора, так и для целей компиляции.

Дополнительно можно упомянуть разногласия в сообществе, возникшие из-за перехода разработчиков фреймворка Serde на поставку crate-пакета serde_derive с макросом derive только в уже скомпилированном бинарном виде. Пакет serde_derive применяется для сериализации и десериализации данных и используется в качестве зависимости в 5495 других пакетах, среди которых 10 имеют более 50 млн загрузок. Общее число загрузок serde_derive оценивается в 172 млн (до 400 тысяч загрузок в день).

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

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

Код Serde продолжает быть открытым и распространяется под лицензиями MIT и Apache 2.0, а несогласным с политикой разработчикам предложено создать и поддерживать собственный форк пакета. В ответ на критику, связанную с потерей возможности анализа кода пакета перед использованием, мэйнтейнер Serde указал, что даже на бросающийся в глаза перевод serde_derive в бинарную форму обратили внимание только спустя 4 недели и 12 релизов. При таком отношении профессионально обфусцированная вредоносная вставка в исходных текстах, вероятно, может годами оставаться незамеченной.

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

В выпуске 1.0.184 разработчики вернулись к поставке пакета serde_derive в исходных текстах, решив отложить переход на поставку в бинарном виде до принятия в пакетный менеджер crate изменений для полноценной поддержки верификации предкомпилированных макросов. Разработчиками Serde подготовлен RFC с предложением реализовать в Crate верификацию предкомпилированных пакетов, проводимую на сервере репозитория crates.io через сверку бинарного файла с повторяемой сборкой из исходных текстов [2] .

Rust 1.71

14 июля 2023 года стало известно о том, что опубликован релиз языка программирования общего назначения Rust 1.71, основанного проектом Mozilla, но ныне развиваемого под покровительством независимой некоммерческой организации Rust Foundation. Язык сфокусирован на безопасной работе с памятью и предоставляет средства для достижения параллелизма выполнения заданий, при этом обходясь без использования сборщика мусора и runtime (runtime сводится к базовой инициализации и сопровождению стандартной библиотеки).

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

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

• Стабилизирован ABI C-unwind (‘extern «C-unwind»‘), который отличается от ABI без суффикса «-unwind» (‘extern «C»‘) сохранением безопасного поведения (safe), если процесс «размотки» (unwinding), инициируемый при аварийном завершении программы или генерации исключения в стиле C++, пересекает границу ABI (например, когда исключение, возникшее в коде на одном языке программирования, при размотке затрагивает стек, связанный с кодом на другом языке программирования).
• Стабилизирована поддержка атрибутов ‘#[debug_visualizer(natvis_file = «. «)]’ и ‘#[debug_visualizer(gdb_script_file = «. «)]’, позволяющих встраивать в Rust-библиотеки метаданные Microsoft Natviz и скрипты GDB для оптимизации отладочного вывода при инспектировании структур данных, создаваемых библиотеками. Подобные скрипты уже включаются для стандартной библиотеки, а теперь появилась возможность их включения и для сторонних библиотек.
• На платформе Windows реализована возможность использования функций из динамических библиотек, которые недоступны во время сборки (например, чтобы не устанавливать лишние библиотеки в сборочное окружение и упростить кросс-компиляцию). Для связывания с отсутствующими библиотеками в атрибуте «#[link]» предложена опция ‘kind=»raw-dylib»‘.
• Целевые платформы, использующие Си-библиотеку Musl («*-linux-musl»), переведены на выпуск Musl 1.2.3 (ранее использовалась версия 1.1.24), что позволяет использовать тип time64 на 32-разрядных системах.
• В стандартной библиотеке предложен вариант макроса thread_local, инициализируемый с признаком «const», допускающим использование в контексте вместо констант, что позволяет генерировать более оптимальный код.

• В разряд стабильных переведена порция API, в том числе стабилизированы методы и реализации типажей:

CStr::is_empty
BuildHasher::hash_one
NonZeroI*::is_positive
NonZeroI*::is_negative
NonZeroI*::checked_neg
NonZeroI*::overflowing_neg
NonZeroI*::saturating_neg
NonZeroI*::wrapping_neg
Neg for NonZeroI*
Neg for &NonZeroI*
From <[T; N]>for (T. )
From <(T. )>for [T; N]
windows::io::AsHandle for Box
windows::io::AsHandle for Rc
windows::io::AsHandle for Arc
windows::io::AsSocket for Box
windows::io::AsSocket for Rc
windows::io::AsSocket for Arc
Признак «const», определяющий возможность использования в любом контексте вместо констант, применён в функциях:
::read
::read_unaligned
::read
::read_unaligned
ptr::read
ptr::read_unaligned
::split_at

• В пакетном менеджере Cargo разрешено указание именованных опций debuginfo в файле Cargo.toml. В метаданные добавлена опция workspace_default_members. При выполнении команд «cargo new» и «cargo init» обеспечено автоматическое наследование полей рабочих пространств (workspace).
• Реализован второй уровень поддержки целевой платформы loongarch64-unknown-linux-gnu. Второй уровень поддержки подразумевает гарантию сборки.
• Реализован третий уровень поддержки для платформы x86_64h-apple-darwin. Третий уровень подразумевает базовую поддержку, но без автоматизированного тестирования, публикации официальных сборок и проверки возможности сборки кода [3] .

Rust 1.68

10 марта 2023 года стало известно о том, что опубликован релиз языка программирования общего назначения Rust 1.68, основанного проектом Mozilla, но ныне развиваемого под покровительством независимой некоммерческой организации Rust Foundation. Язык сфокусирован на безопасной работе с памятью и предоставляет средства для достижения параллелизма выполнения заданий, при этом обходясь без использования сборщика мусора и runtime (runtime сводится к базовой инициализации и сопровождению стандартной библиотеки).

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

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

• В пакетном менеджере Cargo и репозитории crates.io стабилизирована поддержка протокола Sparse, определяющего способ работы с индексом, в котором отражены доступные версии всех существующих в репозитории пакетов. Обновленный протокол позволяет оптимизировать скорость работы с crates.io и решить проблемы с масштабированием при дальнейшем росте числа пакетов в репозитории.
• Для сокращения задержек, возникающих из-за загрузки полного индекса, в Sparse вместо доступа к индексу с использованием Git задействована прямая загрузка по HTTPS только необходимых индексных данных, охватывающих зависимости конкретного проекта. Для отдачи индексных данных задействован сервис index.crates.io. По умолчанию протокол планируют задействовать в ветке Rust 1.70, а до этого для его включения можно установить переменную окружения «CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse» или добавить в секцию «registries.crates-io» файла .cargo/config.toml параметр ‘protocol = «sparse»‘.
• Добавлен макрос «pin!», позволяющий создать структуру Pin из выражения «T» с локальным закреплением его состояния (в отличие от Box::pin не выделяет память в куче, а выполняет привязку на уровне стека).
• Предложен применяемый по умолчанию обработчик ошибок распределения памяти, применяемый при использовании штатного пакета alloc. Приложения в которых включается только alloc (без std) при сбоях выделения памяти отныне будут вызывать обработчик «panic!», который при желании может быть перехвачен при помощи «#panic_handler». Программы, использующие библиотеку std, как и раньше будут выводить информацию об ошибке в stderr и аварийно завершать выполнение.
• В разряд стабильных переведена следующая порция API, в том числе стабилизированы методы и реализации типажей:
  • ::pin::pin!
  • impl From for
  • std::path::MAIN_SEPARATOR_STR
  • impl DerefMut for PathBuf

  Rust 1.67

  26 января 2023 года стало известно о том, что публикован релиз языка программирования общего назначения Rust 1.67, основанного проектом Mozilla, но ныне развиваемого под покровительством независимой некоммерческой организации Rust Foundation. Язык сфокусирован на безопасной работе с памятью и предоставляет средства для достижения параллелизма выполнения заданий, при этом обходясь без использования сборщика мусора и runtime (runtime сводится к базовой инициализации и сопровождению стандартной библиотеки).

  

  Rust 1.67. Иллюстрация: i.ytimg.com.

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

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

  • Для функций async с Future::Output реализована возможность указания аннотаций «#[must_use]», включающих вывод предупреждения в случае игнорирования возвращаемого значения, что помогает выявить ошибки, вызванные предположением, что функция изменит значения, а не вернёт новое значение.
  • Обновлена реализация FIFO-очередей std::sync::mpsc (multi-producer single-consumer), которая переведена на использование модуля crossbeam-channel с сохранением прежнего API. Данная реализация отличается решением ряда проблем, более оптимальной производительностью и оптимизацией сопровождения кода.
  • В разряд стабильных переведена порция API, в том числе стабилизированы методы и реализации типажей.
  • Признак «const», определяющий возможность использования в любом контексте вместо констант, применён в функциях:
    • char::from_u32
    • char::from_digit
    • char::to_digit
    • core::char::from_u32
    • core::char::from_digit

    Дополнительно можно отметить публикацию компанией ARM патчей, позволяющих использовать язык Rust для разработки драйверов и модулей ядра Linux, собираемых для систем на базе архитектуры AArch64 [5] .

    2022

    Rust 1.63

    11 августа 2022 года стало известно о том, что опубликован релиз языка программирования общего назначения Rust 1.63, основанного проектом Mozilla, но ныне развиваемого под покровительством независимой некоммерческой организации Rust Foundation. Язык сфокусирован на безопасной работе с памятью и предоставляет средства для достижения надлежащего параллелизма выполнения заданий, при этом обходясь без использования сборщика мусора и runtime (runtime сводится к базовой инициализации и сопровождению стандартной библиотеки).

    

    Rust 1.63. Фото: wallup.net.

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

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

    • Добавлен API std::thread::scope, позволяющий создавать потоки в привязке к области видимости (Scoped threads). В отличие от ранее доступных потоков данный API std::thread::scope допускает передачу заимствованных (borrowing) нестатических данных, в то время как потоки, создаваемые при помощи классического API std::thread::spawn, должны были владеть всеми передаваемыми аргументами и не могли получать заимствованные переменные. API std::thread::scope обеспечивает, что любые порождённые потоки будут завершены до возвращения данных, обеспечивая должный уровень безопасности для механизма заимствования.
    • Предложены дополнительные типы-обвязки для файловых дескрипторов — BorrowedFd и OwnedFd, обеспечивающие заимствование и владение. Типы помечены при помощи «#[repr(transparent)]», что позволяет напрямую использовать их во внешних Си-привязках с учётом владения.
    • Предоставлена возможность вызова Condvar::new, Mutex::new и RwLock::new в контексте констант для создания глобальных статических значений Mutex, RwLock и Condvar без применения пакетов типа lazy_static.
    • Для функций типа fn foo(value: T, f: impl Copy) разрешено использование синтаксиса вида «foo::(3, 3)», явно указывая тип дженерика.
    • Завершён переход на использование техники NLL (Non-Lexical Lifetimes) для выявления проблем с заимствованием переменных. NLL осуществляет учёт на уровне набора указателей в графе потока выполнения, что позволяет оптимизировать качество проверки заимствования переменных (borrow checker) и допустить выполнение некоторых видов корректного кода, использование которого ранее приводило к выводу ошибки. Поддержка старого механизма, использовавшего привязку времени жизни на лексическом уровне, теперь полностью удалена из rustc, а использование другого NLL внедрено повсеместно.
    • В разряд стабильных переведена очередная порция API, в том числе стабилизированы методы и реализации типажей:
      • array::from_fn
      • Box::into_pin
      • BinaryHeap::try_reserve
      • BinaryHeap::try_reserve_exact
      • OsString::try_reserve
      • OsString::try_reserve_exact
      • PathBuf::try_reserve
      • PathBuf::try_reserve_exact
      • Path::try_exists
      • Ref::filter_map
      • RefMut::filter_map
      • NonNull::::len
      • ToOwned::clone_into
      • Ipv6Addr::to_ipv4_mapped
      • unix::io::AsFd
      • unix::io::BorrowedFd
      • unix::io::OwnedFd
      • windows::io::AsHandle
      • windows::io::BorrowedHandle
      • windows::io::OwnedHandle
      • windows::io::HandleOrInvalid
      • windows::io::HandleOrNull
      • windows::io::InvalidHandleError
      • windows::io::NullHandleError
      • windows::io::AsSocket
      • windows::io::BorrowedSocket
      • windows::io::OwnedSocket
      • thread::scope
      • thread::Scope
      • thread::ScopedJoinHandle
      • array::from_ref
      • slice::from_ref
      • intrinsics::copy
      • intrinsics::copy_nonoverlapping
      • ::copy_to
      • ::copy_to_nonoverlapping
      • ::copy_to
      • ::copy_to_nonoverlapping
      • ::copy_from
      • ::copy_from_nonoverlapping
      • str::from_utf8
      • Utf8Error::error_len
      • Utf8Error::valid_up_to
      • Condvar::new
      • Mutex::new
      • RwLock::new

      Rust 1.62

      30 июня 2022 года стало известно о том, что опубликован релиз языка программирования общего назначения Rust 1.62, основанного проектом Mozilla, развиваемого на июль 2022 года под покровительством независимой некоммерческой организации Rust Foundation. Язык сфокусирован на безопасной работе с памятью и предоставляет средства для достижения высокого параллелизма выполнения заданий, при этом обходясь без использования сборщика мусора и runtime (runtime сводится к базовой инициализации и сопровождению стандартной библиотеки).

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

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

      • В пакетном менеджере «cargo» предложена команда «add», позволяющая из командной строки добавлять в манифест Cargo.toml новые зависимости или изменять имеющиеся зависимости. Команда также позволяет указывать отдельные свойства (feature) и версии, например:
        cargo add serde —features derive
        cargo add nom@5
      • Добавлена возможность использования «#[derive(Default)]» с перечислениями (enum), в которых при помощи атрибута «#[default]» определён вариант по умолчанию.
        #[derive(Default)]
        enum Maybe #[default]
        Nothing,
        Something(T),
        >
      • На платформе Linux задействована более компактная и быстрая реализация механизма синхронизации Mutex, основанная на применении фьютексов, предоставляемых ядром Linux. В отличие от ранее используемой реализации на базе библиотеки pthreads, для хранения состояния Mutex в новом варианте расходуется всего 5 байт вместо 40. Аналогично на futex переведены механизмы блокировок Condvar и RwLock.
      • Реализован второй уровень поддержки целевой платформы x86_64-unknown-none, предназначенной для формирования исполняемых файлов, способных работать без операционной системы. Например, указанная целевая платформа может использоваться при написании компонентов ядра. Второй уровень поддержки подразумевает гарантию сборки.

      Реализован третий уровень поддержки для платформ aarch64-pc-windows-gnullvm и x86_64-pc-windows-gnullvm. Третий уровень подразумевает базовую поддержку, но без автоматизированного тестирования, публикации официальных сборок и проверки возможности сборки кода.

      • В разряд стабильных переведена добавленная порция API, в том числе стабилизированы методы и реализации типажей:
        bool::then_some
        f32::total_cmp
        f64::total_cmp
        Stdin::lines
        windows::CommandExt::raw_arg
        impl значение по умолчанию для AssertUnwindSafe
        From> для Rc
        From> для Arc
        FusedIterator для EncodeWide [6]

      Rust 1.60

      7 апреля 2022 года стало известно о том, что опубликован релиз языка программирования общего назначения Rust 1.60, основанного проектом Mozilla, но ныне развиваемого под покровительством независимой некоммерческой организации Rust Foundation. Язык сфокусирован на безопасной работе с памятью и предоставляет средства для достижения параллелизма выполнения заданий, при этом обходясь без использования сборщика мусора и runtime (runtime сводится к базовой инициализации и сопровождению стандартной библиотеки).

      

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

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

      • В компиляторе rustc стабилизирована основанная на LLVM система для генерации coverage-данных, используемых для оценки охвата кода при тестировании. Для включения coverage-данных при сборке необходимо использовать флаг «-Cinstrument-coverage», например, запуская сборку командой «RUSTFLAGS=»-C instrument-coverage» cargo build». После запуска собранного таким образом исполняемого файла в текущем каталоге будет сохранён файл default.profraw, для обработки которого можно использовать утилиту llvm-profdata из компонента llvm-tools-preview. Обработанный утилитой llvm-profdata вывод затем можно передать программе llvm-cov для генерации аннотированного отчёта со сведениями об охвате кода. Информация о привязке к исходным текстам берётся из исследуемого исполняемого файла, в который включаются необходимые данные о связи coverage-счётчиков с кодом.
      • В пакетном менеджере cargo стабилизирована поддержка флага «—timings», включающего формирование детального отчёта о ходе сборки и времени выполнения каждого шага. Отчёт может оказаться полезен для оптимизации производительности сборочного процесса.
      • В пакетном менеджере cargo предложен дополнительный синтаксис для механизма условной компиляции и выбора необязательных зависимостей, настраиваемого в файле Cargo.toml через перечисление списка именованных свойств в секции features и активируемого через включение свойств во время сборки пакета при помощи флага «—features». В данной версии добавлена поддержка зависимостей в отдельных пространствах имён и слабых (weak) зависимостей.
      • В первом случае реализована возможность использования внутри секции «features» элементов с префиксом «dep:» для явной привязки к необязательной зависимости без неявного представления этой зависимости как свойства (feature). Во втором случае добавлена поддержка пометки знаком «?» («package-name?/feature-name») необязательных зависимостей, которые следует включить только, если какое-то другое свойство включает данную необязательную зависимость.
      • Возвращена отключённая в прошлом выпуске поддержка инкрементальной компиляции. Ошибка в компиляторе, из-за которой функция была отключена, устранена.
      • Решены некоторые проблемы с предоставлением для таймеров Instant гарантии монотонного расчёта времени, при котором учитывается время, проведённое системой в спящем режиме. Ранее для работы таймера по возможности использовался OS API, который не учитывал проблемные ситуации, нарушающие монотонность времени, такие как проблемы с оборудованием, применение виртуализации или ошибки в операционной системе.
      • В разряд стабильных переведена порция API, в том числе стабилизированы методы и реализации типажей.
      • Реализован третий уровень поддержки для платформ mips64-openwrt-linux-musl и armv7-unknown-linux-uclibceabi (softfloat). Третий уровень подразумевает базовую поддержку, но без автоматизированного тестирования, публикации официальных сборок и проверки возможности сборки кода.
      • Компилятор переведён на использование LLVM 14.

      Дополнительно можно отметить:

      • Добавлена поддержка раскрутки компилятора (bootstrapping) rustc при помощи бэкенда rustc_codegen_gcc, позволяющего использовать библиотеку libgccjit от проекта GCC в качестве генератора кода в rustc, что позволяет обеспечить в rustc поддержку доступных в GCC архитектур и оптимизаций. Под раскруткой компилятора понимается возможность использования в rustc генератора кода на основе GCC для сборки самого компилятора rustc. С практической стороны подобная возможность позволяет собирать rust-программы для архитектур, ранее не поддерживаемых в rustc.
      • Доступен выпуск инструментария uutils coreutils 0.0.13, в рамках которого развивается аналог пакета GNU Coreutils, переписанный на языке Rust. В состав coreutils входит более ста утилит, включая sort, cat, chmod, chown, chroot, cp, date, dd, echo, hostname, id, ln и ls. Целью проекта является создание кроссплатформенной альтернативной реализации Coreutils, способной работать в том числе на платформах Windows, Redox и Fuchsia, а также распространение под пермиссивной лицензией MIT, вместо копилефт-лицензии GPL.

      В данной версии оптимизированы реализации многих утилит, в том числе совместимость утилит cp, dd, df, split и tr с аналогами от проекта GNU. Предоставлена online-документация. Для разбора аргументов командной строки задействован парсер clap, что позволило оптимизировать вывод для флага «—help» и добавить поддержку аббревиатур длинных команд (например, можно указывать «ls —col» вместо «ls —color») [7] .

      2021: Google включила Rust в число основных языков для разработки Android

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

      По сообщению Google, несмотря на то, что команда разработчиков вкладывает много усилий и ресурсов в обнаружение, исправление и смягчение последствий данного класса багов, все же около 70% из всех опасных уязвимостей, выявленных в Android, по-прежнему вызваны ошибками при работе с операционной системой. Использование языка Rust, который ориентирован на безопасную работу с памятью и обеспечивает автоматическое управление памятью, позволит снизить риск возникновения уязвимостей, вызванных ошибками при взаимодействии с памятью.

      

      Google включила Rust в список языков для разработки Android

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

      В Google отметили, что перезаписи существующего кода C/C++ на Rust не будет, язык будет использован для написания нового кода. Это связано с тем, что большинство ошибок обнаруживается в новом или недавно измененном коде — около 50% выявляемых ошибок работы с памятью в Android определяются в коде, написанном менее года назад. [8]

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

      Примечания

      1. ↑2022 Annual Rust Survey Results
      2. ↑Выпуск Rust 1.72. Поставка пакета serde_derive только в скомпилированном виде
      3. ↑Выпуск языка программирования Rust 1.71
      4. ↑Выпуск языка программирования Rust 1.68
      5. ↑Выпуск языка программирования Rust 1.67
      6. ↑Выпуск языка программирования Rust 1.62
      7. ↑Вышла версия 1.60 языка программирования Rust
      8. ↑Google now supports Rust for underlying Android OS development

      Язык программирования Rust: обзор, что пишут на Расте, пример кода

      Язык программирования Rust не является мег ап опулярным языком, как JavaScript, Java, Python, C++ и др , н о уже много лет подряд он остается «народным любимцем» программистов. «Народный любимец» означает, что программисты, которые работают на нем , не видят в нем недостатков. Программистам нравится на нем работать.

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

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

      • при разработк е операционных систем;
      • при разработке компиляторов;
      • для разработки драйверов;
      • для разработки ядер;
      • при программировании микроконтроллеров;
      • при программировании устройств, распространяемых без операционных систем;
      • при программировании других программно-аппаратных средств.

      Для кого нужен язык программирования Rust

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

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

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

      • объектно-ориентированное,
      • процедурное,
      • функциональное.

      Что написано на Rust

      • операционными системами,
      • веб-серверами,
      • системными программами,
      • движками браузеров,
      • в бэкенде,
      • во фронтенде,
      • и др.
      • драйвер ы для операционной системы Windows;
      • серверная часть ресурса Dropbox;
      • компилятор и распределение кэша в Mozilla Firefox;
      • онлайн-площадка по распределению DNS-сервисов — OpenDNS;
      • браузерный движок Servo;
      • серверная часть социальной сети Twitter;
      • и др.

      Пример кода на Rust

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

      fn main()

      println!(«Привет, мир!»);

      >

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

      Заключение

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

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

      Мы будем очень благодарны

      если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.