Are the critiques in "All the things I hate about Python" valid?
Steven D'Aprano
steve+comp.lang.python at pearwood.info
Tue Feb 20 23:13:57 EST 2018
On Tue, 20 Feb 2018 10:17:12 -0700, Ian Kelly wrote:
> On Tue, Feb 20, 2018 at 8:38 AM, Steven D'Aprano
> <steve+comp.lang.python at pearwood.info> wrote:
>> On Tue, 20 Feb 2018 15:23:44 +0100, Antoon Pardon wrote:
>>
>>>> Okay. Now create a constraint on a name in C++ such that it can only
>>>> accept integers representing A.D. years which, on the Gregorian
>>>> calendar, are leap years. (Using a dedicated integer-like type is
>>>> permitted.) It must accept all multiples of four, except those which
>>>> are multiples of one hundred, unless they're also multiples of four
>>>> hundred.
>>>>
>>>> That's what Steve asked for. Can you do it? Or is the C++ type system
>>>> not flexible enough for that?
>>>
>>> Steve had multiple contributions in this thread. I didn't react to the
>>> one where he asked for that.
>>
>> Yes you did: you refused to meet the challenge, stating (and I quote):
>>
>> "Why should this be done at compile time?"
>>
>> https://mail.python.org/pipermail/python-list/2018-February/730995.html
>
> I really don't understand what point you're driving at here, Steven.
To be perfectly frank, neither do I any more. I fear I've been suckered
into taking a position I didn't intend to, as often happens when I reply
to Antoon Pardon.
Obviously both statically and dynamically typed languages are Turing
Complete, so any constraint you can apply at run-time in one you can
apply at run-time in the other. How *easy* that is depends on the
language features, and particularly for older languages, statically typed
languages tend to be harder and less convenient to write in. There's
typically more boilerplate, and more time spent placating the type-
checker. Do I need to justify this or can we take it as a given?
So I didn't think I was taking a controversial position to say that
dynamic languages are good for writing constraints that are enforced at
run-time, *as opposed to trying to do so within the type-system* which
was the topic under discussion.
I have argued in the past that the hard distinction between static and
dynamic languages has been gradually worn away (if it ever existed at
all!) as statically-typed languages add dynamic features, and dynamically-
typed languages add static features. For example, Java supports run-time
method dispatch; Python added type annotations to standardise on syntax
for static type testing.
Antoon's example of Pascal range checking is another run-time feature (a
form of dynamic typing, in a fifty year old statically typed language no
less!), as are Eiffel pre- and post-condition assertions (although the
compiler can optimize them away if it can determine that they always
hold). I've linked to Steve Yegge a lot, e.g.:
https://
steve-yegge.blogspot.com.au/2008/05/dynamic-languages-strike-back.html
so I certainly know that there's a certain amount of convergence between
static and dynamic features and it was never my intention to suggest that
statically-typed code can't validate values at run-time. That would be a
ludicrous position to take.
If Antoon was arguing in good faith surely he must have realised I
couldn't have meant that. By all means call me out on factual
inaccuracies, but do so in good faith. Don't assume I mean something
ludicrous.
If you look back at my reply to Bart:
https://mail.python.org/pipermail/python-list/2018-February/730943.html
you will see that the context is a discussion comparing:
compile-time static analysis
versus
run-time dynamic checks
strategies. Hence my challenge to perform the same kind of check at
compile-time using an actual, existing type-system. (Not merely say a
sufficiently clever type-system can do it and handwave away the practical
difficulties.)
Of course we can perform arbitrarily complex run-time checks in a
language with static typing (it might not be as convenient or easy,
especially if you have to declare every single temporary variable, do a
lot of explicit casts, never re-use any variable, and use a lot of
verbose boilerplate, but it can be done).
> The
> original claim (by you) was that dynamic languages excel at "enforcing
> constraints at run-time which are hard to enforce at compile-time". The
> counter-argument, as I understand, it was that while the constraints may
> be hard to enforce at compile-time, they are just as easy to enforce at
> run-time in a static language as in a dynamic language, so that can't
> really be considered a *strength* per se of dynamic languages.
Fair enough -- I acknowledge there's something to what you say, even if I
wouldn't say it that way.
But in which case, if dynamically typed languages are no easier to use
than statically typed ones, and no faster, and no more secure, why do
people use them?
The conventional answer is that they are easier to use, hence more rapid
prototyping and application development. But if we say that static typed
languages are *just as easy to use* then the existence and popularity of
Python, Ruby, Javascript, Perl, Smalltalk, Lisp, Scheme etc become a
mystery. Why do we bother?
> You then
> followed this up by issuing a challenge to enforce this as a
> compile-type check in C++.
[Pedant: I never said C++, I said the choice of his language.]
Looking back, I see that I misinterpreted Antoon's response. He is not
disagreeing with me in the way I thought.
I feel that Antoon has a long history of what *seems to me* to be petty
point scoring, where he will make statements which seem carefully crafted
to appear to be more extreme than they really are, so as to encourage
misinterpretation and set off a response.
He and I have a long history where I will make a statement which is not
absolutely 100% pedantically correct, and Antoon will respond in a curt,
peremptory fashion using language which can be read as taking a more
extreme position than a more literal, careful reading will show.
And I keep falling for it :-(
To sketch a caricature of the process, *as I see it*:
Me: "... and as we all know, the world is spherical, not flat."
Antoon: "What are you talking about? The world isn't spherical."
Me: "Of course it is! If not, how do you explain the observation
that the hull of sailing ships disappear from sight before their
sails?"
Antoon: "I don't have to explain that. It has nothing to do with
my argument."
Me: "WTF???"
[and finally, twenty posts later...]
Me: "Wait a second... you didn't actually say the world was flat.
Are you talking about the world being an oblate spheroid?"
Antoon: "No."
Me: *penny drops* "Do you mean the world is within 0.001% of an
oblate spheroid?"
Antoon: "Of course. What did you think I meant?"
(If you search the archives, you'll find other examples of this, but what
you won't see are the many, many, many draft posts I've written in
response to Antoon which I've never sent because I decided there was
simply no point arguing.)
I'm a pedant myself, and I don't mind being corrected when I'm wrong if
the correction is justified by the facts. But I cannot help interpreting
Antoon's style of discourse as petty point-scoring, for the sake of
disagreement rather than for the sake of education. A nanometre short of
trolling.
If I have misinterpreted Antoon's intentions, I apologise, but I can only
be honest about the impression I am getting.
Antoon, if you're reading this, and if you are *not* trying to point-
score, then you ought to work on your communication skills.
--
Steve
More information about the Python-list
mailing list