Not Just Ruby Any More!

On the eve of the first free, online “Clojure
101”
course, Michael Kohl of RubyLearning caught up with Amit Rathore,
author of the forthcoming book – Clojure in
Action. In this interview, Amit
Rathore talks to the Clojure 101 course participants on Clojure.

Michael>> Welcome, Amit and thanks for taking out time for
RubyLearning’s Clojure course participants. For their benefit, could you
tell us something about yourself?

Amit>> I’ve been programming since I was 11, and been designing
and developing software systems in a professional setting for about ten
years now. The last few years have seen me transition from Java to Ruby,
along with a smattering of other languages such as Python, Scheme, and
Smalltalk. Since late 2008, I’ve been using Clojure full-time. I’ve made
a few open-source contributions to the Clojure community – some examples
are data-mappers for HBase and Redis, and another one called Swarmiji
which allows you to write distributed programs (that span multiple CPUs,
not just multiple cores) in Clojure. I’m currently the Chief Software
Architect at a startup called Runa, in Mountain
View, CA. We are a provider of SaaS solutions to online e-tailers to
enable them to provide real-time, analytics-driven promotions to their
shoppers. More than 90% of our backend is written in Clojure.

Michael>> How did you get involved with Clojure?

Amit>> As I said earlier, I’ve used Scheme on my personal projects
from time to time. At Runa, we always knew we could benefit from using a
Lisp for our back-end, what with all the analytics and machine-learning
that the system needs to do. When all the scalability requirements were
thrown in, we seriously considered using Erlang, thanks to it being
functional and its concurrency support. It was just around then that the
Clojure community really started taking off, and we decided to try it
out. We’ve never looked back, and we’re extremely pleased with the
outcome so far. Our analytics-powered, adaptive, conversion-marketing
engine is miles ahead of any potential competition… and we can add
features (and make sure things still work, and are as performant as
needed) faster than any potential competition. If you have read Paul
Graham’s essay called Beating The Averages, you know what I’m talking
about. In Jan 2009, following our initial Clojure deployment, I started
the Bay Area Clojure User
Group. It’s
going to host its 17th Meetup next month. It’s great to see the
community growing, and its great being a part of it.

Michael>> You are currently writing “Clojure in Action”. What can
you tell us about the book?

Amit>> When Manning Publications contacted me regarding a new
Clojure book, they wanted something different from what was already
available, and what they knew was in progress. When we discussed my
Clojure experience and startup background, we came up with the concept
of the Clojure in Action book. The idea basically resulted in a Clojure
book that does a few things:

Teaches Clojure from first principles i.e. why are certain things
the way they are, and how they’re better than what currently exists
in popular languages.

Teaches a developer new to Clojure to get going after reading the
book – it answers the “OK, what now?” question – by addressing
issues like test-driven development, IDEs, dependency management,
debugging/profiling, and so on.

Real-world usage for web-scale applications – from all the
experience I’ve gleaned working with HBase, Redis, RabbitMQ, Amazon
services, Hadoop/MapReduce, and so on.

And finally, advanced usage of macros to build DSLs (domain-specific
languages). So readers of all levels will get something from the
book – folks new to Clojure can get started quickly, while
intermediate to advanced users can gain also.

Michael>> Many of RubyLearning’s Clojure course participants have
a Java and or Ruby background. What, according to you, are the benefits
to these participants after learning Clojure?

Amit>> The functional approach is just a better way to program. So
that, in itself, is a huge learning opportunity. In the words of Eric
Raymond, the famed hacker, “LISP is worth learning for a different
reason — the profound enlightenment experience you will have when you
finally get it. That experience will make you a better programmer for
the rest of your days, even if you never actually use LISP itself a
lot.” And the great news is that Clojure, the latest incarnation of
LISP, is actually so usable that once you start, you will never want to
program in any other language again. This influence includes
meta-programming, which will especially benefit Ruby folks. On the other
hand, it will also make developers from both the camps (especially Java)
realize just how limiting their languages are. Actually, this is also a
good thing.

Michael>> Why do you think that such a free, online Clojure course
at RubyLearning would be beneficial to the Clojure community?

Amit>> Clojure will only succeed if more and more people adopt it.
While it is a no-brainer once you understand what it offers in terms of
productivity and code-quality, it has the initial problem of
getting-the-word-out. Such a free, online course can do this quite
effectively.

Michael>> How should they go about acquiring knowledge and skills
in Clojure? What’s the best approach?

Amit>> There is one book published so far, and several coming out.
Those are good resources. There are plenty of tutorials online, as well
as a ton of open-source code which can be great resources. There are
several very active Clojure user groups around the country, and indeed
all over the world. Also, the IRC channel is fantastic.

Michael>> Which areas in Clojure should a would-be Clojure
programmer concentrate on?

Amit>> Functional programming would be an important topic. People
coming from an imperative background have to sort of re-wire their
brains. Another topic is “the Lisp way”, which is this idea of bottom-up
design (as opposed to the traditional top-down approach to breaking
things down). Creating mini-languages (fashionably called Domain
Specific Languages these days) that allow the developer to program at a
much higher-level of abstraction is another important design philosophy.
These I’d say are things that take time to really “get into”… so some
deliberate attention should be paid them. Other things, such as
Clojure’s concurrency mechanism are also important, and yet easy to
learn and use.

Michael>> Do you have any suggestions for RubyLearning’s Clojure
course participants? Anything you would like to share with them?

Amit>> I’d just like to say this: As developers gain experience,
they learn certain things that become guiding principles. One such thing
is the power of abstractions. As they gain expertise of the programming
language they’re using, they discover the natural limit to the kind of
abstractions that their language of choice can create. They realize that
certain things just can’t be expressed in that language. At times this
manifests in wishing that the language had this feature or that. Lisp
frees you from such tyranny. The parenthesis are there for a reason, and
that reason is to make the macro system possibly. And that makes
wonderful things happen. And Clojure is an incredible Lisp. So, stay
with it, give it a real go, the parenthesis disappear in a few days, and
the real power becomes apparent. And then you can never go back

Michael>> After the course, most participants would like to
contribute their time, skills and expertise to a Clojure project but
invariably are unaware of where and how to do so. Could you suggest how
this can be achieved?

Amit>> There are plenty of open-source projects that add something
to the Clojure world. GitHub is a great place to start looking, and
there are others.

Michael>> On a final note: What do you perceive as the future of
Clojure?

Amit>> We are all craftsmen: programming languages and software
requirements are our raw material. Given that complexity of software
requirements is continuing to grow, it behooves us all to use better and
better tools and languages to create the next software system. As a
matter of fact, tomorrow’s software almost needs to be adaptive – it
needs to learn and adjust its behavior based on things like the data
that it sees, or patterns of usage, and so on. This kind of complexity
needs really flexible and powerful tools on the implementation side. A
Lisp is a natural fit for such a dynamic, demanding world. Further,
Clojure’s functional and concurrency story is very strong – as software
moves to clouds of multi-core CPUs, this becomes a great advantage.
Finally, being able to leverage battle-tested Java libraries in such a
seamless manner is another boon. I see more and more people being
enlightened about these issues, and more and more adoption of Clojure.
I’d be very surprised if it doesn’t become the discerning developer’s
first choice within the next couple of years.

Thank you Amit. In case you have any queries and/or questions, kindly
post your questions here (as comments to this blog post) and Amit would
be glad to answer.