Recs.
Updated
An established industry workhorse language, Common Lisp is an ANSI standard Lisp, which boasts a high amount of features, power and flexibility. Code written in Common Lisp will work in many of the different Common Lisp implementations available, often without any change needed. Portability, thus , is very high. Some implementations also allow Lisp code to run almost as fast as C or Fortran, if one has such need.
Common Lisp is a true multi-paradigm language, allowing for functional, imperative, procedural, object-oriented, and even logic-programming; what's more, the features provided for each of these paradigms are often superb. Particularly in the case of object-oriented programming, the oop system ("CLOS") might be the most powerful and flexible OOP system in any programming language.
Common Lisp was born as the convergence ("Common") of several Lisp dialects that were already in use for various production systems in the late 70s and early 80s, so the whole language was created by incorporating features which were already proven to be good, and as a consequence it incorporates features essential for building complex systems. One of such features is the "condition-restart" system which is a very powerful system for handling and recovering from exceptions, far beyond what a language such as Java could offer, in comparison. This is one of the unique characteristics of CL.
Another good feature for writing complex or large codebases is the comprehensive namespacing system. You can define all sorts of namespaces for your modules, and, additionally, function names, symbols, class names, and variables, all reside in their own namespace, so they don't clash at all.
Specs
Pros
Pro Powerful macro system
Allows directly abstracting common code patterns to a degree almost impossible in non-lisp languages, which greatly improves readability and reduces code duplication with almost no runtime overhead.
Pro Interactive programming
On top of the REPL, a command line style interface to the language which lets you interactively call into any aspect of your program, Common Lisp is built from the ground up to support redefining any aspect of your program at runtime. This greatly reduces development time, as modifications to individual functions and classes can be loaded in while the program is running to test their effects.
Pro Homoiconic syntax
The code itself is a data structure in the language. It's lists of lists. Some more recent languages have syntax macros like Lisp, but you have to program them in an abstract syntax tree (AST) metalanguage. Lisp is practically its own AST, which makes it easy to manipulate Lisp code objects in Lisp--metaprogramming.
Pro Powerful debugging capabilities
Common Lisp has a large selection of interactive debugging tools built into the language, including a GCC style debugger which activates on any otherwise uncaught errors, the ability to trace all calls and return values of any given function, and an inspection system which can give detailed reports about any object in the runtime.
Pro Image based runtime
The state of the program may be saved and reloaded as an image, supporting safer modification of the running program. New code may be compiled into the image as the program runs, while late binding ensures that symbol redefinitions take effect throughout the program.
Pro Powerful type system and data type support
Common Lisp is strongly typed; implementations like SBCL allow for (optional) static typing, and the type system is powerful, allowing for complex type definitions, as well as a good struct system and a superb class system (CLOS). Additionally, the support for various data types is exemplary -- allowing for rational numbers, arbitrary-length integers, arbitrary-length floats, complex numbers, bitwise manipulation, etc.
Cons
Con Different from other languages
Common Lisp (and lisp languages in general, but especially Common Lisp) is very different from other mainstream languages in ways that are difficult to adjust to, leading to a higher learning curve when transitioning from a C or Algol based language.
Con Very impure
Although the Lisp family is often described as functional languages, they do in practice rely a lot on mutation and side-effects/ Common Lisp in particular does not even try very much to stick to the functional paradigm, or any other ideal. Instead, it has a philosophy of allowing whatever approach seems most convenient, and encourages users to tack whatever is needed onto the language with macros. Combined with the lack of static types, this can lead to problems with interoperability and makes it hard to understand code you have not written yourself.
Con No obvious way to distribute software
ECL compile Common Lisp code to native binaries but it's just one implementation from others, and if your code includes implementation-specific pieces like SBCL's sb-
packages, you can't use ECL to compile it. SBCL itself can "dump executable", which will give you an executable several megabytes in size irrelevant of your own application size. And if your application relies on external asset files like images, icons, sounds, texts and so on, you're really screwed.
Recommendations
Comments
Flagged Pros + Cons
Pro Carefully designed for interactive use
Almost all aspects of the language are designed with interactive/repl use in mind.
Con A lot of implementations with different crucial feature sets
Although all modern implementations support Common Lisp according to standard, non-standard features can be extremely important and you will bind yourself to one particular implementation as a result. For example, SBCL has comparatively good support for streams, but ECL can compile to native binaries, and commercial AllegroCL and LispWorks have GUI toolkits built-in, while Armed Bear CL has native integration with Java. And if you want all this in one package, you're out of luck.