@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/getting-start-tdd/scala/11-collections-and-lazy-evaluation.md

@@ -1,103 +0,0 @@
----
-type: Article
-title: "第 11 章: コレクション処理と遅延評価"
-description: "Scala の強みの 1 つは、表現力の高いコレクションライブラリです。"
-tags: [article, getting-start-tdd, scala]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 11 章: コレクション処理と遅延評価
-
-## 11.1 はじめに
-
-Scala の強みの 1 つは、表現力の高いコレクションライブラリです。`List` や `Vector` を使った宣言的な処理により、ループ中心の実装より意図を明確に書けます。
-
-ここで重要なのが評価戦略です。
-
-- 正格評価（eager evaluation）: すぐに計算する
-- 遅延評価（lazy evaluation）: 必要になるまで計算しない
-
-## 11.2 イミュータブルコレクション
-
-Scala の標準コレクションは、デフォルトでイミュータブルを前提に設計されています。
-
-- `List`: 連結リスト。先頭追加や再帰的処理と相性がよい
-- `Vector`: ランダムアクセスに強い
-- `Map`: キーと値の対応
-- `Set`: 重複しない集合
-
-イミュータブルな設計により、副作用を抑えやすくなり、テストしやすいコードになります。
-
-## 11.3 コレクション操作の連鎖
-
-`map`、`flatMap`、`filter`、`foldLeft` を連鎖させると、データ変換の流れを自然に表現できます。
-
-```scala
-val numbers = (1 to 20).toList
-val result = numbers
-  .map(FizzBuzz.generate)
-  .filter(_ != "FizzBuzz")
-  .foldLeft(List.empty[String])((acc, v) => acc :+ v)
-```
-
-for 内包表記も同じ考え方で使えます。
-
-```scala
-val result = for
-  n <- 1 to 100
-  value = FizzBuzz.generate(n)
-  if value != n.toString
-yield value
-```
-
-for 内包表記は、`map`、`flatMap`、`filter` の組み合わせを読みやすく書くための構文糖衣です。
-
-## 11.4 LazyList による遅延評価
-
-FizzBuzz では無限シーケンスを `LazyList` で表現できます。
-
-```scala
-def lazyList: LazyList[String] =
-  LazyList.from(1).map(generate)
-```
-
-`LazyList.from(1)` は 1 から始まる無限列です。`map(generate)` を付けても、実際の計算は要素を取り出すまで実行されません。
-
-```scala
-val firstFive = FizzBuzz.lazyList.take(5).toList
-// List("1", "2", "Fizz", "4", "Buzz")
-```
-
-遅延評価の利点は次のとおりです。
-
-- 必要な分だけ計算するため無駄が少ない
-- 無限リストを安全に表現できる
-- `take`、`drop`、`filter` を組み合わせた逐次処理を書きやすい
-
-## 11.5 テスト
-
-`LazyList` は「必要なときだけ評価される」ことを確認するテストが重要です。
-
-```scala
-test("lazyList: 遅延リストから最初の 5 要素を取得する") {
-  val result = FizzBuzz.lazyList.take(5).toList
-  assert(result === List("1", "2", "Fizz", "4", "Buzz"))
-}
-
-test("lazyList: 遅延リストから 15 番目の要素を取得する") {
-  assert(FizzBuzz.lazyList(14) === "FizzBuzz")
-}
-```
-
-先頭数件だけを取り出すテストと、任意の位置の要素を直接参照するテストを組み合わせると、遅延シーケンスの振る舞いを網羅できます。
-
-## 11.6 まとめ
-
-この章では、Scala のコレクション処理と遅延評価を確認しました。
-
-- イミュータブルコレクションを前提に実装する
-- `map`、`flatMap`、`filter`、`foldLeft` を連鎖して処理を記述する
-- `LazyList` で無限シーケンスと必要時評価を実現する
-
-次章では、`Option` や `Either` を使った型安全なエラーハンドリングを扱います。

package/lib/assets/docs/article/getting-start-tdd/scala/12-error-handling-and-type-safety.md

