jm wrote:
-snip-
> * The strong/weak static/dynamic manifest/implicit argument seems to
> take diametrically opposing points of view. Is it possible that there's
> a third side to this argument?

Several third sides:
- strong/weak are just emotionally loaded stand-ins for good/bad (in
contrast to the technical term 'type safe')
- static/dynamic isn't a nice dichotomy ('static' languages may also do
dynamic type checks)
- manifest/latent explicit/implicit, skilled users of type inferenced
languages often explicitly declare types ('typeful' programmers think
in terms of types and like to see type info).


> * I like the point made in the article that algorithmic correctness is
> not guaranteed by typing (weak or strong).

Death and Taxes are guaranteed, everything else...


> * For some reason I keep typing string when I mean strong. :^).
>
> * I suppose what I was thinking with the language_profile email was
> signaling to interpreter/compiler what optimisations and checks it
> can/should run at a particular level in the code rather than or
> necessarily on the entire body of code.
>
> good quote from article, Guido van Rossum says,
>
>    You can also easily write a small piece of code in Python and see
> that it works. You can
>    do very fine-grained unit testing. Bottom-up program development
> works really well. You
>    can easily start with only a vague idea of what you want, start to
> implement it, and see
>    how well it works so far. You can then change many things around. If
> you have a strongly
>    typed language, changing things around becomes much more painful.
>
> this equally applies to ruby.

No doubt Haskell programmers would say it's easy to do bottom-up
program development, and changing things around in their strong typed
language is easy.