Paul Prescod recently published an article entitled Why I Promote Python. He deals the obvious telling blows against C, C++, and Perl. For myself, though, I prefer Java, Haskell, or (of course) Nickle
to Python for writing most programs these days…
The main reason I prefer these languages is that they are safer than Python. Most importantly, they check the basic
sanity of things typed at them statically rather than
waiting until runtime (i.e., too late) to expose defects.
The most important static check is strong type checking, but the checks are pretty sophisticated these days, and also
catch things like uninitialized variables. With Haskell's type inference, one needn't even give explicit types to get static type safety.
In particular, module interfaces need to be statically typed. Narrow module interfaces are what make large programs possible; static typing provides the most basic kind of enforced contract for modules. One of the difficulties with Object Oriented Programming is that it tends to be difficult to get the module interfaces right—they are much easier to design in the functional/imperative world, where interfaces can be described just by function signatures.
Other features of these languages are also safer. For example, Haskell has a
well-defined formal semantics; I can formally verify
a Haskell program. The English specifications of the other
languages make this difficult at best.
Haskell and Java are mature, stable languages. There's little question what they will look like in 6 months. Even Nickle hasn't changed a lot in the last few years. Python, like Perl, is still continuously evolving. Evolving languages are bad for writing large, safe programs.
Consider Common Lisp as an alternative to Python. In what way does Common Lisp meet Prescod's stated criterion for language goodness less well than Python does? Prescod states that
My primary criteria [sic] for decency—whether in programming languages, markup languages, or graphical systems—is scalability. By scalability, I mean two things: the ability to scale from easy to difficult problems and the ability for beginners and experts to be comfortable.
Perhaps Java is tough for beginners (although I find it no tougher than Python). Otherwise, I think Java, Haskell, and Nickle meet this primary criterion quite well, and so does Common Lisp. Prescod rejects Lisp as "dismissed by programmers". I'm not sure why that's a criterion: surely there's no point in just picking the most popular language to advocate for.
Let me be clear that I think Python is pretty neat. I've seen some good solutions put together with it, and even helped to do so myself. I just think that if you have to pick a silver bullet, there are better choices. Even if C, C++, Perl, and TCL aren't four of them.