Вот как вы можете использовать ИИ, чтобы научить вас ржавчину - 15 проектов, чтобы произвести впечатление на рекрутеров Maang

Зачем один монитор, когда у вас может быть пять? (У меня три ...)

Ржавчина сегодня король - и ИИ может помочь вам узнать это

Это не просто сложно, но и подавлять давнее доминирование C и C ++.

Это достигает этого, предоставляя:

Опрос разработчиков Stack Overflow в течение восьми лет подряд увенчал ржавчину «самый любимый» язык программирования.

Эта беспрецедентная популярность проистекает из того факта, что разработчики, которые преодолевают его первоначальную кривую обучения.

Эти немногие счастливчики находят особенности и гарантии ржавчины как выгодных, так и продуктивных.

Убийственные особенности ржавчины для программирования систем

Ржавчина взяла на себя всю индустрию программирования систем.

Вот почему.

Безопасность памяти без коллекционера мусора:

• Компилятор Rust Статически гарантирует безопасность памяти
• Это устраняет целые категории общих ошибок, таких как:
  • Null Pointer Dereferences
  • буферные переполнения
  • Висящие указатели.

// This code, which would cause a dangling pointer in C++, won't even compile in Rust.
fn get_dangling_reference() -> &String {
    let s = String::from("hello");
    &s // Error: `s` does not live long enough
}

Абстракции с нулевыми ценами:

• Ржавчина позволяет писать высокоуровневый, выразительный код, используя:
• Абстракции, такие как:
  • Iterators
  • Закрытие
  • асинхрон/жду
  • Карта/уменьшить шаблоны
  • Первоклассные функции:
• Без наказания штрафы за выполнение выполнения.

// This high-level iterator...
let numbers = vec![1, 2, 3, 4, 5];
let sum_of_squares: i32 = numbers.iter().map(|&x| x * x).sum();

// ...compiles down to machine code as efficient as a manual C-style loop.

Бесстрашная параллелизм:

• Та же самая система владения и типа, которая гарантирует безопасность памяти:

• Предотвращает гонки данных во время компиляции!

• Это значительно проще и безопаснее писать одновременные, многопоточные программы.

use std::thread;

fn main() {
    let mut data = vec![1, 2, 3];

    // This attempt to use the same mutable data from two threads is a compile-time error.
    // Rust forces you to use safe concurrency primitives like Arc and Mutex.
    // thread::spawn(|| { data.push(4); }); // Error: closure may outlive current function
    // thread::spawn(|| { data.push(5); }); // Error
}

Современный инструмент с грузом:

• Груз - это интегрированная система сборки Rust и менеджер пакетов

• It is praised for its simplicity and power

• Грузовые ручки:

  • Создание проекта
  • Управление зависимостью
  • здание
  • тестирование

• И гораздо больше с простыми командами.

# Create a new project
cargo new my_awesome_project

# Add a dependency by adding one line to Cargo.toml
# [dependencies]
# serde = "1.0"

# Build and run
cargo run

Печально известный СтеКривая обучения EP

• Основным препятствием для начинающих является компилятор Rust.

• This strictness means code that might run (and later crash) in other languages will not even compile in Rust until it meets the safety rules.

Правила проверки заимствований и владения

• Управление памятью Rust регулируется набором правил, которые компилятор проверяет во время компиляции.
• Эта система называется владением.

Правило 1: Каждое значение в ржавчине имеет одного владельца.

fn main() {
    // s is the owner of the String data "hello" allocated on the heap.
    let s = String::from("hello");
}

Правило 2: Там может быть только один владелец за раз.

• Когда значение присваивается другой переменной, право собственностивзолнованныйПолем

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Ownership of the String data is moved from s1 to s2.

    // The line below will cause a compile-time error because s1 is no longer a valid owner.
    // println!("s1 is: {}", s1); // Error: value borrowed here after move
}

Правило 3: Когда владелец выходит из сферы действия, значение отбрасывается.

• Ржавчина автоматически вызывает специальную функцию падения, чтобы освободить память.

fn main() {
    {
        let s = String::from("I live only within these curly braces");
    } // `s` goes out of scope here, and the memory is automatically freed.
}

