@k2works/claude-code-booster 4.9.0 → 4.11.0

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

@@ -1,69 +1,69 @@
----
-title: Scala で学ぶ並行処理
-description: Scala 3 による並行処理プログラミング
-published: true
-date: 2025-12-31T10:00:00.000Z
-tags: concurrency, scala, parallel
-editor: markdown
-dateCreated: 2025-12-31T10:00:00.000Z
----
-
-# Scala で学ぶ並行処理
-
-## 概要
-
-本シリーズでは、Scala 3 を使用して並行処理プログラミングの基礎から応用までを学びます。
-
-## 目次
-
-| Part | トピック | 内容 |
-|------|----------|------|
-| [Part I](part-1.md) | 逐次処理 | パスワードクラッキング、パフォーマンス |
-| [Part II](part-2.md) | スレッド | Thread、Future、並列実行 |
-| [Part III](part-3.md) | マルチタスキング | ゲームループ、タスクスケジューリング |
-| [Part IV](part-4.md) | 並列パターン | Fork/Join、パイプライン |
-| [Part V](part-5.md) | 同期と排他制御 | synchronized、デッドロック回避 |
-| [Part VI](part-6.md) | ノンブロッキング I/O | NIO、Selector |
-| [Part VII](part-7.md) | 非同期プログラミング | Future、Promise |
-| [Part VIII](part-8.md) | 分散並列処理 | MapReduce、並列コレクション |
-
-## 環境設定
-
-### 必要なツール
-
-- Scala 3.3.1
-- sbt 1.9.7
-- JDK 11 以上
-
-### プロジェクト構成
-
-```
-apps/scala/
-├── build.sbt
-├── project/
-│   └── build.properties
-├── src/
-│   ├── main/scala/concurrency/
-│   │   ├── ch02/    # Part I
-│   │   ├── ch04/    # Part II
-│   │   ├── ch05/    # Part II
-│   │   ├── ch06/    # Part III
-│   │   ├── ch07/    # Part IV
-│   │   ├── ch08/    # Part V
-│   │   └── ch13/    # Part VIII
-│   └── test/scala/concurrency/
-```
-
-### ビルドと実行
-
-```bash
-cd apps/scala
-sbt compile    # コンパイル
-sbt test       # テスト実行
-```
-
-## 参考資料
-
-- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)
-- [Scala Documentation](https://docs.scala-lang.org/)
-- [Scala Parallel Collections](https://docs.scala-lang.org/overviews/parallel-collections/overview.html)
+---
+title: Scala で学ぶ並行処理
+description: Scala 3 による並行処理プログラミング
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, scala, parallel
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Scala で学ぶ並行処理
+
+## 概要
+
+本シリーズでは、Scala 3 を使用して並行処理プログラミングの基礎から応用までを学びます。
+
+## 目次
+
+| Part | トピック | 内容 |
+|------|----------|------|
+| [Part I](part-1.md) | 逐次処理 | パスワードクラッキング、パフォーマンス |
+| [Part II](part-2.md) | スレッド | Thread、Future、並列実行 |
+| [Part III](part-3.md) | マルチタスキング | ゲームループ、タスクスケジューリング |
+| [Part IV](part-4.md) | 並列パターン | Fork/Join、パイプライン |
+| [Part V](part-5.md) | 同期と排他制御 | synchronized、デッドロック回避 |
+| [Part VI](part-6.md) | ノンブロッキング I/O | NIO、Selector |
+| [Part VII](part-7.md) | 非同期プログラミング | Future、Promise |
+| [Part VIII](part-8.md) | 分散並列処理 | MapReduce、並列コレクション |
+
+## 環境設定
+
+### 必要なツール
+
+- Scala 3.3.1
+- sbt 1.9.7
+- JDK 11 以上
+
+### プロジェクト構成
+
+```
+apps/scala/
+├── build.sbt
+├── project/
+│   └── build.properties
+├── src/
+│   ├── main/scala/concurrency/
+│   │   ├── ch02/    # Part I
+│   │   ├── ch04/    # Part II
+│   │   ├── ch05/    # Part II
+│   │   ├── ch06/    # Part III
+│   │   ├── ch07/    # Part IV
+│   │   ├── ch08/    # Part V
+│   │   └── ch13/    # Part VIII
+│   └── test/scala/concurrency/
+```
+
+### ビルドと実行
+
+```bash
+cd apps/scala
+sbt compile    # コンパイル
+sbt test       # テスト実行
+```
+
+## 参考資料
+
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)
+- [Scala Documentation](https://docs.scala-lang.org/)
+- [Scala Parallel Collections](https://docs.scala-lang.org/overviews/parallel-collections/overview.html)

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

@@ -1,78 +1,78 @@
----
-title: Part I - 逐次処理
-description: パスワードクラッキングで学ぶ逐次処理の基礎
-published: true
-date: 2025-12-31T10:00:00.000Z
-tags: concurrency, sequential, scala
-editor: markdown
-dateCreated: 2025-12-31T10:00:00.000Z
----
-
-# Part I: 逐次処理
-
-## 概要
-
-本章では、パスワードクラッキングを例に逐次処理の基礎を学びます。
-
----
-
-## パスワードクラッカーの実装
-
-### 組み合わせ生成
-
-```scala
-object PasswordCracker:
-  private val Letters: String = "abcdefghijklmnopqrstuvwxyz"
-
-  /** Generate all combinations of lowercase letters of the given length */
-  def getCombinations(length: Int): List[String] =
-    @tailrec
-    def generate(current: List[String], remaining: Int): List[String] =
-      if remaining == 0 then current
-      else
-        val next = for
-          prefix <- current
-          letter <- Letters
-        yield prefix + letter
-        generate(next, remaining - 1)
-
-    generate(List(""), length)
-```
-
-### ハッシュ計算
-
-```scala
-import java.security.MessageDigest
-
-/** Calculate SHA-256 hash of the given password */
-def getCryptoHash(password: String): String =
-  val digest = MessageDigest.getInstance("SHA-256")
-  val bytes = digest.digest(password.getBytes("UTF-8"))
-  bytes.map(b => f"$b%02x").mkString
-```
-
-### パスワード解析
-
-```scala
-/** Check if the password matches the given hash */
-def checkPassword(password: String, cryptoHash: String): Boolean =
-  getCryptoHash(password) == cryptoHash
-
-/** Crack password by brute force */
-def crackPassword(cryptoHash: String, length: Int): Option[String] =
-  getCombinations(length).find(checkPassword(_, cryptoHash))
-```
-
----
-
-## 特徴
-
-- **末尾再帰**: `@tailrec` アノテーションでスタックオーバーフローを防止
-- **for 内包表記**: 宣言的な組み合わせ生成
-- **Option 型**: null の代わりに `Option[String]` で結果を表現
-
----
-
-## 次のステップ
-
-[Part II](part-2.md) では、スレッドを使った並列処理を学びます。
+---
+title: Part I - 逐次処理
+description: パスワードクラッキングで学ぶ逐次処理の基礎
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, sequential, scala
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part I: 逐次処理
+
+## 概要
+
+本章では、パスワードクラッキングを例に逐次処理の基礎を学びます。
+
+---
+
+## パスワードクラッカーの実装
+
+### 組み合わせ生成
+
+```scala
+object PasswordCracker:
+  private val Letters: String = "abcdefghijklmnopqrstuvwxyz"
+
+  /** Generate all combinations of lowercase letters of the given length */
+  def getCombinations(length: Int): List[String] =
+    @tailrec
+    def generate(current: List[String], remaining: Int): List[String] =
+      if remaining == 0 then current
+      else
+        val next = for
+          prefix <- current
+          letter <- Letters
+        yield prefix + letter
+        generate(next, remaining - 1)
+
+    generate(List(""), length)
+```
+
+### ハッシュ計算
+
+```scala
+import java.security.MessageDigest
+
+/** Calculate SHA-256 hash of the given password */
+def getCryptoHash(password: String): String =
+  val digest = MessageDigest.getInstance("SHA-256")
+  val bytes = digest.digest(password.getBytes("UTF-8"))
+  bytes.map(b => f"$b%02x").mkString
+```
+
+### パスワード解析
+
+```scala
+/** Check if the password matches the given hash */
+def checkPassword(password: String, cryptoHash: String): Boolean =
+  getCryptoHash(password) == cryptoHash
+
+/** Crack password by brute force */
+def crackPassword(cryptoHash: String, length: Int): Option[String] =
+  getCombinations(length).find(checkPassword(_, cryptoHash))
+```
+
+---
+
+## 特徴
+
+- **末尾再帰**: `@tailrec` アノテーションでスタックオーバーフローを防止
+- **for 内包表記**: 宣言的な組み合わせ生成
+- **Option 型**: null の代わりに `Option[String]` で結果を表現
+
+---
+
+## 次のステップ
+
+[Part II](part-2.md) では、スレッドを使った並列処理を学びます。

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

@@ -1,112 +1,112 @@
----
-title: Part II - プロセスとスレッド
-description: Scala でのスレッド操作と並列パスワードクラッキング
-published: true
-date: 2025-12-31T10:00:00.000Z
-tags: concurrency, threads, scala
-editor: markdown
-dateCreated: 2025-12-31T10:00:00.000Z
----
-
-# Part II: プロセスとスレッド
-
-## 概要
-
-本章では、スレッドの基本操作と並列パスワードクラッキングを実装します。
-
----
-
-## スレッドの基本
-
-### スレッド作成
-
-```scala
-object ThreadBasics:
-
-  /** Create a worker thread with the given name and task */
-  def createWorker(name: String, task: () => Unit): Thread =
-    val thread = new Thread(() => task())
-    thread.setName(name)
-    thread
-
-  /** Create multiple worker threads */
-  def createMultipleWorkers(count: Int, task: Int => Unit): List[Thread] =
-    (0 until count).map { i =>
-      val thread = new Thread(() => task(i))
-      thread.setName(s"Worker-$i")
-      thread
-    }.toList
-
-  /** Start all threads and wait for them to complete */
-  def startAndJoinAll(threads: List[Thread]): Unit =
-    threads.foreach(_.start())
-    threads.foreach(_.join())
-```
-
----
-
-## 並列パスワードクラッキング
-
-### チャンク分割
-
-```scala
-case class ChunkRange(start: Int, end: Int)
-
-object PasswordCrackerParallel:
-  /** Divide a range into chunks */
-  def getChunks(numChunks: Int, totalSize: Int): List[ChunkRange] =
-    val chunkSize = totalSize / numChunks
-    val remainder = totalSize % numChunks
-
-    (0 until numChunks).map { i =>
-      val start = i * chunkSize + math.min(i, remainder)
-      val end = start + chunkSize + (if i < remainder then 1 else 0)
-      ChunkRange(start, end)
-    }.toList
-```
-
-### Future による並列実行
-
-```scala
-import scala.concurrent.{Future, Await, ExecutionContext}
-import scala.concurrent.duration.Duration
-import java.util.concurrent.atomic.AtomicReference
-
-given ExecutionContext = ExecutionContext.global
-
-/** Crack password using parallel execution */
-def crackPasswordParallel(cryptoHash: String, length: Int): Option[String] =
-  val combinations = PasswordCracker.getCombinations(length)
-  val numCores = Runtime.getRuntime.availableProcessors()
-  val chunks = getChunks(numCores, combinations.length)
-
-  val result = new AtomicReference[Option[String]](None)
-
-  val futures = chunks.map { chunk =>
-    Future {
-      val subList = combinations.slice(chunk.start, chunk.end)
-      subList.find { password =>
-        result.get().isEmpty && PasswordCracker.checkPassword(password, cryptoHash)
-      } match
-        case Some(found) => result.compareAndSet(None, Some(found))
-        case None => ()
-    }
-  }
-
-  futures.foreach(f => Await.ready(f, Duration.Inf))
-  result.get()
-```
-
----
-
-## ポイント
-
-- **ExecutionContext**: Scala の並行処理実行環境
-- **Future**: 非同期計算を表現
-- **AtomicReference**: スレッドセーフな結果共有
-
----
-
-## 次のステップ
-
-[Part III](part-3.md) では、マルチタスキングとゲームループを学びます。
+---
+title: Part II - プロセスとスレッド
+description: Scala でのスレッド操作と並列パスワードクラッキング
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, threads, scala
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part II: プロセスとスレッド
+
+## 概要
+
+本章では、スレッドの基本操作と並列パスワードクラッキングを実装します。
+
+---
+
+## スレッドの基本
+
+### スレッド作成
+
+```scala
+object ThreadBasics:
+
+  /** Create a worker thread with the given name and task */
+  def createWorker(name: String, task: () => Unit): Thread =
+    val thread = new Thread(() => task())
+    thread.setName(name)
+    thread
+
+  /** Create multiple worker threads */
+  def createMultipleWorkers(count: Int, task: Int => Unit): List[Thread] =
+    (0 until count).map { i =>
+      val thread = new Thread(() => task(i))
+      thread.setName(s"Worker-$i")
+      thread
+    }.toList
+
+  /** Start all threads and wait for them to complete */
+  def startAndJoinAll(threads: List[Thread]): Unit =
+    threads.foreach(_.start())
+    threads.foreach(_.join())
+```
+
+---
+
+## 並列パスワードクラッキング
+
+### チャンク分割
+
+```scala
+case class ChunkRange(start: Int, end: Int)
+
+object PasswordCrackerParallel:
+  /** Divide a range into chunks */
+  def getChunks(numChunks: Int, totalSize: Int): List[ChunkRange] =
+    val chunkSize = totalSize / numChunks
+    val remainder = totalSize % numChunks
+
+    (0 until numChunks).map { i =>
+      val start = i * chunkSize + math.min(i, remainder)
+      val end = start + chunkSize + (if i < remainder then 1 else 0)
+      ChunkRange(start, end)
+    }.toList
+```
+
+### Future による並列実行
+
+```scala
+import scala.concurrent.{Future, Await, ExecutionContext}
+import scala.concurrent.duration.Duration
+import java.util.concurrent.atomic.AtomicReference
+
+given ExecutionContext = ExecutionContext.global
+
+/** Crack password using parallel execution */
+def crackPasswordParallel(cryptoHash: String, length: Int): Option[String] =
+  val combinations = PasswordCracker.getCombinations(length)
+  val numCores = Runtime.getRuntime.availableProcessors()
+  val chunks = getChunks(numCores, combinations.length)
+
+  val result = new AtomicReference[Option[String]](None)
+
+  val futures = chunks.map { chunk =>
+    Future {
+      val subList = combinations.slice(chunk.start, chunk.end)
+      subList.find { password =>
+        result.get().isEmpty && PasswordCracker.checkPassword(password, cryptoHash)
+      } match
+        case Some(found) => result.compareAndSet(None, Some(found))
+        case None => ()
+    }
+  }
+
+  futures.foreach(f => Await.ready(f, Duration.Inf))
+  result.get()
+```
+
+---
+
+## ポイント
+
+- **ExecutionContext**: Scala の並行処理実行環境
+- **Future**: 非同期計算を表現
+- **AtomicReference**: スレッドセーフな結果共有
+
+---
+
+## 次のステップ
+
+[Part III](part-3.md) では、マルチタスキングとゲームループを学びます。