Rust

🔥CocoIndex — это современный ETL-фреймворк с открытым исходным кодом, предназначенный для подготовки данных к использованию в системах искусственного интеллекта. Он поддерживает пользовательскую логику трансформации и инкрементальные обновления, что делает его особенно полезным для задач индексации данных. 🔧 Основные возможности - Инкрементальная обработка данных: CocoIndex отслеживает изменения в исходных данных и логике трансформации, обновляя только изменённые части индекса, что снижает вычислительные затраты. - Поддержка пользовательской логики: Фреймворк позволяет интегрировать собственные функции обработки данных, обеспечивая гибкость при построении пайплайнов. - Модульная архитектура: Встроенные компоненты для чтения данных (локальные файлы, Google Drive), обработки (разбиение на чанки, генерация эмбеддингов) и сохранения результатов (PostgreSQL с pgvector, Qdrant). - Поддержка различных форматов данных: Поддержка текстовых документов, кода, PDF и структурированных данных, что делает CocoIndex универсальным инструментом. 🚀 Примеры использования - Семантический поиск: Индексация текстовых документов и кода с эмбеддингами для семантического поиска. - Извлечение знаний: Построение графов знаний из структурированных данных, извлечённых из документов. - Интеграция с LLM: Извлечение структурированной информации из неструктурированных данных с помощью больших языковых моделей. ## ⚙️ Быстрый старт 1. Установите библиотеку CocoIndex:

   pip install -U cocoindex
   

https://github.com/cocoindex-io/cocoindex 2. Настройте базу данных PostgreSQL с расширением pgvector. 3. Создайте файл quickstart.py и настройте пайплайн обработки данных. 4. Запустите пайплайн для обработки и индексации данных. 🟢 Github

🎥 Cap — open-source проект Cap, предлагающий функционал, аналогичный популярному сервису Loom. Инструмент уже сейчас позволяет записывать и редактировать видео прямо с рабочего стола, а в ближайших планах — запуск self-hosted версий для Vercel и Render. Гибридная архитектура проекта сочетает Rust для десктоп-приложения и Next.js для веб-версии, с единой системой компонентов на React. Разработчики активно привлекают сообщество к доработке, особенно в части создания инструкций по самостоятельному развертыванию. 🤖 GitHub @react_tg

🧑🏻‍💻Хотите научиться писать нейросети на одном из самых быстрых и безопасных языков программирования?  На открытом уроке 6 мая в 20:00 МСК мы научим вас создавать простейшую нейросеть с нуля, используя минимальные библиотеки. Вы не только познакомитесь с Rust, но и узнаете, как оптимизировать вычисления для работы с нейронными сетями. Вы сможете писать быстрые и эффективные нейросети на Rust — языке, который сегодня активно используется для решения высоконагруженных задач. 👉Присоединяйтесь к открытому уроку и получите скидку на программу обучения «Rust Developer. Basic»: https://otus.pw/AFkT/?erid=2W5zFFzMsCC  Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ". ИНН 9705100963.

🦀 Компания System76 представила седьмую альфа-версию своей революционной DE COSMIC — полностью написанной на Rust альтернативы GNOME. Новый выпуск примечателен не только встроенным Wayland-композитором, но и уникальными режимами работы с окнами: гибридной мозаичной компоновкой и браузерным группированием вкладок. Среди свежих изменений — улучшенная навигация между рабочими столами, экспериментальное дробное масштабирование для XWayland и тонкие настройки звука. При этом проект остаётся кроссплатформенным: пакеты уже доступны для Fedora, Arch, NixOS и даже нишевых дистрибутивов вроде Redox. 🔗 Ссылка - *клик* @rust_code

