@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/integration/05-dev-environment-comparison.md

@@ -0,0 +1,330 @@
+# 開発環境と CI/CD 比較
+
+本章では、12 言語の開発環境構築、ビルドツール、リンター / フォーマッタ、CI/CD パイプラインを比較します。本プロジェクトでは Nix によるすべての言語の開発環境統一を実現しています。
+
+## Nix による統一開発環境アプローチ
+
+### なぜ Nix か
+
+多言語プロジェクトでは、各言語のランタイム、パッケージマネージャ、ツールチェーンのバージョン管理が課題となります。Nix は以下の問題を解決します。
+
+| 課題 | 従来の解決策 | Nix の解決策 |
+|------|------------|------------|
+| ランタイムバージョン管理 | nvm, pyenv, rbenv 等 | `nix develop` で統一 |
+| ツールチェーンの競合 | Docker コンテナ | Nix プロファイルで分離 |
+| 再現可能な環境 | Dockerfile + pinning | `flake.lock` で完全再現 |
+| CI/CD との一貫性 | CI 設定で個別管理 | 同じ flake を使用 |
+
+### 開発環境の起動
+
+各言語の開発環境は以下のコマンドで起動します。
+
+```bash
+# Java 環境
+nix develop .#java
+
+# Python 環境
+nix develop .#python
+
+# TypeScript 環境
+nix develop .#node
+
+# Ruby 環境
+nix develop .#ruby
+
+# Go 環境
+nix develop .#go
+
+# PHP 環境
+nix develop .#php
+
+# Rust 環境
+nix develop .#rust
+
+# C# / F# 環境
+nix develop .#dotnet
+
+# Clojure 環境
+nix develop .#clojure
+
+# Scala 環境
+nix develop .#scala
+
+# Elixir 環境
+nix develop .#elixir
+
+# Haskell 環境
+nix develop .#haskell
+```
+
+### Nix Flake の構造
+
+```
+ops/nix/
+├── flake.nix          # エントリーポイント
+├── flake.lock         # 依存関係のロックファイル
+└── environments/      # 各言語の開発環境定義
+    ├── java.nix
+    ├── node.nix
+    ├── python.nix
+    ├── ruby.nix
+    ├── go.nix
+    ├── php.nix
+    ├── rust.nix
+    ├── dotnet.nix
+    ├── clojure.nix
+    ├── scala.nix
+    ├── elixir.nix
+    └── haskell.nix
+```
+
+## ビルドツール比較表
+
+| 言語 | ビルドツール | 設定ファイル | 依存管理 | タスクランナー |
+|------|------------|------------|---------|-------------|
+| Java | Gradle | `build.gradle` | Maven Central | Gradle tasks |
+| Python | pip / venv | `requirements.txt` / `pyproject.toml` | PyPI | Makefile / Taskfile |
+| TypeScript | npm | `package.json` | npm registry | npm scripts |
+| Ruby | Bundler | `Gemfile` | RubyGems | Rake |
+| Go | go mod | `go.mod` | Go Proxy | Makefile / Taskfile |
+| PHP | Composer | `composer.json` | Packagist | Composer scripts |
+| Rust | Cargo | `Cargo.toml` | crates.io | cargo / Makefile |
+| C# | .NET SDK | `.csproj` | NuGet | dotnet CLI |
+| F# | .NET SDK | `.fsproj` | NuGet | dotnet CLI |
+| Clojure | Leiningen | `project.clj` | Clojars / Maven | lein tasks |
+| Scala | sbt | `build.sbt` | Maven / Ivy | sbt tasks |
+| Elixir | Mix | `mix.exs` | Hex | mix tasks |
+| Haskell | Stack | `package.yaml` / `stack.yaml` | Stackage / Hackage | stack tasks |
+
+### ビルドコマンド比較
+
+| 言語 | ビルド | クリーン | 実行 |
+|------|-------|--------|------|
+| Java | `gradle build` | `gradle clean` | `gradle run` |
+| Python | - (インタプリタ) | - | `python -m app` |
+| TypeScript | `npm run build` | `rm -rf dist` | `npx ts-node src/index.ts` |
+| Ruby | - (インタプリタ) | - | `ruby lib/main.rb` |
+| Go | `go build` | `go clean` | `go run .` |
+| PHP | - (インタプリタ) | - | `php src/main.php` |
+| Rust | `cargo build` | `cargo clean` | `cargo run` |
+| C# | `dotnet build` | `dotnet clean` | `dotnet run` |
+| F# | `dotnet build` | `dotnet clean` | `dotnet run` |
+| Clojure | `lein compile` | `lein clean` | `lein run` |
+| Scala | `sbt compile` | `sbt clean` | `sbt run` |
+| Elixir | `mix compile` | `mix clean` | `mix run` |
+| Haskell | `stack build` | `stack clean` | `stack run` |
+
+## リンター / フォーマッタ比較表
+
+### リンター
+
+| 言語 | リンター | 検出対象 | 設定ファイル |
+|------|---------|---------|------------|
+| Java | Checkstyle | コーディングスタイル | `checkstyle.xml` |
+| Java | PMD | バグパターン、コード複雑度 | `pmd-ruleset.xml` |
+| Python | Ruff | スタイル + バグ + 複雑度 | `pyproject.toml` |
+| TypeScript | ESLint | スタイル + バグパターン | `eslint.config.js` |
+| Ruby | RuboCop | スタイル + バグパターン | `.rubocop.yml` |
+| Go | golangci-lint | スタイル + バグ + 複雑度 | `.golangci.yml` |
+| PHP | PHP_CodeSniffer | コーディングスタイル | `phpcs.xml` |
+| PHP | PHPStan | 静的解析（型チェック） | `phpstan.neon` |
+| PHP | PHPMD | コード複雑度 | `phpmd.xml` |
+| Rust | Clippy | バグパターン + スタイル | `clippy.toml` |
+| C# | dotnet format | スタイル | `.editorconfig` |
+| F# | FSharpLint | スタイル + 複雑度 | `fsharplint.json` |
+| Clojure | Eastwood | バグパターン | `project.clj` |
+| Clojure | Kibit | イディオム改善 | - |
+| Scala | WartRemover | バグパターン | `build.sbt` |
+| Elixir | Credo | スタイル + 複雑度 | `.credo.exs` |
+| Haskell | HLint | スタイル + イディオム | `.hlint.yaml` |
+
+### フォーマッタ
+
+| 言語 | フォーマッタ | 設定 |
+|------|------------|------|
+| Java | Checkstyle（スタイル統一） | `checkstyle.xml` |
+| Python | Ruff format | `pyproject.toml` |
+| TypeScript | Prettier | `.prettierrc` |
+| Ruby | RuboCop（自動修正） | `.rubocop.yml` |
+| Go | gofmt / goimports | 設定不要（標準） |
+| PHP | PHP_CodeSniffer（phpcbf） | `phpcs.xml` |
+| Rust | rustfmt | `rustfmt.toml` |
+| C# | dotnet format | `.editorconfig` |
+| F# | Fantomas | `.editorconfig` |
+| Clojure | cljfmt | `project.clj` |
+| Scala | scalafmt | `.scalafmt.conf` |
+| Elixir | mix format | `.formatter.exs` |
+| Haskell | Ormolu / Fourmolu | 設定不要（標準） |
+
+## CI/CD ワークフロー構成
+
+### GitHub Actions + Nix 共通パターン
+
+すべての言語で共通の CI/CD パターンを採用しています。
+
+```yaml
+# .github/workflows/ci.yml（共通パターン）
+name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        language: [java, python, node, ruby, go, php, rust, dotnet, clojure, scala, elixir, haskell]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Nix
+        uses: cachix/install-nix-action@v27
+        with:
+          nix_path: nixpkgs=channel:nixpkgs-unstable
+
+      - name: Run tests
+        run: |
+          nix develop .#${{ matrix.language }} --command bash -c "
+            cd apps/${{ matrix.language }}
+            # 言語共通: lint -> test -> coverage
+          "
+```
+
+### 言語別 CI コマンド
+
+| 言語 | lint | test | coverage |
+|------|------|------|---------|
+| Java | `gradle checkstyleMain pmdMain` | `gradle test` | `gradle jacocoTestReport` |
+| Python | `ruff check .` | `pytest` | `pytest --cov` |
+| TypeScript | `npx eslint . && npx prettier --check .` | `npx vitest run` | `npx vitest --coverage` |
+| Ruby | `rubocop` | `rake test` | SimpleCov（テスト実行時に自動生成） |
+| Go | `golangci-lint run` | `go test ./...` | `go test -coverprofile=coverage.out` |
+| PHP | `vendor/bin/phpcs && vendor/bin/phpstan && vendor/bin/phpmd` | `vendor/bin/phpunit` | `vendor/bin/phpunit --coverage-text` |
+| Rust | `cargo clippy && cargo fmt --check` | `cargo test` | `cargo tarpaulin` |
+| C# | `dotnet format --verify-no-changes` | `dotnet test` | `dotnet test --collect:"XPlat Code Coverage"` |
+| F# | `dotnet fsharplint lint` | `dotnet test` | `dotnet test --collect:"XPlat Code Coverage"` |
+| Clojure | `lein eastwood && lein kibit` | `lein test` | `lein cloverage` |
+| Scala | `sbt scalafmtCheck wartremoverCheck` | `sbt test` | `sbt coverage test coverageReport` |
+| Elixir | `mix credo` | `mix test` | `mix test --cover` |
+| Haskell | `stack exec -- hlint .` | `stack test` | HPC |
+
+## 品質ゲートの統一
+
+すべての言語で以下の品質ゲートを統一的に適用しています。
+
+### 3 段階の品質ゲート
+
+```
+┌──────────┐    ┌──────────┐    ┌──────────┐
+│  Lint    │───→│  Test    │───→│ Coverage │
+│  (静的)  │    │  (動的)  │    │  (網羅)  │
+└──────────┘    └──────────┘    └──────────┘
+     │               │               │
+     ▼               ▼               ▼
+ スタイル統一    全テスト通過    カバレッジ閾値
+ バグ検出        回帰テスト      未テスト箇所検出
+ 複雑度チェック   統合テスト
+```
+
+### 品質ゲート対応状況
+
+| 言語 | Lint | 複雑度チェック | テスト | カバレッジ |
+|------|------|-------------|-------|-----------|
+| Java | Checkstyle + PMD | PMD | JUnit 5 | JaCoCo |
+| Python | Ruff | Ruff (McCabe) | pytest | pytest-cov |
+| TypeScript | ESLint + Prettier | ESLint (complexity) | Vitest | v8/istanbul |
+| Ruby | RuboCop | RuboCop (Metrics) | Minitest | SimpleCov |
+| Go | golangci-lint | gocyclo | testing | go cover |
+| PHP | PHPCS + PHPStan + PHPMD | PHPMD | PHPUnit | PHPUnit |
+| Rust | Clippy + rustfmt | Clippy (cognitive) | cargo test | tarpaulin |
+| C# | dotnet format | - | xUnit | coverlet |
+| F# | FSharpLint | FSharpLint | xUnit | coverlet |
+| Clojure | Eastwood + Kibit | - | clojure.test | cloverage |
+| Scala | scalafmt + WartRemover | WartRemover | ScalaTest | scoverage |
+| Elixir | Credo | Credo (complexity) | ExUnit | cover |
+| Haskell | HLint | - | HSpec | HPC |
+
+## Taskfile による統一タスクランナー
+
+各言語のビルド / テスト / リント コマンドを `Taskfile.yml` で統一的に管理できます。
+
+```yaml
+# Taskfile.yml（共通タスク定義）
+version: '3'
+
+tasks:
+  lint:
+    desc: "全言語の lint を実行"
+    cmds:
+      - task: lint:java
+      - task: lint:python
+      # ...
+
+  test:
+    desc: "全言語のテストを実行"
+    cmds:
+      - task: test:java
+      - task: test:python
+      # ...
+
+  test:java:
+    dir: apps/java
+    cmds:
+      - gradle test
+
+  test:python:
+    dir: apps/python
+    cmds:
+      - pytest
+
+  test:node:
+    dir: apps/node
+    cmds:
+      - npx vitest run
+```
+
+## 開発ワークフローの統一
+
+### 共通の開発フロー
+
+```
+1. nix develop .#{lang}     # 環境起動
+2. cd apps/{lang}            # プロジェクトディレクトリに移動
+3. {test-command}            # テスト実行（Red）
+4. 実装                      # コード修正（Green）
+5. {test-command}            # テスト再実行
+6. {lint-command}            # リントチェック
+7. git commit               # コミット（Refactor 後）
+```
+
+### ウォッチモード対応
+
+| 言語 | ウォッチコマンド | 特徴 |
+|------|---------------|------|
+| Java | `gradle test --continuous` | 変更検知で自動テスト |
+| Python | `pytest-watch` | ファイル変更で自動テスト |
+| TypeScript | `npx vitest` | デフォルトでウォッチモード |
+| Ruby | `guard` | Guardfile で監視設定 |
+| Go | `go test -watch` (外部ツール) | air, entr 等 |
+| PHP | `phpunit-watcher` | ファイル変更で自動テスト |
+| Rust | `cargo watch -x test` | cargo-watch プラグイン |
+| C# | `dotnet watch test` | 標準対応 |
+| F# | `dotnet watch test` | 標準対応 |
+| Clojure | REPL + test | REPL 駆動で即時テスト |
+| Scala | `sbt ~test` | チルダ前置で継続実行 |
+| Elixir | `mix test --stale` | 変更ファイルのみテスト |
+| Haskell | `stack test --file-watch` | ファイル変更で自動テスト |
+
+## まとめ
+
+1. **Nix** により 12 言語の開発環境を `nix develop .#{lang}` の一コマンドで統一的に起動でき、環境構築の手間を大幅に削減しています
+2. **ビルドツール**は各言語のエコシステムに最適化されていますが、Taskfile で統一的なインターフェースを提供できます
+3. **リンター / フォーマッタ**はすべての言語で導入されており、「lint + complexity + test」の 3 段階品質ゲートを統一的に適用しています
+4. **CI/CD** は GitHub Actions + Nix の共通パターンで、matrix strategy により全言語のテストを並列実行できます
+5. **ウォッチモード**はほぼすべての言語で対応しており、TDD の Red-Green-Refactor サイクルを高速に回すことができます
+
+次章では、これらの言語をどの順序で学ぶべきかのロードマップを提示します。

