🚀 go-pugleaf

[ I've added comp.lang.misc and redirected followups there since this does
  not have anything specifically to do with the other news groups - bevan ]

In article <9523600.18871@mulga.cs.mu.OZ.AU> fjh@mundook.cs.mu.OZ.AU (Fergus Henderson) writes:
   If you want some numerical evidence, I have some.  For a while I
   carefully recorded the cause of every error that I encountered while
   writing a Mercury program.  Of a total of 155 errors (122 errors in
   the code and 33 errors in declarations), 146 were caught at compile
   time - only 9 bugs got past the compiler.  Of the errors detected by
   the compiler, 83 were type errors (73 in the code and 10 in type
   declarations).  Without strong typing, the number of bugs that I had to
   track down myself by manual debugging would have increased from 9 to
   82, i.e.  almost 10-fold.

Did you happen to note down the total compilation time?  I'm
interested in how long was spent in compiling vs. the time (you
estimate) to detect those errors in a latently typed language.

If the compilers/interpreters for the two languages are equally quick
then the statically typed language/implementation would appear to be
superior.  However, if the compiler/interpreter for the statically
typed language is significantly slower, then the situation is less
clear. 

To give a specific example I noticed that I could fix errors in a
Scheme program by incremental testing using an interpreter quicker
than the compilation time for an equivalent program written in Haskell
using hbc&ghc (this was three years ago, so it does not necessarily
reflect on the performance on the latest versions of hbc&ghc).