Scheme or Common Lisp?

Yes, it's a “which programming language to leran ???” thread, but this time it's ...more specific I guess?

So I already know C ^{_{and Perl}} and wish to acquaint myself with other paradigms than the procedural and object-oriented ones I've become uncomfortably familiar with (i.e., functional). I also intend to learn Haskell at some point in the future in order to complete the holy trinity of syntaxes.

So, /anus/. Regarding the thread title, what are the differences that you find make you prefer one Lisp dialect to another? Is there even much of a difference? Or did you just choose one as your way of saying, “I've read SICP”?

>>40
Honestly the biggest reason I'm turned off by CL is because of how much syntax it has.
It appears to have more syntax, but all it does have is a few reader macros which are easy to remember. The reader macros are there only for convenience and pretty much all of them expand to simpler lisp code/expressions. Nothing prevents you from disabling the reader macros or making your own if you wish that.
it seems like it has a lot more of a learning curve
This is true. It might be easier to learn Scheme by reading SICP and then to look at CL later.

However, regardless of which you choose, just set up a good implementation and a good editing environment, and you're ready to start experimenting and learning. Not knowing the whole language does not mean you can't use it, but learning the whole language doesn't take that long (R5RS can be learned in less than a day, if you understand the general concepts, R6RS would probably take a few days to weeks, and Common Lisp a week or more). Once you know a Lisp, you can learn other ones without that much effort, providing you understand the concepts involved. CL does have more things involved than Scheme, but if you consider R6RS, there's some baggage there too.

As for Arc, I did look at it, and it did not provide me with anything CL or Scheme don't already offer. The syntax seems simpler and symbol names are shorter, but that's about it. There's one implementation built on top of an older version of MzScheme (PLT, Racket nowadays), so the choices are limited, compared to the multitude of Common Lisp and Scheme implementations.

On the other hand, Scheme has the Stalin compiler.
Stalin looks cool, but it seems to only support R4RS.

As for game development: there's various libs for both languages, mostly to add support for OpenGL and SDL. If they didn't exist, it shouldn't be that hard to just make FFI bindings for your implementation (CL has a de facto standard, while Schemes seem to vary per implementation).

My opinion: learn both. Pick/use which you like more, unless you're time constrained. Learning Scheme first would probably be easier as it's smaller, and as long as you don't pick up too many bad habbits(like doing all loops as tail-recursion) from it, it should be easy to reuse this knowledge when learning other Lisps.