🔥 Большой гайд по миграции с Go на Rust

Для разработчиков переход обычно упирается не в скорость, а в гарантии корректности, runtime trade-offs и ergonomics.

Внутри подробно сравниваются:

go build → cargo build
go test → cargo test
go vet → cargo clippy
nil → Option<T>
error → Result<T, E>
interfaces → traits
goroutines → async/await
-race → compile-time ограничения через Send / Sync

Отдельно хорошо показано, где Rust действительно выигрывает: data races, lifetime ресурсов, typed errors, отсутствие GC-пауз и более жёсткие гарантии компилятора.

Но автор не агитирует переписывать всё подряд: для большинства backend-сервисов Go остаётся достаточно быстрым и очень удобным.

Rust имеет смысл там, где цена runtime-багов уже выше, чем цена более сложной разработки.

Есть и практический раздел про постепенную миграцию сервисов, а не «rewrite from scratch».

https://corrode.dev/learn/migration-guides/go-to-rust/

@Golang_google

Участвуй во всероссийском ИТ-чемпионате МТС True Tech Champ 2026 c призовой фондом 10 250 000 рублей.

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

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

В финале лучшие 120 участников алгоритмического трека сразятся в лайв-кодинге за шесть призовых мест и 2 750 000 рублей. Всех финалистов ждут:
— Лимитированный мерч;
— Сертификаты об участии;
— Масштабное мероприятие с выступлениями хэдлайнеров и фестивальными активностями.

Успей зарегистрироваться и пройти отборочный этап до 27 сентября.

Erid: 2VSb5xSd2i6

🦀 Rust Pinning без магии: `Pin`, `Unpin` и `Future::poll`

Одна из самых сложных тем в Rust - зачем вообще нужен Pin и почему некоторые значения нельзя просто перемещать в памяти.

Хороший разбор строит механизм буквально с нуля и связывает его с тем, что реально встречается в async Rust:

- как работает Pin
- что означает Unpin
- почему self-referential структуры опасны
- при чём здесь Future
- почему Future::poll принимает Pin<&mut Self>

Главная идея: некоторые значения после начала использования должны оставаться по одному адресу в памяти, иначе внутренние ссылки могут стать невалидными.

Особенно полезно тем, кто пользуется async/await, но до конца не понимает, что происходит под капотом.

https://gmcgoldr.github.io/2026/08/27/pin-in-rust.html

yagni

🦀 NVIDIA официально идёт в native GPU programming на Rust

Теперь CUDA Rust позволяет писать GPU kernels прямо на Rust и компилировать их в PTX - без необходимости держать kernel-код на C++ или другом языке.

NVIDIA развивает сразу два подхода:

SIMT через `cuda-oxide`
- привычная CUDA-модель: один thread → одна операция
- полный контроль над потоками и памятью
- custom rustc backend → MIR → LLVM → PTX
- memory safety проверяется на этапе компиляции

Tile через `cutile-rs`
- работа не с отдельными потоками, а с блоками данных
- компилятор сам решает, как разложить вычисления по GPU
- stable Rust 1.89+
- CUDA 13.3
- уже используется в Hugging Face Grout и mistral.rs


Ownership и типы позволяют ловить часть GPU race conditions и aliasing-ошибок ещё до запуска kernel.

NVIDIA прямо пишет, что в 2026 году начинает всерьёз развивать CUDA Rust и планирует наращивать поддержку в 2027+.

Пока оба проекта ранние и не production-ready, но направление очень показательное:

`Rust → native GPU kernels → PTX → CUDA`

https://developer.nvidia.com/blog/introducing-cuda-rust-two-tracks-for-writing-gpu-kernels/

Zero cost

Rust без аллокатора: `fff` снизил пиковое потребление памяти через `mmap`

Во время тестирования fff обнаружилось, что при создании большого Vec<u64> процесс потребляет заметно больше оперативной памяти, чем требуется для индекса.

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

Теперь на Unix-системах fff выделяет память напрямую через mmap:

* рассчитывает точный объём памяти
* округляет его до размера системной страницы
* создаёт приватное анонимное отображение
* работает с данными через *mut u64
* освобождает память вызовом munmap

На остальных платформах по-прежнему используется обычный Vec<u64>.

В результате fff запрашивает у ядра ровно столько страниц, сколько необходимо для хранения и обработки индекса.

🦀 Как доказать, что Rust-код работает правильно: Amazon рассказывает о Verus

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

Разработчик описывает прямо в исходниках:

* requires - условия перед выполнением функции.
* ensures — свойства результата.
* Инварианты циклов и вспомогательные доказательства.

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

В статье есть показательный пример с бинарным поиском. Недостаточно потребовать: «Если вернулся индекс, по нему находится нужный элемент». Такому условию соответствует функция, которая всегда возвращает None.

Нужно добавить второе требование: если вернулся `None`, искомого элемента действительно нет в массиве.

Amazon уже использует Verus для проверки ключевых примитивов Nitro Isolation Engine, отвечающего за изоляцию виртуальных машин. Инструмент также позволяет доказывать свойства конкурентного кода и безопасность поддерживаемых конструкций unsafe.

Гарантии относятся к заданной спецификации и принятым допущениям: полнота самих требований остаётся ответственностью разработчика.

📖 https://www.amazon.science/blog/developing-provably-correct-rust-code-with-verus

#Rust #Разработка #FormalVerification