@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/grokking-concurrency/scala/part-4.md

@@ -1,109 +0,0 @@
----
-type: Article
-title: "Part IV - タスク分解と並列パターン"
-description: "Fork/Join パターンとパイプラインパターン"
-tags: [article, grokking-concurrency, scala, concurrency, fork-join, pipeline]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part IV: タスク分解と並列パターン
-
-## 概要
-
-本章では、Fork/Join パターンとパイプラインパターンを学びます。
-
----
-
-## Fork/Join パターン: 投票カウンター
-
-### 逐次カウント
-
-```scala
-object VoteCounter:
-  /** Count votes sequentially */
-  def countVotes(votes: List[String]): Map[String, Int] =
-    votes.groupBy(identity).view.mapValues(_.size).toMap
-
-  /** Merge two vote count results */
-  def mergeResults(a: Map[String, Int], b: Map[String, Int]): Map[String, Int] =
-    (a.keys ++ b.keys).map { key =>
-      key -> (a.getOrElse(key, 0) + b.getOrElse(key, 0))
-    }.toMap
-```
-
-### 並列カウント
-
-```scala
-import scala.concurrent.{Future, Await, ExecutionContext}
-import scala.concurrent.duration.Duration
-
-given ExecutionContext = ExecutionContext.global
-
-/** Count votes using fork-join pattern */
-def countVotesParallel(votes: List[String]): Map[String, Int] =
-  if votes.isEmpty then return Map.empty
-
-  val numCores = Runtime.getRuntime.availableProcessors()
-  val chunkSize = math.max(1, votes.size / numCores)
-  val chunks = votes.grouped(chunkSize).toList
-
-  val futures = chunks.map { chunk =>
-    Future(countVotes(chunk))
-  }
-
-  val results = futures.map(f => Await.result(f, Duration.Inf))
-  results.reduce(mergeResults)
-```
-
----
-
-## パイプラインパターン
-
-```scala
-case class Stage(name: String, processor: Any => Any)
-
-class Pipeline[T](stages: List[Stage] = List.empty):
-
-  /** Add a stage to the pipeline */
-  def addStage[A, B](name: String, processor: A => B): Pipeline[T] =
-    new Pipeline[T](stages :+ Stage(name, x => processor(x.asInstanceOf[A])))
-
-  /** Process data through all stages */
-  def process(data: List[T]): List[Any] =
-    if stages.isEmpty then return data
-
-    data.map { item =>
-      stages.foldLeft[Any](item) { (current, stage) =>
-        stage.processor(current)
-      }
-    }
-
-object Pipeline:
-  def apply[T](): Pipeline[T] = new Pipeline[T]()
-```
-
-### 使用例
-
-```scala
-val pipeline = Pipeline[Int]()
-  .addStage("double", (x: Int) => x * 2)
-  .addStage("addOne", (x: Int) => x + 1)
-
-val results = pipeline.process(List(1, 2, 3))
-// List(3, 5, 7)
-```
-
----
-
-## ポイント
-
-- **groupBy + mapValues**: 関数型スタイルの集計
-- **foldLeft**: ステージを順次適用
-- **ビルダーパターン**: 流暢なインターフェース
-
----
-
-## 次のステップ
-
-[Part V](part-5.md) では、同期と排他制御を学びます。

package/lib/assets/docs/article/grokking-concurrency/scala/part-5.md

@@ -1,118 +0,0 @@
----
-type: Article
-title: "Part V - 同期と排他制御"
-description: "銀行口座で学ぶロックとデッドロック回避"
-tags: [article, grokking-concurrency, scala, concurrency, synchronization, lock]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part V: 同期と排他制御
-
-## 概要
-
-本章では、銀行口座を例に同期とデッドロック回避を学びます。
-
----
-
-## 銀行口座クラス
-
-```scala
-class BankAccount(initialBalance: Int):
-  private val lock = new Object
-  private var balance: Int = initialBalance
-
-  def getBalance: Int = lock.synchronized {
-    balance
-  }
-
-  def deposit(amount: Int): Unit = lock.synchronized {
-    balance += amount
-  }
-
-  def withdraw(amount: Int): Boolean = lock.synchronized {
-    if balance >= amount then
-      balance -= amount
-      true
-    else
-      false
-  }
-```
-
----
-
-## デッドロック回避
-
-```scala
-object BankAccount:
-  /** Transfer money between accounts atomically, avoiding deadlock */
-  def transfer(from: BankAccount, to: BankAccount, amount: Int): Boolean =
-    // Always lock in consistent order to avoid deadlock
-    val (first, second) = if System.identityHashCode(from) < System.identityHashCode(to)
-      then (from, to)
-      else (to, from)
-
-    first.lock.synchronized {
-      second.lock.synchronized {
-        if from.balance >= amount then
-          from.balance -= amount
-          to.balance += amount
-          true
-        else
-          false
-      }
-    }
-```
-
----
-
-## デッドロックとは
-
-2 つのスレッドが互いのロックを待つ状態:
-
-```
-Thread A: lock(account1) -> waiting for lock(account2)
-Thread B: lock(account2) -> waiting for lock(account1)
-```
-
-### 解決策: ロック順序の統一
-
-`System.identityHashCode` を使用してロック順序を決定することで、すべてのスレッドが同じ順序でロックを取得します。
-
----
-
-## 並行テスト
-
-```scala
-test("BankAccount should handle concurrent transfers safely"):
-  val account1 = new BankAccount(1000)
-  val account2 = new BankAccount(1000)
-
-  val executor = Executors.newFixedThreadPool(10)
-  val latch = new CountDownLatch(100)
-
-  (1 to 50).foreach { _ =>
-    executor.submit(new Runnable:
-      def run(): Unit =
-        BankAccount.transfer(account1, account2, 10)
-        latch.countDown()
-    )
-    executor.submit(new Runnable:
-      def run(): Unit =
-        BankAccount.transfer(account2, account1, 10)
-        latch.countDown()
-    )
-  }
-
-  latch.await()
-  executor.shutdown()
-
-  // Total balance should be preserved
-  (account1.getBalance + account2.getBalance) shouldBe 2000
-```
-
----
-
-## 次のステップ
-
-[Part VI](part-6.md) では、ノンブロッキング I/O を学びます。

