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

Rust *

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

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

Учимся летать: симуляция эволюции на Rust. 3/5

Уровень сложностиСредний
Время на прочтение30 мин
Количество просмотров2K



Это третья часть серии статей по разработке симуляции эволюции с помощью нейронной сети и генетического алгоритма.



В предыдущей статье мы реализовали простую FFNN (feedforward neural network — нейронная сеть прямого распространения), которая может передавать числа через рандомизированные слои — это первый шаг на пути создания мозга.


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


Но как мы можем обучить группу чисел с плавающей точкой (запятой, если угодно)?

Читать дальше →
Всего голосов 17: ↑17 и ↓0+23
Комментарии1

Новости

Rust 1.79.0: встроенные const, ограничения в ассоциированном типе, продление автоматического времени жизни

Уровень сложностиПростой
Время на прочтение4 мин
Количество просмотров1.3K

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


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


$ rustup update stable

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


Если вы хотите помочь нам протестировать будущие выпуски, вы можете использовать канал beta (rustup default beta) или nightly (rustup default nightly). Пожалуйста, сообщайте обо всех встреченных вами ошибках.

Читать дальше →
Всего голосов 13: ↑13 и ↓0+14
Комментарии0

Пробуем Typst, альтернативу LaTeX

Уровень сложностиПростой
Время на прочтение20 мин
Количество просмотров8.1K

Вы могли слышать об Typst, современной альтернативе LaTeX, написанный на Rust, или не могли, ведь на Хабре я нашёл лишь несколько статей о нём. Некоторые до меня подчёркивали, что есть некоторые недостатки у первого по сравнению с последним.

Те статьи, что уже имеются на Хабре во время написания данной статьи, были, скорее, новостными, чем полноценными обзорами. Мы же попробуем рассмотреть Typst, начиная с установки и заканчивая возможностями и компиляцией, а также разберёмся, какие проблемы могут возникнуть.

Читать далее
Всего голосов 26: ↑26 и ↓0+35
Комментарии55

Написать X-docker-isolation-provider сложно — но не невозможно

Уровень сложностиПростой
Время на прочтение8 мин
Количество просмотров2.6K

Вы когда-нибудь чувствовали себя пионерами? Вот именно так я себя и ощущал, когда писал docker-isolation-provider для платформы ассоциативного программирования Deep.

Все было так: в один прекрасный день у нас на платформе связей решили - было бы славно портировать нашего бота в Deep. А для этого нужно было написать так называемые провайдеры.

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

Ох, как же я тогда ошибался…

Читать далее
Всего голосов 6: ↑6 и ↓0+6
Комментарии0

Истории

Gabriel2 — Open Source асинхронная библиотека для модели Акторов на Rust с использованием Tokio

Уровень сложностиСредний
Время на прочтение7 мин
Количество просмотров1.6K

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

Во время изучения Tokio, я решил написать свой проект для модели Акторов. Как раз низкоуровневая часть Tokio позволила это сделать. Так появилась библиотека Gabriel2.

Примерно 10 месяцев назад у меня получилась первая версия библиотеки. Первым делом я определил типизированную структуру ссылки на Актора:

Читать далее
Всего голосов 3: ↑3 и ↓0+5
Комментарии1

Рисуем фракталы на Rust и CUDA

Уровень сложностиСредний
Время на прочтение14 мин
Количество просмотров7.1K

Фракталы — это бесконечные самоподобные фигуры. Они определяются простыми математическими формулами, которые создают удивительную красоту!

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

Читать далее
Всего голосов 29: ↑29 и ↓0+34
Комментарии65

Учимся летать: симуляция эволюции на Rust. 2/5

Уровень сложностиСредний
Время на прочтение20 мин
Количество просмотров4.1K



Это вторая часть серии статей по разработке симуляции эволюции с помощью нейронной сети и генетического алгоритма.



В этой статье мы заложим основы нашего проекта и реализуем простую FFNN (feedforward neural network — нейронная сеть прямого распространения), которая впоследствии станет мозгом. Мы также рассмотрим множество тонкостей и идиом, которые встречаются в коде Rust, включая тесты.


Готовы? Тогда поехали.

Читать дальше →
Всего голосов 28: ↑28 и ↓0+38
Комментарии2

Ловим спутники без поворотного устройства

Уровень сложностиПростой
Время на прочтение7 мин
Количество просмотров13K

Полагаю, все любители поймать сигнал со спутников начинают с использования простых и легких направленных антенн, подключённых к портативке. Затраты минимальные, а удовлетворение от удачи услышать сигнал из космоса – максимальное. Но со временем надоедает руками держать и направлять на спутник антенну, хочется чего-то удобного. В век компьютеров логично всё автоматизировать. Об одном из возможных вариантов я хочу рассказать далее.

Читать далее
Всего голосов 16: ↑16 и ↓0+20
Комментарии5

Сверхскоростные связные списки

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

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

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

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

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

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

Дополнение (14.05.2024): Я учёл поступившую обратную связь и подчеркнул, какие идеи объективно плохи, прояснил некоторые отступления и удалил идею о imbl.

