It's not like a stack-based language is hard to read to a new programmer or anything. Besides, the reason LISP-likes (except for Dylan) use so many parenthesis is because that makes it easier to pass code around as data, which is necessary for the macro system. A good example is the Loop macro in Common Lisp, which is a macro that turns for example
(loop for x from 1 to 20 do (format t "~a~%" x)) ;This prints out the numbers 1 to 20, each on a new line. Everything after a semicolon is a comment.
into (comments added by me)
;Expanded with Clozure Common lisp, results may look different on other implementations
(BLOCK NIL ;We're in the nil block, so that we can break out of the loop with (break), which is the same as (break nil)
(LET ((X 1)) ;Introduce X as a variable and give it the value 1
(DECLARE (TYPE NUMBER X)) ;Tell the compiler that x is a number, so it can do some optimizations.
(TAGBODY ;We're going to do some jumping so we'll need some tags
ANSI-LOOP::NEXT-LOOP (FORMAT T "~a~%" X) ;At tag ANSI-LOOP::NEXT-LOOP , the compiler places the following code in order: Print x,
(SETQ X (1+ X)) ;Set x to x+1
(IF (> X '20) (PROGN (GO ANSI-LOOP::END-LOOP))) ;If x>20, jump to ANSI-LOOP::END-LOOP. the progn is there in case we introduced cleanup code in the loop definition.
(GO ANSI-LOOP::NEXT-LOOP) ;else, jump back
ANSI-LOOP::END-LOOP))) ;we're done
Anyone who's ever worked with a BASIC-like or assembly language will probably recognize the latter as a simple goto-based loop implementation, while the first is like a loop declaration in a high-level language. You'll also note that the variable declaration and the code to execute every cycle has been smeared out all over the place in the code eventually generated, which the preprocessor can do because before compilation or interpretation, lisp code is essentially a list of code elements. (If you're wondering why the format is still there, loop is a macro, which gets expanded prior to compilation/interpretation, while format is a function that gets called during execution.)
Anyway, if you want to dive into a LISP-like without shelling out,
Practical Common Lisp is a pretty good introduction.