package/lib/assets/docs/article/getting-start-tdd/integration/06-learning-roadmap.md

@@ -0,0 +1,274 @@
+# 学習ロードマップ
+
+本章では、12 言語を効果的に学ぶための推奨順序、各言語で習得できる概念、そして学習を深めるための次のステップを提示します。
+
+## 推奨学習順序
+
+### フェーズ 1: OOP の基盤（1-2 言語）
+
+まず OOP の基本概念を確実に身につけます。
+
+```
+Java ──→ Python
+ │         │
+ │         └─ マルチパラダイムの基礎
+ └─ OOP の王道、静的型付けの基礎
+```
+
+| 順序 | 言語 | 学習期間目安 | 習得する概念 |
+|------|------|-----------|------------|
+| 1 | **Java** | 2-3 週間 | クラス、インターフェース、継承、JUnit 5、Gradle |
+| 2 | **Python** | 1-2 週間 | 動的型付け、ABC、デコレータ、pytest |
+
+**Java を最初に学ぶ理由**:
+- 静的型付けと OOP の概念が明確に分かれている
+- JUnit 5 の構造が TDD の基本パターンを学ぶのに最適
+- エコシステムが成熟しており、学習リソースが豊富
+
+**Python を 2 番目に学ぶ理由**:
+- Java との対比で動的型付けの利点と欠点を体感できる
+- pytest のシンプルさが TDD の本質を理解させる
+- マルチパラダイムへの橋渡し
+
+### フェーズ 2: マルチパラダイムの拡張（2-3 言語）
+
+OOP の基盤の上に、異なるパラダイムの要素を積み上げます。
+
+```
+TypeScript ──→ Ruby ──→ Go or Rust
+     │           │         │
+     │           │         └─ 構造化/所有権という新概念
+     │           └─ OOP + ブロック/Lambda
+     └─ 型システムの拡張（ユニオン型、型ガード）
+```
+
+| 順序 | 言語 | 学習期間目安 | 習得する概念 |
+|------|------|-----------|------------|
+| 3 | **TypeScript** | 1-2 週間 | ユニオン型、型ガード、Vitest、ESLint |
+| 4 | **Ruby** | 1-2 週間 | ブロック/Proc/Lambda、Minitest、RuboCop |
+| 5a | **Go** | 1-2 週間 | 構造体、暗黙的インターフェース、テーブル駆動テスト |
+| 5b | **Rust** | 2-3 週間 | 所有権、借用、trait、Result/Option、Clippy |
+
+**Go と Rust はどちらか一方を選択、または順に学習**:
+- **Go**: シンプルさを重視する場合。インターフェースの構造的部分型が新鮮
+- **Rust**: 型安全性を深く理解したい場合。所有権システムが根本的に新しい
+
+### フェーズ 3: FP への展開（2-4 言語）
+
+関数型プログラミングの概念を段階的に導入します。
+
+```
+F# ──→ Scala ──→ Elixir or Clojure ──→ Haskell
+ │       │              │                   │
+ │       │              │                   └─ 純粋関数型の頂点
+ │       │              └─ BEAM/LISP の世界
+ │       └─ OOP + FP のハイブリッド
+ └─ .NET 上の FP 入門（C# からの橋渡し）
+```
+
+| 順序 | 言語 | 学習期間目安 | 習得する概念 |
+|------|------|-----------|------------|
+| 6 | **F#** | 1-2 週間 | 判別共用体、パイプライン、パターンマッチング |
+| 7 | **Scala** | 2-3 週間 | sealed trait、for 内包表記、Option/Either |
+| 8a | **Elixir** | 1-2 週間 | パターンマッチング、パイプライン、{:ok, :error} |
+| 8b | **Clojure** | 2-3 週間 | S 式、不変データ、プロトコル、REPL 駆動 |
+| 9 | **Haskell** | 3-4 週間 | 型クラス、モナド、遅延評価、do 記法 |
+
+**F# を FP の入口に選ぶ理由**:
+- C# と同じ .NET ランタイム上で動作し、既存知識を活かせる
+- 判別共用体とパターンマッチングが FP の核心を教えてくれる
+- パイプライン演算子がデータフローの思考法を身につけさせる
+
+**Haskell を最後に学ぶ理由**:
+- 純粋関数型の概念（モナド、型クラス）は他の FP 言語の基礎があると理解しやすい
+- 他の言語で「なぜ FP が有用か」を体感した後に、最も厳密な FP を学ぶ
+
+### PHP と C# の位置づけ
+
+PHP と C# は上記のフェーズに含まれていませんが、以下のタイミングで学ぶことを推奨します。
+
+| 言語 | 推奨タイミング | 理由 |
+|------|-------------|------|
+| **PHP** | フェーズ 1 の後 | Web 開発の文脈で OOP を再確認 |
+| **C#** | フェーズ 2 の後 | Java の知識を .NET に転用、F# への橋渡し |
+
+## 各言語で学べる概念マップ
+
+### TDD の基本概念
+
+| 概念 | 最もよく学べる言語 | 理由 |
+|------|----------------|------|
+| Red-Green-Refactor | Java, Python | シンプルな構造で本質に集中 |
+| テストファースト | すべて | 共通概念 |
+| 仮実装 | すべて | 共通概念 |
+| 三角測量 | Java, Go | テストテーブルが三角測量と相性が良い |
+| 明白な実装 | すべて | 共通概念 |
+
+### OOP 概念
+
+| 概念 | 最もよく学べる言語 | 理由 |
+|------|----------------|------|
+| カプセル化 | Java, C# | アクセス修飾子が明確 |
+| 継承 | Java, Ruby | 単一/Mixin 継承の対比 |
+| ポリモーフィズム（名前的） | Java, C#, TypeScript | interface の明示的実装 |
+| ポリモーフィズム（構造的） | Go, TypeScript | 暗黙的インターフェース |
+| デザインパターン | Java, C# | GoF パターンが直接適用 |
+| SOLID 原則 | Java, TypeScript | 依存性の注入が自然 |
+
+### FP 概念
+
+| 概念 | 最もよく学べる言語 | 理由 |
+|------|----------------|------|
+| 高階関数 | Python, TypeScript, Ruby | 馴染みやすい構文 |
+| パターンマッチング | Rust, F#, Scala, Elixir, Haskell | 言語レベルでサポート |
+| 不変データ | Clojure, Haskell, F# | デフォルトが不変 |
+| パイプライン | F#, Elixir | `\|>` 演算子 |
+| モナド | Haskell | 最も純粋な実装 |
+| 代数的データ型 | Haskell, F#, Rust, Scala | 判別共用体 / enum |
+| 遅延評価 | Haskell, Scala, Clojure | 言語レベルでサポート |
+| プロトコル / 型クラス | Clojure, Haskell | ad-hoc ポリモーフィズム |
+
+### 型システム概念
+
+| 概念 | 最もよく学べる言語 | 理由 |
+|------|----------------|------|
+| 静的型付け | Java, Go | 明示的な型宣言 |
+| 型推論 | Haskell, F#, Rust | HM 型推論 |
+| ジェネリクス | Java, TypeScript, Rust | 段階的に学べる |
+| Option/Result | Rust, Haskell | null なし言語 |
+| ユニオン型 | TypeScript, F# | 型で状態を表現 |
+| 型クラス | Haskell | ad-hoc ポリモーフィズム |
+| 所有権 / 借用 | Rust | メモリ安全性 |
+
+### 開発環境概念
+
+| 概念 | 最もよく学べる言語 | 理由 |
+|------|----------------|------|
+| パッケージ管理 | Node (npm), Python (pip) | 最もシンプル |
+| 静的解析 | Rust (Clippy), Go (golangci-lint) | 標準ツールが強力 |
+| CI/CD | すべて | Nix で統一 |
+| REPL 駆動開発 | Clojure, Elixir | REPL が開発の中心 |
+
+## 全体の学習マップ
+
+```
+                    ┌──────────────────────────────────────────┐
+                    │            フェーズ 3: FP               │
+                    │                                          │
+                    │   F# ──→ Scala ──→ Elixir/Clojure       │
+                    │    │                     │               │
+                    │    └─────────┬───────────┘               │
+                    │              ▼                            │
+                    │          Haskell                          │
+                    └──────────────┬───────────────────────────┘
+                                   │
+                    ┌──────────────┴───────────────────────────┐
+                    │       フェーズ 2: マルチパラダイム        │
+                    │                                          │
+                    │   TypeScript ──→ Ruby ──→ Go / Rust      │
+                    │       │                    │             │
+                    │       └── PHP              └── C#        │
+                    └──────────────┬───────────────────────────┘
+                                   │
+                    ┌──────────────┴───────────────────────────┐
+                    │        フェーズ 1: OOP 基盤              │
+                    │                                          │
+                    │         Java ──→ Python                   │
+                    └──────────────────────────────────────────┘
+```
+
+## 学習のヒント
+
+### 各フェーズで意識すべきこと
+
+**フェーズ 1**:
+- TDD の Red-Green-Refactor サイクルを体に染み込ませる
+- テストを「先に」書く習慣を確立する
+- 静的型付けと動的型付けの違いを体感する
+
+**フェーズ 2**:
+- 同じ FizzBuzz 仕様を異なる言語で実装し、「何が同じで何が違うか」を意識する
+- 各言語のイディオムを尊重する（Go のシンプルさ、Ruby の表現力）
+- リンターの指摘を通じて「その言語らしいコード」を学ぶ
+
+**フェーズ 3**:
+- 「なぜ不変データが有用か」を自分の言葉で説明できるようになる
+- パターンマッチングの威力を体感する
+- モナドを「怖いもの」ではなく「便利な道具」として理解する
+
+### 効果的な学習テクニック
+
+1. **比較学習**: 同じ仕様を 2 つの言語で実装し、差分を分析する
+2. **段階的深化**: まず FizzBuzz の基本、次に OOP リファクタリング、最後に FP リファクタリング
+3. **リンター活用**: リンターの指摘を「その言語のベストプラクティス」として学ぶ
+4. **テストから読む**: 新しい言語のコードを読む際は、テストファイルから読み始める
+
+## 次のステップ
+
+### プロジェクトへの応用
+
+本シリーズで学んだ TDD スキルを実際のプロジェクトに応用するためのガイドです。
+
+| ステップ | 内容 | 推奨言語 |
+|---------|------|---------|
+| Web API 開発 | REST API を TDD で構築 | Java (Spring), TypeScript (Express), Go (net/http) |
+| CLI ツール開発 | コマンドラインツールを TDD で構築 | Rust, Go, Python |
+| データ処理 | パイプラインによるデータ変換 | Elixir, Scala, F# |
+| 並行処理 | 並行/並列処理の実装 | Go (goroutine), Elixir (GenServer), Rust (tokio) |
+| ドメインモデリング | DDD + TDD | Java, TypeScript, F# |
+
+### 深い学習リソース
+
+#### TDD・設計
+
+| 書籍 | 著者 | 対応言語 |
+|------|------|---------|
+| テスト駆動開発 | Kent Beck | Java (原書), 全言語に適用可能 |
+| リファクタリング | Martin Fowler | Java / JavaScript |
+| Clean Code | Robert C. Martin | Java |
+| エクストリームプログラミング | Kent Beck | 言語非依存 |
+
+#### 言語別の深い学習
+
+| 言語 | 推奨書籍 / リソース |
+|------|-------------------|
+| Java | Effective Java (Joshua Bloch) |
+| Python | Fluent Python (Luciano Ramalho) |
+| TypeScript | Programming TypeScript (Boris Cherny) |
+| Ruby | Practical Object-Oriented Design (Sandi Metz) |
+| Go | The Go Programming Language (Donovan & Kernighan) |
+| Rust | The Rust Programming Language (Klabnik & Nichols) |
+| C# | C# in Depth (Jon Skeet) |
+| F# | Domain Modeling Made Functional (Scott Wlaschin) |
+| Clojure | Clojure for the Brave and True (Daniel Higginbotham) |
+| Scala | Programming in Scala (Odersky et al.) |
+| Elixir | Programming Elixir (Dave Thomas) |
+| Haskell | Learn You a Haskell for Great Good! (Miran Lipovaca) |
+
+#### FP 全般
+
+| 書籍 | 著者 | 特徴 |
+|------|------|------|
+| 関数型プログラミングの基礎 | - | FP の概念を日本語で |
+| Category Theory for Programmers | Bartosz Milewski | 圏論の基礎 |
+| Domain Modeling Made Functional | Scott Wlaschin | DDD + FP |
+
+### コミュニティ
+
+各言語のコミュニティに参加することで、学習を加速できます。
+
+- **GitHub**: 本プロジェクトの Issues / Discussions
+- **各言語の公式フォーラム**: Rust Users, Elixir Forum, Haskell Discourse 等
+- **カンファレンス**: RubyKaigi, PyCon, GopherCon, RustConf, ScalaMatsuri 等
+
+## まとめ
+
+12 言語の学習は一見膨大に感じますが、以下の戦略で効率的に進めることができます。
+
+1. **フェーズ分けして段階的に**: OOP → マルチパラダイム → FP の順で概念を積み上げる
+2. **FizzBuzz を共通題材に**: 同じ仕様を異なる言語で実装することで、差分に集中できる
+3. **TDD を軸に**: Red-Green-Refactor のサイクルはすべての言語で共通であり、言語を超えた普遍的スキルとなる
+4. **リンターに学ぶ**: 各言語のイディオムはリンターが教えてくれる
+5. **深さと広さのバランス**: すべての言語を深く学ぶ必要はなく、2-3 言語を深く、残りは概要を理解する
+
+本シリーズを通じて、テスト駆動開発の本質 -- 「動作するきれいなコード」を段階的に作り上げるプロセス -- は言語を超えて普遍的であることを体感していただければ幸いです。

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

