Pake

🤱🏻 Превратите любую веб-страницу в настольное приложение с помощью Rust.

Pake поддерживает Mac, Windows и Linux.

https://github.com/tw93/Pake

📲 Мы в MAX

👉 @rust_lib

🚀 Подборка полезных IT каналов в Max


Системное администрирование, DevOps 📌

https://max.ru/i_odmin Все для системного администратора
https://max.ru/bash_srv Bash Советы
https://max.ru/sysadminof Книги для админов, полезные материалы
https://max.ru/i_odmin_book Библиотека Системного Администратора
https://max.ru/i_devops DevOps: Пишем о Docker, Kubernetes и др.
https://max.ru/tipsysdmin Типичный Сисадмин
https://max.ru/channel_win_sysadmin Системный Администратор Windows
https://max.ru/channel_linux_admin Linux: Системный администратор
https://max.ru/channel_linuxmod Linux
https://max.ru/channel_i_linux Системный администратор
https://max.ru/channel_devopslib DevOps, SRE, Sysadmin
https://max.ru/channel_devops_star DevOps Star (Звезда Девопса)

Excel лайфхак 📌
https://t.me/Excel_lifehack Excel лайфхак

Английский с нуля 🇬🇧
https://max.ru/UchuEnglish

1C разработка 📌
https://max.ru/odin1c_rus Cтатьи, курсы, советы, шаблоны кода 1С
https://max.ru/channel_DevLab1C 1С:Предприятие 8

Программирование C++📌
https://max.ru/cpp_lib Библиотека C/C++ разработчика
https://max.ru/channel_cpp_geek C++ geek

Программирование Go📌
https://max.ru/golang_lib Библиотека Go (Golang) разработчика

Программирование React📌
https://max.ru/react_lib React

Программирование Rust📌
https://max.ru/channel_rust_lib

Программирование Python 📌
https://max.ru/python_of Python академия.
https://max.ru/BookPython Библиотека Python разработчика

Java разработка 📌
https://max.ru/bookjava Библиотека Java разработчика
https://max.ru/channel_java_geek Java Geek

GitHub Сообщество 📌
https://max.ru/githublib Интересное из GitHub

Базы данных (Data Base) 📌
https://max.ru/database_info Все про базы данных

Фронтенд разработка 📌
https://max.ru/frontend_1 Подборки для frontend разработчиков

Библиотеки 📌
https://max.ru/programmist_of Книги по программированию
https://max.ru/proglb Библиотека программиста
https://max.ru/bfbook Книги для программистов

Программирование 📌
https://max.ru/bookflow Лекции, видеоуроки, доклады с IT конференций
https://max.ru/itmozg Программисты, дизайнеры, новости из мира IT
https://max.ru/php_lib Библиотека PHP программиста 👨🏼‍💻👩‍💻

Шутки программистов 📌
https://max.ru/itumor Шутки программистов

Защита, взлом, безопасность 📌
https://max.ru/thehaking Канал о кибербезопасности
https://max.ru/xakkep_1 Хакер Free

Книги, статьи для дизайнеров 📌
https://max.ru/odesigners Статьи, книги для дизайнеров

Математика 📌
https://max.ru/Pomatematike Канал по математике
https://max.ru/phismat_1 Обучающие видео, книги по Физике и Математике

Вакансии в IT📌
https://max.ru/progjob
https://max.ru/channel_rabotait

Мир технологий 📌
https://max.ru/mir_teh Канал для любознательных

Городские📌
https://max.ru/piterspb_78 Свежие новости Санкт-Петербурга
https://max.ru/mockva_life Свежие новости Москвы
https://max.ru/piterspb Питер Новости: Санкт-Петербург / СПБ / ДТП
https://max.ru/channel_krasnodar_novosty Краснодар Новости
https://max.ru/channel_novosibirsk_novosti Новосибирск
https://max.ru/channel_samara_novosti Новости Самары
https://max.ru/channel_ekaterinburg_novosti Новости Екатеринбурга
https://max.ru/channel_kazan_novosti Новости Казани
https://max.ru/channel_omsk_novosti Новости Омска
https://max.ru/channel_moskva_24 Москва 24

👻 Сила пустоты: Zero-Sized Types (ZST)

Мы часто говорим про "zero-cost abstractions", но редко задумываемся, как это выглядит в памяти. ZST - это типы, которые занимают 0 байт. Компилятор знает о них, но в рантайме они исчезают.

Зачем это нужно, кроме экономии памяти? Для управления состоянием на уровне типов.

Представьте, что у вас есть стейт-машина. Вместо того чтобы хранить enum State и делать проверки в рантайме:

