Команда разработчиков Rust рада сообщить о выпуске новой версии Rust, 1.34.0. Rust — это язык программирования, который даёт возможность каждому создавать надёжное и эффективное программное обеспечение.

Если у вас установлена предыдущая версия Rust с помощью rustup, то для обновления Rust до версии 1.34.0 вам достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта.

Что вошло в стабильную версию 1.34.0

Основное улучшение этого выпуска это поддержка альтернативных cargo-реестров. Релиз также включает поддержку ? в документационных тестах, некоторые улучшения в #[attribute(...)] и стабилизацию TryFrom. Читайте далее о ключевых вещах или можете посмотреть подробные примечания к выпуску для дополнительной информации.

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

Команда разработчиков Rust рада сообщить о выпуске новой версии Rust, 1.33.0. Rust — это язык программирования, который даёт возможность каждому создавать надёжное и эффективное программное обеспечение.

Если у вас установлена предыдущая версия Rust с помощью rustup, то для обновления Rust до версии 1.33.0 вам достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.33.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.33.0

Основные улучшения этого выпуска: значительное расширение возможностей const fn и стабилизация нового Pin API.

Расширение возможностей const fn

const fn теперь умеет гораздо больше, а именно:

• неопровержимое (irrefutable) сопоставление с образцом (например, const fn foo((x, y): (u8, u8)) { ... })
• let привязки (например, let x = 1;)
• изменяемые let привязки (например, let mut x = 1;)
• выражения присваивания (например x = y) и операторов присваивания (например, x += y), включая присваивание проекциям (например, полю структуры или результату оператора индексирования — x[3] = 42)
• инструкции выражений (expression statements) (например, 3;)

Всем привет!

В грядущее воскресенье (16 декабря) Parity Technologes организует митап в Москве, приуроченный к конференции RustRush

От команды Parity на RustRush приезжает с десяток человек; на митапе Пьер Кригер (@tomaka) будет рассказывать про rust-libp2p, а Джек Френшем (@Vurich) — про Parity Substrate. Доклады будут на английском, но мы поможем с переводом, если вам будет проще формулировать вопросы по-русски.

Митап пройдёт в помещении коворкинга «Ключ Трёхгорка» по адресу: Рочдельская 15, стр. 17–18, 3 этаж (ближайшее метро — «Улица 1095 года»). Начало — в 18:00.

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

Записывайтесь и приходите!

Команда разработчиков Rust рада сообщить о выпуске новой версии Rust, 1.31.0, а также «Rust 2018». Rust — это язык программирования, который даёт возможность каждому создавать надёжное и эффективное программное обеспечение.

Если у вас установлена предыдущая версия Rust с помощью rustup, то для обновления Rust до версии 1.31.0 вам достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.31.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.31.0

Rust 1.31, возможно, самый значительный выпуск со времён Rust 1.0! В данный выпуск включена первая итерация «Rust 2018», но это не единственное нововведение! Обзор улучшений будет длинный, поэтому вот оглавление:

• Что вошло в стабильную версию 1.31.0

Всем привет!

15-16 декабря в Москве пройдёт первая международная конференция по Rust в России, RustRush 2018!

Это двухдневная конференция с докладами и воркшопами.

До 19 ноября открыт приём докладов. Подать доклад.

Билеты уже в продаже. Для участников сообщества доступен промо-код RUSTYCRATE со скидкой 20% на обычные билеты. Купить билет.

Участникам конференции доступен блок номер в отеле конференции — Novotel Moscow City. Как забронировать — читайте дальше.

Если вашей компании интересно мероприятие, свяжитесь с нами по почте sponsor@rustrush.ru. Мы предлагаем групповые билеты, помощь в продвижении ваших продуктов, помощь в поиске разработчиков на Rust.

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

Если у вас установлена предыдущая версия Rust с помощью rustup, то для обновления Rust до версии 1.30.0 вам достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.30.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.30.0

Rust 1.30 — выдающийся выпуск с рядом важных нововведений. Но уже в понедельник в официальном блоге будет опубликована просьба проверить бета-версию Rust 1.31, которая станет первым релизом «Rust 2018». Дополнительную информацию об этом вы найдёте в нашей предыдущей публикации «What is Rust 2018».

Процедурные макросы

Ещё в Rust 1.15 мы добавили возможность определять «пользовательские derive-макросы». Например, с помощью serde_derive, вы можете объявить:

1
2
3
4

#[derive(Serialize, Deserialize, Debug)]
struct Pet {
    name: String,
}

И конвертировать Pet в JSON и обратно в структуру, используя serde_json. Это возможно благодаря автоматическому выводу типажей Serialize и Deserialize с помощью процедурных макросов в serde_derive.

