Can someone explain Clojure’s unquote-splice in simple terms

I can only compare http-kit and clj-http.

clj-http:

• simple API
• HTTP client only
• a wrapper for Apache HttpComponents

http-kit:

• designed for async
• HTTP client and server, more powerful
• client API modeled after clj-http but it adds more abstractions so the cognitive load is higher

If you care about dependencies, http-kit may be a better choice because it is a standalone library with no other dependencies than clojure.core. Because of that it produces smaller uberjars. For a sample HTTP GET project:

clj-http:

1.2M    clj-http-test-0.1.0-SNAPSHOT.jar
6.7M    clj-http-test-0.1.0-SNAPSHOT-standalone.jar

http-kit:

65K     http-kit-test-0.1.0-SNAPSHOT.jar
3.8M    http-kit-test-0.1.0-SNAPSHOT-standalone.jar

On the other hand you may choose clj-http if you prefer to trust the battle tested Apache HttpComponents and potentially better support from bigger Java community.

Transducers are recipes of what to do with a sequence of data without knowledge of what the underlying sequence is (how to do it). It can be any seq, async channel or maybe observable.

They are composable and polymorphic.

The benefit is, you don't have to implement all standard combinators every time a new data source is added. Again and again. As a result, you as user are able to reuse those recipes on different data sources.

Prior to version 1.7 of Clojure you had three ways to write dataflow queries:

1. nested calls

   (reduce + (filter odd? (map #(+ 2 %) (range 0 10))))
   

2. functional composition

   (def xform
     (comp
       (partial filter odd?)
       (partial map #(+ 2 %))))
   (reduce + (xform (range 0 10)))
   

3. threading macro

   (defn xform [xs]
     (->> xs
          (map #(+ 2 %))
          (filter odd?)))
   (reduce + (xform (range 0 10)))
   

With transducers you will write it like:

(def xform
  (comp
    (map #(+ 2 %))
    (filter odd?)))
(transduce xform + (range 0 10))

They all do the same. The difference is that you never call transducers directly, you pass them to another function. Transducers know what to do, the function that gets a transducer knows how. The order of combinators is like you write it with threading macro (natural order). Now you can reuse xform with channel:

(chan 1 xform)