#полезное
😐 Компилируемый асинхронный ORM с динамическим SQL

Rbatis — это высокопроизводительный ORM-фреймворк для Rust, основанный на генерации кода во время компиляции. Он отлично сочетает в себе эффективность разработки, производительность и стабильность, выполняя роль как ORM, так и компилятора динамического SQL.
Гитхаб

👉Новости 👉База вопросов

#Собес #git
🤔 Что такое команды git reset -mixed и git merge - abort?

💬 Кратко:
git reset --mixed : отменяет изменения, которые были добавлены в индекс, но сохраняет изменения в рабочем каталоге.
git merge --abort : отменяет слияние, которое в данный момент находится в процессе, и возвращает репозиторий в состояние до начала слияния.

📌 Полный разбор + примеры использования — на платформе:
👉 Перейти к разбору

📣 Хочешь получать больше таких разборов?
Подпишись на наш главный канал

#полезное
😎 PyApp — новый способ упаковать Python-программы

PyApp написан на Rust и превращает Python-проекты в готовые .exe или бинарники, которые работают без отдельной установки Python.

В отличие от PyInstaller или Nuitka, это не библиотека, а отдельный инструмент:
- для каждого проекта нужна своя сборка;
- зато конфигурация максимально гибкая и можно тонко настроить процесс.
Репозиторий

👉Новости 👉База вопросов

🦀 Поговорим о том, что делает Rust уникальным языком.

Самое важное, о чем стоит помнить при написании кода на Rust - это система владения.
Это излюбленная тема для обсуждения на любом собеседовании Rust. 🗒

Что такое владение?🤔

Владение - система правил, которую проверяет компилятор Rust:
1. Каждое значение в программе имеет владельца - переменную, которая отвечает за это значение.
2. Владелец отвечает за выделенную память. Когда значение больше не нужно, он очистит память.
3. У каждого значения может быть только один владелец в любой момент времени.

Если эти правила нарушены, компилятор не позволит программе собраться.
Это предотвращает целый класс ошибок: утечки памяти, двойное освобождение, использование после освобождения.

Кто может быть владельцем?
- Переменная

let a = String::from("hello"); 

Переменная a - владелец строки.

- Параметр функции

fn greet(name: String) { }

Параметр name - владелец переданной строки

- Составные типы

let community_info = ("YeaHub", 2025, true);
// Кортеж community_info владеет всеми своими элементами

⚠️ Важно помнить!
Владение может переходить от одной переменной к другой. Это называется перемещение владения

Что нужно знать для собеседований?🤑

1. Умение находить ошибки владения в коде.
Например:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{}", s1);
}

Ошибка: использование `s1` после перемещения владения к `s2`.

2. Понимание правил и их преимуществ
Будьте готовы объяснить:
- Как владение предотвращает утечки памяти
- Почему это безопаснее, чем ручное управление памятью в C/C++
- Как это работает без сборщика мусора

Понимание владения - основа для написания безопасных программ и изучения других продвинутых концепций Rust. Освойте эти основы, и собеседования станут намного проще!

🚀 Пост Guru Rust: @PaulEdd

❗️ С чего начать? → Всё самое важное здесь

Guru Rust at YeaHub | ЭДУАРД ПАУЛЬ 🦀

Всем привет!

В 22 года я переехал в Сингапур, чтобы строить торговые системы в фондах. С тех пор я прошел путь от Junior Software Engineer в небольшом фонде до запуска миллиардного фонда с нуля. Все это на Rust и Python Django.

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

А ещё я Guru по Rust в YeaHub: отвечаю за качество контента во всей экосистеме.

📱 Мой блог в Telegram

📱 Мой YouTube канал

📱 Мой LinkedIn

А ещё подписывайтесь на другие каналы Экосистемы YeaHub

Проект YeaHub:

🚀 YeaHub | 🖥 GitHub | ✈️ Telegram

🎵 TikTok | 📹 YouTube | 👥 Чат

#Собес #rust
🤔 Можно ли обьявить несколько переменных в одной строке кода?

💬 Кратко:
Да, в Rust можно обьявить несколько переменных в одной строке с помощью деструктуризации. Например, из кортежа.

📌 Полный разбор + примеры использования — на платформе:
👉 Перейти к разбору

📣 Хочешь получать больше таких разборов?
Подпишись на наш главный канал

#полезное
🥄 Энергоэффективный транспайлер Python в Rust

Depyler — это транспайлер, который преобразует код Python в безопасный и производительный Rust, снижая потребление энергии на 75-85%. Он предлагает мощные инструменты для тестирования и верификации, обеспечивая высокое качество кода и поддержку CI/CD.