@@ -0,0 +1,69 @@
+# 多言語統合解説
+
+本章では、12 言語（Java, Python, TypeScript, Ruby, Go, PHP, Rust, C#, F#, Clojure, Scala, Elixir, Haskell）による FizzBuzz TDD 実装を横断的に比較し、言語の設計思想、テストフレームワーク、TDD パターン、型システム、開発環境を統合的に解説します。
+
+## 本章の目的
+
+各言語の個別解説では、その言語固有の文法や開発フローに焦点を当てました。本章では視点を上げて、以下の問いに答えます。
+
+- パラダイムの違いは TDD にどのような影響を与えるか
+- テストフレームワークの設計は言語の哲学をどう反映しているか
+- 型システムの強さはエラーハンドリングにどう影響するか
+- Nix による統一開発環境は多言語プロジェクトにどう貢献するか
+
+## 対象言語一覧
+
+| 言語 | テスト FW | ビルドツール | リンター | パラダイム |
+|------|----------|-------------|---------|-----------|
+| Java | JUnit 5 | Gradle | Checkstyle, PMD | OOP |
+| Python | pytest | pip/venv | Ruff | マルチ |
+| TypeScript | Vitest | npm | ESLint, Prettier | マルチ |
+| Ruby | Minitest | Bundler | RuboCop | OOP/FP |
+| Go | testing | go mod | golangci-lint | 構造化 |
+| PHP | PHPUnit | Composer | PHP_CodeSniffer, PHPStan, PHPMD | OOP |
+| Rust | cargo test | Cargo | Clippy, rustfmt | マルチ |
+| C# | xUnit | .NET SDK | dotnet format | OOP |
+| F# | xUnit | .NET SDK | FSharpLint | FP/OOP |
+| Clojure | clojure.test | Leiningen | Eastwood, Kibit | FP |
+| Scala | ScalaTest | sbt | scalafmt, WartRemover | OOP/FP |
+| Elixir | ExUnit | Mix | Credo | FP |
+| Haskell | HSpec | Stack | HLint | 純粋 FP |
+
+> **Note**: C# と F# は dotnet 環境として 1 つのイテレーションにまとめています。
+
+## 章構成
+
+| 章 | タイトル | 内容 |
+|----|---------|------|
+| 1 | [12 言語の概要と分類](01-language-overview.md) | パラダイム分類、型システム、ランタイム、FizzBuzz コア実装比較 |
+| 2 | [テストフレームワーク比較](02-test-framework-comparison.md) | テスト構造、アサーション、実行コマンドの比較 |
+| 3 | [パラダイム別 TDD パターン比較](03-tdd-pattern-comparison.md) | OOP/FP の TDD、ポリモーフィズム、コマンドパターン比較 |
+| 4 | [型システムとエラーハンドリング比較](04-type-system-comparison.md) | 静的/動的型付け、Option/Result パターン、型安全性 |
+| 5 | [開発環境と CI/CD 比較](05-dev-environment-comparison.md) | Nix 統一環境、ビルド/リンター比較、CI/CD パターン |
+| 6 | [学習ロードマップ](06-learning-roadmap.md) | 推奨学習順序、概念マップ、次のステップ |
+
+## 読み方のガイド
+
+本章は以下の 3 通りの読み方を想定しています。
+
+### 通読
+
+第 1 章から順に読み進めることで、12 言語の全体像を俯瞰できます。
+
+### リファレンス
+
+特定のトピック（テストフレームワーク、型システムなど）に興味がある場合は、該当する章を直接参照してください。
+
+### 言語選択の参考
+
+新しい言語を学ぶ際のガイドとして、第 6 章の学習ロードマップから始めることをお勧めします。
+
+## 前提知識
+
+- 少なくとも 1 つの言語の個別解説を読了済み（推奨: Java または Python）
+- TDD の基本サイクル（Red-Green-Refactor）の理解
+- FizzBuzz 問題の仕様を把握済み
+
+## 凡例
+
+本章のコード例は、各言語の `apps/` ディレクトリにある実装から抽出しています。すべての開発環境は Nix（`nix develop .#{lang}`）で統一されています。