To access data without taking ownership, you can заниматьэто.

Это делается путем создания ссылки.

Неизменные заимствования:

Вы можете иметь несколько неизменных ссылок (& t) к значению одновременно.

Это доступ только для чтения.

fn main() {
    let s1 = String::from("hello");

    let r1 = &s1; // Immutable borrow
    let r2 = &s1; // Another immutable borrow is fine

    println!("r1 = {}, r2 = {}", r1, r2); // This works perfectly.
}

Изменяемые заимствования:

Вы можете иметь только одну измененную ссылку (& mut t) к значению в определенной области.

Это предотвращаетданные данныхПолем (Google это, чтобы узнать больше)

fn main() {
    let mut s1 = String::from("hello");

    let r1 = &mut s1; // One mutable borrow
    // let r2 = &mut s1; // Error: cannot borrow `s1` as mutable more than once at a time

    r1.push_str(", world!");
    println!("{}", r1);
}

• У вас не может быть измененных заимствований, в то время как существуют неизменные заимствования.

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // immutable borrow
    let r2 = &mut s; // Error: cannot borrow `s` as mutable because it is also borrowed as immutable

    // println!("{}, {}", r1, r2);
}

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

Это крутой подъем каждого ученика.

Этот процесс включает в себя обучение структуре кода таким образом, чтобы удовлетворить гарантии безопасности Руста.

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

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

Другие тайные правила, которые затрудняют ржавчину

Жизнь:

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

• Во многих случаях компилятор может вывести время жизни, но иногда вы должны явно аннотировать их, используя синтаксис апострофы, например, '.

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

// We must explicitly tell the compiler that the returned reference (`&'a str`)
// lives at least as long as the shortest-lived input reference (`'a`).
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

Черты:

• Черта сообщает компилятору ржавчины о функциональности, которую должен предоставить тип.

• Это похоже на интерфейс на таких языках, как Java или C#.

• Это обеспечивает невероятно мощные возможности полиморфизма.

// Define a trait `Summary`
pub trait Summary {
    fn summarize(&self) -> String;
}

// Implement the trait for the `Tweet` struct
pub struct Tweet {
    pub username: String,
    pub content: String,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

Дженерики:

• Дженерики являются абстрактными автономными заведениями для конкретных типов.

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

// This function can take any type `T` that implements the `PartialOrd` and `Copy` traits.
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

Как ИИ может выступать в качестве очень надежного бесплатного наставника

Чтобы изучить ржавчину, вы можете говорить на английском языке с ИИ.

Например:

Это так просто, что дети могут это сделать и делают это!

Помощник ИИ, такой как Google Gemini в Google AI Studio, может действовать как:

1. Неутомимый
2. Интерактивный
3. Персонализированный
4. Регулируемый
5. Custmizable
6. Мощный
7. Нежный
8. Пациент
9. Добрый

И бесконечно энергичный репетитор для обучения сложным концепциям Rust.

Вы можете использовать следующую дорожную карту для изучения ржавчины:

https://roadmap.sh/rust?embedable=true

Вы можете использовать AI (LLMS), чтобы понять каждую концепцию, которую вы не понимаете.

Я поместил их в порядке моего использования, и со многими другими (Mistral, Qwen, Kimi) генеративными моделями ИИ, доступными бесплатно:

Вам не нужно платить за подписку, чтобы изучить ржавчину с помощью ИИ.

Как. Потрясающий. Является. Что!

Например

// User pastes this code and the resulting error:
fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    v.push(4); // Error: cannot borrow `v` as mutable...
    println!("The first element is: {}", first);
}

ИИ объяснение:

Обмен экранами

Практически ни один из других инструментов искусственного интеллекта, который я упомянул, не имеет этой функции, так же хорошо разработанной, как Google Gemini, как дату написания этой статьи.

Потенциальная возможность обмена экранами Gemini может стать спасением для отладки ржавчины, особенно в производстве.

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

Обмен экранами не является платной функцией.

Вы можете получить доступ к нему бесплатно сGoogle AI Studio.

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

АИ-сгенерированный код

