Joe Marshall wrote: > > They *do* have a related meaning. Consider this code fragment: > (car "a string") > [...] > Both `static typing' and `dynamic typing' (in the colloquial sense) are > strategies to detect this sort of error.
The thing is though, that putting it that way makes it seems as if the two approaches are doing the same exact thing, but just at different times: runtime vs. compile time. But they're not the same thing. Passing the static check at compile time is universally quantifying the absence of the class of error; passing the dynamic check at runtime is existentially quantifying the absence of the error. A further difference is the fact that in the dynamically typed language, the error is found during the evaluation of the expression; in a statically typed language, errors are found without attempting to evaluate the expression. I find everything about the differences between static and dynamic to be frustratingly complex and subtle. (To be clear, I do know that Joe understands these issues quite well.) So I kind of agree with Chris, insofar as I think the terminology plays a role in obscuring rather than illuminating the differences. On the other hand I agree with Joe in that: > I mean that this has been argued time and time again in comp.lang.lisp > and probably the other groups as well. You may not like the fact that > we say that Lisp is dynamically typed, but *we* are not confused by > this usage. In fact, we become rather confused when you say `a > correctly typed program cannot go wrong at runtime' because we've seen > plenty of runtime errors from code that is `correctly typed'. Yes; as I said ealier, the horse has left the barn on this one. The conversation I would *really* like to have is the one where we discuss what all the differences are, functionally, between the two, and what the implications of those differences are, without trying to address which approach is "right" or "better", because those are dependent on the problem domain anyway, and because I can make up my own mind just fine about which one I prefer. The comp.lang.functional and comp.lang.lisp people are probably two of the smartest groups on usenet. (I do not consider myself a member of either group.) You wouldn't *think* that conversation would be *so* hard to have. Marshall -- http://mail.python.org/mailman/listinfo/python-list