Rust

Spinlock<T> с нуля на Rust.

Без Mutex. Только AtomicBool, UnsafeCell и RAII-guard.

За ~60 строк unsafe-кода разобрался с memory ordering и получил рабочую альтернативу мьютексу 🦀

Репозиторий
https://github.com/1rishuraj/low-latency-rust/tree/main/spinlock

🚨 В Rust появился безопасный способ брать указатели на поля без UB

Если работаешь с raw pointers, рано или поздно упираешься в проблему.

Нужно получить указатель на поле структуры. Но через обычную ссылку это может сломать правила borrow checker и привести к скрытым багам.

Особенно если речь про unsafe-код и тонкие места с aliasing.

Для этого в std есть addr_of! и addr_of_mut!.

Они позволяют взять указатель на поле напрямую, без создания временной ссылки. Это важно, потому что ты не нарушаешь stacked borrows и не создаёшь лишних промежуточных состояний.

По сути ты получаешь pointer projection без побочных эффектов.

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

Если пишешь unsafe в Rust, эти макросы стоит знать.

Rust и QUIC уже делают то, к чему ИИ только подбирается

Пока все спорят про агентов и автокодинг, в системной разработке quietly происходит очень важная вещь. Люди начинают нормально проверять сложные системы, а не надеяться на тесты.

Команда Адольфо Очагавии взяла QUIC-симулятор на базе quinn и попыталась убедиться, что он вообще работает корректно. Не на простых кейсах, а на произвольных сетях, включая сценарии уровня Земля–Марс.

Обычные тесты быстро закончились. Покрыть такие сценарии руками невозможно.

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

Ключевой момент в том, как это реализовано. Основную логику вообще не трогали. Проверка вынесена в отдельный слой. Сам verifier достаточно простой, его можно прочитать и понять без погружения в систему. Поверх этого появились golden-тесты, которые ловят регрессии.

Это выглядит как практическая версия того, о чём сейчас много говорят в контексте ИИ. Не просто генерировать код или тесты, а формализовать поведение системы и проверять его на уровне свойств.

Если переносить на AI-системы, то это ровно та же проблема. У нас есть агенты, пайплайны, куча состояний и внешних эффектов. И почти нет нормальной верификации. Всё держится на эвристиках и наблюдении.

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

Разбор здесь
https://ochagavia.nl/blog/a-real-world-case-of-property-based-verification/

🦀 Rust: заметки о написании WASM

Rust - один из лучших языков для разработки WebAssembly, но у него есть немало «острых углов».

В своей статье Brooklyn Zelenka делится практическими уроками из реальной разработки Rust-WASM и объясняет, какие проблемы чаще всего встречаются и как их обходить.

• Rust отлично подходит для компиляции в WebAssembly - безопасная память, хорошая интеграция с LLVM и высокая производительность.
• Однако связка Rust + wasm-bindgen может быть неудобной, и многие разработчики сталкиваются с неожиданными ограничениями и странностями API.
• В реальных проектах важно выработать собственные паттерны архитектуры и взаимодействия с хост-средой (обычно JavaScript).
• Многие проблемы WASM связаны не с Rust, а с самим экосистемным слоем: биндинги, сборка, взаимодействие с браузером и tooling.

Автор делится конкретными практическими приёмами, которые позволяют значительно упростить работу с Rust-WASM и избежать типичных ошибок.

Если вы работаете с WebAssembly или только планируете использовать Rust для WASM — статья обязательна к прочтению.

https://notes.brooklynzelenka.com/Blog/Notes-on-Writing-Wasm

🦀 Rust совет

На прошлой неделе мы показывали, как встраивать статические данные в код с помощью include_str!.

Сегодня - маленький, но очень полезный трюк.

⚙️ Запуск Cargo с конкретной версией toolchain

Иногда нужно проверить, будет ли ваш проект работать на следующей версии Rust (которая скоро станет stable).

Для этого не нужно менять глобальную версию Rust.

Достаточно просто указать toolchain прямо в команде:

cargo +beta test

Можно использовать и другие версии:

cargo +nightly build
cargo +stable check

💡 Это удобно для:
• тестирования совместимости с будущими релизами Rust
• проверки nightly-фич
• CI-пайплайнов
• отлова будущих breaking changes

Маленький трюк, но экономит часы дебага.

#rust #rustlang

🚀 Gemma 4 - новое семейство открытых моделей Google, которые можно запускать прямо на своём железе.

Модели заточены для сложного reasoning и агентных задач.

🔵 Доступны в четырёх вариантах:

• 31B Dense и 26B MoE
Топовый уровень производительности для сложных локальных задач: кастомные код-ассистенты, анализ научных данных и не только.