Чтобы было проще прослеживать этапы реализации и исследовать код, отсылаю вас к репозиторию, сопровождающему этот пост.

Читать далее
Всего голосов 13: ↑12 и ↓1+17
Комментарии1

Укрощаем суммы с плавающей запятой

Уровень сложностиПростой
Время на прочтение9 мин
Количество просмотров8.5K

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

Однако это запросто может привести к произвольно большой накопленной погрешности. Давайте проверим:

naive_sum(&vec![1.0; 1_000_000]) = 1000000.0
naive_sum(&vec![1.0; 10_000_000]) = 10000000.0
naive_sum(&vec![1.0; 100_000_000]) = 16777216.0
naive_sum(&vec![1.0; 1_000_000_000]) = 16777216.0

Ой-ёй… Что произошло? Проблема в том .что следующее 32-битное число с плавающей запятой после 16777216 — это 16777218. Так что при вычислении 16777216 + 1, значение округляется до ближайшего числа с плавающей запятой, имеющей чётную мантиссу, то есть снова до 16777216. Мы зашли в тупик.

К счастью, есть более совершенные способы суммирования массива.

Читать далее
Всего голосов 30: ↑30 и ↓0+37
Комментарии44

Первый год в Rust — история любви

Уровень сложностиПростой
Время на прочтение5 мин
Количество просмотров3.2K

Много лет назад я учился в Политехническом университете и уже думал о том, чем хочу заниматься, но не знал, чем именно. Поковырялся в html, css и js, написал несколько простых телеграм-ботов на питоне (с тех пор они канули в Лету), потом сделал то же самое на Java.

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

Но во время пандемии 2020 года я оказался в информационном поле Linux и с тех пор сильно вник в Linux. В этом году ради общности и системности, чтобы делать задачи, а не придумывать их, потому что та или иная ответственность, я искал «веб-разработку для начинающих» и нашел наставника. Сначала мы обсуждали варианты реактивного кодирования, но затем наставник спросил, что меня интересует, и я сказал, что в целом интересуюсь разработкой программного обеспечения, а мысли о ржавчине/++ отложил в долгий ящик. Итак, я начал писать Rust для проекта Retina в Norcivilian Labs.

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

Сначала мы работали с Nix и Linux. Для того, чтобы начать участвовать в проекте, нам нужно было всё настроить. Я установил NixOS, настроил его и зарегистрировался в нашем проекте на GitLab. Мы сразу же столкнулись с ошибками и добавили сопоставление с образцом в Nix flake для запуска оболочки кроссплатформенной разработки.

Читать далее
Всего голосов 11: ↑6 и ↓5+4
Комментарии4

Учимся летать: симуляция эволюции на Rust. 1/5

Уровень сложностиСредний
Время на прочтение10 мин
Количество просмотров6.8K



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


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


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

Эта серия состоит из нескольких статей:


  1. Введение (что мы будем симулировать, как работает нейронная сеть и генетический алгоритм).
  2. Реализация нейронной сети.
  3. Реализация генетического алгоритма.
  4. Реализация глаз, мозга и самой симуляции (в двух частях).

Интересно? Тогда поехали.

Читать дальше →
Всего голосов 24: ↑24 и ↓0+33
Комментарии3

Rust: за пределами синтаксиса. Обретение просветления в неожиданных местах

Уровень сложностиПростой
Время на прочтение9 мин
Количество просмотров6.1K

Я ненавижу C++. Обычно мне нравится программировать, но каждый проект на C++, за который я брался, казался мне утомительной рутиной. В январе 2023 года я решил изучить Rust, чтобы иметь возможность сказать, что знаю язык системного программирования, который мне действительно хотелось бы использовать.

Первая стабильная версия Rust вышла в 2015 году, и с тех пор, начиная с 2016 года, он ежегодно признается самым любимым языком в ежегодном опросе разработчиков на Stack Overflow (теперь, в 2023 году, это называется "Востребованный"). Почему же разработчики, попробовав Rust, не могут перестать его использовать? В мире разрекламированных преемников C/C++ Rust, похоже, выходит на первое место. Как получилось, что язык, который появился на основной сцене всего в прошлом десятилетии, стал таким популярным?

Читать далее
Всего голосов 17: ↑11 и ↓6+5
Комментарии31

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

AdIndex City Conference 2024
Дата26 июня
Время09:30
Место
Москва
Summer Merge
Дата28 – 30 июня
Время11:00
Место
Ульяновская область

Почему я отказался от разработки игр на Rust, часть 4

Уровень сложностиСредний
Время на прочтение12 мин
Количество просмотров4.3K

Часть 1
Часть 2
Часть 3

Dynamic borrow checking вызывает неожиданные вылеты после рефакторинга

В процессе написания статьи я обнаружил ещё один случай вылета нашей игры из-за пересекающегося World::query_mut. Я работаю с hecs уже около двух лет, такие проблемы — это не тривиальные «ой, я случайно сделал вложенными два запроса», с которыми сталкиваешься, только начав работать с библиотекой. Скорее, это ситуация, когда одна часть кода, находящаяся на верхнем уровне, запускает выполняющую что-то систему, а затем независимая часть кода делает что-то простое с ECS где-то глубоко внизу; после крупномасштабного рефакторинга они неожиданно оказываются пересекающимися.