И, конечно же, как только вы узнаете больше о Rust, вы можете начать просить Близнецов создать для вас код.

Например

Пользовательская подсказка:«Создайте базовый веб -сервер в Rust, используя структуру Axum, которая отвечает:« Привет, мир! » в корневом URL. "

use axum::{routing::get, Router};
use std::net::SocketAddr;

async fn root() -> &'static str {
    "Hello, World!"
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(root));
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Преимущества Google Gemini AI как учителя

• Опыт других образовательных инструментов ИИ, таких как репетитор Хана Академии, показывают, что ИИ может:
  • Обеспечить управляемая практика
  • Ответьте глупым повторным сомнениям
  • Будьте адаптированы на свой уровень
  • Обеспечить подсказки
  • Быть доступным в любое время дня
  • Исправьте себя, когда проверяют факт с компилятором.
  • Добавьте поддержку
  • Обеспечить многодоменные знания, такие как AWS, GCP, Azure и другие
  • Обмен экранами может предвидеть необходимую коррекцию
  • Предоставьте консультации по достойному отключениям на месте.

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

Пример: интерфейс посторонней функции (FFI)

// Opaque C struct
struct CComplexObject;

// Functions imported from a C library
extern "C" {
    fn c_complex_new() -> *mut CComplexObject;
    fn c_complex_process(obj: *mut CComplexObject, value: i32);
    fn c_complex_destroy(obj: *mut CComplexObject);
}

// Idiomatic and safe Rust wrapper
struct SafeWrapper {
    obj: *mut CComplexObject,
}

impl SafeWrapper {
    fn new() -> Self {
        Self { obj: unsafe { c_complex_new() } }
    }

    fn process(&mut self, value: i32) {
        unsafe { c_complex_process(self.obj, value) };
    }
}

impl Drop for SafeWrapper {
    fn drop(&mut self) {
        unsafe { c_complex_destroy(self.obj) };
    }
}

ИИ объяснение:

Смягчение риска галлюцинаций

Но у нас есть преимущество: компилятор ржавчины!

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

Как проверить наличие галлюцинаций ИИ:

Other AI and Some Traditional Tools to Master Rust

Several AI and non-AI tools help to assist your Rust learning journey.

RustCoder

A free and open-source tool called RustCoder has been effectively used as a backend for modern Vibe coding tools like Cursor.

Он тщательно обучен коду ржавчины и может решать большинство проблем ржавчины, которые существуют сегодня.

Это открыто для всех и бесплатно.

Более подробная информация доступна ниже:

https://www.cncf.io/blog/2025/01/10/rustcoder-ai-assisted-rust-learning/?embedable=true

Онлайн -документация языка программирования ржавчины

Окончательное руководство обо всем о ржавчине.

Это классический ресурс, который не должен быть опущен.

https://doc.rust-lang.org/stable/book/?embedable=true

The Companion Exercises - Rustlings

Эти упражнения помогут вам систематически работать через онлайн -книгу Rust.

Если вы застряли, вы можете попросить ИИ для ответа!

https://rustlings.rust-lang.org/?embedable=true

Огромная ценность обучения ржавчине сегодня

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

Возможно, единственным языком в большем спросе является Python для автоматизации и агентов.

И ржавчина тоже догоняет в агентском пространстве!

Компании поворачиваются к ржавчине

• Microsoft:

  Активно переписывая компоненты ядра, такие как части ядра и API Win32, в Rust, чтобы снизить уязвимости безопасности памяти.

• Amazon Web Services (AWS):

  Построенный Firecracker, технология виртуализации, питание AWS Lambda и Fargate, полностью в Rust для безопасности и скорости. Они также используют его в частях S3 и Cloudfront.

• Google:

  Поддерживает ржавчину для разработки ОС Android и финансирует усилия по написанию новых модулей ядра Linux в Rust, особенно для водителей, для повышения безопасности ядра.

• Мета (Facebook):

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

• Яблоко:

  Apple инвестирует в Rust для робототехники, кода AR/VR и обработки нейронных двигателей. Наем для ржавчины на рекордно высоком уровне.

• Cloudflare:

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