Rust 1.30 расширяет функционал процедурных макросов, добавляя возможность определять ещё два других типа макросов: «атрибутные процедурные макросы» и «функциональные процедурные макросы».

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

Если у вас установлена предыдущая версия Rust с помощью Rustup, то для обновления Rust до версии 1.29.0 вам достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен Rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.29.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.29.0

1.29 привносит не очень много изменений. Ожидается что Rust 1.30 и 1.31 будут очень значительными, так что большая часть 1.29 итерации ушла на подготовку к будущим изменениям. Два самых заметных нововведения этого выпуска даже не касаются самого языка: это две новые возможности Cargo и обе они связаны с предупреждениями.

• cargo fix автоматически исправляет предупреждения в коде
• cargo clippy — статический анализатор Rust кода, помогающий поймать распространённые ошибки и просто улучшить код

cargo fix

С выпуском Rust 1.29 у Cargo появляется новая подкоманда: cargo fix. Если вы когда-либо писали на Rust, то скорее всего уже сталкивались с предупреждениями компилятора. Например, рассмотрим такой код:

1
2
3
4
5
6
7

fn do_something() {}

fn main() {
    for i in 0..100 {
        do_something();
    }
}

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

Если у вас установлена предыдущая версия Rust с помощью rustup, то для обновления Rust до версии 1.28.0 вам достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.28.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.28.0

Глобальные аллокаторы

С помощью аллокаторов программы на Rust получают память во время выполнения. Раньше Rust не позволял изменять способ распределения памяти, что ограничивало его использование в некоторых случаях. На одних платформах использовался jemalloc, на других — системный аллокатор, но пользователи не могли это контролировать. В выпуске 1.28.0 стабилизирован атрибут #[global_allocator], который позволяет программам на Rust выбирать системный аллокатор, а также определять новые аллокаторы, реализуя типаж GlobalAlloc.

Аллокатор по умолчанию для Rust-программ на некоторых платформах — это jemalloc. Стандартная библиотека теперь предоставляет дескриптор системного аллокатора, который можно использовать для переключения на использование системного аллокатора, когда это необходимо, путём статического объявления с атрибутом #[global_allocator].

1
2
3
4
5
6
7
8
9
10

use std::alloc::System;

#[global_allocator]
static GLOBAL: System = System;

fn main() {
    let mut v = Vec::new();
    // Память будет выделяться системным аллокатором.
    v.push(1);
}

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

Если у вас установлена предыдущая версия Rust с помощью rustup, то для обновления Rust до версии 1.27.0 вам достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.27.0 можно ознакомиться на GitHub.

Также мы хотим обратить ваше внимание вот на что: перед выпуском версии 1.27.0 мы обнаружили ошибку в улучшении сопоставлений match, введённом в версии 1.26.0, которая может привести к некорректному поведению. Поскольку она была обнаружена очень поздно, уже в процессе выпуска данной версии, хотя присутствует с версии 1.26.0, мы решили не нарушать заведённый порядок и подготовить исправленную версию 1.27.1, которая выйдет в ближайшее время. И дополнительно, если потребуется, версию 1.26.3. Подробности вы сможете узнать из соответствующих примечаний к выпуску.

Что вошло в стабильную версию 1.27.0

В этом выпуске выходят два больших и долгожданных улучшения языка. Но сначала небольшой комментарий относительно документации: во всех книгах в библиотечке Rust теперь доступен поиск! Например, так можно найти «заимствование» («borrow») в книге «Язык программирования Rust» Надеемся, это облегчит поиск нужной вам информации. Кроме того, появилась новая Книга о rustc. В этой книге объясняется, как напрямую использовать rustc, а также как получить другую полезную информацию, такую как список всех статических проверок.

SIMD

Итак, теперь о важном: отныне в Rust доступны базовые возможности использования SIMD! SIMD означает «одиночный поток команд, множественный поток данных» (single instruction, multiple data). Рассмотрим функцию:

1
2
3
4
5

pub fn foo(a: &[u8], b: &[u8], c: &mut [u8]) {
    for ((a, b), c) in a.iter().zip(b).zip(c) {
        *c = *a + *b;
    }
}

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

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

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

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

Если у вас установлена предыдущая версия Rust с помощью rustup, то для обновления Rust до версии 1.26.0 вам достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.26.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.26.0

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

Второе издание книги «Язык программирования Rust»

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

Команда Rust рада сообщить о новой версии Rust: 1.25.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, для обновления достаточно выполнить:

1

$ rustup update stable

Если же у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.25.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.25.0

Несколько последних выпусков были незначительными, но Rust 1.25 содержит много нововведений! Во-первых: мы обновили LLVM с 4-й версии до 6-й. Обновление влечёт ряд изменений, наиболее важное из которых — поддержка AVR.

