Rust: str vs String

оригинал: Ameya • перевод: Norman Ritchie • обучение • поддержите на Patreon

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

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

Выпуск Rust 1.21

оригинал: The Rust Core Team • перевод: ozkriff • новости • поддержите на Patreon

Команда 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 1.20

оригинал: The Rust Core Team • перевод: red75prime и Илья Богданов • новости • поддержите на Patreon

Команда 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. Подобно функциям, ассоциированные константы работают и с типажами, и с перечислениями.

Game development in Rust, 14 сентября, Санкт-Петербург

• Логачев Федор • новости • поддержите на Patreon

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

alt "Ferris"

Будут представлены доклады:

  • SHAR — 3d action на Rust, Фёдор Логачев

Обзор внутренностей и организации достаточно большой игры на Rust.

  • Three-rs — взгляд изнутри, Илья Богданов

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

  • Ржавые пошаговые игры, Андрей Лесников

Андрей расскажет о своём опыте хобби-разработки игры Zone of Control, немного о связанном с этим инструментарии и о своём новом проекте.

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

Мероприятие состоится 14-го сентября (четверг) в 19-00 в петербургском офисе JetBrains.

Для участия во встрече необходима регистрация на meetup

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

• Михаил Панков • обучение • поддержите на Patreon

teaser

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

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

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

• Михаил Панков • обучение • поддержите на Patreon

teaser

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

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

Выпуск Rust 1.19

оригинал: The Rust Core Team • перевод: Илья Богданов • новости • поддержите на Patreon

Команда 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?

• Михаил Панков • обучение • поддержите на Patreon

teaser

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

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

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

Выпуск Rust 1.18

оригинал: The Rust Core Team • перевод: Илья Богданов • новости • поддержите на Patreon

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

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

1
$ rustup update stable

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

Решаем систему логических уравнений на Rust

• Павел Никитин • руководства • поддержите на Patreon

Решение головоломки Lights Off размером 333 на 333

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

  • Rust
  • C
  • Vala

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

Выпуск Rust 1.17

оригинал: The Rust Core Team • перевод: kgv • новости • поддержите на Patreon

Команда 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 теперь автоматически подразумевается для констант или статических переменных. При создании константы или статической переменной:

CoLaboratory: Rust #3. Лаборатория Касперского, 18 мая

• Михаил Панков • новости • поддержите на Patreon

лого

зарегистрироваться

Продолжаем нести знания людям. В этот раз у нас 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.

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

Передача намерений

оригинал: Jasper 'jaheba' Schulz • перевод: Илья Богданов • обучение • поддержите на Patreon

teaser

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

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

Изменение размера изображения с учётом содержимого

оригинал: Martin Hafskjold Thoresen • перевод: Gexon • руководства • поддержите на Patreon

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

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

sample image

Выпуск Rust 1.16

оригинал: The Rust Core Team • перевод: Сергей Веселков • новости • поддержите на Patreon

Команда 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):

Прекрасные конечные автоматы на Rust

оригинал: Andrew 'hoverbear' Hobden • перевод: Илья Богданов • обучение • поддержите на Patreon

teaser

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

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

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

Промежуточные результаты выдвижения на реализацию идей

• Михаил Панков • новости • поддержите на Patreon

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

результаты

CoLaboratory: Rust #3. Принимаем заявки на выступление 18 мая

• Михаил Панков • новости • поддержите на Patreon

лого

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

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

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

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

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

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

Планы сообщества в 2017 году. Часть 4, последняя. Результаты голосования, процесс реализации запланированного и идеи участников

• Михаил Панков • новости • поддержите на Patreon

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

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

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

Опросы

Графическое описание владения и заимствования в Rust

оригинал: Phil Ruffwind • перевод: Шерзод Муталов • обучение • поддержите на Patreon

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

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

Схема

Планы сообщества в 2017 году. Часть 3. Статьи, сайт, Patreon, расширение тем и Ядро команды Сообщества

• Михаил Панков • новости • поддержите на Patreon

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

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

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

редактирование этой статьи

Планы сообщества в 2017 году. Часть 2. Митапы, выступления, календари событий, подкасты и конкурсы

• Михаил Панков • новости • поддержите на Patreon

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

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

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

фото с митапа

Планы сообщества в 2017 году. Часть 1. Вступление, книги и социальные сети

• Михаил Панков • новости • поддержите на Patreon

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

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

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

Вступление

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

карточка в трелле

Русскоязычное сообщество языка Rust в 2016 году

• Михаил Панков • новости • поддержите на Patreon

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

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

число посетителей за год

Соревнование Underhanded Rust 2016

оригинал: The Rust Community Team • перевод: авторы rustycrate.ru • новости • поддержите на Patreon

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

Выпуск Rust 1.13

оригинал: The Rust Core Team • перевод: Александр Ирбис • новости • поддержите на Patreon

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

CoLaboratory: Rust 2. Лаборатория Касперского, 22 ноября

• Михаил Панков • новости • поддержите на Patreon

лого

зарегистрироваться

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

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

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

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

Выпуск Rust 1.12.1

оригинал: The Rust Core Team • перевод: Денис Хлякин • новости • поддержите на Patreon

Мы рады представить новую версию 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

оригинал: The Rust Core Team • перевод: Михаил Панков • новости • поддержите на Patreon

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

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

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

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

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