package/lib/assets/docs/article/grokking-concurrency/scala/part-6.md

@@ -1,82 +0,0 @@
----
-type: Article
-title: "Part VI - ノンブロッキング I/O"
-description: "NIO と Selector パターン"
-tags: [article, grokking-concurrency, scala, concurrency, nio, nonblocking]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VI: ノンブロッキング I/O
-
-## 概要
-
-本章では、Java NIO を使用したノンブロッキング I/O を学びます。
-
----
-
-## ブロッキング vs ノンブロッキング
-
-### ブロッキング I/O
-
-```scala
-// スレッドは I/O 完了まで待機
-val socket = new Socket("localhost", 8080)
-val input = socket.getInputStream
-val data = input.read() // ブロック
-```
-
-### ノンブロッキング I/O
-
-```scala
-import java.nio.channels._
-import java.nio.ByteBuffer
-
-val channel = SocketChannel.open()
-channel.configureBlocking(false)
-channel.connect(new InetSocketAddress("localhost", 8080))
-
-// 接続が完了していなければすぐに戻る
-while !channel.finishConnect() do
-  // 他の作業ができる
-```
-
----
-
-## Selector パターン
-
-```scala
-import java.nio.channels.{Selector, SelectionKey}
-
-val selector = Selector.open()
-channel.register(selector, SelectionKey.OP_READ)
-
-// イベントを待機
-while true do
-  selector.select() // ブロック（イベントがあるまで）
-
-  val keys = selector.selectedKeys().iterator()
-  while keys.hasNext do
-    val key = keys.next()
-    keys.remove()
-
-    if key.isReadable then
-      // 読み取り処理
-      handleRead(key)
-```
-
----
-
-## メリット
-
-| 項目 | ブロッキング | ノンブロッキング |
-|------|-------------|------------------|
-| スレッド数 | 接続数に比例 | 少数で対応可能 |
-| メモリ | 多い | 少ない |
-| 複雑さ | 低い | 高い |
-
----
-
-## 次のステップ
-
-[Part VII](part-7.md) では、Scala の Future を使った非同期プログラミングを学びます。

package/lib/assets/docs/article/grokking-concurrency/scala/part-7.md

@@ -1,130 +0,0 @@
----
-type: Article
-title: "Part VII - 非同期プログラミング"
-description: "Future と Promise による非同期処理"
-tags: [article, grokking-concurrency, scala, concurrency, async, future]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VII: 非同期プログラミング
-
-## 概要
-
-本章では、Scala の Future と Promise を使った非同期プログラミングを学びます。
-
----
-
-## Future の基本
-
-```scala
-import scala.concurrent.{Future, ExecutionContext}
-import scala.concurrent.ExecutionContext.Implicits.global
-
-val future: Future[Int] = Future {
-  Thread.sleep(1000)
-  42
-}
-
-// コールバック
-future.onComplete {
-  case Success(value) => println(s"Result: $value")
-  case Failure(e) => println(s"Error: ${e.getMessage}")
-}
-```
-
----
-
-## Future の合成
-
-### map と flatMap
-
-```scala
-val f1: Future[Int] = Future(10)
-val f2: Future[Int] = Future(20)
-
-// map: 結果を変換
-val doubled: Future[Int] = f1.map(_ * 2)
-
-// flatMap: Future を連結
-val sum: Future[Int] = f1.flatMap(a => f2.map(b => a + b))
-```
-
-### for 内包表記
-
-```scala
-val result: Future[Int] = for
-  a <- Future(10)
-  b <- Future(20)
-  c <- Future(30)
-yield a + b + c
-```
-
----
-
-## 並列実行
-
-```scala
-import scala.concurrent.{Future, Await}
-import scala.concurrent.duration._
-
-// 並列に実行される
-val futures = List(
-  Future { Thread.sleep(1000); "A" },
-  Future { Thread.sleep(1000); "B" },
-  Future { Thread.sleep(1000); "C" }
-)
-
-// 全てを待機
-val results: Future[List[String]] = Future.sequence(futures)
-val values = Await.result(results, 5.seconds)
-// List("A", "B", "C") - 約 1 秒で完了
-```
-
----
-
-## Promise
-
-```scala
-import scala.concurrent.Promise
-
-val promise = Promise[Int]()
-val future = promise.future
-
-// 別のスレッドで完了
-Future {
-  Thread.sleep(1000)
-  promise.success(42)
-}
-
-future.onComplete {
-  case Success(v) => println(s"Got: $v")
-  case Failure(e) => println(s"Failed: $e")
-}
-```
-
----
-
-## エラーハンドリング
-
-```scala
-val future = Future {
-  throw new RuntimeException("Error!")
-}
-
-// recover: 失敗時のフォールバック
-val recovered = future.recover {
-  case _: RuntimeException => 0
-}
-
-// recoverWith: 失敗時に別の Future
-val recoveredWith = future.recoverWith {
-  case _: RuntimeException => Future.successful(0)
-}
-```
-
----
-
-## 次のステップ
-
-[Part VIII](part-8.md) では、MapReduce パターンと並列コレクションを学びます。

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

