timbaldridge

As mentioned in their 2013 PyCon talk, the problem with HTM (at least with current designs) is the hard limits to transaction sizes. They are attempting run run entire interpreted code loops in transactions, while HTM is designed more around smaller transactions.

Specifically I think Haswell requires that all mutated references must fit in the L1 cache. That doesn't really leave much wiggle room

It also allows for multiple copies of the same application to run on the same VM. That is a nice dev feature.

If you're interested in lisp without the JVM, there's always ClojureScript. Once the JVM compiler is up an running it compiles most of my ClojureScript code in about 1 sec, and there's utilities that auto re-compile code as files change.

Author of Mjolnir here. There's some major updates going on in the "datomic" branch. If you're thinking of using Mjolnir in a project, you'll want to keep an eye on that branch over the next few months.

With Datomic, the inference engine is completely re-written in datalog. This allows for a massive code clean-up, and the code in that branch is much cleaner.

sadly, this doesn't seem to support any sort of multithreading. Even something as simple as swap! isn't thread-safe in this implementation. So that kills one of the main reasons to use Clojure in the first place.

I would go a step farther and say that OpenDoc should be in a separate interface from SaveDoc.

Use it every day and you'll probably think different about it.

(baz 33 (bar 12 (foo 33 (+ 1 42))))

Is way harder to read than:

   (->> (+ 1 42)
        (foo 33)
        (bar 12)
        (baz 33))

agreed, it has to the the worst looking site I've seen in awhile.

+1 Since I stopped writing C# code in Visual Studio, I software development doesn't make me nearly as angry as I used to be. Now I write Clojure code on OS X, and couldn't be happier.

Perhaps it does place oriented OOP poorly, but it actually has an extremely nice logic engine (see core.logic).

This is why I use Clojure. I can do Functional, OOP, logic, or any of the dozens of other programming styles in one language. And since it's a lisp I don't have to worry about having to need extra syntax from the language writers to get what I want.

Pragmatic languages FTW!