I happen to like Lisp (well, Scheme at least), but I think a better comparison would be:

    let a = 123, b = 456, c = 789;
    # more code

vs:

    (let ((a 123)
          (b 456)
          (c 789))
          ; more code
     )

In many cases outside of function calls, there are more parens.

Well, a more accurate comparison would be like this:

  {
    let a = 123, b = 456, c = 789;
    # more code
  }

Because Lisp let explicitly defines its scope, while the first example inherits the scope from whatever it is embedded in.

And in Clojure:

     (let [a 123
           b 456
           c 789]
        ...)

Clojure syntax was designed with a clear and deliberate attempt to remove many of the parenthesis from lisp syntax. This is just a part of the greater design goal of offering very concise and elegant syntax in general, which is one of the reasons I keep coming back to it.

Speaking as a beginner, I find the pure lisp example easier to read than the one with the clojure literal syntax. I actually don’t like the []. I’m sure I’ll get used to it tho

Yep, Clojure made some nice improvements (still 4 parens, however), but I just can't get excited about the JVM.

The JVM does solve the distribution problem that's heavily frustrated me with other platforms.

I can create a great tool in Ruby for example, but asking a computer illiterate to run it in Windows isn't going to happen.

You can however hand that person a .jar from Clojure and ask them to run it.

Assuming they have Java installed. Which, in my experience, is less and less likely as time goes on, for random samplings of non-developer Windows boxes.

Not anymore! Java now can link JVM, runtime, and your own modules into a bundle that just works and runs everywhere.

On Linux, you’re even able to compile most of it into a single binary.

Good to know. Does it tree-shake to cut down irrelevant stuff out of thefinal package?

That’s exactly why Jigsaw and jlink were so important, because they provide exactly that.

> (still 4 parens, however)

My example has 2 parens.

Even if you're not excited about the JVM, ClojureScript is particularly productive for front end development, where I genuinely love it tremendously.

well, ok but the comparison is moot when you consider that dense lets are rare in Lisp

that should have been object.function(x,y,z) or function(x,y,z) - typo and it's too late to edit