Команда Rust рада сообщить о новой версии Rust: 1.24.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, для обновления достаточно выполнить:

1

$ rustup update stable

Если же у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.24.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.24.0

Этот выпуск содержит два очень интересных нововведения: rustfmt и инкрементальную компиляцию!

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

О том, как устроены персистентные векторы, быстрее ли они традиционных коллекций — смотрите под катом.

Часто, когда я обсуждаю дизайн Rust на RFCs или на internals-форуме с другими пользователями, я замечаю характерные высказывания насчёт явности. Обычно что-то в духе:

Мне не нравится <дизайн возможности X>, потому что он менее явный. Всякая магия уместна в <другом языке Y>, а Rust — это явный язык, так что следует использовать <дизайн возможности Z>.

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

В своей опубликованной ранее в этом году заметке Аарон пытался докопаться до сути вопроса явности, обсуждая размер контекста (reasoning footprint). Он попытался разбить понятия «явность» и «неявность» на составные части, чтобы подготовить почву для суждения о явности дизайна той или иной возможности. Я же хочу изложить немного другой взгляд на проблему и попытаюсь очертить в общих словах, что мы подразумеваем под словом «явный».

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

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

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

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

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

• Как они сочетаются между собой?

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

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

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

Я буду пристрастен, и вот моё мнение:

2018 должен стать последним годом, когда приходится начинать писать новый проект на C или C++

Всем привет!

Закончился 2017-й, и мы подводим итоги года.

Для начала, число посещений сайта год к году (более тёмный цвет обозначает 2017 год):

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

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

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

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

Команда Rust рада сообщить о новой версии Rust: 1.23.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, для обновления достаточно выполнить:

1

$ rustup update stable

Если же у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.23.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.23.0

Новый год, новый Rust! Нашим первым улучшением является избавление от избыточных копий в некоторых ситуациях. С этими изменениями потребление памяти rustc уменьшилось на 5-10%, но результаты для ваших приложений могут отличаться.

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

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

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

Команда Rust рада сообщить о двух новых версиях Rust: 1.22.0 и 1.22.1. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.

Подождите, две версии? В последний момент мы обнаружили проблему с новой macOS High Sierra в версии 1.22.0 и по разным причинам выпустили версию 1.22.0 как обычно, но так же выпустили 1.22.1 с исправлением. Ошибка была найдена в менеджере пакетов Cargo, а не в rustc, и затронула только пользователей macOS High Sierra.

Если у вас установлена предыдущая версия Rust, для обновления достаточно выполнить:

1

$ rustup update stable

Если же у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.22.0 и 1.22.1 можно ознакомиться на GitHub.

Что вошло в стабильную версии 1.22.0 и 1.22.1

Самое главное изменение в этой версии, которого многие долго ждали: теперь вы можете использовать ? с Option<T>! Около года назад, в Rust 1.13, мы ввели оператор ? для работы с Result<T, E>. С тех пор ведутся дискуссии о том, как далеко оператор ? должен зайти: Должен ли он остаться только для Result? Разрешать ли пользователям расширять его? Должен ли он использоваться с Option<T>?

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

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

Команда Rust рада представить выпуск Rust 1.21.0. Rust — это системный язык программирования, нацеленный на скорость, безопасность и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, для обновления достаточно выполнить:

1

$ rustup update stable

Если же у вас ещё не установлен rustup, вы можете установить его с соответствующей страницы нашего веб-сайта. С подробными примечаниями к выпуску Rust 1.21.0 можно ознакомиться на GitHub.

Что вошло в стабильную версию 1.21.0

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

Первое изменение касается литералов. Рассмотрим код:

1

let x = &5;

В Rust он аналогичен следующему:

1
2

let _x = 5;
let x = &_x;

То есть 5 будет положено в стек или возможно в регистры, а x будет ссылкой на него.

Однако, учитывая, что речь идёт о целочисленном литерале, нет причин делать значение таким локальным. Представьте, что у нас есть функция, принимающая 'static аргумент вроде std::thread::spawn. Тогда вы бы могли использовать x так:

1
2
3
4
5
6
7
8
9

use std::thread;

fn main() {
    let x = &5;

    thread::spawn(move || {
        println!("{}", x);
    });
}

Команда Rust рада представить выпуск Rust 1.20. Rust — это системный язык программирования, нацеленный на скорость, безопасность и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, для обновления достаточно выполнить:

1

$ rustup update stable

Если же Rust ещё не установлен, вы можете установить rustup с соответствующей страницы нашего веб-сайта и ознакомится с подробными примечаниями к выпуску Rust 1.20 на GitHub.

Что вошло в стабильную версию 1.20

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

1
2
3
4
5
6
7
8
9
10
11

struct Struct;

impl Struct {
    fn foo() {
        println!("foo - это ассоциированная функция для Struct");
    }
}

