Rust *

Организация ISRG (Internet Security Research Group), учредитель проекта Let's Encrypt и развивающая технологии для повышения защищённости интернета, представила проект zlib-rs по созданию защищённого аналога библиотеки сжатия данных zlib.

Исходный код zlib-rs написан на языке Rust и распространяется под лицензией Zlib. Разработка ведётся с оглядкой на проект zlib-ng, развивающий высокопроизводительный вариант zlib. Представлены две библиотеки: zlib-rs с реализаций API zlib, не использующей unsafe-блоки и libz-rs-sys - надстройка с C API, содержащая код в режиме unsafe.

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

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

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

Источник: OpenNET.

27 и 28 марта в Лондоне проходила конференция Rust Nation 24. На конференции выступал Ларс Бергстром [Lars Bergstrom], который занимает в Google пост технического директора. Доклад Ларса носил название «Beyond Safety and Speed: How Rust Fuels Team Productivity» (дословно «Кроме безопасности и скорости: как Rust заряжает команду продуктивностью»).

Во время выступления технический директор Google заявил, что команды Rust в Google в два раза продуктивнее команд C++. Этот мощный посыл успел разлететься фотографией с конференции.

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

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

Слегка портит картину то, что Бергстром — это ещё и председатель совета директоров Rust Foundation, поэтому делать такие заявления он непосредственно заинтересован.

На записи видеотрансляции с конференции обсуждение деталей производительности идёт с отметки 7:30:13.

🦀 Бесплатный курс для Rust разработчиков от Google

google / comprehensive-rust: Это курс Rust, используемый командой Android в Google. 

Он содержит актуальный материал для быстрого изучения Rust. ★25023 на Github

🔝 Github

А еще мы собрали лучшие репозитории для Rust разработчиков.

7 марта 2024 года состоялся релиз Boa v0.18 — экспериментального лексера, парсера и компилятора Javascript, а также движка ECMAScript, написанного на языке программирования Rust.

Исходный код проекта выложен на GitHub под лицензией MIT License.

Новая версия Boa позволяет легко встраивать JS-движок в различные проекты, и а также использовать его из WebAssembly и командной строки.

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

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

Впервые проект Boa был представлен на конференции JSConf EU 2019 разработчиком Джейсоном Уильямсом.

Опубликован релиз языка программирования общего назначения Rust 1.76, основанного проектом Mozilla, но ныне развиваемого под покровительством независимой некоммерческой организации Rust Foundation.

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

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

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

Релиз Rust 1.75 состоялся в конце декабря 2023 года.

Microsoft ищет разработчиков для переписывания части своих сервисов с C# на Rust.

Согласно опубликованной вакансии архитектора, в Microsoft намерены переписать с использованием языка Rust ключевые сервисы Microsoft 365, изначально написанные на языке C#.

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

Ранее компания Microsoft использовала язык Rust для разработки компонентов ядра Windows 11.

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

Изначально тема разработки ядра на C++ была поднята в 2018 году инженером из Red Hat, который первого апреля в качестве шутки опубликовал набор из 45 патчей для использования шаблонов, наследуемых классов и перегрузки функций C++ в коде ядра.

С инициативой продолжения обсуждения выступил Ганс Питер Анвин (Hans Peter Anvin), один из ключевых разработчиков ядра в компании Intel и создатель таких проектов, как syslinux, klibc и LANANA, разработавший для ядра Linux систему автомонтирования, реализацию RAID 6, драйвер CPUID и x32 ABI. По мнению Анвина, который является автором многочисленных макросов и ассемблерных вставок в ядре, с 1999 года языки С и С++ значительно продвинулись вперёд в своём развитии, а язык С++ стал лучше подходить для разработки ядра операционных систем, чем С.

Анвин считает, что C++ более предпочтителен, чем Rust, так как последний существенно отличается от языка С по синтаксису, непривычен для текущих разработчиков ядра и не позволяет постепенно переписывать код (в случае языка С++ можно по частям переводить код с языка C, так как С-код можно компилировать как C++). В поддержку использования С++ в ядре также выступили Иржи Слаби (Jiri Slaby) из компании SUSE и Дэвид Хауэллс (David Howells) из Red Hat.

Источник: OpenNET.

Рабочая группа Rust Embedded, созданная для разработки технологий повышения качества и безопасности приложений, прошивок и драйверов к встраиваемым системам, представила первый выпуск фреймворка embedded-hal, предоставляющего набор программных интерфейсов для взаимодействия с периферией, обычно применяемой с микроконтроллерами (например, предоставляются типажи для работы с GPIO, UART, SPI и I2C). Наработки проекта написаны на языке Rust и распространяются под лицензией Apache 2.0.

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

Embedded‑hal 1.0 помечен как первый стабильный выпуск проекта, который можно использовать для создания рабочих драйверов.

