Как стать автором
Обновить
85.83

Rust *

Мультипарадигмальный компилируемый язык

Сначала показывать
Порог рейтинга
Уровень сложности

Создаём REST-сервис на Rust. Часть 3: обновляем базу из консоли

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

Теперь давайте реализуем непосредственно операции обновления БД: создание, обновление, удаление наших записей и соответствующий им интерфейс командной строки.
Читать дальше →

Создаём REST-сервис на Rust. Часть 2: читаем INI; multirust

Время на прочтение4 мин
Количество просмотров19K
Всем привет.

В первой части мы сделали простейший прототип, работающий с PostgreSQL.

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

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

Читать дальше →

Создаём REST-сервис на PostgreSQL и Rust. Часть 1: прототип

Время на прочтение6 мин
Количество просмотров38K
Всем привет.

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



Мы начнём с работы с БД и создадим обычное консольное приложение, а затем добавим, так сказать, REST-фронтенд.
Читать дальше →

Rust, дисциплинирующий язык программирования

Время на прочтение9 мин
Количество просмотров50K
Здравствуйте, уважаемые читатели!

Жизнь не стоит на месте, и вот в «O'Reilly» задумались об издании первой фундаментальной книги о языке программирования Rust:



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

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

Читать дальше →

Истории

Почему мы занимаемся переводом книги с английского на площадке GitHub

Время на прочтение3 мин
Количество просмотров20K
Всем привет!

Недавно команда rust_book_ru закончила перевод книги «The Rust Programming Language» на русский язык.



Когда я только присоединился к проекту перевода, начатого kgv, нам несколько раз говорили: «Вы делаете перевод на GitHub? Странные вы, для краудсорсинг-перевода есть другой сервис — вот ссылка». Мы не стали переходить на другие сервисы и в итоге это решение полностью оправдалось.

Я хочу рассказать о том, почему мы всё же разместили книгу на GitHub и почему даже переводчику полезно быть немного программистом.
Читать дальше →

Заимствование и время существования в Rust

Время на прочтение10 мин
Количество просмотров14K
Представляю вашему вниманию перевод статьи «Rust Borrow and Lifetimes» из блога Артура Ляо (Arthur Liao), инженера Yahoo!

Rust — это новый язык программирования, находящийся в активной разработке с версии 1.0. Я могу написать другой блог о Rust и том, почему он крут, но сегодня я сфокусируюсь на его системе заимствования и времени существования, которая запутывает многих новичков, в том числе и меня самого. Данный пост предполагает, что у вас есть базовое понимание Rust. Если же нет, вы можете сперва прочитать само Руководство и Руководство по указателям.
Читать дальше →

Анонс Rust 1.2

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

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

Время на прочтение13 мин
Количество просмотров14K
Продолжаю свой цикл статей про упрощенный аналог OpenGL на Rust, в котором уже вышло 2 статьи:
  1. Пишем свой упрощенный OpenGL на Rust — часть 1 (рисуем линию)
  2. Пишем свой упрощенный OpenGL на Rust — часть 2 (проволочный рендер)

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

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


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

Почему Go и Rust не враги, а друзья

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

Читать дальше →

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

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

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

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

Почему Go и Rust не соперники

Время на прочтение2 мин
Количество просмотров20K
В этом небольшом посте я расскажу, почему я считаю, что 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 года. Оба более, чем амбициозны и явно готовы потеснить «старожил».

Читать дальше →

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

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

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


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

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

Время на прочтение12 мин
Количество просмотров40K
Продолжение:
Пишем свой упрощенный 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 по-английски «ржавчина»)
Читать дальше →

Ближайшие события

2 – 18 декабря
Yandex DataLens Festival 2024
МоскваОнлайн
25 – 26 апреля
IT-конференция Merge Tatarstan 2025
Казань

Сравнение производительности языков на примере простейшего классификатора

Время на прочтение10 мин
Количество просмотров33K
Доброго времени суток, хабр!


Моим основным ЯП является 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(!!) сек. Тут я решил разобраться.
Читать дальше →

Сравниваем Nim и Rust

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

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

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

Читать дальше →

Ржавая очевидность

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

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

Анонс Rust 1.0

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

Абстракции без накладных расходов: типажи в Rust

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

Этот пост начинает рассказ о третьем столпе:
  • абстракции без накладных расходов.

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

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

Читать дальше →

Пиши на Rust — запускай везде. Взаимодействие Rust и C

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


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

Сопоставление с образцом, изменения и перемещения в Rust

Время на прочтение14 мин
Количество просмотров12K

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



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



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


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

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


Читать дальше →