Новая ошибка заимствования

Числа Пеано на системе типов Rust

• Fedor Logachev • обучение • поддержите на Patreon

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

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

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

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

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

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

1
2
3
4
enum Nat {
  Zero,
  Succ(Nat)
}

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

futures-rs: асинхронщина на Rust

оригинал: Alex Crichton • перевод: Арсен Галимов • обучение • поддержите на Patreon

Замечание: проект 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

оригинал: The Rust Core Team • перевод: Михаил Панков • новости • поддержите на Patreon

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

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

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

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

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

Futures нулевой стоимости в Rust

оригинал: Aaron Turon • перевод: Сергей Ефремов • обучение • поддержите на Patreon

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

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

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

Мифы и легенды о переполнении целых чисел в Rust

оригинал: Huon Wilson • перевод: Станислав Ткач • обучение • поддержите на Patreon

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

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

Введение в Iron

• Арсен Галимов aka «Loo Maclin» • обучение • поддержите на Patreon

Немного об Iron

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

Философия

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

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

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

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

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

1
cargo new rust-iron-tutorial --bin

Анонс Rust 1.10

оригинал: The Rust Core Team • перевод: Михаил Панков • новости • поддержите на Patreon

Мы рады представить новую версию 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.

Большие бинари в моем Rust? (Why is a Rust executable large?)

оригинал: lifthrasiir • перевод: kitsu • обучение • поддержите на Patreon

Это статья — перевод статьи 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

оригинал: The Rust Core Team • перевод: Михаил Панков • новости • поддержите на Patreon

Мы рады представить новую версию 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

оригинал: Pascal Hertleif • перевод: Андрей Лесников • руководства • поддержите на Patreon

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

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

От & str к Cow

оригинал: Joe Wilm • перевод: Алексей Сидоров • обучение • поддержите на Patreon

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

От & str к Cow

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

Lock-free без сборки мусора

оригинал: Aaron Turon • перевод: Сергей Ефремов • обучение • поддержите на Patreon

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

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

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

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

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

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

Утечки не нарушают безопасность памяти

оригинал: Huon Wilson • перевод: Станислав Ткач • обучение • поддержите на Patreon

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

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

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

CoLaboratory: Rust — первая конференция о Rust в Москве

• Михаил Панков • новости • поддержите на Patreon

лого

зарегистрироваться

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

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

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

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

Rust через его основополагающие принципы

оригинал: Ian Whitney • перевод: Станислав Ткач • обучение • поддержите на Patreon

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

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

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

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

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

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

Работа с С-объединениями (union) в Rust FFI

оригинал: Herman J. Radtke III • перевод: Станислав Ткач • обучение • поддержите на Patreon

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

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

Святая Корова! (Holy std: borrow: Cow!)

оригинал: llogic • перевод: Сергей Ефремов • обучение • поддержите на Patreon

На днях я участвовал в обсуждении на 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 для его повторного использования, таким образом, так я официально написал свой первый метод, аннотированный временем жизни. [ДОСТИЖЕНИЕ ОТКРЫТО]

Святая Корова! — Продолжение (Holy std: borrow: Cow! — Redux)

оригинал: llogic • перевод: Сергей Ефремов • обучение • поддержите на Patreon

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

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

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

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

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

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

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

Анонс Rust 1.8

оригинал: The Rust Core Team • перевод: Станислав Ткач • новости • поддержите на Patreon

Мы рады представить новую версию 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);
}

Как пользоваться типажами From и Into

оригинал: llogic • перевод: Сергей Ефремов • обучение • поддержите на Patreon

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

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

Мы начинаем продажу эксклюзивного издания Растономикона!

• Михаил Панков • новости • поддержите на Patreon

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

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

Отладка приложений на Rust с помощью GDB

• Александр Яшкин • обучение • поддержите на Patreon

Введение

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

В этой статье мы рассмотрим, как можно использовать отладчик 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

• Михаил Панков • руководства • поддержите на Patreon

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

IRC-мост

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

Markdown

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

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

Как сделать свой первый Pull Request

• Михаил Панков • руководства • поддержите на Patreon

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

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

Анонс Rust 1.7

оригинал: Rust Core Team • перевод: Михаил Панков • новости • поддержите на Patreon

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

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

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

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

Наши результаты и планы на 2016

• Михаил Панков • новости • поддержите на Patreon

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

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

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

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

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

Rust и парадокс Блаба

оригинал: Jonathan Turner • перевод: Иван Иващенко • размышления • поддержите на Patreon

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

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

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

Анонс Rust 1.6

• Константин Степанов • новости • поддержите на Patreon

Привет в 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.

Rust в 2016 году

оригинал: Nick R. Cameron • перевод: Иван Иващенко • новости • поддержите на Patreon

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

2015

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

IDE для Rust

• Олег В. и Norman Ritchie • руководства • поддержите на Patreon

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

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

Время жизни в Rust (Часть 2)

• Александр Яшкин • обучение • поддержите на Patreon

Введение

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

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

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

Время жизни в Rust (Часть 1)

• Александр Яшкин • обучение • поддержите на Patreon

Введение

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

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

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

Здравствуй, мир!

• команда rustycrate • новости • поддержите на Patreon

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

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

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