Byzantine Reality

Searching for Byzantine failures in the world around us

Programming Clojure Looks Intriguing

I’m an avid fan of the Pragmatic Programmer series of books, which is incredibly obvious to anyone who regularly reads this blog (which at this point is really just me). So they happen to have a ton of books that involve getting done what you need to get done in the least amount of time while keeping good maintainability and such. This has been the main motivation for me to get a lot of books they put out. But I stumbled across a new book entering beta soon that looks positively intriguing: Programming Clojure.

Clojure is a language I ran into a while ago while looking at languages that run on the JVM. It essentially is Lisp on the JVM. And this is a sufficiently interesting combination of languages when you think about it. Contrast this with Scala, which really feels more like a natural advancement to Java. It’s lighter on the syntax and infers types pretty well most of the time and is way less verbose (my main complaint with Java).

Clojure is a totally different beast. Clojure is a dynamically typed language (versus Java/Scala’s static typed) and is based on a language that has a weird long history. Lisp pioneered many language features that were really way ahead of its time (dynamic types, garbage collection, and many others) and are really only gaining traction now.

But I’m hoping the Clojure book will be different from what I’ve seen before. I’ve read SICP and just didn’t really get into Scheme. For a week I was all about it, but while the book was great, it really way just too stuck in abstraction-land. Don’t get me wrong. I LOVE ABSTRACTION. It’s the core of computer science, and if you can’t abstract then you can’t do computer science. Period. But I never found out how to do useful things in Scheme. I never found out how to read from a file and write to it. I never found out real-world examples of how Scheme would make my life easier. I thought it was really cool how Scheme made you think and program but just couldn’t get work done with it. Contrast this with Ruby, where I like how it makes me think and I get an anomalously high amount of work done in it.

So I have high hopes for Clojure. It seems to combine the cool abstraction powers of Lisp with the “actually gets work done” of Java. And yes, I am obviously aware that people have been getting tons of work done in Lisp for the billion years it’s been out. It’s just that the reference book of the gods on it didn’t seem to really touch on it that much and for some reason it never really clicked to me to go look it up (obviously my bad). The page on the book also claims to talk about software transactional memory, which sounds pretty interesting, and claims that Clojure is as fast as Java, which is also pretty cool.

Rest assured that when the book goes into beta I’ll be one of the first to pick it up and talk about it, and hopefully it lives up to expectations.