Rust *

Сегодня завершаются циклы стабильного Rust 1.2 и бета-Rust 1.3! Читайте дальше об основных изменениях или переходите к более подробным release notes.

Продолжаю свой цикл статей про упрощенный аналог OpenGL на Rust, в котором уже вышло 2 статьи:

1. Пишем свой упрощенный OpenGL на Rust — часть 1 (рисуем линию)
2. Пишем свой упрощенный OpenGL на Rust — часть 2 (проволочный рендер)

Напоминаю, что основой моего цикла статей является «Краткий курс компьютерной графики» от haqreu. В предыдущих статьях я шел не очень быстро. Фактически на одну статью курса у меня получилось 2 статьи. Это связанно с тем, что в своих статьях я сосредоточиваюсь главным образом на нюансах работы с Rust, а когда только изучаешь новый язык, сталкиваешься с большим количеством новых для тебя нюансов, нежели чем когда программируешь на нем уже некоторое время. Думаю дальше Rust будет подбрасывать меньше граблей, и я выровняю соотношение своих статей к статьям оригинального курса.

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


То, что мы получим по итогам данной статьи

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

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

Эта статья — небольшой ответ к записи в блоге Дейва Чейни «Почему Go и Rust не соперники». Я настоятельно рекомендую вам почитать его доводы! Вероятно, вам также понравится замечательная дискуссия на реддите.

На самом деле, Go и Rust решают одну и ту же самую проблему: оба пришли в наш мир, чтобы сделать жизнь программистов проще. Go до безобразия упростил концепт конкурентного (ака многопоточного) программирования и мне кажется, сделал программирование приятным занятием, ведь код на Go действительно приятно читать. В то ж время, Rust подарил нам мощные zero-cost абстракции… для паттерн-матчинга. Звучит оправданно, не так ли? Шутки-шутками, но Rust действительно сделал многие непростые штуки проще (частое заблуждение: он не избавился от них). Его дьявольская система типов позволяет гарантировать безопасность памяти, и в том числе, избавиться от состояния гонки, что звучит очень заманчиво.

В этом небольшом посте я расскажу, почему я считаю, что Go и Rust не являются соперниками.

Почему некоторые считают, что Go и Rust соперники?

• Rust и Go анонсировали в примерно одно и то же время. Разработку языка Go начали в 2007 и в ноябре 2009 он уже увидел свет. Rust появился несколько месяцев спустя, в 2010, тем не менее Грейдон отмечает, что разработку начали гораздо раньше. В любом случае, у обоих языков достаточно явно различаются влиятельные предшественники. В случае Go, это CSP Хоара, Alef, и Newsqueak Пайка. Rust рассматривается, как расширение семейства ML-языков.
• Что Rust, что Go — оба считаются безопасными (по части управления памятью). В то время, как это утверждение абсолютно правдиво, оба языка не поощряют использование unsafe кода; что более важно, сегодня мир просто не примет язык без подобных гарантий надежности. Просто так получилось, что Go и Rust — это первые языки, которым удалось доказать, спустя десятилетия доказательств, что в реальности программисты просто не могут безопасно обращаться с памятью вручную.
• Оба очень молоды: Go достиг 1.0 в 2012, а Rust в середине 2015 года. Оба более, чем амбициозны и явно готовы потеснить «старожил».

Итак, в продолжение предыдущей статьи пишу 2-ю часть, где мы попробуем добраться до того, чтобы написать проволочный рендер. Напоминаю, что цель этого цикла статей — написать сильно упрощенный аналог OpenGL на Rust. В качестве основы используется «Краткий курс компьютерной графики» от haqreu, в своих же статьях я сосредоточиваюсь больше не на графике как таковой, а на особенностях реализации при помощи Rust: возникающие проблемы и их решения, личные впечатления, полезные ресурсы для изучающих Rust. Сама получившаяся программа не имеет особенной ценности, польза от этого дела в изучении нового перспективного ЯП и основ трехмерной графики. Наконец, это занятие довольно таки увлекательно.

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


Машинка, которую мы получим в конце статьи

Продолжение:
Пишем свой упрощенный OpenGL на Rust — часть 2 (проволочный рендер).
Пишем свой упрощенный OpenGL на Rust — часть 3 (растеризатор)

