Why Clojure?

He won me at: > ... nor would I expect anybody to switch if they're happy with their current language of choice. For the uninitiated, however, these are the reasons why I love Clojure:

Nice to see a humble post about the language they like without bashing any other language.

Clojure is the most fun programming I've had in years.

It takes quite some time to really kick in (more than one or two pet projects, rather than couple of "hello world"-style lines it took for Ruby), but once it does… walking up and down the ladder of abstraction never felt so good.

I have always wondered why, if functional programming is such a good deal in terms of better abstractions, entire classes of bugs eliminated, cleaner code, etc., it doesn't come near-universally recommended by the world's most experienced programmers for mid- to high-level tasks. I'm thinking people like Martin Fowler, Donald Knuth, etc., but especially people like Rob Pike, Russ Cox, Guido van Rossum, Yukihiro Matsumoto, who are all incredibly smart and experienced engineers who have dedicated their lives to developing non-FP languages. There must be some trade-offs to FP that are almost never make it into these kinds of "FP has dramatically improved my life" articles.

(BTW I don't buy the "they're just not used to it" or "they're comfortable with what they know" explanation for this kind of people. These are not stodgy Java programmers who are working in programming as a day-job who are resistant to learning new things, they're people who know more about programming than a hundred average programmers combined and spend nearly every waking minute thinking about how to make it better.)

The main issue I have with Clojure is the stack trace ... If you've ever hate yourself when an error in Java popup and you have to trace 30 lines of stack trace in Java, it's far worse in clojure.

I'm hoping to pick up clojure this year. If nothing else just to have a new way of thinking about code - both from a functional perspective and a lisp perspective. I seem to find a lot of these articles - the only bad press i've seen about clojure is from other lisp'rs that think clojure isn't good enough.

I do think it is interesting though that so many people love to extoll the virtues of immutability and yet have such a hard time putting those virtues into words.

I love reading articles like this about Clojure -- each one demystifies some part of the transition from another, more imperative language. (Here, for me, it was how to do unittesting in Clojure coming from Python.)

Something the author touched on is the use of the REPL, in vim, to attach to remote running processes and debug. Does anybody have a quick example of how to do this?

Clojure is fun but starting a Clojure program that just prints hello world takes over 1 second, even worse on a raspberry pi. I suppose command line tools are not its main purpose.

As a tip to anyone who wants to give Clojure a try, be sure to grab something for your IDE to handle the brackets. For Sublime, I would recommend Paredit. Your sanity will thank you.

Some people might find the example given of functional:

  (map (comp (partial g a) f) x)

to be more readable as:

  (-> g (partial a) (comp f) (map x))

Given your experiences, would you recommend picking up Python or Clojure for data processing/data science?

I'm currently quite deep into Javascript/Node, and am already comfortable with functional programming. Next I'm looking to gain more data abilities, and had assumed Python would be the natural next step. You're making me wonder whether Clojure would be a smarter step, though I am concerned that most of the jobs still appear to be in Python.

One small nitpick: the supposedly "bad looking" Python example:

    SimpleTestCase(unittest.TestCase):  
        def runTest(self):
            self.assertEqual(true, true)

can be made more pythonic by using a modern testing framework, py.test:

    def test():
        assert True == True

Okay, serious question: What is an example of a mid-sized project to really begin hacking on Clojure? Simple programs utilizing multiple namespaces for trivial reasons are great and all, but if I want to really understand what Clojure can do for me in a few weeks, what should I be trying to build?

Do me a favor, please do not write your configuration files in Clojure as well.

