Rust 2025：45.5%組織採用、TIOBE 13位、Linuxカーネル参入 — あなたのチームもRustを学ぶべきか？

組織採用率:       45.5%（+17.6% YoY）
メイン言語使用:    38.2%
商用利用:         68.75%（2021年比成長）
TIOBEランキング:  13位（史上最高）
Stack Overflow:   9年連続「最も愛される言語」
crates.ioパッケージ: 150,000+（2024年末時点）

年別組織採用率の変化:
2020: 約15%
2021: 約20%
2022: 約25%
2023: 27.9%
2024: 34.8%
2025: 45.5%

// 従来のLinuxカーネルドライバ（C言語）
// NULLポインタ、バッファオーバーフロー等のメモリバグリスク
static int my_driver_probe(struct platform_device *pdev) {
    struct my_data *data;
    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
    if (!data)
        return -ENOMEM;
    // ... 手動メモリ管理
}

// Rustで書かれたカーネルドライバ
// コンパイル時にメモリ安全性を保証
use kernel::prelude::*;

module! {
    type: MyDriver,
    name: "my_driver",
    license: "GPL",
}

struct MyDriver {
    // 所有権システムがメモリ安全性を保証
}

impl kernel::Module for MyDriver {
    fn init(_module: &'static ThisModule) -> Result<Self> {
        pr_info!("Rust driver loaded\n");
        Ok(MyDriver {})
    }
}

Firecracker:   サーバーレスワークロード用マイクロVM（Lambda、Fargateの基盤）
Bottlerocket:  コンテナ専用Linux基盤OS
S2N-TLS:      TLSプロトコル実装
Mountpoint:    S3用ファイルシステムクライアント
Cedar:         認証・認可ポリシー言語およびエンジン

サービス: Read States（既読状態追跡）
問題:    GoのGC（ガベージコレクタ）によるレイテンシスパイク
結果:    Go -> Rustマイグレーション後:
         - P99レイテンシ10倍改善
         - メモリ使用量の大幅削減
         - GC関連レイテンシスパイクの完全解消

1Password:    パスワード管理のコアロジック
Figma:        マルチプレイヤーサーバー
Vercel:       Turbopack（次世代バンドラー）
Shopify:      YJIT（Ruby JITコンパイラ、Rustで作成）
npm:          レジストリインフラの一部

- 素早い開発速度が最優先
- マイクロサービス / APIサーバー
- DevOpsツール（Kubernetesエコシステム）
- チームのオンボーディング速度が重要
- プロトタイピング後の素早いリリース

- 極限のパフォーマンスが必要（P99レイテンシが重要）
- メモリ安全性がセキュリティに直結
- システムプログラミング（カーネル、ドライバ）
- GCなしの予測可能なパフォーマンス
- 組み込み / リソース制約のある環境

// Rust: コンパイラがメモリ安全性を保証
fn process_data(data: &[u8]) -> Vec<u8> {
    let mut result = Vec::new();
    for &byte in data {
        if byte > 0 {
            result.push(byte * 2);
        }
    }
    result
    // resultのメモリはスコープを抜けると自動解放
}

// C++: 開発者が手動でメモリ管理
std::vector<uint8_t> process_data(const uint8_t* data, size_t len) {
    std::vector<uint8_t> result;
    for (size_t i = 0; i < len; ++i) {
        if (data[i] > 0) {
            result.push_back(data[i] * 2);
        }
    }
    return result;
    // dataがダングリングポインタの可能性？ コンパイラは検証しない
}

Javaの強み:
- エンタープライズエコシステム（Spring、Jakarta EE）
- 膨大なライブラリ
- JVM最適化（HotSpot）
- 豊富な人材プール

Rustの強み（Java比）:
- GCなしの予測可能なレイテンシ
- はるかに小さいバイナリ / メモリフットプリント
- ネイティブコンパイル
- システムレベルのアクセス

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1の所有権がs2に移動（move）
    // println!("{}", s1); // コンパイルエラー！ s1はもう有効ではない
    println!("{}", s2); // OK
}

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

    // 不変借用：複数同時に可能
    let len = calculate_length(&s1);
    println!("'{}' の長さ: {}", s1, len); // s1はまだ使用可能

    // 可変借用：同時に1つだけ
    let mut s2 = String::from("hello");
    change(&mut s2);
    println!("{}", s2); // "hello, world"
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn change(s: &mut String) {
    s.push_str(", world");
}

