ClojureScript performance revisited

The difference (like the author states) is that JS & family has mutable data by default, while Clojurescript defaults to immutable such. You have to specify that you want your vectors and maps etc to be transient (fancy pants word for mutable).

You want immutability - think about it: how large % of your bugs are due to more than one procedure changing the value of one variable, and state getting out of sync?

For me in my JS day job, it is definitely a majority of the bugs we create. We also code very defensively to protect us against this.

In CLJS on the other hand, you'd have immutable data, and in tight loops where allocating objects would be expensive, you make your data transient, and then mutate it as much as you wish.

Living your life with immutable values is a serious improvement. Not only to code, but honestly quality of life.

Edit: Clojure doesn't return whole new data structures under the hood, but you never notice that. Here is a great explanation, prepare for (= (mind article) :blown) => http://hypirion.com/musings/understanding-persistent-vector-...

       (map 
         (defn f [c] 
           {:overlap-amount (circle-overlap-distance circle c) 
            :mid-point      (mid-point circle c)}) 
         circle-list)

Is there a reason this uses defn instead of fn? This is the first time I've seen defn used like this.

Since this expands to something like (def f (fn [c] ... and f is never used anywhere, I'd change it to fn. If f is used, I'd consider letfn instead.

The revised code replaces it with #(...) which is shorthand for (fn [...] ...), but am curious if there was a reason for using defn or if it was just an oversight.

kind of misleading when it's throttled the whole time isn't it?