• Раздор:

  Заменил сервис GO на Rust для решения шипов задержки в сервисе в реальном времени, демонстрируя превосходную производительность Rust для приложений с низкой задержкой.

Даже сегодня присоединяются гораздо больше компаний.

Критический фундаментальный шаг: реальные проекты

Вы не можете выучить язык, просто изучая его особенности.

Вам нужно испачкать руки настоящими проектами.

Этот проект GitHub ниже является отличным руководством для системных деталей программирования:

https://github.com/codecrafters-io/build-your-own-x?embedable=true

Есть так много вариантов!

15 Идеи проекта, которые могут привести вас в Маанг

Искусственный интеллект и машинное обучение

1. Федеративная структура обучения «нулевой достопримечательности»:

   • Реализуйте безопасную многопартийную структуру вычислений (MPC) в Rust для моделей обучения машинного обучения на децентрализованных данных.

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

2. Высокопроизводительный двигатель вывода для Edge AI:

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

   • Создайте время выполнения, которое значительно быстрее и более эффективно память, чем существующие решения, такие как Tensorflow Lite, позволяя сложным моделям ИИ работать на более широком диапазоне устройств и датчиков IoT.

3. Подлежащий проверке и воспроизводимый инструмент трубопровода ML:

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

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

   Блокчейн и Web3

4. Масштабируемая и совместимая реализация шарнинга блокчейна:

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

   • Создайте решение на основе ржавчины, которое является более эффективным и безопасным, чем существующие подходы к шардингу, что является основным препятствием для принятия основного блокчейна.

5. Смарт-контрактная платформа, сохраняющая конфиденциальность с доказательствами с нулевым знанием:

   • Создайте платформу блокчейна, которая позволяет заключать конфиденциальные интеллектуальные контракты, используя доказательства с нулевым знанием.

   • Создайте платформу для разработчиков в Rust, которая упрощает создание децентрализованных приложений (DAPPS), сохраняющих конфиденциальность (DAPPS), что является значительным пробелом в текущей экосистеме Web3.

6. Высокопроизводительный протокол связи поперечной цепью:

   • Разработать безопасный и эффективный протокол для совместимости между различными сетями блокчейнов.
   • Создайте решение на основе ржавчины, которое значительно быстрее и надежнее, чем существующие протоколы моста, которые часто являются узкими местами и рисками безопасности в пространстве Web3.

Генеративный ИИ и Трансформеры

7. Оптимизированный сервер вывода для больших языковых моделей (LLMS):

   • Создайте высоко оптимизированную структуру обслуживания для LLMS, которая минимизирует задержку и максимизирует пропускную способность.
   • Используйте параллелизм Rust и управление низким уровнем для создания сервера, который может обрабатывать масштабные выводы для генеративных приложений искусственного интеллекта, что является основной оперативной задачей для компаний, развертывающих эти модели.

8. Эффективная память архитектура трансформатора:

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

   • Обратите внимание на квадратичную сложность механизма самоприщепления, основное узкое место для работы с длинными последовательностями, что делает большие модели более доступными и экономически эффективными для обучения и развертывания

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

   • Разработайте структуру, которая фокусируется на безопасной точной настройке и развертывании генеративных моделей ИИ, решая такие проблемы, как конфиденциальность данных и атаки инверсии модели.
   • Предоставьте решение на основе ржавчины, которое интегрирует технологии повышения конфиденциальности непосредственно в жизненный цикл MLOPS для генеративного ИИ.

Квантовые вычисления

10. Высокопроизводительный симулятор квантовой цепи:

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

    • Используйте производительность Rust и управление памятью, чтобы раздвинуть границы классического моделирования квантовых компьютеров, критический инструмент для разработки квантовых алгоритмов.

11. Библиотека криптографии после кванта для безопасного общения:

    • Разработайте всеобъемлющую и простую в использовании библиотеку для алгоритмов криптографии посткванта.

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

12. Компилятор для высокоуровневого квантового языка программирования:
    • Создайте компилятор, который переводит высокоуровневый, выразительный язык квантового программирования в код квантовой сборки низкого уровня.
    • Создайте этот компилятор в Rust, чтобы обеспечить его правильность и производительность, позволяя разработчикам более легко и с большей уверенностью писать сложные квантовые алгоритмы.

