🚀 go-pugleaf

From article <1991May13.061520.11992@daffy.cs.wisc.edu>, by quale@khan.cs.wisc.edu (Douglas E. Quale):
[...]
> This statement suggests that programs compiled in dynamic languages contain
> more type errors than similar programs written in statically typed languages.
> Unfortunately I don't know of any studies that have been made that could
> definitively affirm or deny this.  In fact, I don't know of any evidence at

You could try looking at:

"An experimental evaulation of data type conventions" by J.D. Gannon,
in Communications of the ACM 20 (8), august 1977, pp 584 - 595

which contains the results of a comparison between statically typed and
untyped languages.  Apparently the author had previously looked at the
question of static vs. dynamic typing (but, unfortunately, published it
in some obscure volume that we don't have here :-(. In the preamble to
the above mentioned paper he briefly summarises some of the results of
this prior comparison:

    "... This evidence indicated that the use of dynamically typed
    operands resulted in errors that remain in programs longer than
    the errors attributable to statically typed operands."

The above paper concludes, unsurprisingly, that static is better than
untyped.

I'm not too sure, however, whether his results are applicable to all
languages.  His experiments were performed with variations on algol-like
languages where the variations were in the type system.  I suspect that
some of his results may say just as much about his choice of the underlying
language as about the type systems imposed upon them.

I think that a distinction that it may be useful to draw here is between
declarative languages (e.g. prolog,ML,hope,miranda,smalltalk) which have
a highly modular structure, and non-declarative languages (such as pascal,
fortran,cobol,ada) which tend, imho, to give rise to rather long-winded
programs.  Gannon's results can be seen as a demonstration, then, that
static typing is definitely better for nd languages (which is his under-
lying model).

> Dynamic typing makes program components easier to test interactively in
> isolation; the components get tested again together.  You may say you do

I don't see this at all.  What has typing got to do with testing program
components.  It seems to me that far more important than the type system
is whether the language is declarative (i.e highly modular) or not.
Imagine a version of pascal with dynamic typing - is it easy to test
program components?  Contrast this with declarative languages with static
typing (e.g. ML,hope,miranda,..) - easy to test components? You bet.

> -- Doug Quale
> quale@khan.cs.wisc.edu

--
 "Merely corrobarative detail, intended to give artistic verisimilitude
 to an otherwise bald and unconvincing narrative"    -- W.S. Gilbert 

Name: Michael Chisnall		email: chisnall@cosc.canterbury.ac.nz