fn main() {
    Struct::foo();
}

Мы называем их «ассоциированными функциями», потому что эти функции связаны непосредственно с самим типом, а не с каким-то определённым экземпляром.

В Rust 1.20 была добавлена возможность определять «ассоциированные константы»:

1
2
3
4
5
6
7
8
9

struct Struct;

impl Struct {
    const ID: u32 = 0;
}

fn main() {
    println!("the ID of Struct is: {}", Struct::ID);
}

Таким образом, константа ID ассоциирована с Struct. Подобно функциям, ассоциированные константы работают и с типажами, и с перечислениями.

14 сентября в Санкт-Петербурге состоится первая в истории встреча посвящённая разработке игр на Rust.

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

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

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

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

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

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

Команда Rust рада представить выпуск Rust 1.19. Rust — это системный язык программирования, нацеленный на скорость, безопасность и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, для обновления достаточно выполнить:

1

$ rustup update stable

Если же Rust ещё не установлен, вы можете установить rustup с соответствующей страницы нашего веб-сайта и ознакомится с подробными примечаниями к выпуску Rust 1.19 на GitHub.

Что вошло в стабильную версию 1.19.0

В Rust 1.19.0 вошли некоторые долгожданные функции, но для начала, замечание для пользователей Windows. На этой ОС Rust использует для сборки link.exe, который входит в состав «Microsoft Visual C++ Build Tools». В последнем выпуске Visual Studio 2017 структура директорий для этих инструментов изменилась. Из-за этого вы были вынуждены использовать инструменты версии 2015 или изменять переменные среды (например, запуская vcvars.bat). В Rust 1.19.0, rustc знает, как найти инструменты версии 2017, поэтому вам не потребуется более использовать обходные пути.

А теперь к новым возможностям! Rust 1.19.0 — это первый выпуск, поддерживающий union (Объединения):

1
2
3
4

union MyUnion {
    f1: u32,
    f2: f32,
}

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

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

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

Команда Rust рада представить выпуск Rust 1.18.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, то для обновления достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен Rust, вы можете установить rustup c соответствующей страницы нашего веб-сайта и ознакомиться с подробным примечанием к выпуску 1.18.0 на GitHub.

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

• Rust
• C
• Vala

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

Команда Rust рада представить выпуск Rust 1.17.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, то для обновления достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен Rust, то вы можете установить rustup c соответствующей страницы нашего веб-сайта и ознакомиться с подробным примечанием к выпуску 1.17.0 на GitHub.

Что вошло в стабильную версию 1.17.0

Выпуск Rust 1.17.0 в основном вносит небольшие улучшения, преимущественно касающиеся удобства использования. Например, время жизни 'static теперь автоматически подразумевается для констант или статических переменных. При создании константы или статической переменной:

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

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

Потом подробно поговорим про основы FFI — как передавать разные объекты из Rust и в Rust, кто будет ими владеть и чем отличается CStr и CString. Всё это нужно, если вы хотите взаимодействовать с Rust из кодобазы на других языках.

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

Что касается новостей, Rust увеличил версию с 1.13 до 1.17. Прошедшие выпуски принесли поддержку многих новых целевых платформ, в том числе Emscripten для компиляции под браузеры. На 2017 заявлена инициатива по повышению эргономики языка, и уже видны первые её плоды — cargo check и много мелких улучшений удобства пользования языком. На пути к макросам 2.0 стабилизированы макросы типа «custom derive». serde достиг версии 1.0. Вышла альфа-версия Rust Language Server для поддержки IDE.

Приходите, будет интересно!

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

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

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

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

Команда Rust рада представить выпуск Rust 1.16.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.

Если у вас установлена предыдущая версия Rust, то для обновления достаточно выполнить:

1

$ rustup update stable

Если у вас ещё не установлен Rust, то вы можете установить rustup c соответствующей страницы нашего веб-сайта и ознакомиться с подробным примечанием к выпуску 1.16.0 на GitHub.

Что вошло в стабильную версию 1.16.0

Самым большим дополнением в Rust 1.16 является команда cargo check. Эта новая подкоманда в большинстве случаев должна ускорить процесс разработки.

Что она делает? Давайте вернёмся немного назад и поговорим о том, как rustc компилирует ваш код. Компиляция происходит в несколько «проходов». Это значит, что компилятор выполняет множество различных этапов, прежде чем из вашего исходного кода будет создан бинарный файл. Вы можете увидеть каждый их этих этапов (и сколько времени и памяти они занимают) передав компилятору параметр -Z time-passes (только для nightly):

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

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

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

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

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

18 мая мы снова встретимся в офисе Лаборатории Касперского — и у вас есть возможность выступить.

Подать заявку можно прямо на этой странице — нажимайте «Читать дальше».

