@k2works/claude-code-booster 6.2.0 → 6.3.1

package/lib/assets/docs/article/grokking-concurrency/clojure/part-3.md

@@ -1,121 +0,0 @@
----
-type: Article
-title: "Part III - マルチタスキングとスケジューリング"
-description: "atom とイベント同期"
-tags: [article, grokking-concurrency, clojure, concurrency, atom]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part III: マルチタスキングとスケジューリング
-
-## 概要
-
-本章では、Clojure の atom とイベント同期を学びます。
-
----
-
-## Atom（アトム）
-
-```clojure
-;; 作成
-(def counter (atom 0))
-
-;; 更新
-(swap! counter inc)        ;; 関数適用
-(swap! counter + 10)       ;; 引数付き
-(reset! counter 0)         ;; 直接設定
-
-;; 取得
-@counter  ;; または (deref counter)
-```
-
----
-
-## イベント同期
-
-### イベントオブジェクト
-
-```clojure
-(defn create-event
-  "イベントオブジェクトを作成"
-  []
-  {:ready (atom false)
-   :lock (Object.)})
-
-(defn signal-event!
-  "イベントをシグナル"
-  [event]
-  (locking (:lock event)
-    (reset! (:ready event) true)
-    (.notifyAll (:lock event))))
-
-(defn wait-event!
-  "イベントを待機"
-  [event]
-  (locking (:lock event)
-    (while (not @(:ready event))
-      (.wait (:lock event)))
-    (reset! (:ready event) false)))
-```
-
----
-
-## GameLoop 実装
-
-### ゲーム状態
-
-```clojure
-(defn create-game-state
-  "ゲーム状態を作成"
-  []
-  {:event-count (atom 0)
-   :rendered-count (atom 0)
-   :running (atom true)})
-
-(defn process-event! [state]
-  (swap! (:event-count state) inc))
-
-(defn render-frame! [state]
-  (swap! (:rendered-count state) inc))
-```
-
----
-
-## ゲームループ
-
-```clojure
-(defn run-game-loop!
-  "ゲームループを実行"
-  [state iterations]
-  (let [processor-event (create-event)
-        renderer-event (create-event)]
-    ;; イベント処理スレッド
-    (future
-      (dotimes [_ iterations]
-        (wait-event! processor-event)
-        (process-event! state)
-        (signal-event! renderer-event)))
-    ;; レンダリングスレッド
-    (future
-      (dotimes [_ iterations]
-        (signal-event! processor-event)
-        (wait-event! renderer-event)
-        (render-frame! state)))))
-```
-
----
-
-## atom vs ref
-
-| 特徴 | atom | ref |
-|------|------|-----|
-| 用途 | 単一値 | 複数値の協調更新 |
-| 更新 | swap!, reset! | alter, ref-set |
-| トランザクション | 不要 | dosync 必須 |
-
----
-
-## 次のステップ
-
-[Part IV](part-4.md) では、Fork/Join と Pipeline パターンを学びます。

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

