@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,386 +0,0 @@
----
-type: Article
-title: "Part VIII: 分散並列処理"
-description: "本章では、大規模データを複数のプロセッサで効率的に処理する MapReduce パターンを学びます。"
-tags: [article, grokking-concurrency, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,106 +0,0 @@
-# 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

@@ -1,107 +0,0 @@
----
-type: Article
-title: "Part I - 逐次処理"
-description: "Clojure の基本と SHA-256 ハッシュ"
-tags: [article, grokking-concurrency, clojure, concurrency, sequential]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,100 +0,0 @@
----
-type: Article
-title: "Part II - プロセスとスレッド"
-description: "future と並列パスワードクラック"
-tags: [article, grokking-concurrency, clojure, concurrency, threads]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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) では、マルチタスキングを学びます。