Заявки принимаются по четверг 13 апреля включительно.

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

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

Всем привет! Продолжаем планировать 2017-й.

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

• Часть 1 — вступление, книги и социальные сети.
• Часть 2 — митапы, выступления, календари событий, подкасты и конкурсы.
• Часть 3 — статьи, сайт, Patreon, расширение тем и Ядро команды Сообщества.
• Часть 4 (эта; последняя) — результаты голосования, процесс реализации запланированного и идеи участников.

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

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

Всем привет! Продолжаем планировать 2017-й.

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

• Часть 1 — вступление, книги и социальные сети.
• Часть 2 — митапы, выступления, календари событий, подкасты и конкурсы.
• Часть 3 (эта) — статьи, сайт, Patreon, расширение тем и Ядро команды Сообщества.
• Часть 4 — результаты голосования, процесс реализации запланированного и идеи участников.

Всем привет! Продолжаем планировать 2017-й.

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

• Часть 1 — вступление, книги и социальные сети.
• Часть 2 (эта) — митапы, выступления, календари событий, подкасты и конкурсы.
• Часть 3 — статьи, сайт, Patreon, расширение тем и Ядро команды Сообщества.
• Часть 4 — результаты голосования, процесс реализации запланированного и идеи участников.

Всем привет! На результаты 2016-го посмотрели, теперь пора планировать 2017-й.

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

• Часть 1 (эта) — вступление, книги и социальные сети.
• Часть 2 — митапы, выступления, календари событий, подкасты и конкурсы.
• Часть 3 — статьи, сайт, Patreon, расширение тем и Ядро команды Сообщества.
• Часть 4 — результаты голосования, процесс реализации запланированного и идеи участников.

Вступление

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

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

Вот для затравки число посетителей сайта за год:

Команда связей с сообществом Rust рада сообщить о первом ежегодном соревновании Underhanded Rust. Это соревнование должно проверить наше предположение о готовности языка Rust и его экосистемы к написанию легко читаемого и надёжного кода. Воодушевившись примерами Underhanded C и Underhanded Crypto, мы хотим, чтобы вы заставили Rust работать неправильно, используя лёгкий для чтения код, к которому сложно придраться. Нам нужна ваша помощь в поиске брешей в языке и способов их исправления. Сможете ли вы написать стопроцентно безопасный код, скрывающий логическую ошибку, или так спрятать эксплойт в unsafe коде, чтобы он прошёл аудит? Попробуйте это сделать!

Команда Rust рада представить выпуск Rust 1.13.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.

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

Это была по-настоящему горячая пора в Rust. Мы участвовали в трёх конференциях подряд — RustConf, RustFest и Rust Belt Rust. Было классно увидеть так много любителей Rust; со многими мы встретились впервые! Мы много думали о будущем, разрабатывали план на 2017 и создавали инструменты, нужные нашим пользователям.

И несмотря на всё это, мы собрали новый выпуск с кучей новых крутых фишек.

Что вошло в стабильную версию 1.13

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

Выпуск содержит важные исправления уязвимостей в Cargo. Он зависит от curl и OpenSSL, а они оба недавно опубликовали обновления безопасности. Подробнее смотрите соответствующие анонсы curl 7.51.0 и OpenSSL 1.0.2j.

Оператор ?

Rust приобрёл новый оператор ?. Он делает работу c ошибками значительно приятнее, убирая визуальный шум. Например, у нас есть такой код для чтения данных из файла:

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

За полгода с последней встречи в мире Rust произошло много интересного. Реализованы футуры и асинхронный ввод-вывод поверх них, сделан первый выпуск системы поддержки IDE, реализована инкрементальная сборка. Пробелы в языке и экосистеме Rust быстро заполняются. Так что самое время познакомиться с инструментом поближе!

22 ноября мы снова встретимся в офисе Лаборатории Касперского. Обсудим опыт реального применения Rust в нескольких задачах системного программирования и тестирования. Что получается хорошо, что — не очень. Расскажем как Rust помогает и как его готовить, чтобы он помогал вам.

Приходите — будет интересно!

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

Как обычно, вы можете установить Rust 1.12.1 с соответствующей страницы официального сайта, или с помощью rustup выполнив команду rustup update stable.

Что вошло в стабильную версию 1.12.1

Секундочку… один-точка-двенадцать-точка… один?

Несколько недель назад, в анонсе версии 1.12, мы сказали:

Выпуск 1.12 — возможно, самый значительный с момента выпуска 1.0.

И это правда. Одним из важных изменений был масштабный рефакторинг компилятора. Новый бэкенд MIR изменил его архитектуру и некоторые детали реализации. В целом процесс модернизации прошёл так:

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

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

Что вошло в стабильную версию 1.12