@@ -1,122 +0,0 @@
----
-type: Article
-title: "Part IV - タスク分解と並列パターン"
-description: "Fork/Join と Pipeline"
-tags: [article, grokking-concurrency, clojure, concurrency, fork-join]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part IV: タスク分解と並列パターン
-
-## 概要
-
-本章では、Fork/Join パターンと Pipeline パターンを学びます。
-
----
-
-## Fork/Join パターン
-
-### VoteCounter 実装
-
-```clojure
-(defn count-votes-sequential
-  "逐次で投票をカウント"
-  [votes]
-  (reduce (fn [acc vote]
-            (update acc vote (fnil inc 0)))
-          {}
-          votes))
-
-(defn merge-counts
-  "複数のカウント結果をマージ"
-  [counts]
-  (reduce (fn [acc m]
-            (merge-with + acc m))
-          {}
-          counts))
-```
-
----
-
-## 並列 Fork/Join
-
-```clojure
-(defn count-votes-parallel
-  "並列で投票をカウント（Fork/Join パターン）"
-  [votes num-workers]
-  (if (empty? votes)
-    {}
-    (let [chunks (partition-all (max 1 (quot (count votes) num-workers)) votes)
-          futures (doall (map #(future (count-votes-sequential %)) chunks))
-          results (map deref futures)]
-      (merge-counts results))))
-```
-
----
-
-## Pipeline パターン
-
-### core.async を使用
-
-```clojure
-(require '[clojure.core.async :as async :refer [chan go >! <! >!! <!!]])
-
-(defn create-pipeline
-  "入力を2倍にするパイプラインを作成"
-  []
-  (let [input (chan 10)
-        output (chan 10)]
-    (go
-      (loop []
-        (when-let [v (<! input)]
-          (>! output (* v 2))
-          (recur))))
-    {:input input :output output}))
-```
-
----
-
-## パイプライン操作
-
-```clojure
-(defn send-to-pipeline! [pipeline value]
-  (>!! (:input pipeline) value))
-
-(defn receive-from-pipeline! [pipeline]
-  (<!! (:output pipeline)))
-
-;; 使用例
-(let [p (create-pipeline)]
-  (send-to-pipeline! p 5)
-  (receive-from-pipeline! p))  ;; => 10
-```
-
----
-
-## チェーンパイプライン
-
-```clojure
-(defn run-chain-pipeline
-  "チェーンパイプラインを実行"
-  [initial-value functions]
-  (if (empty? functions)
-    initial-value
-    (let [channels (repeatedly (inc (count functions)) #(chan 1))]
-      (doseq [[in-ch out-ch f] (map vector channels (rest channels) functions)]
-        (go
-          (when-let [v (<! in-ch)]
-            (>! out-ch (f v)))))
-      (>!! (first channels) initial-value)
-      (<!! (last channels)))))
-
-;; 使用例
-(run-chain-pipeline 5 [#(* % 2) #(+ % 3) #(* % 10)])
-;; => 130  ; ((5 * 2) + 3) * 10
-```
-
----
-
-## 次のステップ
-
-[Part V](part-5.md) では、STM による同期と排他制御を学びます。

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

@@ -1,117 +0,0 @@
----
-type: Article
-title: "Part V - 同期と排他制御"
-description: "STM と ref による銀行口座"
-tags: [article, grokking-concurrency, clojure, concurrency, stm]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part V: 同期と排他制御
-
-## 概要
-
-本章では、Clojure の STM（Software Transactional Memory）を学びます。
-
----
-
-## Ref と dosync
-
-```clojure
-;; ref の作成
-(def balance (ref 1000))
-
-;; トランザクション内で更新
-(dosync
-  (alter balance + 100))
-
-;; 値を取得
-@balance  ;; => 1100
-```
-
----
-
-## BankAccount 実装
-
-### 口座作成
-
-```clojure
-(defn create-account
-  "銀行口座を作成"
-  [id initial-balance]
-  {:id id
-   :balance (ref initial-balance)})
-
-(defn get-id [account] (:id account))
-(defn get-balance [account] @(:balance account))
-```
-
----
-
-## 入出金
-
-```clojure
-(defn deposit!
-  "入金"
-  [account amount]
-  (dosync
-    (alter (:balance account) + amount)))
-
-(defn withdraw!
-  "出金（残高チェック付き）"
-  [account amount]
-  (dosync
-    (if (>= @(:balance account) amount)
-      (do
-        (alter (:balance account) - amount)
-        true)
-      false)))
-```
-
----
-
-## 振込（デッドロックフリー）
-
-```clojure
-(defn transfer!
-  "振込（STM によるデッドロックフリー）"
-  [from to amount]
-  (dosync
-    (if (>= @(:balance from) amount)
-      (do
-        (alter (:balance from) - amount)
-        (alter (:balance to) + amount)
-        true)
-      false)))
-```
-
----
-
-## STM の特徴
-
-| 特徴 | 説明 |
-|------|------|
-| 自動リトライ | 競合時に自動的にリトライ |
-| デッドロックフリー | ロック順序の問題なし |
-| 一貫性 | トランザクション内は一貫 |
-| 分離性 | 他のトランザクションから分離 |
-
----
-
-## 並行テスト
-
-```clojure
-(let [a1 (create-account 1 1000)
-      a2 (create-account 2 1000)
-      f1 (future (dotimes [_ 50] (transfer! a1 a2 1)))
-      f2 (future (dotimes [_ 50] (transfer! a2 a1 1)))]
-  @f1 @f2
-  (+ (get-balance a1) (get-balance a2)))
-;; => 2000（常に合計金額が保持される）
-```
-
----
-
-## 次のステップ
-
-[Part VI](part-6.md) では、ノンブロッキング I/O を学びます。

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

