41

I've been taking a look at Clojure lately and I stumbled upon this post on Stackoverflow that indicates some projects following best practices, and overall good Clojure code. I wanted to get my head around the language after reading some basic tutorials so I took a look at some "real-world" projects.

After looking at ClojureScript and Compojure (two the the aforementioned "good" projects), I just feel like Clojure is a joke. I don't understand why someone would pick Clojure over say, Ruby or Python, two languages that I love and have such a clean syntax and are very easy to pick up whereas Clojure uses so much parenthesis and symbols everywhere that it ruins the readability for me.

I think that Ruby and Python are beautiful, readable and elegant. They are easy to read even for someone who does not know the language inside out. However, Clojure is opaque to me and I feel like I must know every tiny detail about the language implementation in order to be able to understand any code.

So please, enlighten me!

  • What is so good about Clojure?
  • What is the absolute minimum that I should know about the language in order to appreciate it?
Community
  • 1
marco-fiset
  • 8,761
  • 15
    I don't understand why someone would pick Clojure over say, Ruby or Python - it runs on the jvm and can use the entire java library. ... have such a clean syntax arguably, lisp like functional languages have a very clean syntax and structure, its just one most people aren't used to. –  Dec 11 '12 at 21:12
  • 23
    Its name is sexy. – programmer Dec 11 '12 at 21:12
  • 2
    @MichaelT Ruby and Python too have implementations that run on the JVM so this point is not compelling for me. – marco-fiset Dec 11 '12 at 21:14
  • 1
    @JasonHolland I think the name is cool too, but that is not enough to convince me ;) – marco-fiset Dec 11 '12 at 21:17
  • To be fair, lisp code and clojure in particular is somewhat harder to read and understand. Having said that, Clojure have multiple important advantages that have already been discussed in this community. – DPM Dec 11 '12 at 21:44
  • 4
    Any teenager living in a basement can pick up Python and Ruby in a matter of few months. If that is all they ever want to use, then they will never get out of the basement. I am not saying that someone who has done professional Python development for many years is a lesser mortal comparing to someone who writes embedded C, but if Python and Ruby is all they know and all they ever want to know, then something is fishy. By the way, it took me personally over 6 years after graduating to discover and appreciate functional programming and Lisps. My first reaction to Scheme was a knee-jerk. – Job Dec 11 '12 at 22:22
  • 4
    "arguably, lisp like functional languages have a very clean syntax and structure, its just one most people aren't used to.": I have very little experience with Lisp and I have just started to read the book "Practical Common Lisp". So far, I haven't encountered any problems with the syntax; IMHO the myths about Lisp-like syntax being less readable are just FUD. – Giorgio Dec 11 '12 at 22:34
  • 4
    I started looking at Clojure recently (but I have prior experience with Haskell and Scala, so the syntax isn't such a shock). I actually found it surprisingly readable. There are very few symbols outside of parenthesis compared to many languages, and almost no reserved words. The reason you find it unreadable is because it's a totally new paradigm and works in a fundamentally different way than a typical Object Oriented language. Give it some time and power through. – KChaloux Dec 12 '12 at 13:54
  • 3
    Usually data is simple. Lists, Arrays, (Hash) Maps, Sets are quite easily understandable. [a: 1, b: [2,3]] etc. Contrast this to "Commands". Syntax rules are really annoying and complicated. Lisp and Clojure's decision is to reduce all syntax to that of data description. This turns out to be really powerful. As a Web developer, you usually deal with HTML/XML, CSS, Javascript/JSON. All have different Syntax. See https://github.com/Prismatic/dommy for a solution that only uses only Clojure syntax to do all these things. It also scales well with a growing codebase. – wirrbel May 17 '13 at 21:38
  • 1
    I've just started learning Clojure a few days ago, but I think Compojure having only 5 source files with not so much lines pretty much talks for itself. – scadge Nov 05 '15 at 08:29
  • Don't fear parentheses! (a) Use an editor that helps you keep track of them. (b) Learn lisp indentation rules, which allow you to write code compactly in a way that makes it easy to keep track of what's inside of what. (c) Use an editor that will automatically indent according to lisp indentation rules. (d) You get used to them; the parentheses are really not a problem, and lisp syntax has advantages mentioned elsewhere on this page. (e) Clojure has fewer parentheses than other lisps. Square brackets e.g. in Clojure's let make it easier to read than Common Lisp's let. – Mars Jul 25 '17 at 13:59

3 Answers3

48

For the background you gave, if I may paraphrase:

  1. You're familiar with Ruby/Python.
  2. You don't see the advantages of Clojure yet.
  3. You don't find either Lisp or Clojure syntax clear.

...I think the best answer is to read the book Clojure Programming by Emerick, Carper and Grand. The book has numerous explicit code comparisons with Python, Ruby, and Java, and has text explanations addressing coders from those languages. Personally, I came to Clojure after building good-sized projects w/ Python, and having some Lisp experience; reading that book helped convince me to start using Clojure not just in side-projects but for professional ends.

To address your two questions directly:

  1. What's so good about Clojure? Plenty of answers on this site and elsewhere, e.g. see https://www.quora.com/Why-would-someone-learn-Clojure
  2. What is the absolute minimum that I should know about the language in order to appreciate it? I'd suggest knowing the big ideas behind Clojure's design, as articulated in both Clojure Programming and The Joy of Clojure books-wise, and in Rich Hickey's talks, esp. the talk Simple Made Easy. Once you know the what/why you can then start understanding the how when reading Clojure code, esp. how to change your thinking from classes, objects, state/mutation to "just functions and data" (higher-order functions, maps/sets/sequences, types).

Additional suggestions: Lisp's elegance and power is partly from its minimalist and utterly consistent syntax. It's much easier to appreciate that with a good editor, e.g. Emacs with clojure-mode and ParEdit. As you get more familiar with it, the syntax fades away and you'll "see" semantics, intentions, and concise abstractions. Secondly, don't start by reading the source for ClojureScript or Compojure, those are too-much-at-once; try some 4clojure.org problems, and compare solutions with the top coders there. If you see 4-6 other solutions, invariably someone will have written a truly idiomatic, succinct FP-style solution which you can compare with a clumsy, verbose, and needlessly complicated imperative-style solution.

limist
  • 4,646
21

Lisp dialects have a unique niche due to their simple syntax. This simple syntax makes meta programming through the use of macros very simple. This allows you to model the language to suit your problem domain instead of modeling to fit your problem domain into your language. It's really cool once you get your head around it, and it lets you do a lot of things easily that is very difficult in other languages.

The downside, is that since every Lisp program essentially defines its own language, you really need a solid grasp on things to understand what is going on.

Now, to answer your questions...

  1. Clojure is a modern Lisp dialect that runs in the JVM/CLR. This makes it easy to take advantage of the power of Lisp in an existing infrastructure.

  2. It is essential to understand how to use macros to build Lisp to your problem domain to appreciate its usage. I really only understood this after implementing a Lisp runtime, when I found that much of the core language features can easily be implemented in Lisp itself. It takes a fair sized project to get this.

Its pluses aside, although it is fun to program in, I personally don't have many cases where I would turn to it for daily problems. It is a very good tool to learn for mind expansion, and after learning Lisp properly, it became much more natural to take advantage of meta programming facilities in other languages.

The simple syntax makes it easy for computers to interpret (allowing such easy powerful macros), but it makes it very difficult for a human to parse complex expressions quickly.

Guillermo Gutiérrez
  • 103
bunglestink
  • 2,262
  • 2
    Have you looked at light table? –  Dec 11 '12 at 21:51
  • 4
    Your answer makes it sound like macros are the normal way to approach Lisp programming, when in fact most programming problems can be solved with ordinary, first-class functions. Macros are intended primarily to be used for language programming (i.e. extending the language). See also http://www.bookshelf.jp/texi/onlisp/onlisp_9.html – Robert Harvey Dec 11 '12 at 22:11
  • 3
    @RobertHarvey I would argue that if you aren't taking advantage of marcos, then there are a plethora of other languages that I would turn to which offer first-class functions with a much more readable syntax. – bunglestink Dec 11 '12 at 22:23
  • @MichaelT that looks neat. I like the concept. – DPM Dec 11 '12 at 23:25
  • @bunglestink: which ones? – Robert Harvey Dec 12 '12 at 00:01
  • 3
    @RobertHarvey Scala, JavaScript, C#, Python, and Haskell are all on the top of my head as far as languages with first class functions that I would consider more human-parsable syntax than Lisps. – bunglestink Dec 12 '12 at 05:11
  • We don't use macros much. At the moment whatever we are building would have been quicker with JS or Python as well. but if you look at some of the DSLs. simplest one will be Bouncer for validation of nested structure. You would realize how easy it is to express a recurring problem in a DSL than in a regular programming language. So I feel if one can use macros to create a DSL that one can use to build the system, then only one will realize true essence of a Lisp. – Amogh Talpallikar Feb 01 '14 at 17:36
  • I find the syntax of Clojure more readable than C#,JavaScript, et all. It's terse, short, uniform, predictable, and makes for short code that is easy to code review. I even write my pseudo-code in Clojure syntax now. So I'd say you just didn't really put in the same amount of time to become familiar with it as you did the others. It's possible the familiarity curve is higher at first, but it pays off. I compare it to music sheet notation. It's not familiar to someone whose used to the alphabet, but it's unbeatable in its tersness and uniformity in expressing music. – Didier A. May 06 '16 at 09:09
  • "but it makes it very difficult for a human to parse complex expressions quickly." - complex expressions 99% of the time are a design/implementation problem. – Reut Sharabani Feb 08 '17 at 11:22
11

The strengths of Clojure have been highlighted many times, and, sure enough, make for a very powerful language, so I won't repeat them again here.

I always loved lisp, since the uni days and I was really excited when I discovered Clojure (perhaps the chance of using lisp outside of academia at last!). However as I started learning an uneasy feeling has begun to creep in, though I cannot pinpoint exactly what it is that I don't like. First of all I would say that coding in Common lisp was easy and fun for me but Clojure has a steeper learning curve. Clisp had a certain beauty and elegance to it. I'm not sure I'll get the same feeling from Clojure. I'm wondering if that feeling will go away as I get more experience.

I have another guess for my mysterious slight repulsion. I think it might be its great flexibility. For instance you can have structures that are half vector and half map and with a few characters of code you can accept them as parameters, take them apart and process them correctly. Yes, it removes all the boilerplate, but somehow it doesn't feel right. Is like you never know very well the rules under all those parenthesis, colons, brakets, etc are operating.

For me, I still love the language for all its advantages (primarily, running in the JVM and simplifying concurrency, while being much more powerful, and concise than Java and with less obvious design flaws) but the jury is still out as to whether something could have been improved.

Community
  • 1
DPM
  • 1,713