// ライフタイム注釈が必要な場合
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("最も長い文字列: {}", result);
    }
    // ここでresultを使用するとエラー（string2は既に解放済み）
}

// 列挙型とパターンマッチング
enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
    Triangle(f64, f64, f64),
}

fn area(shape: &Shape) -> f64 {
    match shape {
        Shape::Circle(r) => std::f64::consts::PI * r * r,
        Shape::Rectangle(w, h) => w * h,
        Shape::Triangle(a, b, c) => {
            let s = (a + b + c) / 2.0;
            (s * (s - a) * (s - b) * (s - c)).sqrt()
        }
    }
}

// エラー処理：ResultとOption
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("0で割ることはできません".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 3.0) {
        Ok(result) => println!("結果: {}", result),
        Err(e) => println!("エラー: {}", e),
    }

    // ?演算子で簡潔に
    let result = divide(10.0, 0.0).unwrap_or(0.0);
    println!("デフォルト値使用: {}", result);
}

// トレイトの定義と実装
trait Summarizable {
    fn summary(&self) -> String;

    // デフォルト実装の提供が可能
    fn preview(&self) -> String {
        format!("{}...", &self.summary()[..20])
    }
}

struct Article {
    title: String,
    content: String,
}

impl Summarizable for Article {
    fn summary(&self) -> String {
        format!("{}: {}", self.title, &self.content[..50])
    }
}

// ジェネリクスとトレイト境界
fn print_summary<T: Summarizable>(item: &T) {
    println!("{}", item.summary());
}

// イテレータとクロージャ
fn process_numbers(numbers: Vec<i32>) -> Vec<i32> {
    numbers
        .iter()
        .filter(|&&n| n > 0)
        .map(|&n| n * 2)
        .collect()
}

// Axum Webサーバーの例
use axum::{routing::get, Router, Json};
use serde::Serialize;

#[derive(Serialize)]
struct User {
    id: u64,
    name: String,
}

async fn get_user() -> Json<User> {
    Json(User {
        id: 1,
        name: "Alice".to_string(),
    })
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/user", get(get_user));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

# Cargo.toml 依存関係
[dependencies]
axum = "0.7"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

// unsafeブロック：必要な場合のみ使用
unsafe fn dangerous() {
    // 生ポインタの逆参照など
}

// FFI：Cライブラリの呼び出し
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    let result = unsafe { abs(-5) };
    println!("絶対値: {}", result);
}

// 宣言的マクロ
macro_rules! vec_of_strings {
    ($($x:expr),*) => {
        vec![$($x.to_string()),*]
    };
}

fn demo() {
    let names = vec_of_strings!["Alice", "Bob", "Charlie"];
    println!("{:?}", names);
}

無料リソース:
1. The Rust Programming Language（公式ブック）
   - https://doc.rust-lang.org/book/
   - 最も体系的な入門書

2. Rustlings（インタラクティブ演習）
   - https://github.com/rust-lang/rustlings
   - 小さな問題を解きながら学ぶ

3. Rust by Example
   - https://doc.rust-lang.org/rust-by-example/
   - 例題中心の学習

4. 100 Exercises To Learn Rust
   - https://rust-exercises.com/
   - 2024年公開の無料コース

5. Comprehensive Rust（Google）
   - https://google.github.io/comprehensive-rust/
   - Google内部教育資料の公開版

有料・上級リソース:
6. Programming Rust, 2nd Edition（O'Reilly）
7. Rust in Action（Manning）
8. Zero To Production In Rust（Webバックエンド特化）

バックグラウンド別の予想学習期間:
- C/C++開発者:        2-3ヶ月（メモリモデルの理解が速い）
- Go開発者:           3-4ヶ月（所有権の概念への適応が必要）
- Java/C#開発者:      4-5ヶ月（GCのない環境への適応）
- Python/JS開発者:    5-6ヶ月（システムプログラミング＋所有権）
- 最初のプログラミング言語: 推奨しません（先に他の言語を学びましょう）