Основные моменты:
🔵 Эффективное преобразование Python в Rust
🔵 Поддержка многоуровневого тестирования и верификации
🔵 Интеграция с AI для улучшения качества кода
🔵 Поддержка формата Ruchy для функционального программирования
🔵 Высокие стандарты безопасности и производительности

GitHub: https://github.com/paiml/depyler

👉Новости 👉База вопросов

#Собес #rust
🤔 Что такое трейты в Rust?

💬 Кратко:
Трейты в Rust - это механизм определения поведения, который типы могут реализовывать. Это похоже на интерфейсы в других языках, но с уникальными особенностями.

📌 Полный разбор + примеры использования — на платформе:
👉 Перейти к разбору

📣 Хочешь получать больше таких разборов?
Подпишись на наш главный канал

🔥 Механизм заимствования - еще одна причина, по которой Rust код не падает в продакшене.


На прошлой неделе мы говорили о механизме владения. Сегодня разберем еще один важный механизм Rust - заимствование (borrowing). Этот механизм помогает писать безопасный и эффективный код 🛟

Что такое заимствование?❓

Заимствование позволяет передать доступ к значению без передачи владения. Вместо самого значения ты передаёшь ссылку (&T или &mut T).

Тем самым ты избегаешь лишнего копирования и сохраняешь единственный источник истины. А компилятор отлавливает ошибки работы с памятью ещё до запуска программы.

🧑‍🎓Существует два типа ссылок:

1. Неизменяемая ссылка &T
Позволяет только читать данные, но не изменять их.

fn len(s: &String) -> usize { 
  // s.push_str("!")  Здесь будет ошибка. Не можем изменить
  s.len() 
} 

2. Изменяемая ссылка &mut T
Позволяет и читать, и изменять данные.

fn shout(s: &mut String) { 
  s.push_str("!")   // Сработает. Можем изменять
  s.len() 
}    

⚠️На ссылки накладываются определенные правила. Эти правила проверяет часть компилятора Rust, которая называется borrow checker.

1. Много читателей ИЛИ один писатель.
Можно:
- Любое количество неизменяемых ссылок &T одновременно
- Ровно одну изменяемую ссылку &mut T

Нельзя:
- Одновременно иметь &T и &mut T

let mut name = String::from("Rust");

// много неизменяемых ссылок - работает
let a = &name;
let b = &name;
println!("{a} {b}");

// неизменяемая + изменяемая одновременно - ошибка
let c = &name;
let d = &mut name;

Это правило предотвращает гонки данных на уровне компиляции. Если один поток читает данные, а другой их изменяет - это может привести к непредсказуемому поведению.

2. Ссылки не могут пережить данные.

Ссылка должна быть действительна все время своего использования. Нельзя создать ссылку на данные, которые уже освобождены.

fn bad_ref() -> &String {
    let s = String::from("oops");
    &s // Строка s будет очищена после выхода из функции - не сработает
}

Это защищает от висячих указателей - одного из самых частых источников ошибок в C/C++.

На собеседованиях будь готов к этим вопросам 😎
- Какие правила проверяет borrow checker?
- Почему нельзя одновременно иметь &T и &mut T?
- Почему Rust не позволяет возвращать из функции ссылку на локальную переменную?

🚀 Пост Guru Rust: @PaulEdd

#Собес #rust
🤔 Что такое обобщения (generics) в Rust?

💬 Кратко:
Обобщения дают возможность создавать код, который работает с любым типом, указанным при его вызове. При этом можно задавать ограничения (трейты), которые тип должен соблюдать. Это делает код более гибким и повторно используемым.

📌 Полный разбор + примеры использования — на платформе:
👉 Перейти к разбору

📣 Хочешь получать больше таких разборов?
Подпишись на наш главный канал

#новости
🤯 Ларс Бергстром (Google) объявил об инвестициях в Rust в размере $350k:

🟠 $250k — в Rust Foundation на интероперабельность языка
🟠 $100k — в инфраструктуру Crater

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

👉Новости 👉База вопросов

#Собес #rust
🤔 Как использовать заимствование данных в структуре Rust?

