if you're looking for a pure learning experience with plenty of time
on your hands, then lisp is the road to take - richer functionality
(meaning more terse code), better way of coding macros IMHO & faster.

if you're looking to get productive fairly quickly (good ide, web
server, batteries included), then plt scheme is a candidate.

Others divide up this space differently than I, but for most purposes,
I personally regard them as distinct langauges, not mere dialectal
variations, although plainly they are from what I would call the same
language family.

You will probably prefer to use one or the other in the end, but they
each have things to teach you.  Even if you prefer to use neither, you
will use the things you learn from these languages in your future
thinking, becuase they will give you metaphors for thinking about
things that other languages do not.

Both are fine languages.  The choice seems to mostly be made by the
personal preferences of the programmer.  Different personalities are
attracted to features of one or another.  

Scheme is more of a single-paradigm language, appealing to people who
like to be told there's a single small core of stuff that they need to
learn and then they can compose what they need from that.  Its design
has a strong focus on aesthetic and formalism.  For many years, its
specification eschewed including detail information such as error
handling behavior, portability concerns, branch cuts, etc. because it
complicated an otherwise tidily small specification, although of late
this has finally begun to change.  Overall, though, it's a sort of
Republican, nearly Libertarian, approach to language design that
assumes languages shouldn't do for people what they can do for
themselves.  Scheme has tended to prefer a small language core with
additional functionality added as libraries.  As an example, the
Scheme does not have a primitively defined object system, although
there are object systems you can load.

CL is a larger language that offers more out of the box, including
multiple programming paradigms, and a great deal of baggage the
purpose of which is to allow people who program in multiple paradigms
to interact gracefully with one another. CL's aesthetics were
subordinate in design to pragmatic decisions of various kinds.  It has
a rich tradition of compromise in its design in order to accommodate a
varied community.  It's a sort of Democrat / Great Society approach to
language design that assumes people are more concerned with getting
things done than with fussing over religious notions of finding the
single right way to do things, and in some ways makes a kind of art
form out the what some might see as the messy aspects of
multiculturalism, even to the point of providing specific language
features whose sole goal is to allow disagreeing communities to share
the same space without being at each others' throats.  Common Lisp has
a heavily articulated object system (CLOS) and an elaborate
error-handling system, both of which are strongly integrated into the
standard language.

It's EXTREMELY hard to make any comparison without risking being
accidentally critical of one or the other community.  I have tried to
present both of these paragraphs in ways that show both perceived
positives and perceived negatives of both communities, not in order to
start a firestorm, but to give you a sense that each community has
things they are proud of and things that annoy the other.  Looking at
the above paragraphs, I'd hope that most people will find that they see
a bit of truth in them and moreover that the users of the languages
understand that, even if I didn't correctly capture it, there really
is something of the general kind I'm describing at work in how the two
communities differentiate.

There are other ways to make the decisions, btw.  Availability of good
texts is an example.  There are good books available for both languages,
but on unrelated topics, so it's a bit apples and oranges there.  I'm
sure others have opinions on that, so I'll stop here and will assume
others will take up the slack.

--
1st European Lisp Symposium (ELS'08)
http://prog.vub.ac.be/~pcostanza/els08/

However: some people prefer to write out "Common Lisp" in full, and that of
course takes more letters than just writing "Scheme".  So, perhaps it depends
on preferences.

But I think that the political analogy doesn't really hold up.  In some sense,
it seems to suggest that if you're the kind of person that prefers Republican
(or Libertarian!) real politicians or policies, then you probably prefer to
program in Scheme.  And likewise, if you have fond feelings towards LBJ, then
you probably would prefer programming in Common Lisp.

I don't think those implications hold at all.  And not just because an
individual may have different preferences as a voter/citizen than they do
as a programmer.

In particular, I would say that being "more concerned with getting things
done than with [...] finding the single right way to do things" may be a good
distinction between Scheme and CL, but is probably a poor way to distinguish
Republicans from Libertarians from Democrats.

(See, you were worried about igniting a "political" debate in comparing
Scheme with CL, but to simplify you brought in _real_ politics?!  How could
that possibly be simpler?  :-) )

If this is your first Lisp like language or functional programming
language you should start with Scheme.

First read Kent Dybvig's _The Scheme Programming Language, 3rd
Edition_ and then read _The Little Schemer_. Do all of the problem in
TSPL, read it two or three times. It is a short, wonderful book; you
will be amazed at how much you learn with that book.