👣 Задача: "Безопасная многопоточная очередь с приоритетами в Rust" 📌 Условие: Реализуйте потокобезопасную структуру данных — очередь с приоритетами (`PriorityQueue`), которая: - Позволяет добавлять элементы с приоритетом через push(value: T, priority: u32). - Позволяет забирать элемент с наивысшим приоритетом через pop() -> Option<T>. - Гарантирует: - Безопасную работу из нескольких потоков без блокировок на долгие периоды (желательно через минимальные локи или атомарные операции). - Отдачу элементов в порядке убывания приоритета. - Высокую производительность при массовых операциях. Ограничения: - Можно использовать стандартные библиотеки Rust (`std::sync`, `std::collections`). - Нельзя использовать внешние библиотеки вроде tokio, crossbeam, rayon и др. - Структура должна быть универсальной (`Generic`), т.е. работать с любыми типами данных. --- ▪️ Подсказки: - Для внутреннего хранения можно использовать BinaryHeap из std::collections. - Для обеспечения многопоточности можно использовать Arc<Mutex<...>>. - Чтобы минимизировать блокировки, можно подумать о: - Разделении кучи на несколько шардов (`sharding`), - Использовании тонкой блокировки только на операции изменения состояния. --- ▪️ Что оценивается: - Умение правильно работать с владением (`ownership`) и заимствованием (`borrowing`) в многопоточной среде. - Аккуратное управление блокировками (`Mutex`, `RwLock`). - Оптимизация под высокую нагрузку (минимизация времени блокировки). - Чистота и читабельность кода. - Способность правильно обрабатывать ошибки (`PoisonError` при падении потока). --- ▪️ Разбор возможного решения: Идея архитектуры: - Основная структура — Arc<Mutex<BinaryHeap<...>>>. - Каждый push и pop блокирует мьютекс на короткое время (захватывает лок на минимальное изменение). - При push(value, priority): - Оборачиваем значение в структуру, которая реализует Ord так, чтобы приоритет был главным критерием сортировки. - При pop(): - Просто pop() из BinaryHeap. - Обработка ошибок: - При отравлении мьютекса (`PoisonError`) безопасно восстанавливать структуру или пробрасывать ошибку выше. --- ▪️ Мини-пример структуры:

use std::collections::BinaryHeap;
use std::sync::{Arc, Mutex};

#[derive(Eq, PartialEq)]
struct Item<T> {
    priority: u32,
    value: T,
}

impl<T> Ord for Item<T> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        other.priority.cmp(&self.priority) // обратный порядок для max-heap
    }
}

impl<T> PartialOrd for Item<T> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

pub struct PriorityQueue<T> {
    heap: Arc<Mutex<BinaryHeap<Item<T>>>>,
}

impl<T> PriorityQueue<T> {
    pub fn new() -> Self {
        PriorityQueue {
            heap: Arc::new(Mutex::new(BinaryHeap::new())),
        }
    }

    pub fn push(&self, value: T, priority: u32) {
        let mut heap = self.heap.lock().unwrap();
        heap.push(Item { priority, value });
    }

    pub fn pop(&self) -> Option<T> {
        let mut heap = self.heap.lock().unwrap();
        heap.pop().map(|item| item.value)
    }
}

--- ▪️ Возможные подводные камни: - ❗ Не обработать PoisonError — если поток паникует при блокировке, вся очередь будет "сломана". - ❗ Долгая блокировка внутри push или pop, особенно при больших объемах данных. - ❗ Возможная гонка состояний, если попытаться вручную обойти Mutex через небезопасный код (`unsafe`). --- ▪️ Дополнительные вопросы на собеседовании: - Как модифицировать структуру для поддержки тайм-аутов на pop() (если очередь пуста — ждать максимум N миллисекунд)? - Как бы вы реализовали "разделение очереди на несколько шардов" для снижения конкуренции потоков? - Как сделать неблокирующую версию через Atomic примитивы? --- @rust_code