As a non-Clojure developer, having to fight with Clojure configuration files for Riemann was a real pain point, and ended up deciding us against using Riemann for anything as a result (trying to convince a team of sysadmins that they would have to learn Clojure for a single piece of their monitoring infrastructure... didn't work).

IMHO, you're welcome to enjoy your language to the fullest extent possible, I would just ask that you don't force others to use it as well.

EDIT: Since it was asked twice in about 30 seconds, here's why having Clojure as a config option can be bad; it encourages things like this:

https://github.com/guardian/riemann-config/blob/master/main....

Please note that this is considered to be the gold standard by Riemann; it's directly referenced in their documentation.

As for my preferred config file format? ini, yaml, json, in that order. They're simple, there are lots of tools out there to read and write them, and friendly to humans.

I love Clojure. Why? Partly because I am lazy. Larry Wall said a good programmer is lazy, but in my case I am lazy in the wrong ways. If you have enough self-discipline, then you probably don't need immutability. But immutability is a wonderful thing if you are lazy.

I also love immutability because I have had many co-workers who are lazy. Again, not aways the good kind of lazy. I mean the kind of lazy that allows 2 loops with mutable variables into the same function:

howMuchPrizeMoney = 0;

arrayOfMoneyPerCategory =[];

for (i=0; i < users.length; i++) {

    u = users[i];

   howMuchPrizeMoney += u.prize_money;    

}

for (i=0; i < contests.length; i++) {

  c = contests[i];

  for (j=0; j < categories.length; j++) {

        cat = categories[i];  

       if c.name == cat.name {

         arrayOfMoneyPerCategory[cat.name] =   u.prize_money;  

     }

  }

}

Wait, now I have a bug! All the categories have the same amount of money, and I know that is wrong. Where is that bug? Hmm, let me look and look and look. And if this example seems easy, I have seen functions larger than this, where finding the bug gets much harder. I am lazy, and my co-workers are lazy, and if we allow ourselves mutable variables, we will abuse them, so I would be happy if we adopted a language that avoided mutable variables. So for instance, even if I had a loop that looped over all the variables, there would still be no risk of one variable effecting another if I did something like this:

(def vector-of-users [

                        {:name :henry :prize-money 200}   

                       {:name :henry :prize-money 30}   

                       {:name :craig :prize-money 340}   

                       {:name :craig :prize-money 100}   

                       {:name :pasha :prize-money 2330}   

                       {:name :pasha :prize-money 1130}   

                       {:name :pasha :prize-money 430}   

                       {:name :eli :prize-money 60}   

                       {:name :eli :prize-money 330}   

                       {:name :eli :prize-money 89}   ])

(loop [u vector-of-users total 0]

     (if (first u)

       (recur 

           (rest u)

           (+ (:prize-money (first u)) total))

      total))

At the REPL, this gives me 5039.

Now if I do this, and I stupidly put next a loop inside of a loop, is there any risk of a typo? Sure, but I won't get a confusing number back, instead I'll be told that I'm using a var that doesn't exist.

This is the version without the typo:

(def vector-of-categories [:housing :crisis :restaurants :theater])

(def vector-of-contests [

                        {:category :housing :prize-money 200}   

                       {:category :housing :prize-money 30}   

                       {:category :housing :prize-money 340}   

                       {:category :crisis :prize-money 100}   

                       {:category :crisis :prize-money 2330}   

                       {:category :restaurants :prize-money 1130}

                       {:category :restaurants :prize-money 430}   

                       {:category :restaurants :prize-money 60}   

                       {:category :theater :prize-money 330}   

                       {:category :theater :prize-money 89}   ])

(loop

[money-per-category {}

contests vector-of-contests

categories vector-of-categories]

(if (first categories)

(recur

   (assoc money-per-category (first categories) 

       (loop [c contests total 0]  

         (if (first c) 

             (recur 

                (rest c) 

                (if (= (:category (first c)) (first categories)) 

                   (+ total (:prize-money (first c))) 

                    total))

           total)))

   contests

   (rest categories))

money-per-category))

When I try this at the REPL I get:

{:theater 419, :restaurants 1620, :crisis 2430, :housing 570}

But what if I made a typo, just like in the first example? What if instead of this:

(first c)

I stupidly wrote:

(first u)

There would be no "u" that was in scope for the whole of the function. The "u" would only exist inside the first (loop).

Needless to say, no one would ever write Clojure code like this. Anyone who puts 3 loops in function, in Clojure, is taken outside and shot at point blank range. But my first example, in Javascript, is something I have seen in real life.

Clojure is definitely my favorite dynamically typed language. I also think that its community has a world-class aesthetic sense that other languages (looking at you, Haskell) could stand to learn from. Take maps as an example: Clojure has {"one" 1, "five" 5} and Haskell has fromList [("one", 1), ("five", 5)]. Clojure's syntax is a lot more attractive. Clojure has hyphens and Haskell has camelCase. Again, Clojure wins that one. Also, Leiningen is probably the best build tool I've ever used. I also think that Clojure has a great UX sensibility: once you get past That One Thing (parentheses, which are not as bad as they're made out to be) it's more readable than Scala and arguably Haskell. You can also make Clojure blazingly fast for a dynlang, although with some loss of aesthetics due to type hinting and array bashing.

There are two issues with Clojure (3 if you consider static typing a hard requirement, because core.typed is brilliant but probably not "there" yet) and both come from the JVM. The debugging experience is still pretty bad; although I dislike debugging in general if it can be avoided, and that's why I've gravitated toward static typing (catch bugs early). The second is that the JVM itself imposes a ceiling on how well you can do performance-wise, and can require a fair amount of configuration in production. Of course, Clojure may be off the JVM in 10 years and, even if not, it's still a great language in very many ways.