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

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

В этой статье мы рассмотрим, как работает match в Rust. Вот основные элементы, которые match и его дополнение, enum, объединяют в единое целое:

• Структурное сопоставление с образцом: анализ вариантов и удобство использования гораздо лучше, чем при использовании switch в C или Java.
• Исчерпывающий анализ: match гарантирует, что ни один вариант не пропущен.
• match поддерживает и императивный, и функциональный стили: вы можете и дальше использовать оператор break, присваивания и прочее, и вам совершенно не нужно переучиваться на стиль, основанный на выражениях;
• match умеет как «заимствовать», так и «перемещать»: Rust поощряет программиста думать о владении и заимствовании данных. Выражение match спроектировано в том числе с возможностью только заимствования части структуры вместо её перемещения. Это нужно для того, чтобы не передать право владения какими-либо данными раньше, чем нужно.

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

Rust начинался как проект, решающий две трудные проблемы:

• Как обеспечить безопасность (работы с памятью) в системном программировании?
• Как сделать многопоточное программирование безболезненным?

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

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

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

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

Вот какие особенности у многопоточного программирования в Rust:

Сегодня мы рады представить релиз Rust 1.0 Beta! Бета-релиз является очень важным звеном на пути к финальному релизу 1.0. В частности, в бета-релизе все библиотеки и элементы языка, которые мы собирались сделать стабильными в 1.0, отмечены как стабильные. Поэтому по бета-релизу можно весьма точно представить, что вас будет ожидать в Rust 1.0.

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

TL;DR: Rust 1.0 выйдет 15 мая 2015 года

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

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

С удивлением обнаружил, что это ожидаемое многими событие почему-то обошло Хабр стороной. Думаю, что для многих программистов, следящих за этим языком программирования, будет полезно узнать, что тот самый релиз версии Rust 1.0.0 Alpha состоялся 9 января. В этой версии наконец-то стабилизировали ядро языка и большую часть стандартной библиотеки, так что теперь можно начинать писать на Rust'е программы не боясь, что через неделю что-то сломается после обновления компилятора.

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

Привет.

В прошлую субботу я выступал с докладом на очередном митапе Saratov Open-IT, где я рассказал про Rust — многообещающий системный язык программирования, разрабатываемый Mozilla Research и сообществом, и про то, какие проблемы он решает и какие у него есть особенности и инфраструктура. Надеюсь, что моё выступление будет интересно сообществу, поэтому выкладываю его здесь.

(видео не вставлено в пост через тег <video> потому что он не работает с конкретной временной меткой; длительность — примерно полтора часа)
http://www.youtube.com/watch?v=lmauAUF823k#t=2583

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

Замечания к переводу прошу слать в личку.

---

Много важного несёт с собой предстоящий релиз Rust 1.0, но самым главным в нём являются наши усилия по обеспечению стабильности, аналогичные нашей постоянной ориентации на безопасность.

Начиная с версии 1.0, мы перейдём на шестинедельный цикл релизов и к набору «каналов». Канал стабильных релизов обеспечит безболезненные обновления, а канал ночных сборок предоставит первопроходцам доступ к тому функционалу, над которым в данным момент ведётся работа.

Сегодня Аарон Тюрон — разработчик, недавно присоединившийся к разработке Rust в Mozilla — объявил об отсрочке реализации какого-либо механизма исключений, кроме уже существующего макроса try! и типа Result, до неопределённого момента после первого релиза языка программирования Rust.

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

Для обработки ошибок в данной момент в Rust существует тип Result { Ok(value), Err(why) } и макрос try!. Тип Result представляет из себя перечисление (enum), похожее на Option { Some(value), None } и связанное с ним по смыслу. Вариант None типа Option говорит об отстутствии значения, а вариант Err(why) типа Result уточняет, почему значение отсутствует.

Rust предлагает возвращать тип Result из функций, чтобы передавать значение возврата или причину, по которой значение вернуть не удалось. Макрос try! в свою очередь позволяет автоматически возвращать Err(why) из текущей функции, если вызов другой функции не удался (применяется к объекту типа Result).

Полное оригинальное название статьи: «Why your first FizzBuzz implementation may not work: an exploration into some initially surprising but great parts of Rust (though you still might not like them)»

tl;dr;-версия: На первый взгляд некоторые аспекты Rust могут показаться странными и даже неудобными, однако, они оказываются весьма удачными для языка, который позиционируется как системный. Концепции владения (ownership) и времени жизни (lifetime) позволяют привнести в язык сильные статические гарантии и сделать программы на нём эффективными и безопасными, как по памяти, так и по времени.

Лицензия: CC-BY, автор Chris Morgan.

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

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

Rust это «подвижная мишень», тем не менее, язык становится стабильней. Код из статьи работает с версией 0.12. Если что-то сломается, пожалуйста, свяжитесь со мной. Касательно кода на Python, он будет работать как в двойке, так и в тройке.

Абстракции Rust отличаются от привычных в ООП. В частности вместо классов (классов объектов) используются классы типов, которые называются «trait» (не следует путать с trait из Scala, где под этим термином прячутся примеси — mixin).
Классы типов не уникальны для Rust, они поддержаны в Haskell, Mercury, Go, из можно реализовать слегка извращенным способом на Scala и C++.

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