⚡️Легкий способ получать свежие обновления и следить за трендами в разработке на вашем языке. Находите свой стек и подписывайтесь: Python: t.me/pythonl Linux: t.me/linuxacademiya Собеседования DS: t.me/machinelearning_interview Нерйросети t.me/ai_machinelearning_big_data C++ t.me/cpluspluc Docker: t.me/DevopsDocker Хакинг: t.me/linuxkalii Devops: t.me/DevOPSitsec Data Science: t.me/data_analysis_ml Javascript: t.me/javascriptv C#: t.me/csharp_ci Java: t.me/javatg Базы данных: t.me/sqlhub Python собеседования: t.me/python_job_interview Мобильная разработка: t.me/mobdevelop Golang: t.me/Golang_google React: t.me/react_tg Rust: t.me/rust_code ИИ: t.me/vistehno PHP: t.me/phpshka Android: t.me/android_its Frontend: t.me/front Big Data: t.me/bigdatai МАТЕМАТИКА: t.me/data_math Kubernets: t.me/kubernetc Разработка игр: https://t.me/gamedev Haskell: t.me/haskell_tg Физика: t.me/fizmat 💼 Папка с вакансиями: t.me/addlist/_zyy_jQ_QUsyM2Vi Папка Go разработчика: t.me/addlist/MUtJEeJSxeY2YTFi Папка Python разработчика: t.me/addlist/eEPya-HF6mkxMGIy Папка ML: https://t.me/addlist/2Ls-snqEeytkMDgy Папка FRONTEND: https://t.me/addlist/mzMMG3RPZhY2M2Iy 😆ИТ-Мемы: t.me/memes_prog 🇬🇧Английский: t.me/english_forprogrammers 🧠ИИ: t.me/vistehno 🎓954ГБ ОПЕНСОРС КУРСОВ: @courses 📕Ит-книги бесплатно: https://t.me/addlist/BkskQciUW_FhNjEy

👣 Tessa-Rust-T1-7B-Q8_0-GGUF — компактная 8-битная версия Rust-ориентированной модели Tessa-Rust-T1 в формате GGUF для llama.cpp. Создана для генерации и автодополнения кода на Rust с учётом лучших практик языка. Hugging Face 🚀 Обзор модели Архитектура: трансформер на базе Qwen2.5-Coder-7B-Instruct, дообученный на специализированном Rust-датаcете от Tesslate. Цель: автономная генерация идиоматичного Rust-кода — функции, структуры, трейты и модули; интеграция в AI-агенты для автоматизации backend-разработки и CLI-утилит. Hugging Face Размер: ~7.62 B параметров (после квантования Q8_0) → файл ~8.1 GB в формате GGUF. ⚙️ Ключевые особенности Глубокое Rust-мышление: поддерживает включение «think-тегов» в промпт для структурированного, многоэтапного рассуждения перед выдачей результата. Контекстно-чувствительная генерация: учитывает зависимости (crates), lifetimes и идиомы Rust, что снижает количество ошибок после генерации. Интеграция с агентами: модель готова для использования в автономных системах разработки, быстрой генерации backend-логики, тестов и CLI-утилит. https://huggingface.co/Tesslate/Tessa-Rust-T1-7B-Q8_0-GGUF @rust_code

🧠 Задача на Rust — для продвинутых разработчиков

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

fn main() {
    let a = Rc::new(RefCell::new(1));
    let b = a.clone();

    let c = {
        let mut val = b.borrow_mut();
        *val += 1;
        Rc::try_unwrap(b).ok().unwrap().into_inner()
    };

    println!("a: {}", a.borrow());
    println!("c: {}", c);
}

Что выведет код? A. a: 2 c: 2 B. a: 1 c: 2 C. Panic at runtime due to unwrap failure ✅ D. Compilation error due to ownership rules 📌 Ответ: Правильный ответ: C — Panic at runtime due to unwrap failure Почему: Мы создаем a как Rc<RefCell<i32>>, из него делаем b = a.clone() → теперь у Rc два владельца. Мы мутируем значение через b.borrow_mut(), увеличиваем его на 1. Затем пытаемся сделать Rc::try_unwrap(b). ⚠️ Rc::try_unwrap требует, чтобы Rc был единственным владельцем. Но у нас всё ещё есть a, то есть ссылка остаётся → unwrap не срабатывает и unwrap() вызывает паник на runtime. @rust_code