@@ -1,88 +0,0 @@
----
-type: Article
-title: "Part VI - ノンブロッキング I/O"
-description: "future と promise"
-tags: [article, grokking-concurrency, clojure, concurrency, async]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VI: ノンブロッキング I/O
-
-## 概要
-
-本章では、Clojure の future と promise による非同期処理を学びます。
-
----
-
-## Future
-
-```clojure
-;; 非同期計算
-(def result (future
-              (Thread/sleep 1000)
-              (+ 1 2)))
-
-;; 結果を取得（ブロッキング）
-@result  ;; => 3
-
-;; タイムアウト付き
-(deref result 500 :timeout)
-```
-
----
-
-## Promise
-
-```clojure
-;; Promise 作成
-(def p (promise))
-
-;; 別スレッドで値を設定
-(future
-  (Thread/sleep 100)
-  (deliver p :done))
-
-;; 結果を待機
-@p  ;; => :done
-```
-
----
-
-## 複数の非同期タスク
-
-```clojure
-(defn fetch-all [urls]
-  (let [futures (doall (map #(future (fetch-url %)) urls))]
-    (map deref futures)))
-```
-
----
-
-## タイムアウト処理
-
-```clojure
-(defn with-timeout [timeout-ms f]
-  (let [result (future (f))]
-    (deref result timeout-ms :timeout)))
-
-;; 使用例
-(with-timeout 1000 #(Thread/sleep 500))  ;; => nil
-(with-timeout 100 #(Thread/sleep 500))   ;; => :timeout
-```
-
----
-
-## future vs promise
-
-| 特徴 | future | promise |
-|------|--------|---------|
-| 計算開始 | 即座に開始 | deliver まで待機 |
-| 値の設定 | 内部で計算 | 外部から deliver |
-| 用途 | 非同期計算 | スレッド間通信 |
-
----
-
-## 次のステップ
-
-[Part VII](part-7.md) では、core.async を学びます。

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

@@ -1,99 +0,0 @@
----
-type: Article
-title: "Part VII - 非同期プログラミング"
-description: "core.async の詳細"
-tags: [article, grokking-concurrency, clojure, concurrency, core.async]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VII: 非同期プログラミング
-
-## 概要
-
-本章では、Clojure の core.async ライブラリを詳しく学びます。
-
----
-
-## チャネル基礎
-
-```clojure
-(require '[clojure.core.async :as async
-           :refer [chan go >! <! >!! <!! close!]])
-
-;; チャネル作成
-(def ch (chan))           ;; バッファなし
-(def ch (chan 10))        ;; バッファサイズ 10
-
-;; go ブロック内での操作
-(go (>! ch "hello"))      ;; 非ブロッキング送信
-(go (println (<! ch)))    ;; 非ブロッキング受信
-
-;; 通常スレッドでの操作
-(>!! ch "hello")          ;; ブロッキング送信
-(<!! ch)                  ;; ブロッキング受信
-```
-
----
-
-## go ブロック
-
-```clojure
-;; 軽量スレッド（IOC スレッド）
-(go
-  (let [result (<! (async/timeout 1000))]
-    (println "1秒経過")))
-
-;; 複数の go ブロック
-(let [ch (chan)]
-  (go (>! ch 1))
-  (go (>! ch 2))
-  (go (println "受信:" (<! ch) (<! ch))))
-```
-
----
-
-## alt! と alts!
-
-```clojure
-;; 複数チャネルから選択
-(go
-  (alt!
-    ch1 ([v] (println "ch1 から" v))
-    ch2 ([v] (println "ch2 から" v))
-    (async/timeout 1000) (println "タイムアウト")))
-```
-
----
-
-## パイプライン
-
-```clojure
-;; async/pipeline
-(let [in (chan 10)
-      out (chan 10)]
-  (async/pipeline 4 out (map inc) in)
-  (async/onto-chan! in [1 2 3 4 5])
-  (<!! (async/into [] out)))
-;; => [2 3 4 5 6]
-```
-
----
-
-## core.async 関数一覧
-
-| 関数 | 説明 |
-|------|------|
-| chan | チャネル作成 |
-| go | 軽量スレッド |
-| >! / <! | go 内での送受信 |
-| >!! / <!! | ブロッキング送受信 |
-| alt! | 複数チャネル選択 |
-| pipeline | 並列変換 |
-| timeout | タイムアウトチャネル |
-
----
-
-## 次のステップ
-
-[Part VIII](part-8.md) では、MapReduce パターンを学びます。

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