Наверное, мало кто на хабре не в курсе, что такое Rust — новый язык программирования от Mozilla. Уже сейчас он привлекает много интереса, а недавно наконец вышла первая стабильная версия Rust 1.0, что знаменует собой стабилизацию языковых возможностей. Мне всегда импонировали системные ЯП, а уж идея системного языка, предлагающего безопасность превосходящую языки высокого уровня, заинтересовала еще больше. Захотелось новый язык попробовать в деле и, заодно, интересно провести время, программируя что-нибудь увлекательное. Пока думал, что бы такого на расте написать, вспомнился недавний цикл статей про компьютерную графику, который я лишь бегло просмотрел. А очень интересно было бы попробовать все-таки написать все эти красивости самостоятельно. Вот так и родилась идея этого хобби-проекта, а также данной статьи.

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

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


Here is the Rust, which i hope to get at the end. (игра слов, Rust по-английски «ржавчина»)

Доброго времени суток, хабр!


Моим основным ЯП является D. Всегда понимал, что он будет проигрывать C++ из-за сборщика, каких-то высокоуровневых плюшек и т.д. Но никогда не доходили руки проверить насколько. Решил написать простенький классификатор (даже не помню метод как называется) и проверить. Результат меня приятно удивил: версия C++ отработала за 5.47 сек, версия D — за 5.55 сек. «0.08 сек при обработке файла в 74Мб это не так уж и много» — подумал я. Но, на всякий случай, решил попробовать собрать код на D с помощью gdc (dmd как frontend, gnu backend) и тут уже в душу закрались сомнения, что я всё сделал правильно: код отработал за 4.01 сек, что более чем на 20% быстрее версии на С++. Решил собрать с помощью ldc2 (dmd frontend, llvm backend): 2.92(!!) сек. Тут я решил разобраться.

Предлагаю читателям «Хабрахабра» перевод статьи «A Quick Comparison of Nim vs. Rust». Мои замечания будут выделены курсивом.

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

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

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

Особенно отмечу, что не пытаюсь полностью описать язык, а только одну его сторону. Это мой личный взгляд на философию Rust, не обязательно совпадающий с официальной позицией разработчиков! Кроме того, Rust не будет очевиден пришельцу из других языков: кривая обучение довольно резкая, и не раз компилятор заставит вас мысленно сказать «wtf» на пути к просветлению.

Сегодня мы с гордостью представляем релиз Rust версии 1.0, нового языка программирования для создания более надёжных и эффективных систем. Раст объединяет в себе низкоуровневый контроль над производительностью с удобством и гарантиями безопасности языков высокого уровня. Лучше того, он при этом не требует сборщика мусора или среду выполнения, так что библиотеками на Расте можно безболезненно заменять библиотеки на C (англ.). Если вы хотите поэкспериментировать с Растом, лучше всего начать с раздела «Getting Started» книги Rust Book (если вы предпочитаете читать с электронных книг, Паскаль Хертлиф (Pascal Hertleif) поддерживает неофициальные версии этой книги в электронном виде).

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

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

Этот пост начинает рассказ о третьем столпе:

• абстракции без накладных расходов.

Одна из мантр C++, которая делает его таким подходящим для системного программирования — принцип абстракции с нулевой стоимостью:

Реализации C++ подчиняются принципу нулевой стоимости: ты не платишь за то, что не используешь [Страуструп, 1994]. Более того: то, что ты используешь, кодируется наилучшим образом.

– Бьёрн Страуструп

Предлагаю читателям «Хабрахабра» перевод поста «Rust Once, Run Everywhere» из блога Rust за авторством Alex Crichton. Сам я некоторое время уже интересуюсь этим языком, а в связи со скорым релизом версии 1.0 хотел бы продвигать его по своим скромным возможностям. Ничего своего, к сожалению, сейчас у меня написать не получается, но когда-то я занимался переводами, так что решил вспомнить давнее дело. Перевод этого поста на Хабре я не нашёл, так что решил сделать свой.
Некоторые термины, которые обозначают уникальные для Rust-а концепции (ownership, borrowing, lifetime parameter), я не знал, как лучше перевести на русский, так что постарался подобрать наиболее подходящие по смыслу и более-менее понятные для русскоязычной аудитории слова. Любые предложения-улучшения принимаются.

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

Одной из основных целей проекта 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