Выпуск 1.12 — возможно, самый значительный с момента выпуска 1.0. Нам есть о чём рассказать, но если у вас мало времени, вот краткое содержание.

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

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

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

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

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

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

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

1
2
3
4

enum Nat {
  Zero,
  Succ(Nat)
}

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

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

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

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

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

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

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

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

Что вошло в стабильную версию 1.11

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

Что касается видимых пользователям изменений, в последнем выпуске мы рассказывали о новом типе контейнера — cdylib.

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

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

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

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

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

Немного об Iron

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

Философия

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

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

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

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

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

1

cargo new rust-iron-tutorial --bin

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

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

Что вошло в стабильную версию 1.10

В Rust 1.10 стала доступна одна из наиболее желаемых сообществом возможностей: прерывание работы (abort) при панике вместо размотки стека. Это поведение управляется флагом -C panic=abort или настройкой в Cargo.toml. Зачем это нужно? Как вы помните, паника означает непредвиденную проблему, и для многих приложений abort — разумный выбор. При использовании panic=abort генерируется меньше кода, что означает меньшие по объёму исполняемые файлы и чуть меньшее время компиляции. Очень приблизительная оценка говорит об уменьшении на 10% и размера файла, и времени компиляции. Эта возможность была определена в RFC 1513.

Это статья — перевод статьи Why is a Rust executable large?

Большие бинари в моем Rust?

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

1
2
3

fn main() {
    println!("Hello, world!");
}

Скомпилировав получим соответствующий исполняемый файл:

1
2
3

$ rustc hello.rs
$ du -h hello
632K hello

632 килобайт для простого принта?! Rust позиционируется как системный язык, который имеет потенциал для замены C/C++, верно? Так почему бы не проверить аналогичную программу на ближайшем конкуренте?

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

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

Что вошло в стабильную версию 1.9

Управляемая размотка стека

Самое большое изменение в Rust 1.9 — стабилизация модуля std::panic, который предоставляет методы остановки процесса размотки стека, запущенного паникой:

1
2
3
4
5
6
7
8
9
10
11

use std::panic;

let result = panic::catch_unwind(|| {
    println!("привет!");
});
assert!(result.is_ok());

let result = panic::catch_unwind(|| {
    panic!("о нет!");
});
assert!(result.is_err());

Этот интерфейс был определён в RFC 1236.

Прошёл примерно год, как меня заинтересовал Rust, язык программирования от Mozilla Research, сосредоточенный на решении трёх задач: безопасность, скорость и параллелизм. Он такой же низкоуровневый, как Си или C++, имеет хорошую систему типов (с обобщениями (generics) и типажами (traits)), дружелюбный компилятор и отличный менеджер пакетов Cargo.

С выпуска Rust 1.0 прошло уже пол года (май 2015): многие библиотеки (пакеты, crates), включая некоторые мои, были опубликованы в центральном регистре crates.io. Вот неплохие практики (ещё рановато называть их «лучшими»), которые помогут другим людям находить, использовать и дополнять вашу библиотеку.

Эта статья — перевод статьи From & str to Cow за авторством Joe Wilm

От & str к Cow

Одной из первых вещей, которые я написал на Rust’е была структура с &str полем. Как вы понимаете, анализатор заимствований не позволял мне сделать множество вещей с ней и сильно ограничивал выразительность моих API. Эта статья нацелена на демонстрацию проблем, возникающих при хранении сырых & str ссылок в полях структур и путей их решения. В процессе я собираюсь показать некоторое промежуточное API, которое увеличивает удобство пользования такими структурами, но при этом снижает эффективность генерируемого кода. В конце я хочу предоставить реализацию, которая будет одновременно и выразительной и высокоэффективной.

Это перевод статьи.

В нашей среде широко распространена мысль о том, что одним из преимуществ сборщика мусора является простота разработки высоко-производительных lock-free структур данных. Ручное управление памятью в них сделать не просто, а GC с лёгкостью решает эту проблему.

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

• Сделает возможным реализацию lock-free структуры данных, как это делает GC;
• Создаст статическую защиту от неправильного использования схемы управления памятью;
• Будет иметь сравнимые с GC накладные расходы (и более предсказуемые).

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

Я реализовал схему управления памятью, основанную на эпохах («epoch-based memory reclamation») в новой библиотеке Crossbeam, которая на сегодняшний день готова к использованию с вашими структурами данных. В этом посте я расскажу о lock-free структурах данных, алгоритме эпох и внутреннем API Rust.

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

Проще говоря: нарушение доступа к памяти — это какие-то действия с некорректными данными, а утечка памяти — это отсутствие определённых действий с корректными данными. В табличной форме:

1
2
3

                    Корректные данные     Некорректные данные
Используются        OK                    Ошибка доступа к памяти
Не используются     Утечка памяти         OK

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