@@ -1,101 +0,0 @@
----
-type: Article
-title: "第 12 章: エラーハンドリングと型安全性"
-description: "Scala では、例外を多用するよりも型でエラー可能性を表現する設計が推奨されます。"
-tags: [article, getting-start-tdd, scala]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 12 章: エラーハンドリングと型安全性
-
-## 12.1 はじめに
-
-Scala では、例外を多用するよりも型でエラー可能性を表現する設計が推奨されます。コンパイル時に考慮漏れを減らせるためです。
-
-この章では `Option`、`Either`、`Try`、`require` を使い、型安全なエラーハンドリングを整理します。
-
-## 12.2 Option 型
-
-`Option` は「値があるかもしれないし、ないかもしれない」を表現します。
-
-```scala
-def safeGenerate(number: Int): Option[String] =
-  if number > 0 then Some(generate(number))
-  else None
-```
-
-- `Some(value)`: 値あり
-- `None`: 値なし
-
-`Option` は `map`、`flatMap`、`getOrElse` と相性がよく、null チェックを置き換えられます。
-
-```scala
-val message = FizzBuzz.safeGenerate(3)
-  .map(v => s"結果: $v")
-  .getOrElse("入力が不正です")
-```
-
-## 12.3 Either 型
-
-`Either` は成功と失敗のどちらかを保持します。
-
-```scala
-def generateEither(number: Int): Either[String, String] =
-  if number > 0 then Right(generate(number))
-  else Left(s"正の整数が必要です: $number")
-```
-
-- `Right`: 成功値
-- `Left`: エラー情報
-
-`Either` を使うと、エラーを文字列やドメイン型で返せるため、例外より制御しやすくなります。複数処理の連鎖では for 内包表記も利用できます。
-
-```scala
-val result = for
-  a <- FizzBuzz.generateEither(3)
-  b <- FizzBuzz.generateEither(5)
-yield s"$a, $b"
-```
-
-## 12.4 Try 型
-
-`Try` は例外を値として扱う型です。例外が起きうる処理を安全に包めます。
-
-```scala
-import scala.util.Try
-
-val parsed: Try[Int] = Try("42".toInt)
-```
-
-`Try` は `Success` / `Failure` の 2 形です。`map` や `recover` と組み合わせると、例外処理を宣言的に記述できます。
-
-## 12.5 require による事前条件
-
-ドメインモデルの入力検証には `require` が使えます。
-
-```scala
-case class FizzBuzzValue(number: Int, value: String):
-  require(number > 0, s"数値は正の整数でなければなりません: $number")
-```
-
-不正な値でオブジェクトが作られることを防ぎ、ドメイン不変条件をコンストラクタ境界で守れます。
-
-## 12.6 型安全な設計のまとめ
-
-- `Option`: 値の有無を型で表現する
-- `Either`: 成功 / 失敗の分岐を型で表現する
-- `Try`: 例外を値として安全に扱う
-- `require`: 事前条件を明示し、不正状態を早期に排除する
-
-## 12.7 シリーズのまとめ
-
-全 12 章を通して、FizzBuzz を題材に TDD と Scala の設計原則を段階的に学びました。
-
-- TDD の基本サイクル（Red-Green-Refactor）
-- 開発環境の自動化
-- オブジェクト指向設計（ケースクラス、トレイト、パターンマッチ）
-- 関数型プログラミング（高階関数、コレクション、型安全なエラーハンドリング）
-- Scala の OOP と FP の統合
-
-小さな題材でも、設計・テスト・リファクタリングを繰り返すことで、実務で使える設計力を着実に伸ばせます。

package/lib/assets/docs/article/getting-start-tdd/scala/index.md

