clojure Atom example codes: why the difference between let and def? - clojure

Question

I read the doc https://clojure.org/reference/atoms and triy the codes about Fibonacci.
According the outputs below, in test 3, it takes as short as expected, using def. But in test 2,it take quite long time, using let instead of def to redefine fib. I wonder why let does NOT work as the same way as def?
(defn fib "original fib function" [n]
(if (<= n 1)
n
(+ (fib (dec n)) (fib (- n 2)))))
(defn memorize [f]
(let [mem (atom {})]
(fn [& args]
(if-let [e (find #mem args)]
(val e)
(let [ret (apply f args)]
(swap! mem assoc args ret)
ret)))))
(deftest test-memorize
(testing "test memoize 1 - using fib"
(println "test 1")
(is (> (time (fib 35)) 0)))
(testing "test memoize 2 - uising `(let [fib (memorize fib)])"
(println "test 2")
(let [fib (memorize fib)]
(is (> (time (fib 35)) 0))))
(testing "test memoize 3 - using `(def fib (memorize fib))"
(println "test 3")
(def fib (memorize fib))
(is (> (time (fib 35)) 0)))
The outputs:
$ lein test :only app.model-test/test-memorize
lein test app.model-test
test 1
"Elapsed time: 1418.226187 msecs"
test 2
"Elapsed time: 1391.479784 msecs"
test 3
"Elapsed time: 0.215439 msecs"
Ran 1 tests containing 3 assertions.
0 failures, 0 errors.

Answer 1

... why let does NOT work as the same way as def? ... Because they serve different purposes.
def creates, or updates the value of, a global var. It does not creat a local binding. (Compare to Racket where define is used at the top level to create global bindings and within functions for local bindings.) https://clojure.org/reference/special_forms#def
let creates local bindings. https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/let
(testing "test memoize 3 - using `(def fib (memorize fib))"
(println "test 3")
(def fib (memorize fib))
(is (> (time (fib 35)) 0)))
Is redefining the global value of fib to be the value returned by memorize fib. When the called with (fib 35) the memorize code will call what used to be named fib. That, original, fib calls, by name, fib which is now the memoized version, of fib to calculate fib 34. The calculation of fib 34 calls fib to calculate fib 33. So when (fib 34) returns and (fib 35) calls (fib 33), but that value is cached already. The recursive implementation of fib creates a tree of computation. By redefining fib at the top to inject memoization the work, on the first call to (fib 35) is trimming the tree to a single branch.
For let to do the same thing would require Clojure to use dynamic scope instead of lexical scope.
Some ways to observe that fib is being redefined at the top. After running you tests, (doc fib) and see that your documentation string is not there. Because fib is no longer defined as the function you wrote.
Swap the order of the let and def tests. Then let will be getting the memoized fib.
If you define fib using fn as such:
(def fib (fn fib [n]
(if (<= n 1)
n (+ (fib (dec n))
(fib (- n 2))))))
The call to fib inside will always go to itself, because it is using the local binding for fib from the fn form.

Answer 2

As Shannon Severance already answered. def creates a global var. let creates a local binding.
Which effect has this difference on your function?
Case 2 (let):
You create a new function (a memoized version of fib) and bind it locally to the name fib. Then you call fib. fib calls fib recursively, but inside defn fib ... fib refers to the globally defined fib, which is not memoized. So effectively, there is no caching.
(testing "test memoize 2 - uising `(let [fib (memorize fib)])"
(println "test 2")
(let [fib (memorize fib)] ;-> new memoized version of fib, which is bound to the name fib
(is (> (time (fib 35)) 0)))); but it is only available inside the let block
Effect on defn fib:
(defn fib "original fib function" [n]
(if (<= n 1)
n
(+ (fib (dec n)) (fib (- n 2))))) ;-> calls fib, but fib refers to the globally defined fib, which is not memoized
Case 3 (def):
You create a memoized version of fib, then you globally redeclare fib's value to be the new memoized version. You call fib. Fib calls itself, but now it refers to the new defined version, which is memoized.
(def fib (memorize fib)) ; -> you create a new global fn fib, which is memoized
(is (> (time (fib 35)) 0))
Effect on defn fib:
(defn fib "original fib function" [n]
(if (<= n 1)
n
(+ (fib (dec n)) (fib (- n 2))))) ; -> now, the memoized version of fib is called