@@ -1,119 +0,0 @@
----
-type: Article
-title: "Part VIII - 分散並列処理"
-description: "pmap と MapReduce パターン"
-tags: [article, grokking-concurrency, clojure, concurrency, mapreduce]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VIII: 分散並列処理
-
-## 概要
-
-本章では、pmap と MapReduce パターンを学びます。
-
----
-
-## pmap（並列 map）
-
-```clojure
-;; 通常の map
-(map inc [1 2 3 4 5])
-
-;; 並列 map
-(pmap inc [1 2 3 4 5])
-
-;; CPU バウンドな処理に有効
-(pmap expensive-computation large-collection)
-```
-
----
-
-## MapReduce パターン
-
-### Map フェーズ
-
-```clojure
-(require '[clojure.string :as str])
-
-(defn map-phase
-  "Map: テキストを (word, 1) ペアに変換"
-  [text]
-  (->> (str/split (str/lower-case text) #"\s+")
-       (filter (complement str/blank?))
-       (map (fn [word] [word 1]))))
-```
-
----
-
-## Reduce フェーズ
-
-```clojure
-(defn reduce-phase
-  "Reduce: ペアを集約してワードカウント"
-  [pairs]
-  (reduce (fn [acc [word count]]
-            (update acc word (fnil + 0) count))
-          {}
-          pairs))
-```
-
----
-
-## ワードカウント実装
-
-```clojure
-(defn count-words-sequential
-  "逐次ワードカウント"
-  [texts]
-  (->> texts
-       (mapcat map-phase)
-       reduce-phase))
-
-(defn count-words-parallel
-  "並列ワードカウント (pmap による MapReduce)"
-  [texts]
-  (if (empty? texts)
-    {}
-    (->> texts
-         (pmap map-phase)
-         (apply concat)
-         reduce-phase)))
-```
-
----
-
-## 使用例
-
-```clojure
-(count-words-parallel
-  ["hello world" "hello clojure" "world of clojure"])
-;; => {"hello" 2, "world" 2, "clojure" 2, "of" 1}
-```
-
----
-
-## まとめ
-
-本シリーズで学んだ内容:
-
-| Part | トピック | キーポイント |
-|------|----------|-------------|
-| I | 逐次処理 | 純粋関数、SHA-256 |
-| II | スレッド | future、Thread |
-| III | マルチタスキング | atom、イベント同期 |
-| IV | 並列パターン | Fork/Join、Pipeline |
-| V | 同期 | STM、ref、dosync |
-| VI | ノンブロッキング | future、promise |
-| VII | 非同期 | core.async |
-| VIII | 分散処理 | pmap、MapReduce |
-
----
-
-## 参考資料
-
-- [Clojure Reference: Atoms](https://clojure.org/reference/atoms)
-- [Clojure Reference: Refs and Transactions](https://clojure.org/reference/refs)
-- [core.async Guide](https://clojure.org/guides/async_walkthrough)
-- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)