Источник: OpenNET.

Вышел проект Maestro по разработке на Rust легковесного Unix-подобного ядра, реализующего подмножество системных вызовов ядра Linux, достаточное для создания типовых рабочих окружений. Проект был создан в 2018 году и вначале использовал язык C, но в 2020 году был полностью перезапущен с нуля с учётом накопленного опыта и перешёл на Rust для снижения вероятности совершения ошибок, возникающих при работе с памятью.

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

Ядро на Rust имеет монолитную архитектуру и пока поддерживает только системы x86 в 32-разрядном режиме. Кодовая база ядра насчитывает 48.8 тыс. строк кода (для сравнения в ядре Linux - 33 млн. строк кода). Возможен запуск в QEMU, VirtualBox или поверх оборудования. На текущем этапе развития в Maestro реализован 31% (135 из 437) системных вызовов Linux, чего достаточно для загрузки консольного окружения на базе bash и стандартной С-библиотеки Musl. В окружении на базе Maestro также могут выполняться некоторые утилиты из набора GNU coreutils, такие как ls, cat, mkdir, rm, rmdir, uname и whoami.

Источник: OpenNET.

На GitHub вышел проект загрузчика файлов (file downloader) Caracal, написанный на языке программирования Rust.

Исходный код проекта Caracal распространяется под свободной лицензией GNU.

Текущая версия утилиты Caracal имеет поддержку HTTP/HTTP, SFTP и MinIO.

Для сборки Caracal необходимы инструменты и пакеты:rustc, cargo, pkg-config и libgit2.

Пример использования Caracal:

# show usage
caracal help

# download a file from HTTP server
caracal https://www.rust-lang.org/

# download multiple files from HTTP server
caracal https://example.com/a.tar.gz https://example.com/b.zip

# copy a file from local file system
caracal /etc/os-release

# download a file from SFTP server
caracal sftp://my-ssh-server/etc/os-release

# copy a file from MinIO server
caracal minio://myminio/path/to/file

# download multiple files from different services
caracal \
    /etc/os-release \
    https://example.com/a.tar.gz \
    sftp://my-ssh-server/etc/os-release \
    minio://myminio/path/to/file

# download multiple files from different services and put them in directory /tmp/downloads
mkdir -p /tmp/downloads && \
    caracal -D /tmp/downloads \
        /etc/os-release \
        sftp://my-ssh-server/etc/os-release \
        minio://myminio/path/to/file \
        https://example.com/a.tar.gz

В ядро Linux 6.8 запланировано добавление первого сетевого драйвера на языке Rust. В ветку net-next, в которой развиваются изменения для ядра Linux 6.8, включены изменения, добавляющие в состав ядра начальную Rust‑обвязку над уровнем абстракции phylib и использующий данную обвязку драйвер ax88 796b_rust, обеспечивающий поддержку PHY‑интерфейса Ethernet‑контроллера Asix AX88 772A (100MBit). Драйвер включает 135 строк кода и позиционируется как простой рабочий пример для создания сетевых драйверов на языке Rust, готовый для использования с реальным оборудованием.

По своим возможностям драйвер на Rust полностью эквивалентен предыдущему драйверу ax88796b, написанному на языке C, и может быть использован с сетевыми картами X-Surf 100, оснащёнными чипом AX88796B.

Оба сетевых драйвера, на C и на Rust, будут сосуществовать в ядре Linux, и могут включаться в зависимости от предпочтения пользователей системы. Для включения драйвера на Rust в Kconfig предусмотрена настройка AX88796B_RUST_PHY, вместе с которой при помощи параметра RUST_PHYLIB_ABSTRACTIONS также нужно включить Rust-обвязку над phylib.

Кроме того, на языке Rust разработан Ethernet‑драйвер Realtek Generic FE‑GE, который пока не предложен для включения в состав ядра. Ранее также был представлен прототип драйвера rust-e1000 для Ethernet-адаптеров Intel, переписанный на Rust.

Источники: OpenNET, Phoronix.

Инвертирование порядка сортировки в Rust

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

struct Note {
    imp: bool,
    title: &'static str,
}
let mut notes = vec![
    // ...
];
notes.sort_by_key(|k| k.imp);

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

use std::cmp::Reverse;
// ...
notes.sort_by_key(|k| Reverse(k.imp));

Как это реализовано? Давайте взглянем на исходный код стандартной библиотеки Rust:

pub struct Reverse<T>(pub T);

impl<T: Ord> Ord for Reverse<T> {
    fn cmp(&self, other: &Reverse<T>) -> Ordering {
        other.0.cmp(&self.0)
    }
}

Все просто - это тип обертка (newtype) для исходного типа, и для типов с трейтом Ord она переопределяет Ord, но вместо сравнения self с other она сравнивает other с self, что означает - порядок в результате меняется на обратный. Просто и красиво!

