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

[Pascal Costanza]

An excellent post with some very good points.

Anton Vredegoor wrote:

> Its good to see this thread getting back on its track! However I think
> there's another angle on Lisps popularity (besides the social and
> political issues) that's more fundamental. In order to follow my
> argument it's probably necessary to first read this (long) article of
> Daniel Dennett:
> 
> http://www2.psych.cornell.edu/andrews/fws01/dennett_frame.html 
> 
> It's not a waste of time to read it anyway :-)
> 
> What I get from this article is (among other things) that in order to
> fight complexity it is necessary to decide on what's important and
> what's not.
[...]

> Different programming languages offer different way's of encapsulating
> complexity for the user in order to enable her to concentrate on the
> important aspects of the problem. There's a tradeoff here between
> fixed elements in the language which must operate on all kind of
> structures but introduce ambiguity, and flexibility of the language
> which avoids possible ambiguity but at the cost of not reducing
> complexity.
> 
> Of course in the end ambiguity has to be resolved to produce output
> and for this Python uses scopes and Lisp has the parenthesis for that.

I think your statement about encapsulation of complexity can be 
rephrased as in "make the simple things simple and the complex things 
complex". (This is a quote, but I don't remember where I have got it 
from...)

So, for example, in Python the simple things (like the control and data 
structures that you use 90% of the time) are directly supported, in a 
straightforward way. On the other hand, there remains stuff that is hard 
to solve in Python. Pythonists don't care because it's not what the 
language was designed for. (Right?)

The Lisp designers have made different choices. You could say that in 
Lisp, the simple and the complex things are more or less on the same 
level of accessibility. This means that once you have managed to 
understand Lisp you will feel equally comfortable with both solving 
simple and complex problems, at least on the syntax and language level. 
(That's what I recently meant with my statement that Lisp is a language 
for experts - i.e., it is for people who want to solve complex problems.)

I hope this conveys my mental model that a language that decides to make 
simple things simple is forced at the same time to make complex things 
more complex than strictly necessary. So that is exactly the benefit of 
learning Lisp - you get to know a language that allows you to solve 
complex problems in a way that is less complex than in any other language.

There is another issue involved here. The IT industry (and also the 
academic world) focuses a lot on trends and fashions. Now suppose that 
the situation we are currently in changes dramatically some time in the 
future, so that the things that are currently important will become 
unimportant and vice versa. It's a good bet that Lisp will allow you to 
catch up more quickly than other languages. This is exactly what already 
happened in the case of object-oriented programming: Lisp was the first 
language to be able to provide object-oriented concepts in the 70's 
without actually changing the core of Lisp. All other approaches were 
based on creating new object-oriented languages from scratch, and 
therefore took longer to establish themselves.

Now back to the question of popularity: Of course, Lisp's expressive 
power, including its mindset that simple and complex things are more or 
less on par, is among the reasons for its lack of popularity. When 
people get the feeling that a simple thing is unnecessarily complex in a 
piece of technology they tend to dismiss that technology. It's because 
they lack an understanding of the unncecessary complexity of the complex 
things.

Please remember that I don't want to suggest that Lisp is strictly 
superior to any other language. There are certainly situations where 
less powerful languages make more sense, exactly because they offer more 
direct and straightforward support for their intended domain. However, I 
have also made the experience what it means to solve a very complex 
problem in a simple language (JMangler, a program transformation 
framework that transforms Java classes at load time, written in pure 
Java). That problem would have been a breeze to be solve in Common Lisp 
- it's exactly that experience that caused me to take a look at Lisp. I 
don't think that I would have started to appreciate Lisp otherwise.

(So yes, I can relate to people who don't like Lisp for various 
superficial reasons. My suggestion would be to think of a very hard 
problem that you would like to solve, and try to do it in Lisp. Don't 
start with the simple problems - Lisp doesn't have too many advantages 
for simple problems.)


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)