Год назад произошёл выпуск первой стабильной версии языка — Rust 1.0. С тех пор язык активно развивался. Ещё вчера про Rust никто не знал, а сегодня Dropbox переписал на нём ядро своей дисковой инфраструктуры.

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

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

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

Во-первых, мы подходим к этому неправильно. Я уверен, что вы испытывали такие же ощущения. Вы пытаетесь изучить новый язык и не совсем понимаете, как в нём всё устроено. Почему в одном месте используется один синтаксис, а в другом другой? Все эти странности раздражают, и в итоге мы возвращаемся к привычному языку.

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

Это очень похоже на обсуждение автомобилей. Слышали о новом УАЗ Рыбак? Насколько он быстр? Смогу ли я проехать на нём через озеро?

Когда мы похожим образом говорим о языках, то подразумеваем, что они взаимозаменяемы. Как машины. Если я знаю, как управлять Ладой Саранск, значит смогу вести и УАЗ Рыбак без каких-либо проблем. Разница только в скорости и приборной панели, не так ли?

Но представьте, как будет выглядеть PHP-автомобиль. А теперь вообразите, насколько будет отличаться автомобиль Lisp. Пересесть с одного на другой потребует гораздо большего, чем усвоить, какая кнопка управляет отоплением.

Примечание: Эта статья предполагает, что читатель знаком с Rust FFI (перевод), порядком байтов (endianess) и ioctl.

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

На днях я участвовал в обсуждении на reddit того, насколько трудны на самом деле времена жизни. При работе над clippy мне не приходилось до этого времени иметь с ними дела, потому что всем, чем мы пользовались, владел компилятор, особого мнения на этот счёт у меня не было, и тут The_Doculope заявил:

Есть места, в которых опускание времён жизни может укусить нас за задницу.

(/u/The_Doculope на /r/rust)

Честно говоря, я был шокирован!

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

(я на /r/rust)

Сразу после написания этого, мне попалась строка в исходном коде clippy, которой я был не очень доволен, потому что в ней происходило клонирование строки (с помощью .to_string()! богохульство!) просто для использования её в &format(…). Итак, происходило это в Result<String, …>::unpack_or(…), поэтому сначала я попытался дать обладаемой строке такое же время жизни, как и у полученной, без особого смысла.

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

Я избавлю вас от этих покрытых моей кровью сообщений об ошибках, потому что убеждён — если вы писали код на Rust, вы их знаете наизусть, и, даже наоборот, на самом деле все было не так уж и плохо, потому что, к счастью, я вспомнил такой удобный std::borrow::Cow, а уж переписать сниппет с ним (и std::convert::From) было раз плюнуть. Я даже создал fn для его повторного использования, таким образом, так я официально написал свой первый метод, аннотированный временем жизни. [ДОСТИЖЕНИЕ ОТКРЫТО]

Последний раз я использовал очень полезный Cow, чтобы разобраться с тем, нужно ли клонировать str или просто заимствовать её. Это было моё первое применение аннотаций времён жизни, и это было явно похоже на достижение. : -)

На /r/rust, пользователь Artemciy спросил меня очень хороший вопрос

[…] Как это работает? Похоже на какую-то магию. Имею ввиду, как String становится str?

А также предложил свой вариант ответа:

P. S. Похоже, что в String есть реализация IntoCow’, которая преобразует её в str, но если посмотреть на эту реализацию — опять какая-то магия. Может String в тайне является str?

(выделено мной)

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

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

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

Что вошло в стабильную версию 1.8

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

Во-первых, различные операторы составного присваивания, такие как += и -=, теперь могут быть перегружены через соответствующие трейты. Это изменение было результатом RFC 953 и выглядит следующим образом:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

use std::ops:: AddAssign;

#[derive(Debug)]
struct Count {
    value: i32,
}
   
impl AddAssign for Count {
    fn add_assign(&mut self, other: Count) {
        self.value += other.value;
    }
}  

fn main() {
    let mut c1 = Count { value: 1 };
    let c2 = Count { value: 5 };

    c1 += c2;

    println!("{:?}", c1);
}

(Эта статья написана для Rust 1.4, и код по-прежнему работает в 1.7 без изменений)

Пришло время поговорить про типажи From и Into (и некоторые с ними связанные) и задать вопрос, где и когда их использовать. Заметьте, что есть ещё специфические типажи (например, IntoIterator) и более конкретные их варианты (например, FromStr); надо быть в курсе всего этого при написании кода на Rust.

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

Конечно, мы не могли обойти стороной отсылку к Лавкрафту. Напомним, что Некрономико́н (англ. Necronomicon) — вымышленная книга, придуманная Говардом Лавкрафтом и часто упоминаемая в литературных произведениях, основанных на мифах Ктулху. Согласно рассказу «Ведьмин Лог», в этой книге описаны все магические ритуалы, а также полная история Древних, которые постоянно вели ожесточённые войны.