struct Socket<State> {
    inner: FileDesc,
    _marker: PhantomData<State>, // 0 байт
}

// ZST-маркеры
struct Connected;
struct Disconnected;

impl Socket<Disconnected> {
    fn connect(self) -> Socket<Connected> {
        // Логика подключения...
        // Трансформация типа без оверхеда в памяти
        unsafe { std::mem::transmute(self) } 
    }
}

impl Socket<Connected> {
    fn send(&self, data: &[u8]) { ... }
}

В чем профит?

1. Вы физически не можете вызвать метод send у Disconnected сокета. Код просто не скомпилируется.
2. В скомпилированном бинарнике нет никаких флагов состояния, if state == connected и прочего мусора. Метод просто вызывается.

Используйте систему типов, чтобы делать некорректные состояния невыразимыми (Make invalid states unrepresentable).

#rust #advanced #architecture #zst

📲 Мы в MAX

👉 @rust_lib

🛠 Cargo Expand: Загляни под капот макросам

Признайтесь, у вас бывало такое: навесили #[derive(Serialize)] или сложный макрос из sqlx, получили странную ошибку компиляции и сидите в ступоре?

Макросы это круто, но это черный ящик. Чтобы превратить его в прозрачный, поставьте cargo-expand.

cargo install cargo-expand

Запускаем:

cargo expand

И видите весь тот ужас (или красоту), который генерируется до того, как код попадет к компилятору. Это маст-хэв тулза при отладке async трейтов (привет, async-trait крейт) и понимании того, как работает "магия" фреймворков типа Actix или Rocket.

P.S. Только не пугайтесь, когда увидите, во что разворачивается println!.

#rust #tools #cargo #macro

📲 Мы в MAX

👉 @rust_lib

Владение, заимствование и ссылки в Rust: как компилятор делает ваш код безопасным

В Rust одна из самых непривычных для разработчиков тем — это ownership (владение) и borrowing (заимствование). Многие пытаются писать на Rust как на C++ или Python, натыкаются на компилятор, и правила borrow checker'а поначалу кажутся слишком строгими. На деле компилятор просто защищает вас от ошибок, которые в других языках приводят к падениям, утечкам памяти и гонкам данных. Но чтобы подружиться с borrow checker’ом, нужно понять логику, а не заучивать правила.

На открытом вебинаре 9 сентября в 20:00 разберём фундаментальные концепции Rust, которые делают код безопасным без сборщика мусора. Поговорим о том, почему на одни и те же данные можно взять сколько угодно иммутабельных ссылок (&), но мутабельная (&mut) может быть только одна — и не одновременно с иммутабельными. Разберём, чем перемещение (move) отличается от копирования (Copy/Clone). Обсудим, что такое время жизни (lifetimes): когда его нужно указывать явно, а когда компилятор выводит его сам по правилам элизии (lifetime elision). На практических примерах посмотрим, как разбирать типичные ошибки borrow checker'а, писать функции, безопасно работающие со ссылками и слайсами, и почему правила владения и заимствования предотвращают гонки данных, обращение к освобождённой памяти и двойное освобождение.

Вебинар не для тех, кто хочет просто «посмотреть синтаксис» без погружения в модель памяти. Подойдёт тем, кто уже знаком с основами языка — переменными, функциями, типами — и хочет наконец разобраться в модели памяти Rust, а также программистам с опытом в C++, Java или Python, которые хотят понять самую важную и необычную концепцию языка.

👉 Записаться: https://vk.cc/d1fh5M

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576

🐮 Cow: Ленивое клонирование

Все знают: лишний clone() - это грех. Но иногда нам нужно вернуть строку, которая может быть изменена, а может и нет.

Допустим, мы чистим инпут от спецсимволов.

1. Если спецсимволов нет - зачем аллоцировать новую строку? Можно вернуть ссылку на исходную.
2. Если есть - придется создать новую String.

Здесь на сцену выходит std::borrow::Cow (Clone on Write).

use std::borrow::Cow;

fn sanitize(input: &str) -> Cow<str> {
    if input.contains('!') {
        // Аллокация происходит только тут
        Cow::Owned(input.replace('!', "?")) 
    } else {
        // Тут мы просто возвращаем ссылку. Zero allocation.
        Cow::Borrowed(input) 
    }
}

Это мощнейший инструмент для хот-пасов (hot paths), где 90% данных не требуют изменений. Не ленитесь использовать Cow там, где можно избежать лишних аллокаций.

#rust #performance #std

📲 Мы в MAX

👉 @rust_lib

🤠 Трюк Индианы Джонса: std::mem::take

