>>849914
Scheme and Common Lisp are both members of the Lisp family of programming languages, but they are different languages.
After the original Lisp was created different people and corporations started making their own dialects of Lisp and all those dialects were in some way incompatible with each other. They all died out eventually as new languages began adopting features of Lisp and the Lisp machine companies went out of business. Common Lisp was created as a sort of common ground so that one could write portable Lisp programs.
CL is a huge language that includes everything and the kitchen sink and is ugly as fuck due to having bits and pieces from everywhere. On the other hand it gives you a lot of what you need to write real-world applications. However, there is still a lot left up to the implementation, so no real-world program will ever be 100% portable (no 100% portable way of opening a file). The best thing you can do is wrap up the unportable parts behind an interface so that the unportable code can be nicely isolated. Or use a library. Or just pick one implementation and roll with it.
Scheme is its own Lisp and as such it doesn't suffer from the uglyness of Common Lisp. Scheme is also a scam created by (((Sussman))) where MIT students pay tuition and end up learning a language that is completely useless outside the classroom. It's a really nice language though, so the various implementations have added their own stuff to actually make it useful in the real world. The problem is that everyone adds their own flavour of extensions.
How bad is it? Well, until the R6RS standard there was not even a module system, so only if you wrote all your code in one file was it actually portable. What it effectively means that each implementation is its own language. R6RS tried to address this issue and create a language that is actually usable, but many found it to be too bloated, so barely any implementation is standard-compliant. R7RS tried to appease both camps by splitting the languages into two languages: R7RS small is a small language that adds some sorely-needed features (module system, record types), while R7RS is meant to be a huge real-world language (possibly even larger than Common Lisp). R7RS small is complete and Chibi Scheme is its reference implementation:
http://synthcode.com/scheme/chibi/
R7RS large will still take years to be finished. Some implementations like Guile or Racket have essentially given up by this point and barely even pretend to be Schemes. They support some of R6RS, but in practice they are doing their own thing now in order to implement an actually useful language.
> TL;DR
Common Lisp are two different languages with common ancestry. Techniques that work in one work in the other, so pick whichever one either looks better to you or has the libraries you want to use.