update elk layout with structural merge

Author: timothypratley

src/clojure+/print/objects_and_protocols.clj

@@ -7,7 +7,7 @@
             [clojure.core.async.flow :as flow]
             [clojure.datafy :as datafy]
             [clojure.string :as str]
-            [core.async.flow.example.stats :as stats]))
+            [core.async.flow.example.asynctopolis :as asynctopolis]))
 
 ;; The Clojure default for printing objects is noisy.
 ;; Clojure's `print-method` for `Object` delegates to `clojure.core/print-object`
@@ -48,7 +48,7 @@
 ;; Especially in the world of notebooks where we like to show things as we go,
 ;; but also just keeping a tidy REPL or looking into data that contains objects.
 
-(flow/create-flow stats/config)
+asynctopolis/flow
 
 ;; Hmmmm. not so nice. We'll dig into this further below.
 ;; But we also need to be aware that Clojure munges it's names to make Java valid names.
@@ -112,7 +112,7 @@
 
 *ns*
 (((fn aaa [] (fn bbb [] (fn ccc [])))))
-(flow/create-flow stats/config)
+asynctopolis/flow
 
 ;; What is this? It's a reified object that implements protocols.
 ;; We can see this by the $reify part at the end.
@@ -135,10 +135,7 @@
 ;; On the other hand, at my REPL I don't care about that, it's faster than I can notice.
 ;; Leaving aside those concerns, it returns quite a long list...
 
-(def stats-flow
-  (flow/create-flow stats/config))
-
-(all-protocol-vars stats-flow)
+(all-protocol-vars asynctopolis/flow)
 
 ;; But notice that one of them; `#'clojure.core.async.flow.impl.graph/Graph`
 ;; just feels like it is the one we care about most.
@@ -155,7 +152,7 @@
 (defn protocol-ns-matches [x]
   (filter #(ns-match? % x) (all-protocol-vars x)))
 
-(protocol-ns-matches stats-flow)
+(protocol-ns-matches asynctopolis/flow)
 
 ;; Nice.
 ;; In my opinion this is more representative of the object.
@@ -169,20 +166,20 @@
   (->> (protocol-ns-matches x)
        (map var-sym)))
 
-(protocol-ns-match-names stats-flow)
+(protocol-ns-match-names asynctopolis/flow)
 
 ;; The other protocol of interest is Datafiable,
 ;; because it indicates I can get a data representation if I would like to.
 
-(datafy/datafy stats-flow)
+(datafy/datafy asynctopolis/flow)
 
 ;; I think this one is so helpful that it should always be shown on objects,
 ;; regardless of their type of other protocols,
 ;; as a hint that it is possible to get more information.
 ;; I wouldn't want to print them as data by default, because it would be too spammy.
 ;; And checking Datafiable is much less of a performance concern.
 
-(satisfies? clojure.core.protocols/Datafiable stats-flow)
+(satisfies? clojure.core.protocols/Datafiable asynctopolis/flow)
 
 ;; But there is a big problem... **everything** is Datafiable...
 

src/core/async/flow/example/stats.clj …core/async/flow/example/asynctopolis.cljsrc/core/async/flow/example/stats.clj renamed to src/core/async/flow/example/asynctopolis.clj src/core/async/flow/example/stats.clj renamed to src/core/async/flow/example/asynctopolis.clj

@@ -2,10 +2,11 @@
   :clay             {:title  "Stats and Signals in the Flow of Asynctopolis"
                      :quarto {:author   [:alexmiller :timothypratley]
                               :type     :post
+                              :draft    true
                               :date     "2025-05-1"
                               :category :clojure
                               :tags     [:core.async :core.async.flow]}}}