Типичная ситуация: у вас есть &mut self, и вы хотите забрать поле (например, String или Vec), что-то с ним сделать, и, возможно, вернуть обратно или сохранить измененную версию.

Компилятор бьет по рукам: нельзя просто так переместить (move) значение из-за мутабельной ссылки. Новички часто делают .clone(), чтобы успокоить borrow checker. Но это лишняя аллокация!

Решение: std::mem::take.

Оно забирает значение из ссылки, оставляя на его месте Default::default().

struct Buffer {
    data: Vec<u8>,
}

impl Buffer {
    fn process(&mut self) {
        // Мы "выкрадываем" вектор. 
        // В self.data теперь пустой Vec (без аллокаций).
        let raw_data = std::mem::take(&mut self.data);

        // Тяжелая обработка в другом потоке/функции, 
        // требующая владения (ownership)
        let processed = heavy_transform(raw_data);

        // Возвращаем результат
        self.data = processed;
    }
}

Это работает для всего, что реализует Default (Option, String, Vec). Для типов без Default есть std::mem::replace.

Это zero-cost, семантически верно и намного быстрее клонирования.

#rust #std #optimization #tips

📲 Мы в MAX

👉 @rust_lib

Почему Vec::new() это ловушка для производительности.

📈 Векторный рост: Избегаем реаллокаций

Мы часто пишем:

let mut vec = Vec::new();
for item in heavy_iter {
    vec.push(item);
}

Что происходит под капотом?

1. Вектор создается пустым (0 байт).

2. Первый push: аллокация на 4 элемента (условно).

3. Пятый push: места нет.
• Создается новый буфер (размером x2).
• Все старые элементы копируются туда.
• Старый буфер освобождается.
• Новый элемент записывается.



Это называется Reallocation. Это дорого. Если у вас 10 миллионов элементов, вы сделаете десятки реаллокаций и скопируете гигабайты данных просто так.

Решение: Если вы хотя бы примерно знаете размер - подскажите компилятору.

// Идеально, если знаем точно
let mut vec = Vec::with_capacity(exact_count);

// Или используем итераторы, они часто сами знают свой размер
let vec: Vec<_> = heavy_iter.collect(); 

collect() умный. Он смотрит на size_hint итератора и сразу аллоцирует нужный буфер (если итератор "честный").

Правило: Vec::new() - только если вы правда не знаете, будет ли там хоть один элемент. В остальных случаях - with_capacity.

#rust #performance #vectors

📲 Мы в MAX

👉 @rust_lib

Создание кроссплатформенного приложения с GUI на Rust: От идеи до реальности

Electron-приложения тяжелые, потребляют много памяти, а на Rust можно собрать легкое, быстрое и безопасное десктоп-приложение, которое будет работать на Windows, macOS и Linux. Tauri — это фреймворк, который позволяет использовать веб-технологии (HTML/CSS/JS) для интерфейса и мощь Rust для бэкенда. Но чтобы собрать работающий продукт, а не просто «посмотреть пример», нужно понимать, как связать фронтенд с бэкендом, работать с файловой системой, делать асинхронные вызовы и правильно собирать билды.

На открытом вебинаре 23 сентября в 20:00 разберём полный цикл создания кроссплатформенного GUI-приложения на Rust с использованием Tauri. Посмотрим, как организовать проект, как писать логику на Rust и подключать её к интерфейсу, как сохранять и загружать данные,безопасно работать с файловой системой и системными вызовами через новую систему разрешений (permissions) и возможностей (capabilities) в Tauri 2, а также выполнять долгие операции асинхронно. Отдельно обсудим сборку готового приложения, отладку с помощью встроенных инструментов Tauri и лучшие практики, которые помогут избежать типичных ошибок.

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

После вебинара вы сможете создавать функциональные десктоп-приложения на Rust с красивым интерфейсом, разрабатывать логику на бэкенде и связывать её с UI, грамотно настраивать политики безопасности доступа к ресурсам ОС, а также собирать и распространять готовое приложение пользователям.

👉 Записаться: https://vk.cc/d1KKyw

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576

⚡️ Забудь про RefCell для примитивов

Вам нужно изменить поле внутри неизменяемой структуры (&self).
Рука тянется к RefCell? Стоп.

RefCell имеет оверхед:

1. Хранит счетчик заимствований (borrow count).
2. В рантайме проверяет правила (может паниковать!).

Если ваш тип реализует Copy (числа, bool, маленькие структуры) - используйте Cell.

В чем магия Cell?
У него нет никакого рантайм-оверхеда. Вообще. Он не проверяет заимствования.
Он работает так: "Я даю тебе копию значения" (get) или "Я заменяю значение целиком" (set). Вы не можете получить ссылку (&) на содержимое Cell, поэтому правила Rust не нарушаются.

