@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,94 @@
+---
+title: Part VI - ノンブロッキング I/O
+description: async/await によるノンブロッキング処理
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, async, tokio, rust
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VI: ノンブロッキング I/O
+
+## 概要
+
+本章では、Rust の async/await を使用したノンブロッキング I/O を学びます。
+
+---
+
+## ブロッキング vs ノンブロッキング
+
+### ブロッキング I/O
+
+```rust
+use std::fs;
+
+// スレッドは I/O 完了まで待機
+let content = fs::read_to_string("file.txt").unwrap();
+```
+
+### ノンブロッキング I/O (async)
+
+```rust
+use tokio::fs;
+
+async fn read_file_async(path: &str) -> String {
+    fs::read_to_string(path).await.unwrap()
+}
+```
+
+---
+
+## Tokio の基本
+
+```rust
+use tokio;
+
+#[tokio::main]
+async fn main() {
+    let result = fetch_data("https://example.com").await;
+    println!("{}", result);
+}
+
+async fn fetch_data(url: &str) -> String {
+    // 非同期 HTTP リクエスト
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    format!("Data from {}", url)
+}
+```
+
+---
+
+## 並行実行
+
+```rust
+use tokio;
+
+#[tokio::main]
+async fn main() {
+    // 並行実行
+    let (r1, r2, r3) = tokio::join!(
+        fetch_data("url1"),
+        fetch_data("url2"),
+        fetch_data("url3"),
+    );
+
+    println!("{}, {}, {}", r1, r2, r3);
+}
+```
+
+---
+
+## メリット
+
+| 項目 | ブロッキング | async |
+|------|-------------|-------|
+| スレッド消費 | 待機中も占有 | 解放 |
+| スケーラビリティ | 低い | 高い |
+| コード複雑さ | 低い | やや高い |
+
+---
+
+## 次のステップ
+
+[Part VII](part-7.md) では、非同期プログラミングの詳細を学びます。

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

@@ -0,0 +1,133 @@
+---
+title: Part VII - 非同期プログラミング
+description: Future と async/await の詳細
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, async, future, rust
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VII: 非同期プログラミング
+
+## 概要
+
+本章では、Rust の Future と async/await を詳しく学びます。
+
+---
+
+## Future トレイト
+
+```rust
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+// Future は Poll を返す
+pub trait Future {
+    type Output;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
+}
+```
+
+---
+
+## async/await の基本
+
+```rust
+// async fn は Future を返す
+async fn compute() -> i32 {
+    42
+}
+
+// await で結果を取得
+async fn example() {
+    let result = compute().await;
+    println!("{}", result);
+}
+```
+
+---
+
+## 合成
+
+```rust
+use tokio;
+
+// 順次実行
+async fn sequential() -> i32 {
+    let a = compute_a().await;
+    let b = compute_b().await;
+    a + b
+}
+
+// 並列実行
+async fn parallel() -> (i32, i32, i32) {
+    tokio::join!(
+        compute_a(),
+        compute_b(),
+        compute_c(),
+    )
+}
+```
+
+---
+
+## エラーハンドリング
+
+```rust
+async fn safe_computation() -> Result<i32, String> {
+    let result = risky_computation().await?;
+    Ok(result * 2)
+}
+
+async fn risky_computation() -> Result<i32, String> {
+    // エラーの可能性がある処理
+    Ok(42)
+}
+```
+
+---
+
+## キャンセル
+
+```rust
+use tokio::time::{timeout, Duration};
+
+async fn with_timeout() {
+    let result = timeout(
+        Duration::from_secs(5),
+        long_running_task()
+    ).await;
+
+    match result {
+        Ok(value) => println!("Got: {:?}", value),
+        Err(_) => println!("Timed out"),
+    }
+}
+```
+
+---
+
+## select!
+
+```rust
+use tokio::select;
+
+async fn race() {
+    select! {
+        result = task_a() => {
+            println!("A finished first: {:?}", result);
+        }
+        result = task_b() => {
+            println!("B finished first: {:?}", result);
+        }
+    }
+}
+```
+
+---
+
+## 次のステップ
+
+[Part VIII](part-8.md) では、MapReduce パターンと並列配列を学びます。

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

@@ -0,0 +1,155 @@
+---
+title: Part VIII - 分散並列処理
+description: MapReduce パターンと Rayon
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, mapreduce, rayon, rust
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VIII: 分散並列処理
+
+## 概要
+
+本章では、MapReduce パターンと Rayon の並列イテレータを学びます。
+
+---
+
+## MapReduce パターン
+
+### ワードカウント実装
+
+```rust
+use rayon::prelude::*;
+use std::collections::HashMap;
+
+/// Map: Convert text to (word, 1) pairs
+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()
+}
+
+/// Reduce: Aggregate word counts
+pub fn reduce(pairs: Vec<(String, usize)>) -> HashMap<String, usize> {
+    let mut result = HashMap::new();
+    for (word, count) in pairs {
+        *result.entry(word).or_insert(0) += count;
+    }
+    result
+}
+
+/// MapReduce: Count words using parallel execution
+pub fn count_words(texts: &[&str]) -> HashMap<String, usize> {
+    // Map phase (parallel)
+    let mapped: Vec<(String, usize)> = texts
+        .par_iter()
+        .flat_map(|text| map(text))
+        .collect();
+
+    // Reduce phase
+    reduce(mapped)
+}
+```
+
+---
+
+## 完全並列版
+
+```rust
+/// Parallel reduce using Rayon
+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
+            },
+        )
+}
+```
+
+---
+
+## 使用例
+
+```rust
+fn main() {
+    let texts = vec![
+        "hello world",
+        "hello rust",
+        "world of rust",
+    ];
+
+    let result = count_words(&texts);
+    // {"hello": 2, "world": 2, "rust": 2, "of": 1}
+}
+```
+
+---
+
+## Rayon の並列イテレータ
+
+```rust
+use rayon::prelude::*;
+
+// 並列 map
+let doubled: Vec<_> = (1..1000000)
+    .into_par_iter()
+    .map(|x| x * 2)
+    .collect();
+
+// 並列 filter + map
+let processed: Vec<_> = data
+    .par_iter()
+    .filter(|&x| *x > 0)
+    .map(|x| x * 2)
+    .collect();
+
+// 並列 fold + reduce
+let sum: i32 = (1..1000000)
+    .into_par_iter()
+    .fold(|| 0, |acc, x| acc + x)
+    .reduce(|| 0, |a, b| a + b);
+```
+
+---
+
+## まとめ
+
+本シリーズで学んだ内容:
+
+| Part | トピック | キーポイント |
+|------|----------|-------------|
+| I | 逐次処理 | Option、Iterator |
+| II | スレッド | std::thread、Send/Sync |
+| III | マルチタスキング | Condvar、ゲームループ |
+| IV | 並列パターン | Fork/Join、Pipeline |
+| V | 同期 | Mutex、Arc、デッドロック回避 |
+| VI | ノンブロッキング | async/await |
+| VII | 非同期 | Future、Tokio |
+| VIII | 分散処理 | MapReduce、Rayon |
+
+---
+
+## 参考資料
+
+- [The Rust Programming Language - Fearless Concurrency](https://doc.rust-lang.org/book/ch16-00-concurrency.html)
+- [Rayon Documentation](https://docs.rs/rayon/)
+- [Tokio Documentation](https://docs.rs/tokio/)
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)

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

@@ -0,0 +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)

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

@@ -0,0 +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) では、スレッドを使った並列処理を学びます。

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

@@ -0,0 +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) では、マルチタスキングとゲームループを学びます。