What are the advantages of Lisp over ML (more specifically, I know Scheme and OCaml). My knowledge of scheme is probably incomplete, but for what I remember, Scheme is OCaml without static typing, sum types, pattern matching, module system. Scheme is more dynamic (dynamic types, code as data, symbols) but i find type safety much more important (and in a language with type inference, it comes with little overhead).
The macros davidxc mentions are a big win. The important point about Lisp macros is that they are not a separate technology you have to learn, as you have with Camlp4. Once you know Lisp, you automatically know macros.
Lisps are also much better at reflection than the MLs. In Common Lisp, you can rebind function symbols from a backtrace, and then carry on as if nothing happened. Changing a class definition updates every instance in the system to conform to that new definition, which makes interactive testing a joy. You can get hold of your namespaces as Lisp objects and interact with them as any other data structure, and see the effects reflected correctly in your runtime. CLOS is the peak of this sort of thing. And most lisps allow you to save a snapshot of the runtime image, which is awesome.
The MLs were originally written in Lisp, and inherit some of these features, but Ocaml, not so much. Still, I love Ocaml.
Common Lisp has macros. Paul Graham's book On Lisp is usually pointed to as the best treatment of macros in Lisp. CL also has many more features than Scheme, as mentioned in the other comments here.
It's probably not exactly true that CL has "more features" than Scheme. That is to say, the Scheme "core" language (well, as of R5RS) describes the essential functionality that qualifies as Scheme, but the major implementations have tons of additional/optional utilities, convenience features and extensions.
The sum total is that the complexity of CL vs. Scheme may not in practice be all that different. Take a look at newer Scheme standards, R6RS, R7RS, the SRFI's, and implementations like CHICKEN to see what I'm referring to.
Still CL and Scheme are different languages, each has its fans. It does seem to imply that the stuff it takes to get the job done is more or less independent of language, whether it's included with the base language, or contained in modules or libraries, the features need to be there somewhere in some form.
That's basically true. The more advanced Scheme implementations (and there are several) offer a lot of functionality.
One thing I still find true: Common Lisp has much more useful functionality in the core. Thus the core and the libraries are often actually using them.
Example: by default Scheme has poor argument lists. Thus a lot of code does not use keyword args and the compiler usually does not know about that.
Another example: Common Lisp has a standard object system. All implementations support it and some use it extensively. In most extended Common Lisp much of the libraries is using CLOS: conditions are CLOS classes, I/O is based on CLOS, etc.
Whether functionality should be contained in the "core" or in libraries is often a subject arousing contention, but I think it is, or can be, largely a technical distinction.
Where it matters is how well the functionality is integrated with the core language. The argument goes that in Scheme it is less regularly the case that libraries are complete and consistent vs. CL.
The effort of the R7RS-large work group to create a "standard" library of extended functionality is ongoing, but in a year or two should produce a language standard that could create consistency across Scheme implementations, effectively similar to CL.
Of course, how well that works out depends on the willingness of implementors of Scheme to make it so. Let's hope that they will do that.
The big difference between Scheme and CL is probably that the former encourages recursion, hygienic macros and is a Lisp-1. Moving from CL to Scheme is very annoying for this very reason. The lack of portability and a SLIME-like IDE doesn't help either.
The defining features of Scheme, differentiating it from predecessors, were probably "proper tail recursion" and "first class continuations". Recursion was not only encouraged but also the principle method of looping.
Although Scheme has a handy "do" procedure for iteration (somewhat like "for" in C), it's quite possible it's not used as much as it could be.
Most Schemes also offer "unhygienic" or low-level macros, though there's a learning curve for it.
I agree Scheme IDE support is marginal, but editor support is fine. Haven't really missed SLIME or other IDE. Compiling Scheme to native code is for me a different workflow anyway.
I learned Lisp/Scheme many years ago and am learning OCaml now (and loving it). I guess you could be uncharitable and say that Scheme is OCaml without types, etc. That seems inaccurate though; I will have to think about that :)
But one important thing is that Lisp is its own meta language. With OCaml there are changing and competing meta languages as far as I understand (camlp4, MetaOCaml). The simplicity of the language and meta-language being the same leads to a totally different style of programming.
Am I missing something about Common Lisp?