Возможность для backend разработчиков, Яндекс Практикум ищет экспертов! Яндекс Практикум — сервис онлайн-образования, где реально освоить востребованную цифровую профессию. Что делает программный эксперт: ✔️ формирует программу на основе требований рынка и лучших практик в отрасли, ✔️ курирует набор авторов, а затем их работу над обучающим контентом, ✔️ проводит фактчекинг, вносит корректировки — заботится о том, чтобы курс стал по-настоящему полезным и востребованным. От кандидата ожидают: Опыт в коммерческой backend разработке на Rust от 4 лет. Если вы имеете опыт в коммерческой backend разработке на Rust от 4 лет и вы точно знаете «как это должно работать» — добро пожаловать! Узнайте больше о курсе и роли программного эксперта здесь. Ждём ваших откликов, коллеги!

💡 Задача Linux: Пропажа файла после echo У вас есть файл /tmp/testfile с важным содержимым. Вы решили добавить в него строку "Hello, world!" с помощью команды:

echo "Hello, world!" > /tmp/testfile

Однако после выполнения этой команды вы замечаете, что всё старое содержимое исчезло и осталась только одна строка "Hello, world!". Вопрос: Почему это произошло? Как правильно было добавить строку, не потеряв содержимое? ✅ Решение и объяснение: 🔍 Что делает >? Символ > в Bash — это перезапись (truncate) файла. Когда вы пишете: ```bash echo "Hello, world!" > /tmp/testfile``` Это значит: Shell открывает файл на запись с обнулением (truncate). Весь предыдущий контент удаляется, прежде чем echo записывает новую строку. Вот подвох: даже если echo кажется безобидной командой, сам процесс перенаправления (>) выполняется до запуска echo. ✅ Как сделать правильно? Чтобы добавить строку, нужно использовать >>, а не >: ```bash echo "Hello, world!" >> /tmp/testfile ``` >> открывает файл в режиме append, не трогая текущее содержимое. ⚠️ Бонусный подвох (для профи) Выполните это: ```bash cat /tmp/testfile > /tmp/testfile ``` После этого файл станет пустым. Почему? ➡️ Ответ: cat читает из /tmp/testfile, но перенаправление > делает truncate сразу, еще до запуска cat. То есть: Файл обнуляется, Потом cat читает его… но он уже пустой! Чтобы избежать такого поведения, можно использовать временный файл: ```bash cat /tmp/testfile > /tmp/tmpfile && mv /tmp/tmpfile /tmp/testfile```

Смарт-контракты: Автоматизация и сравнение реализаций в Ethereum, TON и Solana Введение в смарт-контракты. Как смарт-контракты заменяют традиционные процессы? Расскажем на открытом уроке! Результаты урока:   - Понимание принципов работы смарт-контрактов и их роли в Web3.   - Навык чтения кода на Solidity, FunC и Rust.   - Умение выбирать блокчейн под конкретные задачи (стоимость, скорость, масштабируемость).   - Готовые примеры для дальнейшего изучения.   👉 Регистрация и подробности о курсе “Разработка децентрализованных приложений” https://otus.pw/ytvC/?erid=2W5zFHbg3ix Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ". ИНН 9705100963.

🔍 Вопрос: что выведет этот код на Rust?

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];

    v.push(4);

    println!("First: {}", first);
}

--- ✔️ Правильный ответ: Ошибка компиляции --- 🧠 Разбор: - let first = &v[0]; ➜ иммутабельная ссылка - v.push(4); ➜ мутабельная операция Rust запрещает это: нельзя иметь и иммутабельную ссылку, и мутабельную операцию одновременно! 📚 Rust выдаст ошибку компиляции: error[E0502]: cannot borrow v as mutable because it is also borrowed as immutable 💥 Подвох: в C++, Go или JS это бы сработало. Rust завернет такое на стадии компиляции ✅ @rust_code

А расскажите, есть ли у вас хобби? Может быть вы чем-то необычным занимаетесь в свободное время? Кажется, нашлось одно очень необычное хобби — изучение философии. Вы задумывались, что в современном мире люди не так часто вспоминают об этой дисциплине? Не только же с помощью психологии и подкастов в интернете можно познавать мир и себя. Ребята из Страдариума недавно запустили формат ридингов философских текстов. Это формат, где участники вместе с профессором Дианой Гаспарян строчка за строчкой читают и разбирают важнейшие философские тексты. У Страдариума невероятное сообщество учеников. В чате ридингов участники со всего мира не только обсуждают философские вопросы, но и находят комьюнити единомышленников. Говорят, что на ридингах Страдариума очень много программистов и работников IT-сферы. Если вы уже участвовали в подобных ридингах, расскажите, как вам? В мае начинают читать «Левиафан» Гоббса, 400-летний текст, который объясняет современный мир. Читают оригинальный текст по изданию 1991 года, прямо на онлайн-встречах, а затем обсуждают прочитанное. Найти новое хобби и записаться на ридинг по скидке можно прямо здесь.

