Why Clojure?

I have recently become quite an enthusiast for the language Clojure.  But why?  Why would someone who has spent the last 30 years programming in C, C++, Java, C#, and Ruby suddenly become enamored with a language that has roots that go back to 1957, i.e. Lisp?

During my first few decades as a professional programmer, I never learned Lisp.  I had heard of it, of course; though mostly in derisive terms.  People sneered about it with names like "Lots of InSignificant Parentheses".  So my view was not particularly favorable.

A few years ago, someone suggested that I learn Lisp by reading a book entitled: "The Structure and Interpretation of Computer Programs".  So I went to Amazon and ordered a copy from the used books section.  It arrived a week or so later, and then sat on my "to read" stack for a couple of years.

I started reading it about two years ago; and it changed everything I had previously felt and believed about Lisp.  It also changed a great deal of what I felt and believed about programming in general.  In short, the book was startling.

SICP is a literary masterpiece.  It's not often that you can say that a technical book is a page-turner, but that's just what I found SICP to be.  The book moves from topic to topic with rare ease and clarity, but more importantly it moves with purpose and mission.  As you read it, you can feel the authors slowly building a tension towards a climax.  The chapters fly by as you read about data structures, algorithms, message passing, first-class procedures, and so much else.  Each concept leads inevitably to the next.  Each chapter adds to the ever building tension.  By time you are half-way through the book, the sense that something important is about to change becomes palpable. 

And then something important changes!  Something you had not anticipated.  Something you should have guessed, but did not.  On page 216 they introduce a concept so familiar that most programming books start with it.  On page 216 they prove to you that you've had some wrong ideas about programming all along.  On page two hundred and sixteen, after talking about algorithms, data structures, recursion, iteration, trees, high-order procedures, scoping, local variables, data abstraction, closures, message-passing, and a plethora of other topics -- after all that, they introduce assignment!

And with that elegant coup-de-grace (which is not the last in this book!), they vanquish the concept that programming is about manipulating state.  With that one stroke, they force you to look back on all you had done in the previous pages in a new and enlightened way -- a functional way.

Moore's Law
Why is functional programming important?  Because Moore's law has started to falter.  Not the part of the law that predicts that the number of transistors on a chip doubles every two years.  Thankfully, that part of the law seems to still be in effect.  The part that faltered is the part that says the speed of computers doubles every two years. 

What this means is that our computers can still get faster, but only if we put multiple CPUs on a chip.  This is why we've seen all these multi-core processors showing up.  And that means that programs that need greater speed will have to be able to take advantage of the multiple cores.

If you've ever written multi-threaded code, the thought of eight, sixteen, thirty-two, or even more processors running your program should fill you with dread.  Writing multi-threaded code correctly is hard!  But why is it so hard?  Because it is hard to manage the state of variables when more than one CPU has access to them.

And this is where functional programming comes in.  Functional programming, of the kind shown in SICP, is a way to write code that does not manage the state of variables, and could therefore be partitioned to run in parallel on as many processors as you like -- at least in theory.  In practice it might not be quite that trivial; but one thing is certain.  Moving functional programs to massively parallel system will be easier than moving non-functional programs.

Why Clojure?
So why is Clojure the best option for a functional language?  After all, there are lots of functional languages out there.  Some are old, like Haskell, and Erlang.  Some are new like Scala and F#.  Why is Clojure the language that has everybody so fired up?  Here are just a few reasons.

• Clojure is Lisp.  And Lisp is a functional, simple, well-known, elegant language. The syntax is almost laughably terse. This is in contrast to languages like F# and Scala which have a complexity and "quirkiness" reminiscent of C++.
  
• Clojure is Java.  Clojure sits on top of the Java stack, and has the ability to inter-operate with Java with extreme ease.  Java programs can call Clojure, and Clojure can call Java.  You can write Clojure code that derives from Java classes and overrides Java methods.  In short, if you can do it in Java, you can do it in Clojure.  What's more there is a Clojure port for the CLR!  So Clojure may be the only functional language that inter-operates well with both major VMs.
  
• Clojure implements Software Transactional Memory which means that any time a Clojure programmer want's to change the state of a variable, they must do so using the same kind of transaction management as they would use for a database. This enforces the functional paradigm do a degree that few other functional languages do.  The STM facilities of Clojure are elegant and simple, just like the rest of the language.  They do not intrude where they aren't needed, and they are simple to employ where state must be changed.
   
• Clojure is fast.  Data structures in functional languages are immutable.  For example, you can't add an item to a list, instead you create a copy of the list with the new item added.  This copying could obviously slow things down a lot.  Clojure manages complex immutable data structures using a sharing technique that eliminates the need to make deep copies of those structures. This means that Clojure runs very fast. 
  
• Clojure is supported.  There are tutorials and blogs.  There are IDE plugins.  And there are mailing lists and user groups.  If you program in Clojure, you won't be alone. 

Conclusion
The last few decades have seen us migrate from procedures to objects.  Now the physical constraints of our hardware is  driving us to make a similar kind of paradigm shift towards functional languages.  The next few years will see us experiment with many different projects using those languages as we try to figure out which functional languages are best.  I fully expect Clojure to be ranked very highly when the results of those experiments come in.