This one is my favorite: https://youtube.com/watch?v=vK1DazRK_a0

If you also are an interactive learner, you can try my Getting Started with Clojure guide which runs in the editor and lets you experiment directly using the REPL. I’ve put a few links to various videos in there as well, in the context I think they apply the most. https://calva.io/get-started-with-clojure/

Getting Clojure is amazing for adjusting to think about Clojure and how to use it

Here's another fantastic talk that's worth checking out: https://youtu.be/Tb823aqgX_0

@siddarthkay I love Tim Baldridge's video series. Clojure masterclasses: https://tbaldridge.pivotshare.com/

You may also like Eric Normand's https://purelyfunctional.tv/

Additionally, I would recommend material you can work with hands-on, like @U0ETXRFEW recommended https://clojurians.slack.com/archives/C053AK3F9/p1647077848713049?thread_ts=1647070007.031119&cid=C053AK3F9. The extremely fluid conversational development workflow a-la Lisps, Smalltalks, APLs is one of the hardest things to teach about these languages. You got to see someone do it, but then fool around on your own to wire it into your brain.

I will also plug the https://github.com/adityaathalye/clojure-by-example we teach at IN/Clojure. It is aimed at people from other programming backgrounds. Each "chapter" progressively builds on the previous ones, with in-line examples, and end-notes suggesting 4clojure exercises to reinforce the "chapter" concepts. The thing converges into a standalone app to process some planetary data :) It should take about a day to work through, and will get you from zero to hobby-level understanding.

An important lesson is to observe a Clojure programmer using a REPL workflow. Here for example: https://youtu.be/gIoadGfm5T8

In JS/PHP you also have fast feedback loops with JS hot reloading and the way PHP is executed. But this is like a different more interactive level on top.

You can refer to this example with Component https://github.com/seancorfield/usermanager-example Or this one with Integrant https://github.com/PrestanceDesign/usermanager-reitit-integrant-example TL;DR: anything with state -> turn into an argument -> state which is injected later

@UK0810AQ2, Thanks for your response - Will read it

i would ask in #integrant also watch https://www.youtube.com/watch?v=tiWTpp_DPIQ&feature=youtu.be and then https://www.youtube.com/watch?v=lvuwxzONXbQ&t=3430s the next day. Then realize what these solutions are offering a common abstraction around systems/processes that have actual physical lifecycles : they start, stop heal, recover, increase, scale up bc you need more, down bc you need less. The ideas are farther from math and closer to physics and so there more need to manage them. These solutions are, for example, more general then k8s which deals with a limited context. But generality isn't itself a goal, but as your solution requires more actors, having a common vocab across them is useful. If that doesn't make sense to anyone, let me know, i might be wrong, i don't get to play with these ideas much (for better or worse!)

@U01J3DB39R6 ^

Basic use of update and mapv:

(update data :a (fn [x]
                  (mapv (fn [y]
                          (if (map? y)
                            (update y :b (fn [z]
                                           (mapv (fn [x]
                                                   (if (map? x)
                                                     (update x :c str/reverse)
                                                     x)) z)))
                            y)) x)))

(defn fif [pred fun] #(if (pred %) (fun %) %))
(clojure.walk/postwalk (fif #{"Hello," "world!"}
                            str/reverse)
                       data)

(defn all-maps-in [k]
  (s/path k
          (s/filterer map?)
          s/ALL))

(s/transform [(all-maps-in :a)
              (all-maps-in :b)
              :c] str/reverse data)

I feel like it’d be possible to write small helper-functions to clean up the basic version :thinking_face:

I like the postwalk suggestion

(clojure.walk/postwalk #(if (string? %) (clojure.string/reverse %) %) x)

(where x is your input sample - it'd reverse each string ending node - compared to the other solution by only referencing hello/world explicitly)

There is also update-in

Yeah, if we assume that the sequences are always vectors (I like to write my code assuming that’s not the case) then this isn’t too bad either!

(-> data
    (update-in [:a 1 :b 1 :c] str/reverse)
    (update-in [:a 2 :b 0 :c] str/reverse))

(defn mup [xs k fun]
  (into (empty xs)
        (map (fif map? #(update % k fun)))
        xs))

(update data :a mup :b #(mup % :c str/reverse))