[Differences]

In so far as the differences are tiny the fights between their proponents vicious.

To me, the difference between MIT Scheme (the dialect in SICP) and ANSI Common Lisp (what 'Common Lisp means these days) is, in some ways a Turing Tarpit. Common Lisp is a big language and has explicitly defined procedures to perform many ordinary type tasks and domain specific languages for loops and formatting text all built in. It was built by consensus on top of existing commercial implementations and rolled many vendor specific features into the spec -- some for compatibility, some because they were good ideas, some because the group defining the language had to pick something.

Scheme is a 'small' language and it's smallness is at least in part motivated by the pedagogical purpose of which SICP is an artifact. Unlike Common Lisp, procedures for many ordinary tasks are external in the standard libraries (plural) and to me, the standard libraries reflect the same philosophy that led to their creation...just as they exist to keep some useful constructs out of the language, the resist inclusion of other useful constructs. For example, standard Scheme does not include `(while...)` nor do its libraries. Everyone gets to write their own macro.

The different origin stories explain a lot of the difference. Common Lisp was created by and for working programmers and done while those programmers were working. Industry was involved...Steele's Common Lisp: The Language
was published by Digital Equipment Corporation (DEC) press. Scheme grew out of academic AI research at MIT.

Recently, I've been thinking that the big difference between Common Lisp and Scheme and pretty much every other programming language comes from its concurrent development with Lisp Machines. The hardware abstraction of the programming language means that there is no programmer/user dichotomy. Common Lisp just has users and they are users in the same sense as Windows users or OSX users.

In terms of language design, this created a context where telling the user to type

(rename-file #P"foo" #P"bar")

For the same reasons a user might be instructed to click on the start menu or the trashcan icon or File->New. The high bit of typing s-expressions in Common Lisp's design is not writing programs, it's using a computer. The parallel is the high bit of s-expressions in Emacs Lisp is editing text.

[Now what]

1. Probably the simplest step from SICP toward writing applications is the Racket ecosystem. It is robust and well documented and well maintained and beginner friendly.

2. The second set of alternatives are Clojure or ClojureScript. They are less beginner friendly and are harder to learn without a background in the underlying platforms (JVM and the browser).

3. Common Lisp would be my third choice as a recommendation for developing applications. It's the least newbie friendly of the three and the ecosystem of widgets and add-ons is harder to navigate: partly because age means that there is obsolescent advice and abandoned tooling, partly because it is a mix of commercial and open source projects (and therefore the default is very often, if you want it open your wallet), and partly because it is from the age when Read the Manual was the answer to everything except an actual bug [but see item 4].

4. Common Lisp would be my first recommendation for what to learn next. Partly because the RTM age produced really good manuals. Common Lisp: The Language is very readable while still being a specification. Partly because the best book on programming I've read is Norvig's Paradigms of Artificial Intelligence: Case Studies in Common Lisp...someone said it was, I picked up a copy and they were write.

Another reason to learn Common Lisp is as a stepping stone to Clojure. Although nobody says it because it would be horrible for marketing, understanding Common Lisp is necessary for really understanding why Clojure is the way it is: Leiningen is just another system definition facility, the high bit of the REPL is using a computer not programming one, and probably a number of things I have thought of yet.

Good luck.