DevOps и Mlops

13. Процветающий, кроссплатформенный инструмент сборки и развертывания:

    • Разработайте инструмент сборки и развертывания следующего поколения в Rust, который значительно быстрее и эффективнее, чем текущие решения, такие как Jenkins или Travis CI.
    • Создайте инструмент с минимальной площадью и первоклассной поддержкой для контейнеризации и современных облачных средах, учитывая необходимость более быстрых и надежных трубопроводов CI/CD.

14. Безопасная и наблюдаемая структура микросервисов:

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

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

15. Платформа MLOPS для моделей на основе ржавчины:

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

Это так сложно! Я новичок! (ИИ на помощь)

Для новичка, борьба с крупным сложным проектом - это марафон, а не спринт.

Такие помощники искусственного интеллекта, как Google AI Studio, могут выступать в качестве личного репетитора и партнера по кодированию.

Ваш логический процесс мышления (детские шаги)

1. Понять основную проблему:

   • Перед написанием одной строки кода используйте AI, чтобы объяснить домен проекта.

   • Спросите это: «Объясните федеративное обучение в простых терминах».

   • Или «Что такое трилемма масштабируемости блокчейна?»

2. Сломать это:

   • Спросите своего помощника искусственного интеллекта: «Я хочу построить квантовый симулятор схемы в Rust. Какие основные компоненты мне нужно построить

   • Разбейте это на более мелкие, управляемые задачи ».

3. Генерировать скелет:

   • Для небольшой задачи, такой как «Создать структуру для блока блокчейна», попросите ИИ генерировать начальный код ржавчины.

   • Это дает вам отправную точку для строительства.

4. Код, тест, уточнить, повторить:

   • Напишите свой код для одной маленькой части.

   • Если вы нажмите на ошибку, вставьте код и сообщение об ошибке в помощника ИИ и попросите отладки помощи.

5. Сразу же публично:

   • Создайте проект на платформе, такой как GitHub с первого дня.

   • Это сигнализирует о вашем намерении сотрудничать и облегчает присоединение других.

6. Документируйте свое путешествие:
   • Используйте ИИ, чтобы помочь вам написать четкий файл readme.md, объясняющий цель вашего проекта и то, как другие могут помочь.
   • Хорошее описание проекта имеет решающее значение для привлечения сотрудников.

Как помогают помощники ИИ

• Концепция объяснения: Попросите простые объяснения сложных тем, таких как «Что такое доказательство нулевого знания?»

• Генерация кода: Сгенерировать код, функции и структуры данных шаблон, чтобы начать.

• Отладка: Вставьте разбитый код и сообщение об ошибке, чтобы получить предложения для исправления.

• Написание документации: Попросите ИИ сгенерировать комментарии для ваших функций или написать файл Project Readme.md.

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

Сила открытого исходного кода

• Общая рабочая нагрузка: Вам не нужно строить все это самостоятельно.
• Учиться у других: Обзор кода от участников - это мощный способ учиться.
• Получите обратную связь: Больше глаз на ваш код означает лучшее качество и более быстрое установление ошибок.
• Создайте сеть: Общайтесь с другими разработчиками, которые могут стать наставниками или будущими коллегами.

Критические первые шаги для начинающих

1. Узнайте основы ржавчины:

   • Прежде чем начать большой проект, пройдите базовый курс.

   • Вы не можете эффективно использовать помощника ИИ, не понимая основы языка.

2. Убедитесь, что вы понимаете git:

   • Git является фундаментальным.

   • Вы должны быть знакомы с основами GIT и GitHub.

3. Выберите один проект:

   • Выберите идею, которая вас больше всего волнует и придерживайтесь ее.

   • Фокус - недооцененная сверхдержава.

4. Создать общественный репозиторий:

   • Используйте GitHub для размещения вашего проекта.

   • Блог о вашем продукте на среднем или Hackeronoon.

5. Определите четкую цель:

   • Напишите описание в один параграф, чего стремится достичь вашего проекта.

   • Используйте ИИ, если это необходимо, но убедитесь, что вы понимаете все, о чем говорите.

   • ИИ тоже может помочь вам в этом!