Введение

По мотивам статьи Михаэля Петерсона, которую мы переработали и сделали актуальной на данный момент.

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

1
2
3
4
5

$ rustc -V
rustc 1.7.0 (a5d1e7a59 2016-02-29)

$ gdb --version
GNU gdb (GDB) 7.11

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

Всем привет! Как вы знаете, у нас есть несколько чат-каналов на сервисе Gitter, и сегодня я расскажу о некоторых интересных вещах, которые он умеет.

IRC-мост

Gitter предоставляет возможность читать и писать в канал через IRC. Для настройки IRC-клиента посетите https://irc.gitter.im/ и следуйте инструкциям.

Matrix-мост

Можно сидеть через Matrix, в клиенте Riot. Подробнее.

Markdown

Gitter поддерживает Markdown в сообщениях, благодаря чему код может выглядеть похожим на код: с моноширинным шрифтом и подсветкой синтаксиса. Чтобы это работало, блоки кода нужно заключать в тройные обратные кавычки (вот такие: ` ).

Вот краткая справка по остальным возможностям:

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

Сначала мы приведём высокоуровневое описание процесса, а затем подробно опишем каждый этап.

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

Как всегда, вы можете установить Rust 1.7 с соответствующей страницы официального сайта, а также посмотреть подробный список изменений для версии 1.7 на Github. Этот релиз включил в себя 1300 патчей.

Что вошло в стабильную версию 1.7

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

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

Обсудить эти планы можно в комментариях к публикации.

Но сначала я хочу сказать спасибо всем участникам нашего сообщества — за работу, за общение и за поддержку. Я рад, что не я один работаю над улучшением сообщества. У нас очень дружелюбный народ в чате. Мы выросли до 150 человек за пару месяцев. Продолжайте в том же духе — это много значит :)

Также прошу присылать Pull Request’ы с исправлениями и дополнениями этой публикации, если что-то не так.

А теперь к делу. Я рассмотрю результаты 2015-го и разные грани возможных улучшений — и при этом, надеюсь, не напишу очень длинный текст. Я не буду сильно вдаваться в подробности, поэтому если вы хотите узнать о чём-то больше — пишите мне на почту или в чате.

Несколько недель назад я наткнулся на сравнительный анализ Rust, D и Go от Андрея Александреску. Андрей, уважаемый член сообщества C++ и главный разработчик языка программирования D, нанёс Rust сокрушительный удар под конец своего повествования, высказав нечто, что выглядит довольно проницательным наблюдением:

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

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

Привет в 2016-м году! Мы рады объявить первый в этом году релиз Rust — 1.6. Rust — системный язык программирования, нацеленный на безопасную работу с памятью, скорость и параллельное выполнение кода.

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

Что вошло в стабильную версию 1.6

В этот релиз вошли ряд небольших доработок, одно большое нововведение и изменение на Crates.io.

Стабилизация libcore

Самое большое нововведение в 1.6 — стабилизация библиотеки libcore. Стандартная библиотека Rust состоит из двух слоёв: маленькая базовая библиотека libcore и полная стандартная библиотека libstd, которая построена на основе libcore. Сама libcore полностью платформенно-независимая и требует, чтобы было определено несколько внешних функций. Полная библиотека libstd основана на libcore и добавляет поддержку выделения памяти, операций ввода-вывода и многопоточность. При использовании Rust во встроенных средах и при написании операционных систем часто отказываются от libstd и используют только libcore.

2015 год был значительным годом для Rust: мы выпустили версию 1.0, стабилизировали большинство элементов языка и кучу библиотек, значительно выросли как сообщество, а также реорганизовали управление проектом. Может показаться что 2016 год не будет таким же интересным (будет трудно превзойти выпуск 1.0), но это будет супер-важный год для Rust, в которым произойдёт много захватывающих вещей. В этой статье я расскажу о том, что, как я думаю, должно произойти. Это не официальная позиция и не обещание разработчиков Rust.

2015

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

Это вики-статья. Последнее обновление: 16 ноября 2017.

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

Введение

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

Постановка задачи

Мы создадим структуру Customer, описывающую покупателя, который должен владеть экземпляром структуры Car. Покупатель будет иметь возможность покупать, продавать и обмениваться с другими покупателями автомобилями.

Введение

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

Постановка задачи

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

Добро пожаловать на русскоязычный сайт для разработчиков на Rust!

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

Создание сообщества назревает уже давно. Наш язык миновал заветный выпуск «1.0». Rust стабилен, экосистема растёт как на дрожжах, а улучшения поспевают в каждом новом выпуске. Самое время расширять аудиторию!