@@ -1,65 +0,0 @@
-# テスト駆動開発から始める Scala 入門
-
-## 概要
-
-本シリーズでは、テスト駆動開発（TDD）の実践を通じて Scala の特徴を学びます。FizzBuzz 問題を題材に、Red-Green-Refactor サイクルを体験しながら、Scala のオブジェクト指向と関数型プログラミングの両方を段階的に習得します。
-
-## 対象読者
-
-- プログラミングの基礎知識を持つ方
-- TDD に興味がある方
-- Scala や JVM 上の関数型プログラミングに興味がある方
-
-## 前提条件
-
-- Scala 3.x、sbt がインストールされていること
-- テキストエディタまたは IDE が利用可能であること
-- Git の基本操作ができること
-
-## Scala の特徴
-
-| 特徴 | 説明 |
-|------|------|
-| OOP と FP の統合 | オブジェクト指向と関数型プログラミングを自然に組み合わせ可能 |
-| 型推論 | 強力な型推論により型アノテーションを最小限に抑制 |
-| ケースクラス | 不変の値オブジェクトを簡潔に定義 |
-| パターンマッチ | 網羅的で型安全な分岐処理 |
-| トレイト | 柔軟なミックスインによるコード再利用 |
-| コレクションライブラリ | 統一的な API による豊富なコレクション操作 |
-| JVM 互換 | Java エコシステムとの完全な相互運用性 |
-
-## 開発ツール
-
-| ツール | 用途 |
-|--------|------|
-| sbt | ビルドツール・パッケージマネージャ |
-| ScalaTest | テスティングフレームワーク |
-| scalafmt | コードフォーマッタ |
-| WartRemover | 静的解析（コード品質チェック） |
-| Metals | Language Server Protocol 実装 |
-
-## 目次
-
-### 第 1 部: TDD の基本サイクル
-
-1. [第 1 章: TODO リストと最初のテスト](./01-todo-list-and-first-test.md)
-2. [第 2 章: 仮実装と三角測量](./02-fake-it-and-triangulation.md)
-3. [第 3 章: 明白な実装とリファクタリング](./03-obvious-implementation-and-refactoring.md)
-
-### 第 2 部: 開発環境と自動化
-
-4. [第 4 章: バージョン管理と Conventional Commits](./04-version-control-and-conventional-commits.md)
-5. [第 5 章: パッケージ管理と静的解析](./05-package-management-and-static-analysis.md)
-6. [第 6 章: タスクランナーと CI/CD](./06-task-runner-and-ci-cd.md)
-
-### 第 3 部: オブジェクト指向設計
-
-7. [第 7 章: ケースクラスとトレイトによるポリモーフィズム](./07-case-classes-and-traits.md)
-8. [第 8 章: パターンマッチとシールドトレイト](./08-pattern-matching-and-sealed-traits.md)
-9. [第 9 章: パッケージとモジュール設計](./09-packages-and-module-design.md)
-
-### 第 4 部: 関数型プログラミング
-
-10. [第 10 章: 高階関数と関数合成](./10-higher-order-functions-and-composition.md)
-11. [第 11 章: コレクション処理と遅延評価](./11-collections-and-lazy-evaluation.md)
-12. [第 12 章: エラーハンドリングと型安全性](./12-error-handling-and-type-safety.md)

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

