I'm a big fan of Haskell and I have a desire to move my career in that direction, but nevertheless I find Frank Atanassow's belittling comments that "dynamic languages have no advantages" tiresome. Mathematically his argument is no doubt true in the sense that if you can only accept a perfectly correct program, something like Haskell will always be better than something like Perl.
However he is willfully ignoring the fact that perfect correctness is not a requirement for most programs. He might be unable to sleep at night without knowing that every case has been accounted for, but in the real world you can often create tremendous value hacking together a vague idea of what you need. Piping some text files through an ad-hoc perl script can be incredibly useful even if the script has horrible horrible bugs due to unconsidered cases.
Atanassow seems to be arguing that the fact that the perl script has bugs that would have easily discovered in a statically typed program nullifies the benefit of rushing a script out the door that produces the correct output for the output at hand even if the incorrect cases would never be run in practice. This mentality is a luxury afforded to PL researchers and other people who are paid purely to think, however it does more harm than good to bringing the powerful ideas in modern functional programming to the average programmer who, in my opinion, is in desperate need of them.
Frank Atanassow's contention is that statically-typed languages are more expressive, and therefore superior because they can perform both static and dynamic type checking (he actually only uses the word "type" for something that can be statically checked; he uses "tag" for something carrying dynamic type information). Dynamic languages cannot perform static validation, and so are less expressive, and therefore strictly inferior.
His reasoning is sound, but I have an intuition as to why his conclusion is a bit off: Dynamic languages may be less expressive, but it can be much simpler to write, and especially modify, code without having to worry about two different sets of type semantics. Take the situation where you have a variable whose type was originally static, but now, because of a new requirement, needs to potentially take on values of different types determined at runtime. With a dynamic language, this probably isn't a major issue -- just assign the new values to the variable, and change the code to handle the new values where necessary. With a statically-typed language, you may have to redesign the entire static type structure of your program to change what were static "types" into dynamic "tags" and create new static types to handle those tags, which can mean major surgery.
Sure, a well-designed type structure is important even with a dynamic language, but in real life there are so many cases when it just isn't worth the time to refactor your whole design just to add a new feature. More than that, big refactorings can introduce bugs, and who honestly has 100% test coverage?
In a large enough project with a large enough budget, redesigning to maintain a proper static type structure is always going to be the better choice when viewed over a long enough time frame. As another commenter put it, statically-typed language are only "asymptotically superior". My sense is that, for finite projects/budgets/timeframes, ditching strict static typing is often a useful simplification, even if just to make a program easier to understand for busy programmers with finite available attention.
Just a thought that occurred while reading the comments -- I may not really know what I'm talking about.
However he is willfully ignoring the fact that perfect correctness is not a requirement for most programs. He might be unable to sleep at night without knowing that every case has been accounted for, but in the real world you can often create tremendous value hacking together a vague idea of what you need. Piping some text files through an ad-hoc perl script can be incredibly useful even if the script has horrible horrible bugs due to unconsidered cases.
Atanassow seems to be arguing that the fact that the perl script has bugs that would have easily discovered in a statically typed program nullifies the benefit of rushing a script out the door that produces the correct output for the output at hand even if the incorrect cases would never be run in practice. This mentality is a luxury afforded to PL researchers and other people who are paid purely to think, however it does more harm than good to bringing the powerful ideas in modern functional programming to the average programmer who, in my opinion, is in desperate need of them.