On Wed, Dec 21, 2011 at 10:51 AM, Devin Jeanpierre email@example.com wrote:
Perhaps, instead, we should stop claiming things are "strong" or "weak". If I said that, relatively speaking, Python is weakly typed, people would get offended -- not because I made any technically incorrect statement (on the spectrum, Python is far closer to assembly than Agda), but because to call it "weak" is insulting.
When you can mutate a str object into an int object (or vice-versa), then you can claim Python is weakly typed without being technically incorrect.
Weak typing has a very specific meaning: objects can change their type without changing their identity (e.g. via pointer casting in C and C++). Python lets objects *lie* about their types to some degree (by altering __class__), but type(obj) will always reveal the true underling type (indeed, "obj.__class__ != type(obj)" is one of the ways to detect when you've been given a proxy object, if the distinction matters for a particular use case). (For CPython, extension module authors can actually use C code to get around the strong typing if they really try, but the authors of such code get no sympathy when it inevitably blows up in obscure and hard to debug ways. Old-style classes in 2.x can also be legitimately described as weakly typed, since *all* instances of such classes share a single underlying type, and __class__ is the true determinant of their behaviour)
Weak vs strong typing and dynamic vs static typing are well-defined concepts - it's just all too common that folks that initially learn to program with a static language confuse the two spectra and think that "static typing" and "strong typing" are the same thing. They're not only not the same, they're actually completely orthogonal. CPython, for example, uses the weak static typing of C to implement Python's strong dynamic typing mechanisms. IronPython and Jython have strong typing at both levels, but retain the static vs dynamic split. I believe PyPy uses strong dynamic typing throughout (although RPython has a type inference mechanism and a few other tricks to support translation to machine code)