Eh, IMO

    (let [x (+ 1 2)
          y (+ x 3)]
      (* x y))

Is always less verbose than:

    (let ((x (+ 1 2))
          (y (+ x 3)))
      (* x y)) 

I program in Clojure every day, and that latter example makes me say "aahhhh! The parens!"

And the Clojure example makes me say "aaah the ambiguity!" The key/value pairs makes much more sense to me when they are delimited as such. It's a minor point, anyhow. Clojure is just fine. I just don't think that it is significantly less verbose than Scheme. Let's just keep hacking with Lisps and be happy. :)

It's dramatically less verbose when you are dealing with code that uses associative data structures, both because of having nicer literal syntax and because the data structures can be applied directly without needing to reach for things like hash-ref. (Which makes a boatload of sense, because immutable hash maps actually have more in common with mathematical functions than Scheme procedures do.) In addition, functional nested updates are very verbose in Scheme.

However, both of these problems can be solved in Racket by third-party libraries.

    (let* ([x (+ 1 2)]
           [y (+ x 3)])
      (* x y))

Less ambiguity, all of the clarity of what is what. I don't get why you use other delimiters for your Clojure code, but have this view that they can't be used in other Lisps/Schemes.

(You will also have to use `let*` in (most?) schemes because the binding for y has absolutely nothing to do with the binding for x and so cannot be used in the binding of y.)

>I don't get why you use other delimiters for your Clojure code

Do other delimiters mean the same thing as in Clojure tho ? I only know Clojure - in Clojure [] - vector- is a different data structure from () - linked list - which is different from {} - hash map. Is this similar to Racket or is it all just lists in Racket ?

In Racket all kinds of parenthesis are equivalent, using one or the other is a matter of convention and readability.

I think the newest Scheme standard takes the same approach.