If you love the expressiveness of S-expressions but hate the super noisy parenthesis, check the sugar version, called "sweet-expressions". http://readable.sourceforge.net/
(define (pointless-function a z)
(let* ((numbers (map (lambda (n) (* n 2)) (range a z)))
(multiple-of-three? (lambda (n) (= 0 (mod n 3))))
(multiples-of-three (filter multiple-of-three? numbers)))
(printf "Your numbers are: ~s~%" multiples-of-three)))
† OK, I'll grant you, this function is not at all realistic. But I think the structure of the code is pretty lifelike. I didn't have any Lisp code at hand to use as an example, so I just banged out something that used let and lambda to illustrate that the structure of S-expressions can be pretty intricate.
define (pointless-function a z)
let*
numbers (map (lambda (n) (* n 2)) (range a z))
multiple-of-three? (lambda (n) (= 0 (mod n 3)))
multiples-of-three (filter multiple-of-three? numbers)
printf "Your numbers are: ~s~%" multiples-of-three
* bindings (let forms & similar) make implicit pairs, so it's (let [a 1 b 2] ...) instead of (let ((a 1) (b 2)) ...)
* square brackets as shorthand for vectors - the nesting level might be the same, but the second kind of brackets somehow helps the brain find the way in the parenthesis jungle.
* lots of helpful macros (e.g. -> and ->>) and other helpers that help write terse code with low nesting. #(+ 5 %) as shorthand for (fn [x] (+5 x))
Yet they quote pg as if he ever said that Lisp source code were ugly.
Regarding the "noisyness", I really think that the one and only place that you can really criticize is the closing of the outermost method.
And any text editor worth its grain of salt can be programmed to automagically collapse these closing parentheses. Hence preserving the eyes of non-lispers.
Also, when you're using something like paredit or subpar you hardly ever have any issue of non-matching parentheses.
I'm really surprised that people are still whining about that instead of trying to focus on the bigger picture: the benefits that homoiconicity brings to the table.
Get a real editor and deal with it. Once you write your first macro, you'll realize how stupid all the whining was and why homoiconicity is in many aspects superior to other syntaxes without sacrificing much at all.
For example, declaring a bunch of variables in Lisp:
(let ((a 1)
(b 2)
(c 3))
(format t "They are ~D, ~D and ~D~%" a b c))
int a = 1;
int b = 2;
int c = 3;
printf("They are %d, %d and %d\n", a, b, c);
To illustrate further, Clojure gets the "OMG parens" complaint a lot less than most Lisps because it consciously shies away from the traditional parens-everywhere look of Lisp. For example, the above code in Clojure:
(let [a 1
b 2
c 3]
(printf "They are %d, %d and %d\n" a b c))
This isn't to say that this is really a problem, but the idea that parens in Lisp are equivalent to brackets in C isn't really right either. Parens in Lisp are used in place of nearly every bit of syntax in C, from braces to equals signs to semicolons.