主要懸念事項（2025年調査）:
1. 複雑性の増加:          41.6%
2. 産業採用の不足:        42.1%
3. 学習曲線:              （上位の不満事項）
4. コンパイル時間:        （継続的な問題）
5. 不完全なツールサポート: （IDE、デバッガ）

// Rustのasyncが複雑な理由を示す例
// 他の言語と異なり、async関数の戻り値の型が複雑になることがある
use std::future::Future;

fn make_request(url: &str) -> impl Future<Output = Result<String, reqwest::Error>> + '_ {
    async move {
        let response = reqwest::get(url).await?;
        response.text().await
    }
}

プロジェクト規模別の概算コンパイル時間（クリーンビルド）:
- 小規模（1万行）:     10-30秒
- 中規模（10万行）:    2-5分
- 大規模（50万行以上）: 10-30分

改善方法:
- cargo checkの活用（型チェックのみ、コード生成省略）
- sccacheによるキャッシュ
- ワークスペースの分割
- インクリメンタルコンパイルの活用
- craneliftバックエンド（デバッグビルド）

成熟した領域:
- Webフレームワーク（Axum、Actix）
- シリアライゼーション（serde）
- HTTPクライアント（reqwest）
- CLIツール（clap）
- 非同期ランタイム（tokio）

成長中の領域:
- GUI（iced、egui - まだ初期段階）
- ORM（diesel、sea-orm - 発展中）
- エンタープライズパターン（Springのような統合フレームワーク不在）
- 機械学習（burn、candle - 初期段階）

Rust開発者市場:
- 需要: 急増（特にインフラ、セキュリティ分野）
- 供給: 不足（全開発者の少数派）
- 平均年収: 上位層（米国基準で約120-180K USD）
- 示唆: 学べば競争力が高まるが、チームビルディングは困難

1. FFI境界から始める
   - 既存コードとRustをFFIで接続
   - 最もリスクの高い部分（メモリ安全性の問題）からRustに転換
   - パフォーマンスが重要なホットパスから開始

2. 新サービスはRustで作成
   - 既存コードはそのまま維持
   - 新しいマイクロサービスをRustで開始
   - 段階的にRust領域を拡大

3. Strangler Figパターン
   - 既存システムを包む新しいRust層を構築
   - トラフィックを段階的に新しい層に移行
   - 旧システムを段階的に廃止

マイグレーションすべきタイミング:
- GC関連のレイテンシスパイクがビジネスに影響
- P99レイテンシ要件が非常に厳格
- メモリ使用量の最適化が必須
- 並行性バグによる障害の繰り返し

マイグレーションすべきでないタイミング:
- Goのパフォーマンスで十分な場合
- チームにRust経験が全くない場合
- 素早い開発速度が最優先の場合
- CRUD中心のビジネスロジック

// GoからRustへ：HTTPハンドラの比較

// Go版（参考用の擬似コード）
// func getUser(w http.ResponseWriter, r *http.Request) {
//     id := r.URL.Query().Get("id")
//     user, err := db.FindUser(id)
//     if err != nil {
//         http.Error(w, err.Error(), 500)
//         return
//     }
//     json.NewEncoder(w).Encode(user)
// }

// Rust（Axum）版
use axum::{extract::Query, Json};
use serde::Deserialize;

#[derive(Deserialize)]
struct UserQuery {
    id: String,
}

async fn get_user(Query(params): Query<UserQuery>) -> Result<Json<User>, AppError> {
    let user = db::find_user(&params.id).await?;
    Ok(Json(user))
}

段階的アプローチ:
ステップ1: Rustで新モジュールを作成、C++ FFIで接続
ステップ2: テストカバレッジの確保（既存C++コード）
ステップ3: 最もリスクの高いモジュールからRustにポーティング
ステップ4: 統合テストで動作検証
ステップ5: 段階的に拡大

FFIツール:
- cxx: C++とRust間の安全なFFI
- bindgen: C/C++ヘッダからRustバインディングを自動生成
- cbindgen: RustからC/C++ヘッダを生成

// cxxを使用したC++連携の例
#[cxx::bridge]
mod ffi {
    // C++側が提供する関数
    unsafe extern "C++" {
        include!("legacy/include/processor.h");
        fn process_legacy_data(input: &[u8]) -> Vec<u8>;
    }

