Python is DOOMED! Again!

[Steven D'Aprano]

Paul Rubin wrote:

> Steven D'Aprano <steve+comp.lang.python at pearwood.info> writes:
>> Since the "language wars" of the 1990s, dynamic languages have won.
> 
> Are you kidding?  Nothing has won, the wars are still going on, and
> dynamic and static typing both have their winning use cases and will be
> around forever.

No, I stand by my statement, on the basis that Bob Martin said it and he's
smarter than me and he actually was a participant so he knows what he's
talking about *wink*

In one sense, "language wars" still go on. Conflict never really ends, it
just shifts from place to place, and there will always be "brush wars",
like Pascal versus PL/P, Pascal versus C, C versus Java, Perl versus
Python, Python versus Ruby, etc.

But the 1990s idea was that there ought to be One Language To Rule Them All,
that there should be a single language which is the optimal language for
every programming task. The 90s brought that to a head, with Smalltalk,
Java, C, and Lisp all contenders.

Today the nature of the wars has tended to change. Naturally there are still
clueless n00bs who insist that there must be One True Language for
everything but the wars today are more about the full technology stack
(e.g. C#/.NET/IIS/Windows versus Java/J2EE/Apache/Solaris) rather than
specifically about the language.

So in the sense that people still argue about languages, you are correct
that "language wars" continue, but Martin's specific claim was that dynamic
languages *as a group* won the war in the sense that all popular static
languages now include dynamic features, while dynamic languages don't
include static features:

Popular dynamic languages include:
- Python
- PHP
- Javascript

None of them can really be characterised as having "static" features in any
meaningful sense. (The introduction of type-hints to Python won't change
that, any more than documenting the types in a docstring has changed it.)

Popular static languages include:
- Java has reflection and runtime generics
- C# has the "dynamic" keyword which is based on .Net's reflection
- C++ has dynamic dispatch and virtual functions


Go is an interesting (counter-?) example: it is a static language almost
entirely lacking in dynamic features. From the Go FAQs:

"The only way to have dynamically dispatched methods is through an
interface. Methods on a struct or any other concrete type are always
resolved statically."

http://golang.org/doc/faq#How_do_I_get_dynamic_dispatch_of_methods

(Go may have other dynamic features, but I am unaware of them.) But Go is
lacking many other features (exceptions, generics, variant types, even
basic numeric coercions. Go is either going to revolutionise programming or
it will end up just another niche language. I suspect the latter.

The point is, despite maverick languages like Go, mainstream static
languages have developed dynamic features, while dynamic languages have not
reduced their dynamicism to become more static. Instead, dynamic languages
are developing Just In Time compilers to use *runtime* type information for
efficiency (e.g. Mercury, PHP, Python, Javascript all do this).




-- 
Steven