I also like Chicken, for purely aesthetic reasons. But, since that's a
scheme environment, forget that I mentioned it...

CMUCL, because it's solid [IME], has a good compiler, and its
interpreter's design means that it's good for "scripting", too:
it starts up *fast* [slightly faster than CLISP, actually, on
the machines I use], and its interpreter does lazy analysis of
DEFUN bodies [which is good if you have large scripts with a
bunch of DEFUNs only a few of which get called on any single
script invocation]. Its "green threads" are also well-integrated
with standard CL stream I/O, and give you automatic non-blocking
I/O when running multiple network connections at the same time
[e.g., when using it as a web application server].

It has some downsides, but none of them currently affect me:

- Only has "green threads" [user-mode coroutines], so threading
  only uses a single CPU, and that only on the x86 platforms
  (Linux & BSD, mainly). [But all the platforms I currently
  run it on are single-CPU, x86 Linux or BSD.]

- Doesn't (yet) run on Windows. [But I don't do Windows.]

- Rebuilding is a bit tricky. [But I tend to run the "-RELEASE"
  binaries without ever rebuilding.]

-Rob

Also, it's not a Common Lisp implementation, but PLT Scheme is pretty
freaking cool.

- gives me best performance
- reasonably safe and fast code by default
- statistical profiler that works on Linux
- reasonable debugging

I also use other implementations: clisp, Closure CL, ecl, gcl
and Poplog clisp.  clisp, ecl and gcl mostly for portability: AFAIK
there are platforms where one of them works and all other Lisp
implementations does not work (or at least inexperienced people
trying to build other implementations failed).  Closure CL
gives me reasonable fast code (slower than sbcl -- the main
reason is than sbcl profiler allows me to eliminate bottlenecks,
while Closure CL on Linux does not provide statistical profiler
so I do not know where are Closure CL specific bottlenecks)
and very good compilation speed.  Poplog clisp gives me low
footprint and very fast compilation, but for me main attraction
of Poplog is that beside Lisp it offers a few other languages.

In the past used cmucl, but now sbcl gives me similar features,
and is more portable and more stable.

  * Simple and easy to learn and use
  * Very well suited for metaprogramming:

     -  Macros are implemented as fexprs in old Lisps.
        Advantage: simpler, more expressive. Main argument
        against fexprs was that it is harder to write
        optimizing compilers. Newlisp is interpreter,
        so that disadvantage is not important.
     -  First class macros.
     -  Functions and macros are not the result of
        evaluation of the definitions, but definitions
        itself, can be analyzed and mutated during runtime.
     -  Dynamic scope.
     -  Unrestricted eval (access to local variables.)
     -  Doesn't lose speed or increases size significantly
        if code contains lot of evals or macros calls.

  * Still in development.
  * Friendly community.

Newlisp has other advantages and disadvantages, no doubt,
but this is the answer why I use it. Majority of people
seems to use it because it is good for "scripting."

 From the opensourced I do not have prefference, but I'm finding myself
attached more and more to OpenCL, but I'm also regurarly checking out
all others - ABCL, ECL, GCL, SBCL, CMUCL, etc.

I'm still learning Common Lisp (and various other Lisp) sanyway, so no
problemo here.

http://www.cs.bham.ac.uk/research/projects/poplog/freepoplog.html

Poplog was commercial in the past, but for several years it is
open-source with MIT-type licence.

Because it is practical. More or less the most widely used lisp today.

Considered as a tool, it has probably some 10 times more users than
either Common Lisp or Scheme Lisp.

For example, i consider emacs lisp, more powerful than Perl, as a text
processing language, for 2 major reasons: (1) It has buffer datatype
and associated datatypes such as point, marker, region, etc.. Which is
more powerful than treating text as inert chars and lines, which Perl,
Python, Ruby, etc do. (2) elisp's integrated nature with emacs. This
means, for odd text manipulation jobs that happens daily in every
software coding, i can write text processing programs that interact
with me while i edit.

The above paragraph, details why i love emacs lisp. However, it is not
so much about lisp language's nature. I find nothing in particular of
lisp lang's features of emacs lisp that made me love emacs lisp, other
than it being a functional language. It's more about how it happens
that emacs has a embedded lang and that happens to be a lisp. It is
not difficult to have another language, or a new editor with a embeded
lang that functions similar to emacs, or a editor with a engine that
supports multiple langs. However, emacs just happens to be almost the
only one, or the most prominent one. (i am a expert in Microsoft Word
in early 1990s, and although i haven't ventured into its Visual Basic,
but i know it can do scripting. I'm sure, now after almost 20 years,
and with Microsoft's “.NET”, it possibly might compete with emacs with
its elisp, but i know nothing about it to comment further. (i'd very
much welcome any comment from someone who are a expert of scripting
Microsoft Word with Visual Basic; on how it compares to emacs, if at
all. (if you don't have say 1 year of full-time experience in this,
please spare me your motherfucking drivel)))

As to the reason i am not a fan of the 2 other major lisps: Common
Lisp and Scheme Lisp. These 2, are little used in the industry. Common
Lisp is a moribund dinosaur. Scheme Lisp is little used and is
confined to Academia. There is nothing in these 2 langs that i
consider elegant or powerful today. I would, in a blink of a eye,
consider Mathematica, OCaml, Haskell, erlang, far more elegant or
powerful.

I would like to see Common Lisp and or Scheme Lisp die a miserable,
horrid, deaths, due to fanaticism as exhibited by Common Lisp and
Scheme Lisp regulars in newsgroups. I consider these 2 langs not only
impractical and inelegant, but their people are the hog of any
possible progress of lisp in general.

See also:

• Language, Purity, Cult, and Deception
  http://xahlee.org/UnixResource_dir/writ/lang_purity_cult_deception.html

I do consider lisp, or the lisp way, a lang with lisp characteristics,
can be the most beautiful, elegant language. (in fact, i consider
Mathematica being one such example) However, given the social milieu
of the 3 major lisp communities: Common Lisp, Scheme Lisp, Emacs Lisp,
it might happen when pigs fly.

--------------

Of the existing lisps, especially new ones, i support NewLisp, and i
also support Clojure. Personally, i'm not likely to invest time in
them in the next 5 years, if ever. Second to these, i mildly support
Qi.

I was a avid fan of functional programing, and was a big fan of lisp
too. Lisp, even just 10 years ago, was still a great language, almost
the only one that are much better than all others, in both practical
industry use and also academic theoretical considerations. But due to
the rapid development of software technologies and vast number of lang
today that happened in the past decade, including a profusion of
quality functional langs, i see little point in lisp.

See also:

• Proliferation of Computing Languages
  http://xahlee.org/UnixResource_dir/writ/new_langs.html

  Xah
∑ http://xahlee.org/

The essay is now clearned up a bit and archived at:

http://xahlee.org/UnixResource_dir/writ/whats_your_fav_lisp.html

  Xah
∑ http://xahlee.org/

(Only in some cases, when I want to use packages that run only on
 sbcl, do I run sbcl. And I'd think that once threading is completed
 in clisp, these packages will support it as well, and I could stay
 with clisp even more often).