6. Найдите "хорошие первые проблемы":

   • Ищите для начинающих задач в других проектах с открытым исходным кодом, чтобы почувствовать процесс вклада.
   • Это дает вам доверие и опыт.
   • Кроме того, фактические вклад с открытым исходным кодом являются дофамином!

7. Активно ищите сотрудников:

   • Поделитесь своим проектом на платформах, таких как/R/Rust Subreddit или сообщества Discord.
   • Создайте осведомленность о своем проекте онлайн с Hashnode и LinkedIn.

Учебные ресурсы

• Комплексная ржавчина (Google)

https://google.github.io/comprehness-rust/?embedable=true

• Руководство пользователя LINFA (ML Library)

https://rust-ml.github.io/linfa/?embedable=true

• Построить учебник по блокчейну в Rust

https://blog.logrocket.com/how-to-build-ablockchain-in-rust/?embedable=true

• Приложения командной строки в ржавчине

https://rust-cli.github.io/book/?embedable=true

Заключение

Я нашел статью ниже удивительно полезной для эффективной подготовки к успешной карьере ржавчины:

https://medium

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

Ссылки

1. Переполнение стека. (2023). 2023 Обзор разработчиков.

   https://survey.stackoverflow.co/2023/# Самая любовь к чтению

2. Ханская академия. (2023). Использование ИИ для образования.

   https://www.khanmigo.ai/

3. Революция на языке ржавчины: почему компании мигрируют?
   https://stefanini.com/en/insights/news/the-rust-language-technology-revolution-hy-ar-companies-migrating

4. 2022 Обзор | Принятие ржавчины в бизнесе
   https://rustmagazine.org/issue-1/2022-review-the-adoption-of-rust-in-business

5. Ржавчина в 2025 году: почему мета, Google и Apple все в | Ржасцы

   https://medium.com/rustaceans/why-meta-google-and-apple-are-cretly-betting-on-rust-in-2015

6. Microsoft присоединяется к Rust Foundation - Microsoft Open Source Blog
   https://opensource.microsoft.com/blog/2021/02/08/microsoft-joins-rust-foundation

7. Google принимает Rust для Android: изменение игры для безопасности и производительности мобильных ОС
   https://coinsbench.com/googles-rust-adoption-in-android-a-game-changer-for-mobile-os-development

8. Amazon Web Services. (2020). Почему AWS любит ржавчину.

   https://aws.amazon.com/blogs/opensource/why-aws-loves-rust-and-how-wed-like-to-help/

9. Блог Discord. (2020). Почему раздор переключается от перейти на ржавчину.

   https://discord.com/blog/why-discord-is-switching-from-go-to-rust

10. Общее обучение ржавчине

    • Язык программирования ржавчины («книга»)
      • https://doc.rust-lang.org/book
    • Упражнения из шуста
      • https://github.com/rust-lang/rustlings
    • Комплексная ржавчина (Google)

      • https://google.github.io/comprehness-rust/

    11AI/мл в ржавчине

    • Linfa (ML-структура, похожая на Scikit-Learn)
      • https://github.com/rust-ml/linfa
      • https://rust-ml.github.io/linfa/
    • Учебное пособие: создайте модель машинного обучения в Rust

      • https://www.freecodecamp.org/news/how-to-build-a-machine-learning-model-in-rust/

    12Blockchain & Web3 в ржавчине

    • Учебное пособие: строительство блокчейна в ржавчине

      • https://blog.logrocket.com/how-to-build-ablockchain-in-rust/

      • https://dev.to/iamzubin/how-to-build-ablockchain-from-scratch-in-rust-38d6

    13Генеративный ИИ в ржавчине

    • Обнимающая свечу лица (минималистская структура ML)

      • https://github.com/huggingface/candle

    14Квантовые вычисления в ржавчине

    • Ziskit Rust (квантовые привязки IBM)

      • https://github.com/qiskit/qiskit-rust

    15. DevOps в ржавчине

    • Книга: приложения командной строки в ржавчине

      • https://rust-cli.github.io/book/