Профили времени компиляции в Rust: зачем, как и когда Возможность выбирать профиль времени компиляции в Rust может повысить производительность, размер, удобство сопровождения, безопасность и переносимость вашего кода. Ниже приведены несколько аргументов в пользу того, почему вам следует использовать их при работе: https://betterprogramming.pub/compile-time-feature-flags-in-rust-why-how-when-129aada7d1b3 #rust @rust_code

🧑🏻‍💻Как эффективно управлять ошибками в коде и избегать багов? На открытом вебинаре 23 апреля в 20:00 МСК вы познакомитесь с мощной системой обработки ошибок в Rust и узнаете, почему этот подход считается одним из самых безопасных и надёжных. Вместе с экспертом вы освоите оператор «?» и работу с типами Result и Option. Вы получите практические навыки и сможете легко писать код без неожиданных сбоев и исключений, повысив надежность ваших приложений. 👉Регистрируйтесь на вебинар и получите специальную скидку на полный курс «Rust Developer. Basic»: https://otus.pw/mbYb/?erid=2W5zFJ8tVPE  Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ". ИНН 9705100963.

🦀 less_slow.rs — продвинутый Rust Это практическое руководство по написанию высокопроизводительного кода на Rust. Цель — увеличить скорость и глубже понять, как работает производительный Rust-код. 🚀 В проекте: • Сравнение async и sync подходов • Работа с кеш-френдли структурами и layout-оптимизациями • SIMD-ускорения и многопоточность • Разбор быстродействия через микробенчмарки • Примеры быстрой сериализации и парсинга (JSON, Arrow, Parquet) • Работа с полями struct, layout, memory alignment 📦 Используемые библиотеки: rayon, tokio, simd, polars, serde, simd-json, tracing, mimalloc 💡 Must-read, если ты хочешь не просто писать на Rust, а писать быстрый и эффективный Rust-код. 🔧 Еще в серии: 🧠 less_slow.cpp — C++ без тормозов: ассемблер, кеши, SIMD, аллокации, парсинг JSON и трюки с памятью 👉 github.com/ashvardanian/less_slow.cpp 🐍 less_slow.py — Python на максималках: pandas vs polars, Cython, PyO3, Numba, Parquet, zero-copy 📚 Все проекты сопровождаются примерами, микробенчмарками и понятными объяснениями. 📚 Репозиторий: github.com/ashvardanian/less_slow.rs @rust_code

❔ ЗАДАЧА : Что выведет этот код?

use std::mem;

