Why is Python popular, while Lisp and Scheme aren't?

[Pascal Costanza]

A. Lloyd Flanagan wrote:

>>In summary, Lisp's problem is that it had no BDFL.
>>
> 
> Exactly.  In addition, Lisp proponents have historically been
> contemptous of attempts to run efficiently on available hardware,
> something which is somewhat important to anybody without a bunch of
> extra cash to buy more powerful hardware.  You can't completely ignore
> the desires of the market and expect to sell a whole lot of anything.

This situation has changed considerably. On the one hand, Common Lisp 
vendors have improved their implementations a lot with regard to 
efficiency. On the other hand, machines are powerful enough nowadays in 
order to give you some convenience in language constructs, like dynamic 
type checking. This argument shouldn't be too alien to Python fans.

> In addition, I think Common Lisp killed a lot of Lisp's momentum. 
> Much of Lisp's power comes from the application of just a few basic
> language elements; CL added an incredible amount of complexity in the
> process of including each and every favorite feature of all the major
> players in the Lisp market.  Check out Guy Steele's Common Lisp. 
> Python has the power but hasn't (yet at least) been drowned in
> complexity.

Common Lisp has a small core with a big library. Many people regard 
Common Lisp as a big language because there's no obvious disctinction 
between the language-defined and user-defined features. If you compare 
this with the situation for examle in the case of Java, there you have a 
clear distinction between the language and its API. However, the API in 
Java is actually much bigger than the built-in functionality in Common Lisp.

I think the blurred boundaries between the core language and the library 
in Common Lisp are a big advantage.

To summarize some claims, some people say that Common Lisp is too big 
while some say that it is lacking in APIs. However, you can't say both 
things at the same time, this would be contradictory. If you want to try 
a Lispy language with a considerable number of reasonably portable 
features/libraries you should go for Common Lisp. If you want to insist 
on a small core with a standard library of a manageable size you might 
probably want to take a look at Scheme. However, it should be clear that 
in the long run, a large library pays off. (Most Scheme implementations 
come with large libraries as well, but they are not standardized.)

(These are not the only considerations to take into account. For example 
in my opinion, Scheme focuses more on features that are of an academic 
interest whereas Common Lisp stresses features that are proven in 
action. Of course, YMMV.)

Pascal

-- 
Pascal Costanza               University of Bonn
mailto:costanza at web.de        Institute of Computer Science III
http://www.pascalcostanza.de  Römerstr. 164, D-53117 Bonn (Germany)