@k2works/claude-code-booster 6.2.0 → 6.3.0

package/lib/assets/docs/article/grokking-concurrency/python/part-8.md

@@ -1,359 +0,0 @@
----
-type: Article
-title: "Part VIII - 分散並列処理"
-description: "MapReduce パターンと分散処理を学ぶ"
-tags: [article, grokking-concurrency, python, concurrency, mapreduce, distributed]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VIII: 分散並列処理
-
-## 概要
-
-本章では、MapReduce パターンを使った分散並列処理を学びます。行列乗算とワードカウントの実装を通じて、大規模データの並列処理手法を理解します。
-
----
-
-## 第13章: MapReduce パターン
-
-### MapReduce とは
-
-MapReduce は、大規模データを並列処理するためのプログラミングモデルです。
-
-### 処理フロー
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "Input Data" as input
-rectangle "Map" as map #LightBlue
-rectangle "Shuffle" as shuffle #LightYellow
-rectangle "Reduce" as reduce #LightGreen
-rectangle "Output Data" as output
-
-input --> map
-map --> shuffle
-shuffle --> reduce
-reduce --> output
-
-note right of map : 各データに関数を適用
-note right of shuffle : キーでグループ化
-note right of reduce : グループごとに集約
-@enduml
-```
-
----
-
-## 行列乗算の並列化
-
-### 逐次処理版
-
-```python
-#!/usr/bin/env python3
-
-"""行列乗算（逐次処理版）"""
-
-from typing import List
-
-Row = List[int]
-Matrix = List[Row]
-
-
-def matrix_multiply(matrix_a: Matrix, matrix_b: Matrix) -> Matrix:
-    """2つの行列を乗算"""
-    num_rows_a = len(matrix_a)
-    num_cols_a = len(matrix_a[0])
-    num_cols_b = len(matrix_b[0])
-
-    result = [[0] * num_cols_b for _ in range(num_rows_a)]
-
-    for i in range(num_rows_a):
-        for j in range(num_cols_b):
-            for k in range(num_cols_a):
-                result[i][j] += matrix_a[i][k] * matrix_b[k][j]
-
-    return result
-```
-
-### 並列処理版
-
-```python
-#!/usr/bin/env python3
-
-"""行列乗算（並列処理版）"""
-
-from typing import List, Tuple
-import random
-from multiprocessing import Pool
-
-Row = List[int]
-Column = List[int]
-Matrix = List[Row]
-
-
-def process_row(args: Tuple[Matrix, Matrix, int]) -> Column:
-    """1行分の計算を実行"""
-    matrix_a, matrix_b, row_idx = args
-    num_cols_a = len(matrix_a[0])
-    num_cols_b = len(matrix_b[0])
-
-    result_row = [0] * num_cols_b
-    for j in range(num_cols_b):
-        for k in range(num_cols_a):
-            result_row[j] += matrix_a[row_idx][k] * matrix_b[k][j]
-    return result_row
-
-
-def matrix_multiply_parallel(matrix_a: Matrix, matrix_b: Matrix) -> Matrix:
-    """行列を並列で乗算"""
-    num_rows_a = len(matrix_a)
-    num_cols_a = len(matrix_a[0])
-    num_rows_b = len(matrix_b)
-
-    if num_cols_a != num_rows_b:
-        raise ArithmeticError(
-            f"Invalid dimensions: {num_rows_a}x{num_cols_a} * "
-            f"{num_rows_b}x{len(matrix_b[0])}")
-
-    # 各行の計算を並列実行
-    with Pool() as pool:
-        args = [(matrix_a, matrix_b, i) for i in range(num_rows_a)]
-        results = pool.map(process_row, args)
-
-    return results
-
-
-if __name__ == "__main__":
-    rows, cols = 100, 100
-    A = [[random.randint(0, 10) for _ in range(cols)]
-         for _ in range(rows)]
-    B = [[random.randint(0, 10) for _ in range(rows)]
-         for _ in range(cols)]
-
-    C = matrix_multiply_parallel(A, B)
-    print(f"Result matrix shape: {len(C)}x{len(C[0])}")
-```
-
-### パフォーマンス比較
-
-```python
-import time
-from multiprocessing import Pool
-
-
-def time_sequential(A, B):
-    start = time.perf_counter()
-    matrix_multiply(A, B)
-    return time.perf_counter() - start
-
-
-def time_parallel(A, B):
-    start = time.perf_counter()
-    matrix_multiply_parallel(A, B)
-    return time.perf_counter() - start
-
-
-# 500x500 行列の場合
-# Sequential: ~15秒
-# Parallel (4 cores): ~5秒
-```
-
----
-
-## ワードカウント
-
-### MapReduce によるワードカウント
-
-```python
-#!/usr/bin/env python3
-
-"""MapReduce によるワードカウント"""
-
-from collections import defaultdict
-from multiprocessing import Pool
-import typing as T
-
-
-def map_function(text: str) -> T.List[T.Tuple[str, int]]:
-    """Map: テキストを (word, 1) のペアに変換"""
-    words = text.lower().split()
-    return [(word, 1) for word in words]
-
-
-def reduce_function(word_counts: T.List[T.Tuple[str, int]]) -> T.Dict[str, int]:
-    """Reduce: 同じ単語のカウントを集約"""
-    result = defaultdict(int)
-    for word, count in word_counts:
-        result[word] += count
-    return dict(result)
-
-
-def word_count_mapreduce(texts: T.List[str]) -> T.Dict[str, int]:
-    """MapReduce でワードカウント"""
-
-    # Map フェーズ（並列）
-    with Pool() as pool:
-        mapped = pool.map(map_function, texts)
-
-    # Shuffle: 全ての結果をフラット化
-    shuffled = [pair for sublist in mapped for pair in sublist]
-
-    # Reduce フェーズ
-    result = reduce_function(shuffled)
-
-    return result
-
-
-if __name__ == "__main__":
-    texts = [
-        "Hello world hello",
-        "World of programming",
-        "Hello programming world",
-    ]
-
-    counts = word_count_mapreduce(texts)
-    for word, count in sorted(counts.items(), key=lambda x: -x[1]):
-        print(f"{word}: {count}")
-```
-
-### 実行結果
-
-```
-world: 3
-hello: 3
-programming: 2
-of: 1
-```
-
----
-
-## 分散処理アーキテクチャ
-
-### マスター・ワーカー構成
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "Scheduler" as sched #LightBlue
-rectangle "Master" as master #LightYellow
-rectangle "Worker 1" as w1 #LightGreen
-rectangle "Worker 2" as w2 #LightGreen
-rectangle "Worker 3" as w3 #LightGreen
-
-sched --> master : タスク分配
-master --> w1 : コーディネーション
-master --> w2
-master --> w3
-
-note right of sched : タスク分配
-note right of master : コーディネーション
-note bottom of w1 : ワーカー
-@enduml
-```
-
-### ワーカーの実装例
-
-```python
-#!/usr/bin/env python3
-
-"""分散ワードカウントのワーカー"""
-
-import socket
-import pickle
-from collections import defaultdict
-
-
-def count_words(text: str) -> dict:
-    """テキスト内の単語をカウント"""
-    counts = defaultdict(int)
-    for word in text.lower().split():
-        counts[word] += 1
-    return dict(counts)
-
-
-def worker(host: str = 'localhost', port: int = 9000) -> None:
-    """ワーカープロセス"""
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.connect((host, port))
-        print("Connected to master")
-
-        while True:
-            # タスクを受信
-            data = s.recv(4096)
-            if not data:
-                break
-
-            text = pickle.loads(data)
-            print(f"Processing: {text[:50]}...")
-
-            # 処理を実行
-            result = count_words(text)
-
-            # 結果を送信
-            s.send(pickle.dumps(result))
-
-
-if __name__ == "__main__":
-    worker()
-```
-
----
-
-## スケーリングの考慮事項
-
-### 水平スケーリング
-
-| 要素 | 説明 |
-|------|------|
-| データ分割 | データを均等に分配 |
-| 負荷分散 | ワーカー間で作業量を均等化 |
-| 耐障害性 | ワーカー障害時のリカバリ |
-| 通信コスト | ネットワークオーバーヘッド |
-
-### Amdahl の法則
-
-並列化による高速化の限界を示す法則:
-
-```
-Speedup = 1 / (S + P/N)
-
-S: 逐次部分の割合
-P: 並列部分の割合 (P = 1 - S)
-N: プロセッサ数
-```
-
----
-
-## まとめ
-
-本シリーズで学んだ内容:
-
-| Part | トピック | キーポイント |
-|------|----------|-------------|
-| I | 逐次処理 | 基本概念、パフォーマンス測定 |
-| II | プロセス/スレッド | GIL、スレッドプール |
-| III | マルチタスキング | タイムシェアリング |
-| IV | 並列パターン | Fork/Join、パイプライン |
-| V | 同期 | Lock、Semaphore、デッドロック |
-| VI | ノンブロッキング I/O | イベントループ、Reactor |
-| VII | 非同期 | asyncio、コルーチン |
-| VIII | 分散処理 | MapReduce |
-
----
-
-## 参考コード
-
-- `apps/python/Chapter 13/matmul/`
-- `apps/python/Chapter 13/wordcount/`
-
----
-
-## 参考資料
-
-- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency) - 原著
-- [Python 公式ドキュメント - concurrent.futures](https://docs.python.org/3/library/concurrent.futures.html)
-- [Python 公式ドキュメント - asyncio](https://docs.python.org/3/library/asyncio.html)
-- [MapReduce: Simplified Data Processing on Large Clusters](https://research.google/pubs/pub62/) - Google 論文

package/lib/assets/docs/article/grokking-concurrency/rust/index.md

@@ -1,260 +0,0 @@
-# Grokking Concurrency - Rust 版
-
-本シリーズは「Grokking Concurrency」（Kirill Bobrov 著）の学習コンパニオンとして、並行処理プログラミングの概念を Rust で実装しながら日本語で解説します。
-
----
-
-## 対象読者
-
-- Rust の基礎知識があり、並行処理に興味がある開発者
-- 所有権と借用を活用した安全な並行処理を学びたい方
-- マルチスレッド、非同期プログラミングを理解したいエンジニア
-- Rayon や Tokio を使った並列処理に興味がある方
-
----
-
-## 記事一覧
-
-### [Part I: 並行処理の基礎](part-1.md)
-
-逐次処理と並行処理の違い、基本概念を学びます。
-
-| 章 | トピック |
-|----|----------|
-| 第2章 | 逐次処理、パスワードクラッキング例 |
-
-**キーワード**: 逐次処理、Iterator、Option/Result
-
----
-
-### [Part II: プロセスとスレッド](part-2.md)
-
-スレッドの基本と所有権の関係を学びます。
-
-| 章 | トピック |
-|----|----------|
-| 第4章 | スレッド、JoinHandle、Send/Sync |
-| 第5章 | 並列処理、Rayon |
-
-**キーワード**: std::thread、Send、Sync、Rayon
-
----
-
-### [Part III: マルチタスキングとスケジューリング](part-3.md)
-
-マルチタスキングとイベント駆動の概念を学びます。
-
-| 章 | トピック |
-|----|----------|
-| 第6章 | マルチタスキング、Condvar、ゲームループ |
-
-**キーワード**: Condvar、Mutex、イベント駆動
-
----
-
-### [Part IV: タスク分解と並列パターン](part-4.md)
-
-並列処理のデザインパターンを学びます。
-
-| 章 | トピック |
-|----|----------|
-| 第7章 | タスク分解、Fork/Join、パイプライン |
-
-**キーワード**: Rayon、mpsc、Pipeline
-
----
-
-### [Part V: 同期と排他制御](part-5.md)
-
-並行処理における同期問題と解決策を学びます。
-
-| 章 | トピック |
-|----|----------|
-| 第8章 | Mutex、Arc、デッドロック回避 |
-
-**キーワード**: Mutex、Arc、MutexGuard
-
----
-
-### [Part VI: ノンブロッキング I/O](part-6.md)
-
-ノンブロッキング I/O と非同期処理の基礎を学びます。
-
-| 章 | トピック |
-|----|----------|
-| 第10章 | ブロッキング vs ノンブロッキング I/O |
-
-**キーワード**: async、Future、Tokio
-
----
-
-### [Part VII: 非同期プログラミング](part-7.md)
-
-Rust の async/await を使った非同期プログラミングを学びます。
-
-| 章 | トピック |
-|----|----------|
-| 第12章 | Future、async/await、Tokio |
-
-**キーワード**: async、await、tokio
-
----
-
-### [Part VIII: 分散並列処理](part-8.md)
-
-MapReduce パターンと分散処理を学びます。
-
-| 章 | トピック |
-|----|----------|
-| 第13章 | MapReduce、ワードカウント |
-
-**キーワード**: MapReduce、Rayon、並列イテレータ
-
----
-
-## 使用ライブラリ
-
-| ライブラリ | 用途 | 対応章 |
-|------------|------|--------|
-| std::thread | スレッド操作 | Part II-V |
-| std::sync | 同期プリミティブ | Part III, V |
-| rayon | データ並列処理 | Part II, IV, VIII |
-| tokio | 非同期ランタイム | Part VI, VII |
-| sha2 | ハッシュ計算 | Part I, II |
-
----
-
-## リポジトリ構成
-
-```
-grokking_concurrency/
-├── apps/rust/                     # Rust サンプルコード
-│   ├── Cargo.toml                 # プロジェクト設定
-│   └── src/
-│       ├── lib.rs                 # モジュール定義
-│       ├── ch02.rs                # 逐次処理
-│       ├── ch04.rs                # スレッド基礎
-│       ├── ch05.rs                # 並列パスワードクラッカー
-│       ├── ch06.rs                # ゲームループ
-│       ├── ch07.rs                # Fork/Join, Pipeline
-│       ├── ch08.rs                # 銀行口座（同期）
-│       └── ch13.rs                # MapReduce
-└── docs/article/rust/             # 解説記事
-    ├── index.md                   # この記事
-    ├── part-1.md                  # Part I
-    └── ...                        # 以降の Part
-```
-
----
-
-## Rust と並行処理
-
-Rust は**所有権システム**により、コンパイル時にデータ競合を防ぎます。
-
-### スレッド
-
-```rust
-use std::thread;
-
-fn main() {
-    let handle = thread::spawn(|| {
-        println!("Hello from thread!");
-    });
-    handle.join().unwrap();
-}
-```
-
-### Arc と Mutex
-
-```rust
-use std::sync::{Arc, Mutex};
-use std::thread;
-
-fn main() {
-    let counter = Arc::new(Mutex::new(0));
-    let mut handles = vec![];
-
-    for _ in 0..10 {
-        let counter = Arc::clone(&counter);
-        let handle = thread::spawn(move || {
-            let mut num = counter.lock().unwrap();
-            *num += 1;
-        });
-        handles.push(handle);
-    }
-
-    for handle in handles {
-        handle.join().unwrap();
-    }
-
-    println!("Result: {}", *counter.lock().unwrap());
-}
-```
-
-### Rayon による並列処理
-
-```rust
-use rayon::prelude::*;
-
-fn main() {
-    let sum: i32 = (1..=1000)
-        .into_par_iter()
-        .map(|x| x * 2)
-        .sum();
-    println!("Sum: {}", sum);
-}
-```
-
-### 非同期プログラミング
-
-```rust
-use tokio;
-
-#[tokio::main]
-async fn main() {
-    let result = fetch_data().await;
-    println!("{}", result);
-}
-
-async fn fetch_data() -> String {
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-    "Data fetched".to_string()
-}
-```
-
----
-
-## 主要な概念
-
-### 所有権と並行処理
-
-| トレイト | 説明 |
-|----------|------|
-| Send | 別スレッドに所有権を移動可能 |
-| Sync | 複数スレッドから参照可能 |
-
-### 同期プリミティブ
-
-| 型 | 説明 |
-|----|------|
-| Mutex<T> | 排他制御によるデータ保護 |
-| RwLock<T> | 読み書きロック |
-| Arc<T> | スレッド間での共有所有権 |
-| Condvar | 条件変数 |
-
-### 並行処理の利点
-
-1. **コンパイル時の安全性** - データ競合をコンパイル時に検出
-2. **ゼロコスト抽象化** - 安全性を犠牲にしないパフォーマンス
-3. **表現力** - 所有権により意図を明確に表現
-4. **エコシステム** - Rayon、Tokio 等の強力なライブラリ
-
----
-
-## 参考資料
-
-- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency) - 原著
-- [The Rust Programming Language - Fearless Concurrency](https://doc.rust-lang.org/book/ch16-00-concurrency.html)
-- [Rust 公式ドキュメント - std::thread](https://doc.rust-lang.org/std/thread/)
-- [Rayon](https://github.com/rayon-rs/rayon)
-- [Tokio](https://tokio.rs/)

package/lib/assets/docs/article/grokking-concurrency/rust/part-1.md

@@ -1,107 +0,0 @@
----
-type: Article
-title: "Part I - 並行処理の基礎"
-description: "逐次処理とパスワードクラッカーの実装"
-tags: [article, grokking-concurrency, rust, concurrency, sequential]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part I: 並行処理の基礎
-
-## 概要
-
-本章では、並行処理の基礎として逐次処理を学びます。
-
----
-
-## パスワードクラッカーの実装
-
-### SHA-256 ハッシュ計算
-
-```rust
-use sha2::{Sha256, Digest};
-
-/// Compute SHA-256 hash of a password
-pub fn get_crypto_hash(password: &str) -> String {
-    let mut hasher = Sha256::new();
-    hasher.update(password.as_bytes());
-    let result = hasher.finalize();
-    format!("{:x}", result)
-}
-```
-
----
-
-### ブルートフォース探索
-
-```rust
-/// Crack password by brute force (sequential)
-pub fn crack_password(
-    crypto_hash: &str,
-    alphabet: &[char],
-    length: usize,
-) -> Option<String> {
-    if length == 0 {
-        return None;
-    }
-    crack_recursive(crypto_hash, alphabet, String::new(), length)
-}
-
-fn crack_recursive(
-    crypto_hash: &str,
-    alphabet: &[char],
-    prefix: String,
-    remaining: usize,
-) -> Option<String> {
-    if remaining == 0 {
-        if get_crypto_hash(&prefix) == crypto_hash {
-            return Some(prefix);
-        }
-        return None;
-    }
-
-    for &c in alphabet {
-        let mut candidate = prefix.clone();
-        candidate.push(c);
-        if let Some(result) = crack_recursive(
-            crypto_hash, alphabet, candidate, remaining - 1
-        ) {
-            return Some(result);
-        }
-    }
-    None
-}
-```
-
----
-
-## 使用例
-
-```rust
-fn main() {
-    let alphabet: Vec<char> = "ab".chars().collect();
-    let target_hash = get_crypto_hash("ab");
-
-    match crack_password(&target_hash, &alphabet, 2) {
-        Some(password) => println!("Found: {}", password),
-        None => println!("Not found"),
-    }
-}
-```
-
----
-
-## Rust の特徴
-
-| 概念 | 説明 |
-|------|------|
-| Option<T> | 値が存在しない可能性を表現 |
-| Iterator | 遅延評価による効率的な処理 |
-| 所有権 | メモリ安全性の保証 |
-
----
-
-## 次のステップ
-
-[Part II](part-2.md) では、スレッドを使った並行処理を学びます。