struct Tracer(&'static str);

impl Tracer {
  fn new(name: &'static str) -> Tracer {
    println!("Creating {}", name);
    Tracer(name)
  }
}

impl Drop for Tracer {
  fn drop(&mut self) {
    println!("Dropping {}", self.0);
  }
}

struct Test {
  a: Tracer,
  b: Tracer,
}

fn main() {
  let mut t = Test {
    a: Tracer::new("A"),
    b: Tracer::new("B"),
  };

  mem::replace(&mut t.a, Tracer::new("X"));

  println!("Midpoint");
}

✅ ОТВЕТ: ```Creating A Creating B Creating X Dropping A Midpoint Dropping B Dropping X ``` 1. Создание: Tracer::new("A") → Creating A 2. mem::replace(...): Creating X Dropping A 3. println!("Midpoint"): Midpoint 4. Drop поля: B, затем X Этот код демонстрирует поведение Drop при замене полей структуры в Rust через std::mem::replace. @rust_code

⚙️Уже работаете с Rust, но хотите эффективно интегрировать его с другими языками? Или интересуетесь, как устроен процесс сборки и линковки в этом языке?  📆На открытом вебинаре 24 апреля в 20:00 мск мы подробно разберем, как собирать и линковать библиотеки в Rust, как использовать Rust-библиотеки в других языках, а также реализуем Си ABI (Application Binary Interface). Вы получите знания, которые помогут вам повысить производительность ваших проектов и интегрировать Rust в существующие решения. 👨‍💻Урок будет полезен всем, кто хочет углубить свои знания в Rust, повысить квалификацию и навыки работы с библиотеками и системами. Вы сможете применять полученные знания в реальных проектах. 👉Присоединяйтесь к открытому вебинару и получите скидку на большое обучение «Rust Developer. Professional»: https://otus.pw/PRWxe/?erid=2W5zFFz8mQt Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ". ИНН 9705100963.

👣 Вопрос: Какие строки и в каком порядке будут выведены на консоль при запуске этой программы? Приведите полный список выводимых сообщений.этого кода.

use std::mem;

struct Tracer(&'static str);

impl Drop for Tracer {
    fn drop(&mut self) {
        println!("Dropping {}", self.0);
    }
}

struct Container {
    tracer: Tracer,
}

fn make_tracer(name: &'static str) -> Tracer {
    println!("Creating {}", name);
    Tracer(name)
}

fn main() {
    let a = make_tracer("a");
    let b = make_tracer("b");
    {
        let temp = make_tracer("temp");
        println!("Inside block");
        // temp перемещается в c
        let c = temp;
        println!("Exiting block");
    } // <- здесь c (то есть «temp») умирает

    let mut container = Container {
        tracer: make_tracer("container1"),
    };
    // замена поля: старый контейнер1 будет сброшен
    container.tracer = make_tracer("container2");

    println!("Before dropping b explicitly");
    mem::drop(b);
    println!("End of main");
} // <- здесь умирают: container.tracer ("container2"), затем a

🔜 Ответ Вот что выведется на консоль, построчно: ```bash Creating a Creating b Creating temp Inside block Exiting block Dropping temp Creating container1 Creating container2 Dropping container1 Before dropping b explicitly Dropping b End of main Dropping container2 Dropping a``` Пояснение по шагам: let a = make_tracer("a"); Сначала вызывается make_tracer("a"), который печатает Creating a и возвращает Tracer("a"). let b = make_tracer("b"); Аналогично: Creating b Блок { … }: let temp = make_tracer("temp"); → Creating temp println!("Inside block"); → Inside block let c = temp; — просто перемещение, без нового вывода. println!("Exiting block"); → Exiting block В конце блока выходит из области видимости c (он же temp), срабатывает Drop → Dropping temp Инициализация container: rust let mut container = Container { tracer: make_tracer("container1"), }; → Creating container1 Перезапись поля tracer: ```rust container.tracer = make_tracer("container2"); Сначала вычисляется правая часть → Creating container2. Затем старый container.tracer (то есть container1) сбрасывается → Dropping container1.``` Явное удаление b: ```rust println!("Before dropping b explicitly"); mem::drop(b); → Before dropping b explicitly Затем drop(b) вызывает Drop для b → Dropping b``` Выход из main: ```rust println!("End of main"); → End of main``` После этого по правилам Rust объекты уничтожаются в порядке обратном созданию (LIFO): Сначала поле container.tracer (уже “container2”) → Dropping container2 Затем переменная a → Dropping a Таким образом и получается приведённая последовательность.

⚡️Хотите стать востребованным разработчиком и освоить один из самых перспективных языков программирования? Курс «Rust Developer. Basic» от OTUS создан для тех, кто уже знаком с программированием и хочет уверенно развиваться в современной разработке. Rust гарантирует безопасность, высокую производительность и востребован в веб-разработке, блокчейне, анализе данных и даже в создании встроенных систем. Вас ждут живые лекции от опытных экспертов, актуальные материалы и практика на реальных задачах. Вы научитесь писать безопасный и производительный код, создавать сложные многопоточные приложения, асинхронно работать с сетью и файловыми системами. 👉Оставьте заявку прямо сейчас и получите скидку на обучение: https://otus.pw/oMlC/?erid=2W5zFGjLASU  Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ". ИНН 9705100963.