-(ns core.async.flow.example.stats
+(ns core.async.flow.example.asynctopolis
   (:require [clojure.core.async :as a]
             [clojure.core.async.flow :as flow]
             [clojure.core.async.flow-static :as flow-static]
@@ -311,18 +312,18 @@
 ;; Held together by channels, purpose, and trust.
 
 (def config
-  {:procs {:generator  {:args {:min 0 :max 12 :wait 500}
+  {:procs {:Randomius  {:args {:min 0 :max 12 :wait 500}
                         :proc (flow/process #'Randomius)}
-           :aggregator {:args {:min 1 :max 10}
+           :Tallystrix {:args {:min 1 :max 10}
                         :proc (flow/process #'Tallystrix)}
-           :scheduler  {:args {:wait 3000}
+           :Chronon    {:args {:wait 3000}
                         :proc (flow/process #'Chronon)}
-           :notifier   {:args      {:prefix "Alert: "}
+           :Claxxus    {:args      {:prefix "Alert: "}
                         :proc      (flow/process #'Claxxus)
                         :chan-opts {:in {:buf-or-n (a/sliding-buffer 3)}}}}
-   :conns [[[:generator :out] [:aggregator :stat]]
-           [[:scheduler :out] [:aggregator :poke]]
-           [[:aggregator :alert] [:notifier :in]]]})
+   :conns [[[:Randomius :out] [:Tallystrix :stat]]
+           [[:Chronon :out] [:Tallystrix :poke]]
+           [[:Tallystrix :alert] [:Claxxus :in]]]})
 
 ^:kind/hiccup
 [:iframe {:width  "100%"
@@ -333,13 +334,13 @@
 ;; Describe your duties.
 ;; Initialize your station.
 
-(def f (flow/create-flow config))
+(def flow (flow/create-flow config))
 
 ;; The city is ready, but not yet in action.
 
-(datafy/datafy f)
+(datafy/datafy flow)
 
-(def chs (flow/start f))
+(def chs (flow/start flow))
 
 chs
 
@@ -354,22 +355,22 @@ chs
 ;; The city breathes, the asynchronous allegiance stirs.
 ;; Transition with order.
 
-(flow/resume f)
+(flow/resume flow)
 
 ;; Transform with purpose.
 
-(flow/inject f [:aggregator :poke] [true])
-(flow/inject f [:aggregator :stat] ["abc1000"])             ;; trigger an alert
-(flow/inject f [:notifier :in] [:sandwich])
+(flow/inject flow [:Tallystrix :poke] [true])
+(flow/inject flow [:Tallystrix :stat] ["abc1000"])             ;; trigger an alert
+(flow/inject flow [:Claxxus :in] [:sandwich])
 
 (a/poll! (:report-chan chs))
 (a/poll! (:error-chan chs))
 
 ;; The flow can coordinate peace.
 
-(flow/pause f)
+(flow/pause flow)
 
-(flow/stop f)
+(flow/stop flow)
 
 ;; The city falls silent.
 

src/core/async/flow/exploration.clj …flow/example/before_his_wings_melted.cljsrc/core/async/flow/exploration.clj renamed to src/core/async/flow/example/before_his_wings_melted.clj src/core/async/flow/exploration.clj renamed to src/core/async/flow/example/before_his_wings_melted.clj

@@ -1,27 +1,52 @@
 ^{:kindly/hide-code true
-  :clay             {:title  "Core Async Flow Exploration"
+  :clay             {:title  "What He Saw Before His Wings Melted"
                      :quarto {:author   [:daslu :timothypratley]
                               :type     :post
                               :draft    true
                               :date     "2025-05-1"
                               :category :clojure
                               :tags     [:core.async :core.async.flow]}}}
-(ns core.async.flow.exploration
+(ns core.async.flow.example.before-his-wings-melted
   (:require [clojure.core.async :as async]
             [clojure.core.async.flow :as flow]
             [clojure.datafy :as datafy]
-            [core.async.flow.example.stats :as stats]
-            [core.async.flow.visualization :as fv]))
+            [core.async.flow.example.asynctopolis :as asynctopolis]
+            [core.async.flow.example.flow-show :as show]))
 
-;; One of Clojure’s superpowers is the ability to coordinate asynchronous operations
-;; using `core.async`.
+;; Long before he flew too high,
+;; before the wax gave way and the world remembered only his fall,
+;; Iccarus flew *low*.
+;; They often leave out this part of his misadventures,
+;; when curiosity, not hubris, guided his wings.
+;; He flew not to ascend to Olympus,
+;; but rather to get a good view of the lesser known Asynctopolis.
+
+;; A city pulsing with signals, stitched together by invisible threads.
+;; From above, its patterns unfolded like a diagram.
+;; Flows of information, agents in silent collaboration,
+;; each unaware of the others, yet perfectly aligned.
+
+;; This is what he saw.
+
+;; ## Asynctopolis from the Clouds
+
+(show/flow-svg asynctopolis/flow {:show-chans   false
+                                  :with-content false})
+
+;; Coordinate asynchronous operations using `core.async`.
 ;; While powerful, these operations can become hard to reason about as they grow in complexity.
+;; The `core.async.flow` library is a higher-level abstraction for modeling async processes as a Directed Acyclic Graph (DAG).
+;; We can visualize flows [flow-monitor](https://github.com/clojure/core.async.flow-monitor).
+
+;; He circled the skyline.
+;; He watched the channels breathe.
+;; And slowly, he spiraled down,
+;; drawn not by ambition, but fascination—
+;; closer to each process,
+;; each transformation,
+;; each role in the great asynchronous allegiance.
+
 
-;; The new `core.async.flow` library offers a higher-level abstraction for modeling
-;; async processes as a **Directed Acyclic Graph (DAG)**.
-;; And now, with [flow-monitor](https://github.com/clojure/core.async.flow-monitor),
-;; we can *visualize* and *analyze* those flows.
-;;
 ;; Let's walk through an exploration of such a flow.
 
 ;; ## What We'll Explore
@@ -32,78 +57,68 @@
 ;; 2. **Static visualization**: How can we inspect its components?
 ;; 3. **Dynamic interaction**: How do values move through the flow, and what happens when they do?
 
-;; ## 1. Creating a Flow
-
-;; Flows are created from configuration
-
-(def stats-flow
-  (flow/create-flow stats/config))
-
-(fv/flow-svg stats-flow)
-
 ;; This flow models a small system involving aggregation, notification, and reporting.
 ;; Internally, it consists of processes connected via channels.
+(show/flow-svg asynctopolis/flow {:chans-as-ports true
+                                  :with-content   false})
 
-;; ## 2. Inspecting the Flow
+(show/flow-svg asynctopolis/flow {:chans-as-ports false
+                                  :with-content   false})
 
-;; That's a lot to take in! Fortunately, we can make things more digestible
-;; by viewing just the **processes** involved.
 
-(fv/proc-table stats-flow)
+(show/proc-table asynctopolis/flow)
 
 ;; This table gives us a clear list of components in the flow, including their names
 ;; and behaviors.
 
 ;; Next, let’s examine how these processes are **connected**.
 
-(fv/conn-table stats-flow)
+(show/conn-table asynctopolis/flow)
 
 ;; Now we’re seeing the wiring: who talks to whom, and through what channels.
 
 ;; Flows implement the `Datafy` protocol so we can inspect them as data...
 ;; Good luck with that, there's a lot of it
 
 ^:kind/portal
-(datafy/datafy stats-flow)
+(datafy/datafy asynctopolis/flow)
 
 
 ;; ## 3. Running the Flow
 
 ;; Time to bring our flow to life!
 ;; Calling `start` activates the processes and returns a map of the important channels for interaction.
 
-(def chs (flow/start stats-flow))
-
 ;; We can now **inject values** into specific points in the flow.
 ;; Think of this like poking the system and watching how it reacts.
 
 ;; We send a “poke” signal to the `aggregator` process.
 
-@(flow/inject stats-flow [:aggregator :poke] [true])
+@(flow/inject asynctopolis/flow [:Tallystrix :poke] [true])
 
 ;; We send a stat string that is designed to trigger an alert.
 
-@(flow/inject stats-flow [:aggregator :stat] ["abc1000"])
+@(flow/inject asynctopolis/flow [:Tallystrix :stat] ["abc1000"])
 
 ;; We send a notification message into the `notifier`.
 
-@(flow/inject stats-flow [:notifier :in] [:sandwich])
+@(flow/inject asynctopolis/flow [:Claxxus :in] [:sandwich])
 
 ;; ## 4. Observing the Results
 
 ;; Our flow includes a `report-chan`, where summaries and reports might be sent.
 
-(def report-chan (:report-chan chs))
+(def report-chan (:report-chan asynctopolis/chs))
 
-(flow/ping stats-flow)
+(flow/ping asynctopolis/flow)
 
 (async/poll! report-chan)
 
 ;; After pinging the system, we check if anything landed in the report channel.
 
 ;; We can also inspect the `error-chan`, where any issues in the flow are reported.
 
-(def error-chan (:error-chan chs))
+(def error-chan (:error-chan asynctopolis/chs))
 
 (async/poll! error-chan)