Интерфейсы числовых типов довольно громоздки, и я буду вставлять здесь только фрагменты кода. Весь код доступен на github (Update: работающая версия доступна на crates.io).
Большинство реализованных здесь интерфейсов имеют статус experemental или unstable и скорее всего будут меняться. Я постараюсь поддерживать код и текст актуальными.

Rust поддерживает перегрузку операций, но, в отличие от C++, у операций есть метод-синоним с обычным буквенным именем. Так a+b может быть записано a.add(b), а для переопределения операции '+' надо просто реализовать метод add.

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

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

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

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

---

Rust 1.0 уже в пути! Мы определились со списком фич и плотно заняты их реализацией. Наш план — выпустить бета-версию 1.0 в конце года. Если всё будет в порядке, то релиз 1.0 состоится вскоре после беты. Будущие версии в ветке 1.x будут обратно совместимыми, то есть существующий код будет ими компилироваться без изменений (естественно, за исключением багов в компиляторе).

Естественно, релиз 1.0 не означает только лишь стабилизацию («ваш код продожит компилироваться»); для нас он значит, что язык стал таким, каким мы хотим его видеть. Если ещё точнее, что он минимален. На данный момент язык выстроен вокруг простых базовых концепций, которые мы называем владением (ownership) и заимствованием (borrowing) (подробнее о них далее). Применяя эти концепции, всё остальное мы смогли вынести в библиотеки. Это очень здорово, потому что вы сами сможете написать аналогичные библиотеки. Из-за этого мы уверены, что Rust не только достигнет своих первоначальных целей, но и пойдёт дальше, применяясь в таких задачах, какие мы даже себе не представляли.

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

Дело не только в компиляции. Mozilla считает, что дизайн Rust наконец-то приобретает желаемую минималистичную форму. К примеру, раньше было несколько типов указателей, сейчас остались только &T, и &mut T. Упрощение затронуло и другие аспекты, в том числе замыкания, которые вызывали много споров.

Rust сочетает в себе эффективность С и С++ с безопасностью Java.

Весь дизайн построен на концепции «владения и заимствования» (ownership and borrowing). Изначально предполагалось использовать механизм владения для быстрого и безопасного переноса данных между процессами. Но потом пришло понимание, что этот же механизм можно использовать для передачи значительной части функций в библиотеки. В итоге, Rust получился даже более низкоуровневым, чем разработчики предполагали, и без ущерба для безопасности. На минимальной конфигурации Rust можно даже написать ядро операционной системы (примеры: 1, 2, 3)!

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



Для начала пара слов о том, что такое Rust. Последние 15 лет между разработчиками на Java и на C++ ведётся спор о том, какой язык программирования хуже — Java или C++. Программы на C++ глючат, падают, и в них утекает память. Программы на Java тормозят и требуют слишком много памяти.

Rust — новый современный язык программирования, разрабатываемый компанией Mozilla — решает проблемы Java и C++: программы, написанные на Rust, одновременно быстрые и безопасные. Rust является таким же низкоуровневым (в смысле close-to-metal) языком программирования, как и C++, однако в язык встроены конструкции, позволяющие на этапе компиляции доказывать, что в программе не случатся ошибки работы с памятью, как то обращение после использования, двойное удаление, использование неинициализированной памяти и т.п. В Rust для этого используется механизм borrowed pointers. Большая часть моего рассказа была посвящена описанию этого механизма.

Это вторая часть из цикла статей по переводу книги «Rust by Example». Первую часть можно прочитать здесь.

Продолжим?

Этот цикл статей является вольным переводом книги «Rust by Example», которую пишет Хорхе Апарисио на Github.

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

Давайте начинать!

Всем привет! Недавно вышел перевод статьи о том, как TJ Holowaychuk прощался с Node.js, решив двигаться в сторону Go. В конце статьи была ссылка на посвящённый сравнению и критике языка Go пост Уилла Ягера, который просили перевести — собственно, с результатами перевода я и предлагаю ознакомиться. Я пытался более-менее сохранить как многословный стиль изложения, присущий автору, так и оригинальную разбивку на предложения и параграфы.
Буду очень рад любым конструктивным замечаниям и предложениям по переводу, опечаткам и/или оформлению, но очень прошу помнить, что точка зрения переводчика может не совпадать с позицией автора переведённой статьи.

Mozilla и сообщество Rust выпустили новый релиз Rust, версии 0.11.0.

Несмотря на то, что язык находится в активной фазе разработки, работа была сфокусирована над улучшением системы типов и библиотек. Главная работа была проведена над имплементацией типов с динамическим размером (DST) и рефакторингом стандартной библиотеки.
В этом релизе также удалили ~ и @ в угоду типам Box и Gc из стандартной библиотеки (компилятор пока знает о этих типах больше чем нужно, но вскоре эти типы станут самыми обычными типами Rust).

Данный пост основывается на Сравнение Rust и С++ на примерах и дополняет приведенные там примеры кодом на D с описанием различий.

Все примеры были собраны с помощью компилятора DMD v2.065 x86_64.