💬 Кратко:
Чтобы структура могла заимствовать данные, используются аннотации времён жизни ('а ). Они гарантируют, что заимствованные данные существуют до тех пор, пока существует структура.

📌 Полный разбор + примеры использования — на платформе:
👉 Перейти к разбору

📣 Хочешь получать больше таких разборов?
Подпишись на наш главный канал

#новости
😬 Rust 1.90.0 вышел

Основные изменения:

LLD по умолчанию на x86_64-unknown-linux-gnu
Заметное ускорение линковки, особенно для больших проектов и incremental builds. Откат через -C linker-features=-lld.

cargo publish --workspace
Публикация всех crates в workspace одной командой с правильным порядком зависимостей.

x86_64-apple-darwin → Tier 2
Понижение из-за прекращения GitHub macOS x86_64 runners и планов Apple. Билды пока доступны через rustup.

Стабилизированные API:
• u{n}::checked_sub_signed, wrapping_sub_signed, saturating_sub_signed, overflowing_sub_signed
• Copy и Hash для IntErrorKind
• const контекст: <[T]>::reverse(), математические функции для float
• PartialEq между CStr/CString/Cow<CStr>

Изменения совместимости:
• Tier 3 musl targets линкуются динамически по умолчанию
• Небазовые extern "{abi}" формы теперь последовательно отвергаются

https://blog.rust-lang.org/2025/09/18/Rust-1.90.0

👉Новости 👉База вопросов

Знаете, что спрашивают на каждом втором собесе по Rust? Правильно, умные указатели 👆
Давайте разберёмся раз и навсегда 🗒

Что такое умные указатели? ❓

Умные указатели - это обёртки над обычными указателями, которые управляют памятью автоматически и предоставляют дополнительные гарантии безопасности.

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

Святая троица: Box, Rc, RefCell

Box<T> 📦
Самый базовый умный указатель. Аллоцирует данные в куче вместо стека.

Когда использовать:
- Размер типа неизвестен на этапе компиляции (рекурсивные структуры)
- Трейт-объекты (Box<dyn Trait>)

// Классика: связный список
enum List {
    Cons(i32, Box<List>),
    Nil,
}

Никакого оверхеда в рантайме. Просто аллокация в куче с одним владельцем.

Rc<T> - когда владельцев много
Reference Counting. Позволяет иметь несколько владельцев одних и тех же данных.
Rc ведёт подсчёт ссылок, и когда последний владелец исчезает - память освобождается.

Ограничения:
- Только для однопоточного кода (для многопоточки используется Arc)
- Данные неизменяемы (только shared reference)

let data = Rc::new(vec![1, 2, 3]);
let data2 = Rc::clone(&data); // Увеличили счётчик
// Оба указателя владеют данными

Идеально для графов, деревьев и других структур с разделяемым владением.

RefCell<T> - внутренняя изменяемость 🤔
Обычно в Rust компилятор проверяет правила заимствования на этапе компиляции: либо много иммутабельных ссылок &T, либо одна мутабельная &mut T.
Но иногда вам нужна гибкость: изменять данные через иммутабельную ссылку. RefCell переносит эти проверки с компиляции на время выполнения.

Как это работает:
- borrow() (получить иммутабельную ссылку)
- borrow_mut() (получить мутабельную ссылку)
- Правила те же: либо много borrow(), либо один borrow_mut()
- Если нарушите правила - получите панику в рантайме

let data = RefCell::new(5);

// Изменяем значение
*data.borrow_mut() += 1;

// Читаем значение
println!("{}", data.borrow()); // 6

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

Комбинация Rc<RefCell<T>> 🤝
А теперь самое интересное. Что если нужно и множественное владение, и внутренняя изменяемость?

Объединяем силы:

use std::rc::Rc;
use std::cell::RefCell;

let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
let clone1 = Rc::clone(&shared_data);
let clone2 = Rc::clone(&shared_data);

// Каждый клон может изменять данные
clone1.borrow_mut().push(4);
clone2.borrow_mut().push(5);

println!("{:?}", shared_data.borrow()); // [1, 2, 3, 4, 5]

⚠️ Помните: Это не бесплатно. Оверхед на подсчёт ссылок + проверки заимствования в рантайме.

Подведем итог
Умные указатели - это конкретные инструменты под конкретные задачи. Box для базовой работы с кучей, Rc для разделяемого владения, RefCell для внутренней изменяемости.

На собесе главное - не теряться и объяснить, когда какой указатель использовать и в чем их особенности💪

Успехов на собесах! 🚀

🚀 Пост Guru Rust: @PaulEdd

#полезное
🤯 smol — простой и эффективный рантайм асинхронности для Rust.

Де-факто на текущий момент является заменой async-std (который пока что press F).
Для того же Axum есть интеграции вроде smol-axum.

Так что если у вас уже кошмары от Send + 'static, — пробуйте smol :3

👉Новости 👉База вопросов

#полезное
🤯 smol — простой и эффективный рантайм асинхронности для Rust.

Де-факто на текущий момент является заменой async-std (который пока что press F).
Для того же Axum есть интеграции вроде smol-axum.

Так что если у вас уже кошмары от Send + 'static, — пробуйте smol :3

👉Новости 👉База вопросов