Re: Is strong typing worth the cost?

[Colin_Paul_Gloster@ACM.org (Colin Paul Gloster)]

In article news:3CCEB246.9090009@worldnet.att.net , Jim Rogers wrote:
"dmjones wrote:
  
 > Marc,
 > 
 > 
 > Why?  Can you prove to me that the benefits will be greater
 > than the costs?
 > 
 > Why am I asking for this evidence?  I am working on a detailed
 > analysis of C that includes material on coding guidelines.
 > I have set myself the target of basis these guidelines on
 > empirical evidence.  I am a fan of strong typing.  However,
 > unless I can find any evidence to the contrary, the most I
 > can say at the moment is "some people think ...".
 > 
  
  
  What costs are you seeing?
  
  Seriously, any software that reports itself as safe and
  correct must perform a significant amount of what the old
  COBOL programmers call data editing. It must verify that the
  data is correct in all phases of the program. Weakly typed
  languages such as C do not avoid this problem. C simply
  delegates all such responsibility to the application
  programmer."

And of course, these programmers do not bother to put in more than a
flimsy counterpart to the rigorous sentinel a strongly typed compiler
would produce.

" Ada, on the other hand, allows the application
  programmer to supply important information, such as the minimum
  and maximum values for a scalar type, and then lets the
  compiler generate the range checking.
  
  Range checking always requires someone to do the coding.
  Ada has put that burden on the compiler developer. C puts it
  on the application developer. For the application developer this
  makes coding in C more expensive than coding in Ada.
  
  C complicates the problem by its extensive use of implicit
  numeric convrsions. The C compiler is not allowed to object if
  you assign an int to a double. In all cases, such assignments
  are dangerous. C insists the danger does not exist because a
  double can always represent all values representable in an int.
  The problem is that you can be assigning an AppleCount to a
  WeightOfScrapIron."

Of course, even with fellow integer counts that would not be
sensible. E.g. AppleCount and NumberOfPeoplePushingTheAppleCart. Even a
C++ programmer could produce code (using fully fledged objects) to do
the idiomatic (to Ada users) practise of divorcing integer metrics from
each other if they are in separate domains, but normally a C++ lover would
see this as overkill. Indeed, it has been lamely argued that there would
be an upsurge of identifiers to remember: was that variable of type
AppleCount or ApplesCount?, oooohh, so much hassle to check its
declaration and even which of those types exists. Did somebody say renames
anyway?

 "Strong typing can flag the danger of such
  assignments, forcing you as the programmer to review your
  program. Weak typing gives you no help. You are left with the
  need to carefully test all possible value combinations for your
  code, an impossible task for any non-trivial program."