• E4B и E2B (Edge)
Оптимизированы для мобильных устройств — работают в реальном времени с текстом, изображениями и аудио.

🤖 Что можно делать:

• строить автономных ИИ-агентов
• планировать и выполнять многошаговые задачи
• взаимодействовать с приложениями
• искать данные и вызывать API

👉 Встроенная работа с инструментами (tool use) из коробки.

🧠 Контекст до 256K токенов:

• анализ целых кодовых баз
• длинные цепочки действий без потери контекста
• стабильная работа в сложных сценариях

⚡️ Начать можно уже сейчас через Google AI Studio

Также веса моделей доступны на Hugging Face, Kaggle и Ollama.

Лицензия: Apache 2.0.

Blog: https://blog.google/innovation-and-ai/technology/developers-tools/gemma-4/
GGUFs: https://huggingface.co/collections/unsloth/gemma-4
Guide: https://unsloth.ai/docs/models/gemma-4


@ai_machinelearning_big_data

#Gemma

🦀 Rust: Traits, Generics и Coherence

Система traits в Rust очень мощная, но правила coherence и orphan rules иногда делают разработку довольно болезненной.

Часто кажется, что язык просто не даёт реализовать trait там, где это логично.

В статье разбирают, как перестать бороться с этими ограничениями и вместо этого использовать более гибкий подход — context-generic реализации traits.

Это позволяет:

- писать более модульный код
- избегать конфликтов impl
- лучше работать с generics
- обходить ограничения orphan rules без хака

Хороший разбор для тех, кто уже пишет на Rust и хочет глубже понять архитектуру trait-системы.

https://contextgeneric.dev/blog/rustlab-2025-coherence/

#rust #rustlang

Парень переписал Claude Code на Python за ночь - и взорвал GitHub

Anthropic случайно засветили исходники своего ИИ-редактора Claude Code и они мгновенно разлетелись по сети.

Разработчик из Южной Кореи, Sigrid Jin, увидел это в 4 утра и не стал ждать.

За одну ночь он переписал ключевые части проекта на Python и выложил форк под названием Claw Code.

Результат:
- 50 000 звёзд всего за 2 часа
- вирусное распространение по всему GitHub
- полноценный агентный стек, сохранённый в новой реализации

Сейчас он уже работает над версией на Rust.

История про то, как скорость и скилл иногда решают больше, чем команды и бюджеты

https://github.com/instructkr/claw-code

🐍 полезные ресурсы 🚀Max

@machinelearning_interview

🦀 Хотите расти как Rust-разработчик ?

Перестаньте читать только статьи с абстракциями. Начните разбирать реальный код под нагрузкой.

Настоящий уровень приходит, когда вы работаете с системными проблемами:

- анализируете memory pressure
- находите lock contention
- оптимизируете структуры данных
- переходите к data-oriented design
- профилируете поведение в production-сценариях

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

Почему это важно:

В Rust рост происходит не через синтаксис или паттерны.
Рост происходит, когда вы начинаете думать в терминах:

- кэш-локальность
- аллокации
- layout данных
- contention
- пропускная способность

Главный переход в карьере Rust-разработчика:

От “как написать правильно” → к “как это работает под нагрузкой”.

Именно там начинается настоящая системная инженерия.

https://mnt.io/articles/about-memory-pressure-lock-contention-and-data-oriented-design/

🌟 Лучшие репозитории на GitHub для Claude Code, которые могут ускорить ваш следующий проект

Claude Mem
https://github.com/thedotmack/claude-mem

Память для Claude с сохранением контекста между задачами
UI UX Pro Max
https://github.com/nextlevelbuilder/ui-ux-pro-max-skill

Набор навыков для генерации продакшен-уровня интерфейсов
n8n-MCP
https://github.com/czlonkowski/n8n-mcp

Интеграция Claude с n8n через MCP для автоматизации workflow
Obsidian Skills
https://github.com/kepano/obsidian-skills

Навыки для работы с Obsidian и структурированием знаний
LightRAG
https://github.com/HKUDS/LightRAG

Лёгкая RAG-система для быстрого поиска и генерации
Everything Claude Code
https://github.com/affaan-m/everything-claude-code

Большая база знаний, паттернов и практик по Claude Code
Superpowers
https://github.com/obra/superpowers

Расширение возможностей Claude Code для сложных задач
Awesome Claude Code
https://github.com/hesreallyhim/awesome-claude-code

Кураторская подборка инструментов и ресурсов
GSD (Get Shit Done)
https://github.com/gsd-build/get-shit-done

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

🦀 Вышел Rust 1.94.1