@@ -1,403 +0,0 @@
-# Grokking Concurrency：多言語統合解説
-
-本記事シリーズは、8 つの言語（Python, Java, C#, Scala, F#, Rust, Haskell, Clojure）での実装を横断的に比較し、並行処理プログラミングの**本質**と**言語固有の表現**を統合的に解説します。
-
-## 本シリーズの目的
-
-各言語の個別記事は「その言語でどう実装するか」に焦点を当てています。本統合記事は、それらを横断して以下を明らかにします：
-
-- **共通の本質**: 言語を超えて成り立つ並行処理の原則
-- **言語間の差異**: ランタイム、メモリモデル、並行処理プリミティブの違いが実装にどう影響するか
-- **選択の指針**: どの言語・ライブラリがどの並行処理パターンに適しているか
-
-## 言語特性マトリクス
-
-### 言語分類
-
-| グループ | 言語 | 特徴 |
-|---------|------|------|
-| 関数型ファースト | Haskell, Clojure | 不変性・STM による安全な並行処理 |
-| マルチパラダイム（静的） | Scala, Rust, F# | 型システムを活用した並行処理の安全性保証 |
-| OOP ファースト + 並行処理ライブラリ | Java, C#, Python | プラットフォームの並行処理 API を活用 |
-
-### 特性比較
-
-| 特性 | Python | Java | C# | Scala | F# | Rust | Haskell | Clojure |
-|------|--------|------|-----|-------|-----|------|---------|---------|
-| 実行環境 | CPython | JVM | .NET (CLR) | JVM | .NET (CLR) | ネイティブ | GHC | JVM |
-| スレッドモデル | OS スレッド (GIL) | OS スレッド + Virtual Thread | OS スレッド + Task | OS スレッド + Future | OS スレッド + Async | OS スレッド | Green Thread | OS スレッド (JVM) |
-| 軽量タスク | asyncio Task | Virtual Thread (21+) | Task (TPL) | Future | Async ワークフロー | tokio Task | forkIO | core.async go ブロック |
-| 排他制御 | threading.Lock | synchronized / ReentrantLock | lock / Monitor | synchronized | MailboxProcessor | Mutex / RwLock | MVar / TVar | atom / ref |
-| 共有状態管理 | Lock + 変数 | synchronized | lock + volatile | synchronized | Agent / MailboxProcessor | Arc\<Mutex\<T\>\> | STM / TVar | atom / ref / STM |
-| チャネル / メッセージ | queue.Queue | BlockingQueue | Channel | なし（標準） | MailboxProcessor | mpsc / crossbeam | Chan / TChan | core.async chan |
-| 非同期 I/O | asyncio | NIO / CompletableFuture | async/await (Task) | Future | Async ワークフロー | tokio (async/await) | async ライブラリ | core.async |
-| 並列イテレータ | multiprocessing.Pool | parallelStream | Parallel LINQ | .par | Array.Parallel | Rayon par_iter | par (parallel) | pmap / reducers |
-| メモリ安全性 | ランタイム (GIL) | ランタイム (JVM) | ランタイム (CLR) | ランタイム (JVM) | ランタイム (CLR) | コンパイル時 (所有権) | ランタイム (GC) | ランタイム (JVM) |
-| データ競合防止 | GIL（部分的） | ランタイム検出 | ランタイム検出 | ランタイム検出 | 型レベル（部分的） | コンパイル時 (Send/Sync) | 型レベル (STM) | 不変データ + STM |
-
-## 記事構成
-
-### Part I: 並行処理の基礎（第 2 章）
-
-| Part | 統合記事 | テーマ | 比較のポイント |
-|------|---------|--------|---------------|
-| I | [並行処理の基礎](./part-1-ch02-sequential.md) | 逐次処理、パスワードクラッキング | 各言語の基本構文、イテレーション、ハッシュ計算の表現スタイル |
-
-#### 主な言語間比較テーマ
-
-- **基本構文**: 各言語のループ・イテレーション表現（for vs イテレータ vs 再帰）
-- **ハッシュ計算**: 標準ライブラリ vs サードパーティ（sha2 crate vs MessageDigest vs hashlib）
-- **パフォーマンス計測**: 各言語のベンチマーク手法の違い
-
-### Part II: プロセスとスレッド（第 4-5 章）
-
-| Part | 統合記事 | テーマ | 比較のポイント |
-|------|---------|--------|---------------|
-| II | [プロセスとスレッド](./part-2-ch04-05-threads.md) | プロセス、スレッド、スレッドプール | スレッド生成 API、ライフサイクル管理、IPC の違い |
-
-#### 主な言語間比較テーマ
-
-- **スレッド生成**: `std::thread::spawn` vs `Thread()` vs `threading.Thread` vs `forkIO` vs `future`
-- **スレッドプール**: Rayon vs ExecutorService vs ThreadPoolExecutor vs Async ワークフロー
-- **所有権とスレッド**: Rust の `Send`/`Sync` トレイト vs 他言語のランタイム保護
-
-### Part III: マルチタスキングとスケジューリング（第 6 章）
-
-| Part | 統合記事 | テーマ | 比較のポイント |
-|------|---------|--------|---------------|
-| III | [マルチタスキング](./part-3-ch06-multitasking.md) | タイムシェアリング、ゲームループ | イベントループ、条件変数、協調的マルチタスキングの実現方法 |
-
-#### 主な言語間比較テーマ
-
-- **ゲームループ**: Condvar (Rust) vs wait/notify (Java) vs Monitor (C#) vs MVar (Haskell)
-- **協調的スケジューリング**: asyncio (Python) vs core.async (Clojure) vs Async (F#)
-- **プリエンプティブ vs 協調的**: 各言語ランタイムのスケジューリングモデル
-
-### Part IV: タスク分解と並列パターン（第 7 章）
-
-| Part | 統合記事 | テーマ | 比較のポイント |
-|------|---------|--------|---------------|
-| IV | [並列パターン](./part-4-ch07-parallel-patterns.md) | Fork/Join、パイプライン、データ並列 | 並列パターンのイディオム、チャネル vs ストリーム |
-
-#### 主な言語間比較テーマ
-
-- **Fork/Join**: ForkJoinPool (Java/Scala) vs Rayon (Rust) vs parallel (Haskell) vs pmap (Clojure)
-- **パイプライン**: mpsc (Rust) vs BlockingQueue (Java) vs Channel (C#) vs core.async pipeline (Clojure)
-- **データ並列**: parallelStream (Java) vs par_iter (Rust) vs Array.Parallel (F#) vs pmap (Clojure)
-
-### Part V: 同期と排他制御（第 8-9 章）
-
-| Part | 統合記事 | テーマ | 比較のポイント |
-|------|---------|--------|---------------|
-| V | [同期と排他制御](./part-5-ch08-09-synchronization.md) | Race Condition、Lock、Semaphore、デッドロック | 排他制御の抽象度、デッドロック防止策の違い |
-
-#### 主な言語間比較テーマ
-
-- **排他制御**: `Mutex<T>` (Rust) vs `synchronized` (Java) vs `lock` (C#) vs STM (Haskell/Clojure)
-- **デッドロック回避**: Rust のコンパイル時検出 vs Haskell STM の楽観的並行制御 vs ロック順序規約
-- **不変性による回避**: Clojure の永続データ構造 + atom vs Haskell の純粋性による副作用分離
-
-### Part VI: ノンブロッキング I/O（第 10-11 章）
-
-| Part | 統合記事 | テーマ | 比較のポイント |
-|------|---------|--------|---------------|
-| VI | [ノンブロッキング I/O](./part-6-ch10-11-nonblocking-io.md) | ブロッキング vs ノンブロッキング、イベントループ、Reactor パターン | I/O モデル、イベントループ実装、Reactor パターンの表現 |
-
-#### 主な言語間比較テーマ
-
-- **I/O モデル**: NIO (Java) vs async I/O (Python) vs tokio (Rust) vs async ワークフロー (F#)
-- **イベントループ**: asyncio (Python) vs libuv 相当 (tokio) vs GHC I/O マネージャ (Haskell)
-- **Reactor パターン**: Selector (Java) vs epoll/kqueue ラッパー (Rust) vs 各言語の抽象化レベル
-
-### Part VII: 非同期プログラミング（第 12 章）
-
-| Part | 統合記事 | テーマ | 比較のポイント |
-|------|---------|--------|---------------|
-| VII | [非同期プログラミング](./part-7-ch12-async.md) | Future、Coroutine、async/await | async/await の意味論、Future/Promise の型表現 |
-
-#### 主な言語間比較テーマ
-
-- **async/await**: Rust (ゼロコスト Future) vs Python (コルーチン) vs C# (Task ベース) vs Scala (Future)
-- **コルーチン**: Python ジェネレータ vs Clojure go ブロック vs Haskell 軽量スレッド
-- **Future の型表現**: `Future<Output=T>` (Rust) vs `CompletableFuture<T>` (Java) vs `Task<T>` (C#) vs `Async<'a>` (F#)
-
-### Part VIII: 分散並列処理（第 13 章）
-
-| Part | 統合記事 | テーマ | 比較のポイント |
-|------|---------|--------|---------------|
-| VIII | [分散並列処理](./part-8-ch13-mapreduce.md) | MapReduce、ワードカウント、行列乗算 | MapReduce の関数型的表現、並列コレクション |
-
-#### 主な言語間比較テーマ
-
-- **MapReduce**: parallelStream (Java) vs par_iter (Rust) vs pmap/reducers (Clojure) vs parMap (Haskell)
-- **並列コレクション**: Scala `.par` vs Rayon vs Array.Parallel (F#) vs multiprocessing.Pool (Python)
-- **関数型的表現**: map/reduce の合成、不変データ構造上での並列演算
-
-## 各章の統合記事構成テンプレート
-
-各統合記事は以下の構成で執筆します：
-
-```
-1. はじめに
-   - テーマの概要と並行処理での意義
-
-2. 共通の本質
-   - 言語を超えて成り立つ並行処理の原則
-
-3. 言語別実装比較
-   - 8 言語の代表的なコードを並べて比較
-   - 各言語のイディオムを活かした実装の違い
-   - 言語グループ別の傾向分析
-
-4. 比較分析
-   - ランタイムとメモリモデルの影響
-   - 安全性保証のアプローチ（コンパイル時 vs ランタイム）
-   - 表現力と安全性のトレードオフ
-
-5. 実践的な選択指針
-   - どの言語特性がこのテーマに最も適しているか
-   - ユースケースに応じた選択基準
-
-6. まとめ
-   - 言語横断的な学び
-   - 各言語の個別記事へのリンク
-```
-
-## 執筆ルール
-
-### 1. 執筆フォーマット
-
-````markdown
-# Part N: パートタイトル
-
-## N.1 セクションタイトル
-
-本文...
-
-### 言語別実装比較
-
-#### 関数型ファースト言語
-
-<details>
-<summary>Haskell 実装</summary>
-
-```haskell
--- コード例
-```
-
-</details>
-
-<details>
-<summary>Clojure 実装</summary>
-
-```clojure
-;; コード例
-```
-
-</details>
-
-#### マルチパラダイム言語
-
-<details>
-<summary>Scala 実装</summary>
-
-```scala
-// コード例
-```
-
-</details>
-
-<details>
-<summary>Rust 実装</summary>
-
-```rust
-// コード例
-```
-
-</details>
-
-<details>
-<summary>F# 実装</summary>
-
-```fsharp
-// コード例
-```
-
-</details>
-
-#### OOP + 並行処理ライブラリ言語
-
-<details>
-<summary>Java 実装</summary>
-
-```java
-// コード例
-```
-
-</details>
-
-<details>
-<summary>C# 実装</summary>
-
-```csharp
-// コード例
-```
-
-</details>
-
-<details>
-<summary>Python 実装</summary>
-
-```python
-# コード例
-```
-
-</details>
-````
-
-### 2. リスト記述ルール
-
-タスク項目やリスト項目は、ラベル行の後に **1 行空けて** から記述します。
-
-**OK**:
-
-```markdown
-**比較ポイント**:
-
-- 排他制御の抽象度
-- パフォーマンス特性
-- 安全性保証
-```
-
-### 3. 言語グループ別の整理
-
-コード比較では 8 言語を以下のグループに分けて提示します：
-
-1. **関数型ファースト**: Haskell → Clojure
-2. **マルチパラダイム（静的）**: Scala → Rust → F#
-3. **OOP + 並行処理ライブラリ**: Java → C# → Python
-
-## 執筆計画
-
-### 概要
-
-全 8 Part の統合記事を、Part ごとの統合難易度に基づき 3 つのイテレーションで執筆します。
-
-- **総ソース量**: 8 言語 × 8 Part = 64 ファイル
-- **統合記事数**: 8 本
-- **各記事の想定規模**: 500〜1,000 行
-
-### 難易度分類
-
-| 難易度 | Part 数 | 特徴 |
-|--------|---------|------|
-| Low | 3 Part（I-III） | 全言語で構造が一貫、基礎概念で統合しやすい |
-| Medium | 3 Part（IV, VII, VIII） | パターンの表現方法に言語差があるが共通構造あり |
-| High | 2 Part（V, VI） | 同期モデル・I/O モデルが言語ごとに根本的に異なる |
-
-### イテレーション 1: 基礎と並行処理入門（Low 難易度）
-
-**対象**: Part I + Part II + Part III（第 2, 4-6 章）
-
-全言語で概念構造が一貫しており、統合が最も容易です。
-
-| Part | タイトル | 難易度 | 統合方針 |
-|------|---------|--------|---------|
-| I | 並行処理の基礎 | Low | 逐次処理の表現を全言語で横断比較 |
-| II | プロセスとスレッド | Low | スレッド生成・管理の API を言語別に比較 |
-| III | マルチタスキング | Low | ゲームループ実装を通じたイベント駆動モデルの比較 |
-
-**執筆順序**: I → II → III
-
-**完了条件**:
-
-- [ ] 各 Part が統合記事構成テンプレートに準拠
-- [ ] 8 言語すべてのコード例を含む
-- [ ] 言語グループ別の傾向分析を含む
-
-### イテレーション 2: 並列パターンと非同期（Medium 難易度）
-
-**対象**: Part IV + Part VII + Part VIII（第 7, 12, 13 章）
-
-並列パターンの表現差が大きいが、共通のアルゴリズム構造を軸に統合可能です。
-
-| Part | タイトル | 難易度 | 統合方針 |
-|------|---------|--------|---------|
-| IV | タスク分解と並列パターン | Medium | Fork/Join・パイプラインの構造を軸に言語別実装を比較 |
-| VII | 非同期プログラミング | Medium | async/await と Future/Promise の型表現を比較 |
-| VIII | 分散並列処理 | Medium | MapReduce の関数型的表現と並列コレクションを比較 |
-
-**執筆順序**: IV → VIII → VII
-
-**完了条件**:
-
-- [ ] Fork/Join パターンの 8 言語比較表を含む
-- [ ] async/await の意味論の違いを図解
-- [ ] MapReduce のパフォーマンス特性の比較を含む
-
-### イテレーション 3: 同期と I/O モデル（High 難易度）
-
-**対象**: Part V + Part VI（第 8-11 章）
-
-同期モデルと I/O モデルが言語ごとに根本的に異なり、最難関です。
-
-| Part | タイトル | 難易度 | 統合方針 |
-|------|---------|--------|---------|
-| V | 同期と排他制御 | High | Lock/STM/所有権の根本的な違いを言語別に深掘り |
-| VI | ノンブロッキング I/O | High | Reactor パターンと I/O モデルの違いを言語別に解説 |
-
-**執筆順序**: V → VI
-
-**完了条件**:
-
-- [ ] 排他制御モデル（Lock vs STM vs 所有権）の比較表を含む
-- [ ] I/O モデル（ブロッキング vs ノンブロッキング vs 非同期）の比較表を含む
-- [ ] デッドロック防止策の言語別アプローチを比較
-
-### 全体スケジュール
-
-| イテレーション | Part 数 | 難易度構成 | 主な課題 |
-|---------------|---------|-----------|---------|
-| 1 | 3 Part（I-III） | Low × 3 | ウォームアップ、8 言語比較のフォーマット確立 |
-| 2 | 3 Part（IV, VII, VIII） | Medium × 3 | 並列パターンの表現差の整理、async モデルの比較 |
-| 3 | 2 Part（V, VI） | High × 2 | 同期モデル・I/O モデルの根本的差異への対応 |
-
-### 進捗管理
-
-| Part | タイトル | イテレーション | 難易度 | 状態 |
-|------|---------|---------------|--------|------|
-| I | 並行処理の基礎 | 1 | Low | 完了 |
-| II | プロセスとスレッド | 1 | Low | 完了 |
-| III | マルチタスキング | 1 | Low | 完了 |
-| IV | タスク分解と並列パターン | 2 | Medium | 完了 |
-| V | 同期と排他制御 | 3 | High | 完了 |
-| VI | ノンブロッキング I/O | 3 | High | 完了 |
-| VII | 非同期プログラミング | 2 | Medium | 完了 |
-| VIII | 分散並列処理 | 2 | Medium | 完了 |
-
-## 言語別個別記事へのリンク
-
-| 言語 | 並行処理ライブラリ | 個別記事一覧 |
-|------|-------------------|-------------|
-| Python | threading, asyncio, multiprocessing | [全 8 Part](../python/index.md) |
-| Java | ExecutorService, CompletableFuture, Virtual Thread | [全 8 Part](../java/index.md) |
-| C# | Task (TPL), async/await, Channel | [全 8 Part](../csharp/index.md) |
-| Scala | Future, synchronized, Parallel Collections | [全 8 Part](../scala/index.md) |
-| F# | Async ワークフロー, MailboxProcessor, Agent | [全 8 Part](../fsharp/index.md) |
-| Rust | std::thread, Rayon, tokio | [全 8 Part](../rust/index.md) |
-| Haskell | forkIO, async, STM | [全 8 Part](../haskell/index.md) |
-| Clojure | atom, ref/STM, core.async | [全 8 Part](../clojure/index.md) |
-
-## 参照
-
-- 「Grokking Concurrency」Kirill Bobrov, Manning Publications
-- [Python threading ドキュメント](https://docs.python.org/3/library/threading.html)
-- [Java Concurrency in Practice](https://jcip.net/)
-- [C# 非同期プログラミング](https://docs.microsoft.com/ja-jp/dotnet/csharp/async)
-- [Scala 並行処理ドキュメント](https://docs.scala-lang.org/overviews/core/futures.html)
-- [F# 非同期プログラミング](https://docs.microsoft.com/ja-jp/dotnet/fsharp/tutorials/async)
-- [Rust Fearless Concurrency](https://doc.rust-lang.org/book/ch16-00-concurrency.html)
-- [Haskell Concurrency](https://wiki.haskell.org/Concurrency)
-- [Clojure Concurrency](https://clojure.org/about/concurrent_programming)
-- [Rayon](https://github.com/rayon-rs/rayon)
-- [Tokio](https://tokio.rs/)