Такое у меня случается не впервые; обычно советуют такое решение: «твой код просто плохо структурирован, поэтому ты сталкиваешься с такими проблемами; необходимо его отрефакторить и спроектировать правильно». Спорить с такими аргументами довольно сложно, потому что по сути своей они правдивы — это происходит, потому что какие-то части кодовой базы спроектированы неоптимально. Проблема в том, что это ещё один случай, когда Rust вынуждает делать рефакторинг там, где бы этого не требовал никакой другой язык. Пересекающиеся архетипы — не всегда преступление, и ECS-решения не на основе Rust (например, flecs) вполне их допускают.

Но эта проблема возникает не только в ECS. У нас она много раз возникала при использовании RefCell<T>, когда два .borrow_mut() создают пересечение и вызывают неожиданный вылет.

Дело в том, что это не всегда вызвано «плохим кодом». Люди говорят, что обойти эту проблему можно, «выполняя заимствование на кратчайшее время», но за это приходится расплачиваться. Очевидно, что это тоже зависит от правильного структурирования кода, но, как мы уже определили, геймдев — это не разработка серверов, а код в нём не всегда организуется оптимальным образом. Иногда в коде может быть цикл, которому нужно использовать что-то из RefCell, и бывает очень логично расширить заимствование на весь цикл, а не заимствовать только там, где это необходимо. Если цикл достаточно большой и вызывает систему, которой та же ячейка может понадобиться где-то ещё (обычно для условной логики), то это способно сразу создать проблему. Кто-то снова может сказать «просто используй косвенность и выполняй условную логику через событие», но в таком случае мы снова идём на компромисс: геймплейная логика не будет двадцатью строками понятного читаемого кода, а окажется разбросанной по всей кодовой базе.

Читать далее
Всего голосов 14: ↑13 и ↓1+21
Комментарии3

Туториал по Tokio. 2/2

Уровень сложностиСредний
Время на прочтение38 мин
Количество просмотров2.6K



Hello world!


Представляю вашему вниманию вторую часть туториала по Tokio.



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

Читать дальше →
Всего голосов 19: ↑19 и ↓0+26
Комментарии0

Реализация Streebog256 и Streebog512 на языке RUST

Уровень сложностиПростой
Время на прочтение18 мин
Количество просмотров2.4K

Как и планировалось, следом за реализацией семейства хэш-функций SHA, появляется Стрибог и тоже в двух версиях, для 256 и 512 бит на выходе. Надеюсь эта статья будет полезна другим студентам. Более опытные разработчики в комментариях приветствуются.

Весь код сохранен в репозитории GitVerse.

Читать далее
Всего голосов 16: ↑13 и ↓3+12
Комментарии14

Туториал по Tokio. 1/2

Уровень сложностиСредний
Время на прочтение35 мин
Количество просмотров6.6K



Hello world!


Представляю вашему вниманию первую часть туториала по Tokio.



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

Читать дальше →
Всего голосов 27: ↑27 и ↓0+37
Комментарии2

Создаем собственные линтеры в Rust с DyLint

Уровень сложностиСредний
Время на прочтение5 мин
Количество просмотров1.3K

Привет, Хабр!

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

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

Читать далее
Всего голосов 9: ↑9 и ↓0+12
Комментарии0

Почему я отказался от разработки игр на Rust, часть 3

Уровень сложностиСредний
Время на прочтение16 мин
Количество просмотров9.4K

Часть 1
Часть 2

Ситуация с GUI в Rust просто ужасна

В сообществе Rust ходит шутка, что на 5 игр существует 50 игровых движков; наверно, ещё одна такая шутка нужна про фреймворки GUI. Люди пробуют разные подходы, что, учитывая полную обобщённость Rust как языка, имеет смысл. Но в этой статье мы говорим о разработке игр, и я считаю, что в этой сфере у нас не просто дефицит, а полное отсутствие решений.

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

Я даже не касаюсь тем наподобие частиц в UI и различных эффектов, которые могут понадобиться пользователю. Очевидно, что полностью независимая от всего библиотека GUI не может иметь сложных шейдерных эффектов и частиц, но мне кажется, что это тоже стало частью общей проблемы. Библиотеки GUI перекладывают всю эту ношу на пользователя, поэтому каждому пользователю приходится заново изобретать велосипед в выбранном фреймворке/движке.

Читать далее
Всего голосов 25: ↑23 и ↓2+32
Комментарии77

Когда целый день программировал на Zig: впечатления Rust-энтузиаста

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

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

В прошлом году мне не раз доводилось слышать о новом низкоуровневом языке программирования, он называется Zig. И вот, наконец, я нашёл время, чтобы опробовать его на практике. В этой статье я хочу рассказать, что мне понравилось и не понравилось Zig (который я рассматривал с точки зрения Rust-программиста и тех высоких стандартов, к которым я привык в Rust).
Читать дальше →
Всего голосов 24: ↑21 и ↓3+27
Комментарии24
1
23 ...