use std::cell::Cell;

struct Metric {
    count: Cell<u64>, // Zero overhead
}

impl Metric {
    fn inc(&self) {
        // Мы меняем значение по неизменяемой ссылке &self
        let current = self.count.get();
        self.count.set(current + 1);
    }
}

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

#rust #std #optimization #interior_mutability

📲 Мы в MAX

👉 @rust_lib

🗝 Турбируем HashMap

Стандартный std::collections::HashMap в Rust использует алгоритм хэширования SipHash.
Почему? Он криптографически стоек к HashDoS атакам (когда злоумышленник подбирает ключи так, чтобы все они попадали в один бакет, превращая мапу в связный список и убивая CPU).

Но SipHash медленный. Если вы решаете алгоритмические задачи, пишете геймдев или у вас внутренний сервис без внешнего доступа - вам не нужна защита от DoS. Вам нужна скорость.

Используйте сторонние хэшеры. Самые популярные:

1. FxHash (rustc-hash) - используется внутри самого компилятора Rust и Firefox. Молниеносно быстрый для коротких ключей (integers).
2. AHash - современный, быстрый, использует аппаратные инструкции AES.

Пример с крейтом rustc-hash:

use rustc_hash::FxHashMap;

// Это та же HashMap, но с быстрым хэшером
let mut map: FxHashMap<u32, &str> = FxHashMap::default();

Прирост производительности на операциях вставки/поиска может достигать 2x-3x на простых ключах.

Итог:

• Backend наружу? Оставляем дефолтный SipHash.
• GameDev / Algo / Internal Data Processing? Ставим FxHash или AHash.

#rust #performance #hashmap #external_crates

📲 Мы в MAX

👉 @rust_lib

🔮 Ты не пройдешь: Магия предсказателя ветвлений

Вы когда-нибудь задумывались, почему обработка отсортированного массива чисел происходит в разы быстрее, чем случайного, даже если логика одна и та же?

Всё дело в конвейере (pipeline). Процессор выполняет инструкции не по одной, а потоком: пока одна декодируется, другая уже выполняется. Но тут появляется if (ветвление).

Процессор не знает, пойдет код в then или в else, пока не вычислит условие. Но ждать он не может - конвейер встанет. Поэтому он угадывает.

• Угадал? Выполнение продолжается без задержек.

• Не угадал? Происходит Pipeline Flush. Процессор выбрасывает все инструкции, которые успел "набрать" по неверному пути, и начинает заново с правильного адреса. Это огромная потеря тактов (10-20 циклов CPU).

Пример на Rust:

// Если data отсортирован: T T T T T F F F F F (паттерн ясен)
// Если data случайный: T F T T F F T F (паттерн непредсказуем)
for &x in &data {
    if x > 128 {
        sum += x;
    }
}

На случайных данных BPU ошибается в 50% случаев. На сортированных почти никогда.

Вывод: Чем предсказуемее ваши данные, тем быстрее работает ваш код. Иногда data.sort() перед обработкой окупается с лихвой.

#rust #cpu #lowlevel #performance #branch_prediction

📲 Мы в MAX

👉 @rust_lib

🥶 Холодный расчет: #[cold] и likely

Компилятор Rust (LLVM) очень умный, но иногда мы знаем о поведении программы больше, чем он. Мы можем подсказать ему, какая ветка кода будет выполняться чаще.

1. Атрибут #[cold]
Идеально для обработки ошибок. Вы говорите компилятору: "Сюда мы будем заходить крайне редко".
Компилятор сдвинет этот код в "дальний угол" бинарника, чтобы "горячий" путь шел линейно в памяти (это улучшает работу кэша инструкций и BPU).

#[cold] // <-- Подсказка
fn handle_fatal_error() {
    // Логирование, паника, сложная логика...
}

fn process(data: &str) {
    if let Err(_) = parse(data) {
        handle_fatal_error(); // Компилятор знает, что это маловероятно
        return;
    }
    // Happy path идет дальше линейно
}

2. likely / unlikely (Nightly / Crates)
В стабильном Rust пока нет std::intrinsics::likely, но есть крейт likely или хаки. Это прямая инструкция процессору через LLVM.

// С крейтом `likely`
if likely(x > 0) {
    // Оптимизатор будет строить код так, 
    // будто это условие почти всегда true
}

Используйте #[cold] для ошибок и граничных случаев. Это стабильно, бесплатно и делает код чище.

#rust #optimization #llvm #hints

📲 Мы в MAX

👉 @rust_lib