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

[Ian Bicking]

At one time during school I had gotten into Smalltalk, and felt the same
way about it as many do about Lisp -- it was a great language and why
didn't people use it more?  I think many of Smalltalk's flaws are
similar to Lisp's flaws (and I still like both languages, but actively
use neither).

In both cases the syntax is novel.  Smalltalk's syntax is actually quite
aesthetically pleasing (in comparison to Lisp and most other languages,
even Python), but regardless it doesn't look anything like standard
Algol-style syntaxes.  Speed is more of an issue with Smalltalk, but
it's certainly no worse than Python.

But I don't think syntax is the biggest problem with either of these
languages.  Neither Lisp nor Smalltalk allows a person to move gradually
between environments.  My first experience with Python was using it to
create small scripts.  They were learning devices to be sure, but they
were also useful.  My similar experiments with Smalltalk were not useful
-- and the only way I could truly be useful in Smalltalk without writing
large and complete applications would be to use a Smalltalk
environment.  I even considered actually doing this -- living in a
Smalltalk world, with a Smalltalk browser and email client, storing my
documents in Smalltalk objects, the whole deal.  But that would be hard,
and I never actually made that leap.  People have made that same leap
with Lisp -- the Lisp Machines of yore.

But that's not going to be mainstream.  In a heterogeneous environment
both Lisp and Smalltalk have serious issues.  Their style isn't friendly
to outsiders, and even worse their environment usually isn't friendly. 
Python might not have as many libraries as Perl, but it has a heck of a
lot -- and best, a lot of libraries that connect to C libraries of
significant functionality.  

That's not fair, though -- neither language is fundamentally
isolationist.  So maybe the real blame lies with timing.  Python came
around when free software/open source was becoming a truly functional. 
Python gets a lot from that, and it also happens to get a lot from
having a single implementation.  Together, when something is implemented
by one (sharing) person, it is shared among all Python programmers --
not programmers of a specific implementation, nor among everyone who
finds it useful enough to pay for.  This community could not have come
to exist fifteen or twenty years ago, when those other languages were
still fresh.  

There's other important practical issues.  It's easy to share Python
programs and modules.  It's easy to manage the modules you get from
others.  It's easy to install Python, and while it doesn't start up
instantly, it starts up pretty quick (quicker than Common Lisp or
Smalltalk to be sure).  People can script in Python, they can't in big
languages.  Scripting is a great way to pull people in, and unlike other
languages (*coughperlcough*) they won't be burned when they try
something of significant size.  These are all details, but they are very
important details.

  Ian