stlog/posts/post06_clojure_and_arguile.skr

(post
 :title "Arguile Updates, Clojure Comparison"
 :date (make-date* 2017 3 16)
 :tags '("clojure" "clj" "lisp")

 (h3 [Update])

 (p [Finally found the downtime to write some brief updates. Over the
             past few months, I've been using Clojure at my job. It's
             pretty awesome,
             and solves many of the problems attempted by Arguile.
             It also has some major wins over Arguile:
             it's highly concurrent (arguile still relies on kernel threads/mutexes)
             it runs on the JVM (arguile written in c) a debatable win, and has fast dynamic
             polymorphism through protocols
             (arguile has slower dispatch-on-type polymorhism). There are many more
             examples, each a decent strike
             against Arguile. Most programmers would be happy with Clojure, and me too, but
             Arguile is still a small project, so not exactly fair to compare.
             Regardless, I have found some interesting differences between the two
             , and even a few wins in the Arguile camp.
             But first, let's quickly overview what I've copied
             from Clojure into Arguile.])
 (h3 [Things Arguile needed to copy:])
 (ul
  (li
   (p [vector and hash-table syntax. Just a great feature that leverages these unused characters]))
  (li (p [Data destructuring. Used all over the place in clojure, and for good reason]))
  (li (p [Expression threading. Turns (f1 (f2 (f3 exp))) into (-> exp f3 f2 f1).]))))