❓100 Вопросов по Машинному обучению (Machine Learning) - Вопрос_9

🔠Вопрос_9: В чем разница между Rapids, Vaex, Pandas, Polars, Modin, Dask они же все для анализа данных ?

✔️Ответ:

1. Pandas предоставляет гибкие структуры данных, такие как DataFrame, и мощные инструменты для манипуляции, фильтрации, агрегации и анализа данных. Pandas обычно используется для работы с небольшими и средними объемами данных, которые могут поместиться в оперативную память одного компьютера;

2. Dask позволяет обрабатывать данные, превышающие объем доступной оперативной памяти, с использованием распределенных вычислений. Dask предоставляет абстракции, такие как DataFrame и Array, которые подобны структурам данных из Pandas и NumPyx;

3. Polars обладает высокой производительностью благодаря использованию Rust в своей реализации, а также предлагает возможности параллельной обработки данных. Она может работать с большими объемами данных и поддерживает некоторые распределенные вычисления;

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

5. Modin предоставляет интерфейс, совместимый с Pandas, но с оптимизированной производительностью. Она использует различные движки обратной совместимости, такие как Dask и Ray, для распределенных и параллельных вычислений.

   https://t.me/DenoiseLAB

Разработчики языка программирования Rust предупредили об отключении 20 ноября 2023 года поддержки в репозитории crates.io неканонических загрузок, в которых используются нормализованные имена пакетов с заменёнными символами подчёркивания и дефиса. В качестве причины внесения изменения называется желание повысить надёжность и оптимизировать производительность.

До сих пор было неважно, подчёркивание или дефис указаны в имени при загрузке — crates.io автоматически приводил подобные ссылки к необходимому виду. Например, для размещённого в репозитории пакета «имя_пакета» при загрузке можно было указывать «имя‑пакета» и наоборот. В репозитории также присутствует защита от размещения похожих имён, не позволяющая разместить пакет с именем «имя‑пакета» если уже имеется пакет «имя_пакета».

Наличие процедуры нормализации имён требует вызова специального обработчика, что не позволяет напрямую использовать сети доставки контента для отдачи запросов на загрузку пакетов. Кроме того, перебор вариантов создаёт дополнительную нагрузку на бэкенды и БД проекта. Анализ логов показал, что неканонические имена используются только в запросах с User Agent cargo-binstall/1.1.2, Faraday v0.17.6, Go-http-client/2.0, GNU Guile и python-requests/2.31.0. Автор утилиты cargo-binstall, используемой для установки бинарных артефактов к пакетам, уже внёс изменения, учитывающие грядущее отключение поддержки неканонических имён.

Источник: OpenNET.

Компактный match в Rust

match часто используется для работы с енумами, посмотрим на такой пример:

enum NextStep {
    TurnLeft,
    TurnRight
}

fn main() {
    let next_step = NextStep::TurnLeft;
    match next_step {
        NextStep::TurnLeft => println!("turn left"),
        NextStep::TurnRight => println!("turn right"),
    }
}

Это может быть не очевидно, но енумы в Rust можно принести в текущее пространство имен, это позволяет сделать код более компактным:

// ...
    use NextStep::*;
    match next_step {
        TurnLeft => println!("turn left"),
        TurnRight => println!("turn right"),
    }
// ...

Ну, а чтобы ограничить эффект только одним match, придется задать границы используя {} для дополнительного блока:

// ...
    {
        use NextStep::*;
        match next_step {
            // ...
        }
    }
// ...

Полезный антипаттерн в Rust

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

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

struct Admins(Vec<u128>);

Теперь можно использовать этот тип:

fn print_admin_count(users: Admins) {
    println!("admins count: {}", users.0.len());
}

Это работает, но выглядит уже не так приятно, как если бы мы просто использовали массив users.len().

В Rust существуют типажи (traits) Deref/DerefMut, которые решают эту проблему, если мы реализуем их для типа обертки, то это позволит работать с внутренним типом напрямую:

impl Deref for Admins{
    //...
}

fn print_admin_count(users: Admins) {
    println!("admins count: {}", users.len());
}

Полный сниппет

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

в Rust есть метод transpose, иногда бывает полезен, особенно хорошо работает с anyhow:

use std::str::FromStr;
use anyhow::Context;

fn add(a: Option<&str>, b: Option<&str>) -> anyhow::Result<f32> {
    let a = a.map(f32::from_str).transpose()?.context("not a value")?;
    let b = b.map(f32::from_str).transpose()?.context("not a value")?;
    Ok(a + b)
}

fn main() {
    println!("{:?}", add(Some("12"), Some("1.2")));
    println!("{:?}", add(Some("a"), Some("1.2")));
    println!("{:?}", add(None, Some("1.2")));
}

вывод:

Ok(13.2)
Err(invalid float literal)
Err(not a value)