Команда Rust выпустила новый патч-релиз - 1.94.1.

- это не новый функциональный релиз
- исправляет 3 ошибки, появившиеся в 1.94.0

Обновиться можно одной командой:

rustup update stable

Rust 1.94.0 (предыдущий релиз) принёс реальные изменения:
- новые API и улучшения стандартной библиотеки
- улучшения Cargo и конфигов
- расширение поддержки платформ (включая RISC-V)
- обновления Unicode и lint’ов

👉 А вот 1.94.1 - это чисто «починка после релиза»:
фиксит баги, которые всплыли сразу после выхода 1.94.0
Вывод:
- если ты уже на 1.94.0- обновляться обязательно
- если нет, просто ставь 1.94.1 и не думай

Классический Rust-подход:
сначала выкатывают фичи → потом быстро стабилизируют продакшен

https://blog.rust-lang.org/2026/03/26/1.94.1-release/

📘 На Stepik вышел курс — «Rust для профессионалов»

Уже уверенно пишете на Rust и готовы к новым вызовам? Этот курс — именно то, что нужно, чтобы вывести свои навыки на экспертный уровень.

🔍 Что вы получите:
• Глубокое понимание ключевых тем: generics, lifetimes, async, управление памятью
• Решение реальных инженерных задач: параллелизм, системное программирование, архитектура
• 150 интерактивных заданий с автопроверкой — всё в браузере, без установки, в удобное для вас время

🎓 Сертификат по завершении — добавьте его в резюме или профиль LinkedIn

🚀 Прокачайте Rust с пользой и удовольствием. Начните уже сегодня и получите скидку 25%, которая действительна в течение 48 часов

👉 Пройти курс на Stepik

🤖 Spacebot: AI для команд и сообществ

Spacebot — это мощный AI-агент, созданный для работы в многопользовательских средах, таких как Discord и Slack. Он обрабатывает множество запросов одновременно, не блокируя пользователей и не теряя контекст. Идеально подходит для активных сообществ и команд, обеспечивая эффективное взаимодействие и выполнение задач.

🚀 Основные моменты:
- Поддержка одновременных разговоров и задач.
- Интеграция с Discord, Slack и Telegram.
- Специализированные процессы для выполнения различных задач.
- Возможность развертывания через один клик или самостийно.
- Многофункциональные инструменты для работы с файлами и кодом.

📌 GitHub: https://github.com/spacedriveapp/spacebot

#rust

📌 Google разработала алгоритм квантования KV-кэша без потери точности.

Подразделение Research анонсировало TurboQuant, алгоритм векторного квантования, объединяющий 2 других метода - QJL и PolarQuant, который решает проблему увеличения KV-кэша при работе с длинным контекстом.

TurboQuant будет представлен на ICLR 2026, PolarQuant - на AISTATS 2026.

KV-кэш хранит промежуточные представления токенов, чтобы модель не пересчитывала их на каждом шаге генерации. С ростом контекста он превращается в узкое место по памяти.

Обычное векторное квантование сжимает эти данные, но вносит накладные расходы: для каждого блока нужно хранить константы квантования в полной точности, а это плюс 1–2 бита на элемент, что частично обесценивает само сжатие.

🟡TurboQuant - двухэтапный пайплайн.

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

На втором этапе подключается QJL, метод на основе преобразования Джонсона-Линденштраусса, который кодирует остаточную ошибку первого этапа всего одним знаковым битом и через встроенную оценочную функцию сочетает высокоточный запрос с низкоточными сжатыми данными, корректно вычисляя attention score.

Ни один из методов не требует обучения или дообучения и работает в режиме "без предварительного анализа набора данных".

Алгоритмы тестили на бенчмарках для длинного контекста: LongBench, Needle In A Haystack, ZeroSCROLLS, RULER и L-Eval с моделями Gemma и Mistral.

При квантовании KV-кэша до 3 бит TurboQuant показал нулевую деградацию точности на всех задачах: поиск «иголки в стоге сена», QA, генерация кода, суммаризация.

Объем KV-кэша при этом сократился в 6 раз. На H100 четырехбитный TurboQuant ускорил вычисление attention-логитов до 8 раз по сравнению с 32-битными ключами.

Область применения не ограничивается KV-кэшем. В экспериментах с высокоразмерным векторным поиском TurboQuant стабильно превзошел по recall методы PQ и RaBitQ несмотря на то, что те использовали крупные код-буки и подстройку под конкретный датасет.


🟡Статья
🟡Arxiv


@ai_machinelearning_big_data

🎯Полезные Мл-ресурсы 🚀 Max

#AI #ML #LLM #TurboQuant #Google