@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/grokking-concurrency/all/part-8-ch13-mapreduce.md

@@ -0,0 +1,377 @@
+# Part VIII: 分散並列処理
+
+## 8.1 はじめに
+
+本章では、大規模データを複数のプロセッサで効率的に処理する **MapReduce パターン**を学びます。ワードカウントを題材に、8 つの言語がそれぞれどのような並列コレクション・並列イテレータを提供しているかを比較します。
+
+### MapReduce とは
+
+MapReduce は 3 つのフェーズで構成されます：
+
+```
+入力データ → [Map] → (key, value) ペア → [Shuffle] → グループ化 → [Reduce] → 最終結果
+```
+
+1. **Map**: 各入力要素を (key, value) ペアに変換
+2. **Shuffle**: ペアをキーごとにグループ化
+3. **Reduce**: 各グループの値を集約
+
+## 8.2 共通の本質
+
+### ワードカウントのアルゴリズム
+
+```
+入力: ["hello world", "hello rust", "world of rust"]
+
+Map:
+  "hello world" → [("hello", 1), ("world", 1)]
+  "hello rust"  → [("hello", 1), ("rust", 1)]
+  "world of rust" → [("world", 1), ("of", 1), ("rust", 1)]
+
+Shuffle:
+  "hello" → [1, 1]
+  "world" → [1, 1]
+  "rust"  → [1, 1]
+  "of"    → [1]
+
+Reduce:
+  "hello" → 2, "world" → 2, "rust" → 2, "of" → 1
+```
+
+### 並列化のポイント
+
+Map フェーズは**恥ずかしいほど並列**（embarrassingly parallel）です。各テキストの処理は完全に独立しており、ロックや同期なしで並列化できます。
+
+## 8.3 言語別実装比較
+
+### Map フェーズ
+
+#### 関数型ファースト言語
+
+<details>
+<summary>Haskell 実装</summary>
+
+```haskell
+mapPhase :: String -> [(String, Int)]
+mapPhase text = [(map toLower word, 1) | word <- words text, not (null word)]
+```
+
+**特徴**: リスト内包表記でワンライナー。`words` は標準関数。
+
+</details>
+
+<details>
+<summary>Clojure 実装</summary>
+
+```clojure
+(defn map-phase [text]
+  (->> (str/split (str/lower-case text) #"\s+")
+       (filter (complement str/blank?))
+       (map (fn [word] [word 1]))))
+```
+
+**特徴**: スレッディングマクロ `->>` でデータ変換パイプラインを表現。
+
+</details>
+
+#### マルチパラダイム言語
+
+<details>
+<summary>Rust 実装</summary>
+
+```rust
+pub fn map(text: &str) -> Vec<(String, usize)> {
+    text.to_lowercase()
+        .split_whitespace()
+        .filter(|s| !s.is_empty())
+        .map(|word| (word.to_string(), 1))
+        .collect()
+}
+```
+
+</details>
+
+<details>
+<summary>Scala 実装</summary>
+
+```scala
+def map(text: String): List[(String, Int)] =
+  text.toLowerCase
+    .split("\\s+")
+    .filter(_.nonEmpty)
+    .map(word => (word, 1))
+    .toList
+```
+
+</details>
+
+<details>
+<summary>F# 実装</summary>
+
+```fsharp
+let map (text: string) : (string * int) list =
+    text.ToLower().Split([|' '; '\t'; '\n'|], StringSplitOptions.RemoveEmptyEntries)
+    |> Array.map (fun word -> (word, 1))
+    |> Array.toList
+```
+
+</details>
+
+#### OOP + 並行処理ライブラリ言語
+
+<details>
+<summary>Java 実装</summary>
+
+```java
+public static List<Map.Entry<String, Integer>> map(String text) {
+    return Arrays.stream(text.toLowerCase().split("\\s+"))
+        .map(word -> Map.entry(word, 1))
+        .toList();
+}
+```
+
+</details>
+
+<details>
+<summary>C# 実装</summary>
+
+```csharp
+public static List<KeyValuePair<string, int>> Map(string text) {
+    return text.ToLower()
+        .Split(' ', StringSplitOptions.RemoveEmptyEntries)
+        .Select(word => new KeyValuePair<string, int>(word, 1))
+        .ToList();
+}
+```
+
+</details>
+
+<details>
+<summary>Python 実装</summary>
+
+```python
+def map_function(text: str) -> List[Tuple[str, int]]:
+    words = text.lower().split()
+    return [(word, 1) for word in words]
+```
+
+</details>
+
+### 並列 MapReduce（全体）
+
+#### 並列化メカニズムの比較
+
+| 言語 | 並列化 API | 特徴 |
+|------|-----------|------|
+| Python | `multiprocessing.Pool.map()` | プロセスベース（GIL 回避） |
+| Java | `parallelStream()` | ForkJoinPool 自動管理 |
+| C# | `AsParallel()` (PLINQ) | LINQ との統合 |
+| Scala | `.par` コレクション | ワンメソッドで並列化 |
+| F# | `Array.Parallel.collect` | Array 専用並列モジュール |
+| Rust | `par_iter()` (Rayon) | ワークスティーリング |
+| Haskell | `mapConcurrently` | 非同期並列マップ |
+| Clojure | `pmap` | 並列マップ関数 |
+
+<details>
+<summary>Rust 実装（完全並列 fold/reduce）</summary>
+
+```rust
+pub fn count_words_full_parallel(texts: &[&str]) -> HashMap<String, usize> {
+    texts
+        .par_iter()
+        .flat_map(|text| map(text))
+        .fold(
+            || HashMap::new(),
+            |mut acc, (word, count)| {
+                *acc.entry(word).or_insert(0) += count;
+                acc
+            },
+        )
+        .reduce(
+            || HashMap::new(),
+            |mut a, b| {
+                for (k, v) in b {
+                    *a.entry(k).or_insert(0) += v;
+                }
+                a
+            },
+        )
+}
+```
+
+**特徴**: Map + Reduce を `par_iter().fold().reduce()` で一貫して並列実行。チャンク分割も自動。
+
+</details>
+
+<details>
+<summary>Java 実装（parallelStream）</summary>
+
+```java
+public static Map<String, Integer> wordCount(List<String> texts) {
+    List<Map.Entry<String, Integer>> mapped = texts.parallelStream()
+        .flatMap(text -> map(text).stream())
+        .toList();
+    return reduce(mapped);
+}
+
+public static Map<String, Integer> reduce(List<Map.Entry<String, Integer>> pairs) {
+    return pairs.stream()
+        .collect(Collectors.groupingBy(
+            Map.Entry::getKey,
+            Collectors.summingInt(Map.Entry::getValue)
+        ));
+}
+```
+
+**特徴**: `parallelStream()` を呼ぶだけで並列化。`Collectors` で宣言的な集約。
+
+</details>
+
+<details>
+<summary>C# 実装（PLINQ）</summary>
+
+```csharp
+public static Dictionary<string, int> CountWords(List<string> texts) {
+    var mapped = texts
+        .AsParallel()
+        .SelectMany(text => Map(text))
+        .ToList();
+    return Reduce(mapped);
+}
+```
+
+**特徴**: `.AsParallel()` を挿入するだけで LINQ クエリが並列化。
+
+</details>
+
+<details>
+<summary>Haskell 実装</summary>
+
+```haskell
+countWordsParallel :: [String] -> IO (Map String Int)
+countWordsParallel [] = return Map.empty
+countWordsParallel texts = do
+    mapped <- mapConcurrently (return . mapPhase) texts
+    return $ reducePhase (concat mapped)
+```
+
+</details>
+
+<details>
+<summary>Clojure 実装（pmap）</summary>
+
+```clojure
+(defn count-words-parallel [texts]
+  (if (empty? texts)
+    {}
+    (->> texts
+         (pmap map-phase)
+         (apply concat)
+         reduce-phase)))
+```
+
+**特徴**: `map` を `pmap` に置き換えるだけで並列化。
+
+</details>
+
+## 8.4 比較分析
+
+### 並列化の手軽さ
+
+```
+最も簡単  ┌──────────────────────────────┐
+          │ Scala: .par                  │ ← 1 メソッド追加
+          │ C#: .AsParallel()            │
+          │ Clojure: map → pmap          │
+          ├──────────────────────────────┤
+手軽      │ Java: stream → parallelStream │
+          │ Rust: iter → par_iter        │
+          │ F#: Array.map → Parallel.map │
+          ├──────────────────────────────┤
+やや複雑  │ Haskell: mapConcurrently     │ ← IO モナドが必要
+          │ Python: Pool.map()           │ ← プロセス分離が必要
+          └──────────────────────────────┘
+```
+
+### Reduce フェーズの実装
+
+| 言語 | Reduce 方法 | 特徴 |
+|------|-----------|------|
+| Python | `defaultdict(int)` + ループ | 命令的 |
+| Java | `Collectors.groupingBy` + `summingInt` | 宣言的コレクター |
+| C# | `GroupBy` + `Sum` | LINQ 統合 |
+| Scala | `groupBy` + `mapValues` + `sum` | 関数型コレクション |
+| F# | `List.groupBy` + `List.sumBy` | パイプライン |
+| Rust | `HashMap.entry().or_insert()` | Entry API |
+| Haskell | `foldl'` + `Map.insertWith (+)` | 純粋関数型 |
+| Clojure | `reduce` + `update` + `fnil` | 関数合成 |
+
+### パフォーマンス特性
+
+| 言語 | 並列化方式 | スレッドプール | 最適なケース |
+|------|----------|-------------|------------|
+| Python | プロセスプール | OS プロセス | CPU バウンド（GIL 回避） |
+| Java | ForkJoinPool | ワークスティーリング | 汎用並列処理 |
+| C# | ThreadPool | .NET ThreadPool | LINQ クエリ並列化 |
+| Scala | Fork/Join | ワークスティーリング | コレクション操作 |
+| F# | .NET ThreadPool | .NET ThreadPool | 配列操作 |
+| Rust | Rayon | ワークスティーリング | ゼロコスト並列化 |
+| Haskell | GHC RTS | Green Thread | I/O 並行処理 |
+| Clojure | JVM ThreadPool | 固定プール | 関数適用 |
+
+### アムダールの法則
+
+```
+高速化率 = 1 / (S + P/N)
+
+S = 逐次処理の割合
+P = 並列化可能な割合 (P = 1 - S)
+N = プロセッサ数
+
+例: 逐次 10%、並列 90%、4 コア
+高速化率 = 1 / (0.1 + 0.9/4) = 3.08 倍
+```
+
+並列化可能な部分（Map フェーズ）の割合が大きいほど、コア数に比例した高速化が期待できます。
+
+## 8.5 実践的な選択指針
+
+### 大規模データ処理に適した言語
+
+**最も適している**:
+
+- **Rust (Rayon)** — `fold` + `reduce` で Map と Reduce を一貫して並列化。ゼロコスト抽象化
+- **Java (parallelStream)** — エンタープライズ規模のデータ処理。Stream API の成熟度
+
+**手軽さ重視**:
+
+- **Scala (.par)** — ワンメソッドで並列化。ただし順序保証に注意
+- **C# (PLINQ)** — `.AsParallel()` で既存 LINQ クエリを即座に並列化
+- **Clojure (pmap)** — `map` を `pmap` に置き換えるだけ
+
+**関数型アプローチ**:
+
+- **Haskell** — 純粋関数は安全に並列化。`mapConcurrently` が宣言的
+- **F#** — `Array.Parallel` モジュールで配列操作を並列化
+
+## 8.6 まとめ
+
+### 言語横断的な学び
+
+1. **MapReduce は関数型の自然な拡張** — `map` + `reduce` を並列化するだけで大規模データ処理が可能
+2. **並列化の手軽さは言語の設計思想** — `.par` / `.AsParallel()` / `pmap` のワンメソッド並列化
+3. **Reduce の表現力** — 宣言的 (Java Collectors) vs 命令的 (Python ループ) vs 関数型 (Haskell foldl')
+4. **アムダールの法則** — 逐次部分の割合が並列化の効果を決定
+
+### 各言語の個別記事
+
+| 言語 | 個別記事 |
+|------|---------|
+| Python | [Part VIII - 分散並列処理](../python/part-8.md) |
+| Java | [Part VIII - 分散並列処理](../java/part-8.md) |
+| C# | [Part VIII - 分散並列処理](../csharp/part-8.md) |
+| Scala | [Part VIII - 分散並列処理](../scala/part-8.md) |
+| F# | [Part VIII - 分散並列処理](../fsharp/part-8.md) |
+| Rust | [Part VIII - 分散並列処理](../rust/part-8.md) |
+| Haskell | [Part VIII - 分散並列処理](../haskell/part-8.md) |
+| Clojure | [Part VIII - 分散並列処理](../clojure/part-8.md) |

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

@@ -0,0 +1,116 @@
+---
+title: Clojure で学ぶ並行処理
+description: Grokking Concurrency の Clojure 実装
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, stm
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Clojure で学ぶ並行処理
+
+## 概要
+
+本シリーズでは、Clojure の並行処理機能を使用して「Grokking Concurrency」の概念を実装します。
+
+Clojure は JVM 上で動作する関数型言語で、不変データ構造と強力な並行処理プリミティブを提供します。
+
+---
+
+## 目次
+
+| Part | タイトル | トピック |
+|------|----------|----------|
+| [Part I](part-1.md) | 逐次処理 | 基本、SHA-256 |
+| [Part II](part-2.md) | スレッド | future、Thread |
+| [Part III](part-3.md) | マルチタスキング | atom、イベント同期 |
+| [Part IV](part-4.md) | 並列パターン | Fork/Join、Pipeline |
+| [Part V](part-5.md) | 同期と排他制御 | STM、ref、dosync |
+| [Part VI](part-6.md) | ノンブロッキング I/O | future、promise |
+| [Part VII](part-7.md) | 非同期プログラミング | core.async |
+| [Part VIII](part-8.md) | 分散並列処理 | pmap、MapReduce |
+
+---
+
+## Clojure の並行処理プリミティブ
+
+### 1. Atom（アトム）
+
+```clojure
+;; CAS ベースの単一値更新
+(def counter (atom 0))
+(swap! counter inc)    ; インクリメント
+(reset! counter 0)     ; リセット
+@counter               ; 値を取得
+```
+
+### 2. Ref + STM（ソフトウェアトランザクショナルメモリ）
+
+```clojure
+;; 複数の値を同期的に更新
+(def account (ref 1000))
+(dosync
+  (alter account + 100))  ; トランザクション内で更新
+```
+
+### 3. Agent（エージェント）
+
+```clojure
+;; 非同期の状態更新
+(def logger (agent []))
+(send logger conj "message")  ; 非同期で更新
+```
+
+### 4. Future / Promise
+
+```clojure
+;; 非同期計算
+(def result (future (expensive-computation)))
+@result  ; 結果を待機
+
+;; Promise
+(def p (promise))
+(deliver p :done)
+@p
+```
+
+### 5. core.async
+
+```clojure
+(require '[clojure.core.async :refer [chan go >! <!]])
+
+(def ch (chan))
+(go (>! ch "hello"))     ; チャネルに送信
+(go (println (<! ch)))   ; チャネルから受信
+```
+
+---
+
+## 環境構築
+
+### Leiningen プロジェクト
+
+```bash
+lein new app grokking-concurrency-clojure
+```
+
+### 依存関係（project.clj）
+
+```clojure
+:dependencies [[org.clojure/clojure "1.11.1"]
+               [org.clojure/core.async "1.6.681"]
+               [buddy/buddy-core "1.11.423"]]
+```
+
+### テスト実行
+
+```bash
+lein test
+```
+
+---
+
+## 次のステップ
+
+[Part I](part-1.md) から始めて、逐次処理の基礎を学びます。

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

@@ -0,0 +1,108 @@
+---
+title: Part I - 逐次処理
+description: Clojure の基本と SHA-256 ハッシュ
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, sequential
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part I: 逐次処理
+
+## 概要
+
+本章では、Clojure の基本と逐次処理を学びます。
+
+---
+
+## PasswordCracker 実装
+
+### SHA-256 ハッシュ
+
+```clojure
+(ns grokking-concurrency.ch02.password-cracker
+  (:require [buddy.core.hash :as hash]
+            [buddy.core.codecs :as codecs]))
+
+(defn sha256
+  "SHA256 ハッシュを計算"
+  [s]
+  (-> (hash/sha256 s)
+      (codecs/bytes->hex)))
+```
+
+---
+
+## パスワード生成
+
+```clojure
+(def ^:private alphabet "abcdefghijklmnopqrstuvwxyz")
+
+(defn generate-password
+  "数値インデックスからパスワードを生成"
+  [index length]
+  (let [base (count alphabet)]
+    (loop [idx index
+           acc '()]
+      (if (= (count acc) length)
+        (apply str acc)
+        (recur (quot idx base)
+               (cons (nth alphabet (mod idx base)) acc))))))
+```
+
+---
+
+## 範囲検索
+
+```clojure
+(defn crack-password-range
+  "範囲内でパスワードを検索"
+  [target-hash start end length]
+  (loop [idx start]
+    (when (< idx end)
+      (let [password (generate-password idx length)
+            hash (sha256 password)]
+        (if (= hash target-hash)
+          password
+          (recur (inc idx)))))))
+```
+
+---
+
+## 逐次クラック
+
+```clojure
+(defn crack-password
+  "パスワードをクラック（逐次処理）"
+  [target-hash length]
+  (let [total-combinations (long (Math/pow (count alphabet) length))]
+    (crack-password-range target-hash 0 total-combinations length)))
+```
+
+---
+
+## 使用例
+
+```clojure
+(let [target-hash (sha256 "aabb")]
+  (crack-password target-hash 4))
+;; => "aabb"
+```
+
+---
+
+## Clojure の特徴
+
+| 特徴 | 説明 |
+|------|------|
+| 不変データ | デフォルトで不変 |
+| 遅延評価 | lazy sequences |
+| マクロ | コード生成 |
+| REPL | 対話的開発 |
+
+---
+
+## 次のステップ
+
+[Part II](part-2.md) では、スレッドと並列処理を学びます。

package/lib/assets/docs/article/grokking-concurrency/clojure/part-2.md

@@ -0,0 +1,101 @@
+---
+title: Part II - プロセスとスレッド
+description: future と並列パスワードクラック
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, clojure, threads
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part II: プロセスとスレッド
+
+## 概要
+
+本章では、Clojure のスレッド機能と future を学びます。
+
+---
+
+## スレッド基礎
+
+### Java Thread の使用
+
+```clojure
+(defn run-in-thread
+  "新しいスレッドでタスクを実行"
+  [task]
+  (let [thread (Thread. task)]
+    (.start thread)
+    thread))
+
+;; 使用例
+(run-in-thread #(println "Hello from thread!"))
+```
+
+---
+
+## future
+
+```clojure
+;; 非同期計算
+(def result (future
+              (Thread/sleep 1000)
+              (+ 1 2)))
+
+;; 結果を取得（ブロッキング）
+@result  ;; => 3
+```
+
+---
+
+## 並列パスワードクラック
+
+### チャンク分割
+
+```clojure
+(defn chunk-range
+  "範囲をチャンクに分割"
+  [start end num-chunks]
+  (let [size (- end start)
+        chunk-size (long (Math/ceil (/ size num-chunks)))]
+    (loop [current start
+           chunks []]
+      (if (>= current end)
+        chunks
+        (let [next-end (min (+ current chunk-size) end)]
+          (recur next-end (conj chunks [current next-end])))))))
+```
+
+---
+
+## 並列クラック
+
+```clojure
+(defn crack-password-parallel
+  "並列でパスワードをクラック"
+  [target-hash length num-threads]
+  (let [total-combinations (long (Math/pow 26 length))
+        chunks (chunk-range 0 total-combinations num-threads)
+        futures (doall
+                  (for [[start end] chunks]
+                    (future
+                      (crack-password-range target-hash start end length))))]
+    (some identity (map deref futures))))
+```
+
+---
+
+## future の特徴
+
+| 特徴 | 説明 |
+|------|------|
+| 非同期 | バックグラウンドで実行 |
+| キャッシュ | 結果は一度だけ計算 |
+| ブロッキング | deref で結果を待機 |
+| 例外 | deref 時に再スロー |
+
+---
+
+## 次のステップ
+
+[Part III](part-3.md) では、マルチタスキングを学びます。