@@ -1,128 +0,0 @@
----
-type: Article
-title: "Part VIII - 分散並列処理"
-description: "MapReduce パターンと並列コレクション"
-tags: [article, grokking-concurrency, scala, concurrency, mapreduce, parallel-collections]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VIII: 分散並列処理
-
-## 概要
-
-本章では、MapReduce パターンと Scala の並列コレクションを学びます。
-
----
-
-## MapReduce パターン
-
-### ワードカウント実装
-
-```scala
-import scala.collection.parallel.CollectionConverters.*
-
-object WordCount:
-
-  /** Map: Convert text to (word, 1) pairs */
-  def map(text: String): List[(String, Int)] =
-    text.toLowerCase
-      .split("\\s+")
-      .filter(_.nonEmpty)
-      .map(word => (word, 1))
-      .toList
-
-  /** Reduce: Aggregate word counts */
-  def reduce(pairs: List[(String, Int)]): Map[String, Int] =
-    pairs.groupBy(_._1).view.mapValues(_.map(_._2).sum).toMap
-
-  /** MapReduce: Count words in multiple texts using parallel collections */
-  def countWords(texts: List[String]): Map[String, Int] =
-    // Map phase (parallel)
-    val mapped = texts.par.flatMap(map).toList
-
-    // Reduce phase
-    reduce(mapped)
-```
-
----
-
-## 使用例
-
-```scala
-val texts = List(
-  "hello world",
-  "hello scala",
-  "world of scala"
-)
-
-val result = WordCount.countWords(texts)
-// Map(hello -> 2, world -> 2, scala -> 2, of -> 1)
-```
-
----
-
-## 並列コレクション
-
-### 基本的な使い方
-
-```scala
-import scala.collection.parallel.CollectionConverters.*
-
-val numbers = (1 to 1000000).toList
-
-// 逐次処理
-val seqSum = numbers.map(_ * 2).sum
-
-// 並列処理
-val parSum = numbers.par.map(_ * 2).sum
-```
-
-### 注意点
-
-```scala
-// 順序が保証されない
-val result = (1 to 10).par.map(x => s"$x: ${Thread.currentThread.getName}")
-// 順序はランダム
-
-// 副作用のある操作は危険
-var counter = 0
-(1 to 1000).par.foreach(_ => counter += 1) // 競合状態
-// counter < 1000 になる可能性あり
-```
-
----
-
-## 並列コレクションの選択
-
-| コレクション | 並列版 | 適した操作 |
-|-------------|--------|-----------|
-| List | ParVector | map, filter |
-| Array | ParArray | インデックスアクセス |
-| Range | ParRange | 連続処理 |
-| Map | ParMap | キー操作 |
-
----
-
-## まとめ
-
-本シリーズで学んだ内容:
-
-| Part | トピック | キーポイント |
-|------|----------|-------------|
-| I | 逐次処理 | 基本概念、ブルートフォース |
-| II | スレッド | Thread、Future |
-| III | マルチタスキング | ゲームループ |
-| IV | 並列パターン | Fork/Join、Pipeline |
-| V | 同期 | synchronized、デッドロック回避 |
-| VI | ノンブロッキング | NIO、Selector |
-| VII | 非同期 | Future、Promise |
-| VIII | 分散処理 | MapReduce、並列コレクション |
-
----
-
-## 参考資料
-
-- [Scala Parallel Collections](https://docs.scala-lang.org/overviews/parallel-collections/overview.html)
-- [Scala Futures and Promises](https://docs.scala-lang.org/overviews/core/futures.html)
-- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)