    // Rust側が提供する関数
    extern "Rust" {
        fn validate_data(data: &[u8]) -> bool;
    }
}

fn validate_data(data: &[u8]) -> bool {
    // Rustの安全な検証ロジック
    !data.is_empty() && data.len() < 1_000_000
}

事前準備:
[ ] チーム内にRustチャンピオン1-2名を確保
[ ] パイロットプロジェクトで経験蓄積（2-3ヶ月）
[ ] 現在のシステムのパフォーマンスベースラインを測定
[ ] マイグレーション対象モジュールの優先順位選定
[ ] CI/CDパイプラインにRustビルドを追加

実行:
[ ] FFIインターフェースの設計
[ ] ユニットテストの作成（Rust側）
[ ] 統合テストの維持（既存テストスイート）
[ ] 段階的なトラフィック転換
[ ] パフォーマンスの監視と比較

事後:
[ ] パフォーマンス改善の測定と文書化
[ ] チーム教育資料の作成
[ ] 次のマイグレーション対象の選定

Axum（tokioチーム開発）:
- tokioエコシステムとの完璧な統合
- Towerミドルウェア互換
- 型安全なルーティング
- 2024-2025年最も急速に成長しているRust Webフレームワーク

Actix Web:
- 最高水準のベンチマークパフォーマンス
- 成熟したエコシステム
- 多数のエンタープライズ使用事例

Loco.rs:
- Ruby on Railsスタイルのオールインワンフレームワーク
- 2024年に登場、急速に成長中
- 開発生産性に焦点

Bevy:
- データ指向ゲームエンジン
- ECS（Entity Component System）アーキテクチャ
- 急速に成長するコミュニティ
- まだ1.0前だが注目度は高い

wgpu:
- WebGPU実装
- クロスプラットフォームGPUプログラミング
- Firefoxで使用

Tauri:
- Electronの代替
- Web技術（HTML/CSS/JS）+ Rustバックエンド
- はるかに小さいバイナリサイズ（Electron比10-100倍小さい）
- メモリ使用量の大幅削減
- v2.0リリースでモバイルサポート追加

Dioxus:
- ReactスタイルのRust UIフレームワーク
- Web、デスクトップ、モバイル対応

// Rust -> WASMの例（wasm-bindgen使用）
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a: u64 = 0;
            let mut b: u64 = 1;
            for _ in 2..=n {
                let temp = b;
                b = a + b;
                a = temp;
            }
            b
        }
    }
}

// JavaScriptからの呼び出し:
// import { fibonacci } from './pkg/my_wasm';
// console.log(fibonacci(50));

Rust + WASMの使用事例:
- Figma: リアルタイムコラボレーションエディタのコアロジック
- Cloudflare Workers: エッジコンピューティング
- 1Password: ブラウザ拡張機能
- Amazon Prime Video: ビデオ処理
- AutoCAD: Web版のレンダリングエンジン

burn:
- PyTorchスタイルのディープラーニングフレームワーク
- 多様なバックエンドサポート（GPU、CPU、WASM）
- 純粋なRust実装

candle（Hugging Face）:
- 軽量ML推論フレームワーク
- LLM推論に特化
- Python依存なしでMLモデルを実行

ort:
- ONNX RuntimeのRustバインディング
- 学習済みモデルのプロダクションデプロイに適合
- 多様なハードウェアアクセラレーションサポート

linfa:
- scikit-learnスタイルの伝統的MLライブラリ
- クラスタリング、分類、回帰など

従来のツール -> Rust代替:
grep     -> ripgrep (rg)
find     -> fd
cat      -> bat
ls       -> exa/eza
du       -> dust
top      -> bottom (btm)
sed      -> sd
curl     -> xh
diff     -> delta

CLIライブラリ:
- clap: コマンドライン引数パース（デファクトスタンダード）
- ratatui: TUI（ターミナルUI）フレームワーク
- indicatif: プログレスバー
- dialoguer: 対話型プロンプト

embassy:
- 非同期組み込みフレームワーク
- no_std環境でasync/awaitサポート
- STM32、nRF、RP2040等の多様なMCUサポート

esp-rs:
- ESP32ファミリーMCU用Rustサポート
- WiFi、Bluetooth対応

probe-rs:
- デバッグ/フラッシュツール
- ARM、RISC-Vサポート