Re: Is strong typing worth the cost?

[Richard Riehle <richard@adaworks.com>]

dmjones wrote:

> The real problem with the discussion so far is that it has
> only mentioned the benefits.  What about the costs?

When developing software with a significant dependability requirement
you may want to believe you cannot afford type safety.   However, in the
words of an insurance agent, when told by a prospect he cannot afford to
buy a particular kind of insurance, "Mr. Jones, you can't afford not to buy

this policy."     What level of insurance do you want to offset the risk
when
delivering a reliable system on-time and within budget?   Perhaps, when
assessing cost, we might say, "Mr. Jones, you can't afford not to use
type safety."

It is not clear what costs you mean.   It is also not clear
what you mean by "strong typing."    A type is characterized by:

               A type name
               A set of values
               A set of operations
               A set of rules relative to objects of other types

Nearly every language has types.   Therefore, nearly every
language has some level of type safety.  I think what you mean
by strong typing is the rigor of type safety.  Even COBOL has
a certain amount of type safety.  For example, one cannot
add a PICTURE XX to a PICTURE 99.

Is there a cost associated with type safety?  Is there a corresponding
cost associated with lack of type safety?    In Ada, type safety begins
earlier in the development process than in most languages.   For small,
programs, extensive reliance on type safety is probably overkill.   As
an application gets larger,  type safety tends to scale nicely with the
demands and complexity of that larger set of code.   The cost of resorting
to the debugger, examining lots of cross-reference listings, and prowling
through hexadecimal dumps can be expensive on large-scale software.

So the cost of type safety, if there is a cost,  on small, relatively easy
programs may not not offset the ease of invoking debugging tools. But
as that program grows, and as more programmers work on modules that
must interface with each other, the cost of type safety tends to be
cancelled out by the cost of debugging efforts.

Richard Riehle