Re: Is strong typing worth the cost?

["Robert I. Eachus" <rieachus@attbi.com>]

Larry Hazel wrote:


> Wes - It may have been SAIC.  We converted a pilot training simulator from
> assembly language to Fortran 77.  The company funded an R&D project to convert
> the Fortran to Ada.  It was quite successful, and found some errors in the
> Fortran.  I didn't ever see a report on the results but I'm sure there was one.


At Honeywell SSD, we converted a (fielded as part of an OS) module from 
Fortran to Ada 83.  The module was mature, but had a number of closed 
bug reports against it.  The process of converting the module discovered 
several errors in the FORTRAN code.  The Ada code ran slower than the 
original code, but much faster than the corrected/debugged Fortran code.

Does that say that coding in Ada found lots of bugs that were not found 
by the original implementors?  (No, some were clearly introduced by 
other bug fixes.)  Does that say that an Ada implementation was less 
likely to have bugs than a Fortran implementation?  (No, there could 
have been other problems that would not have been noticed in a pure Ada 
implementation that were not a problem in Fortran or were discovered and 
fixed during the Fortran implementation.)  So what did the study really 
tell us?

That strong typing and subtypes were more than free in Ada, they 
resulted in tighter, faster machine code.  I think Intermetrics had a 
similar result they presented in a conference.  (SIGPLAN 84?)  The 
constraint checking optimizations resulted in about 2% smaller code than 
with constraint checking turned off.  There were enough similar results 
about the same time than it has become accepted wisdom in the Ada 
community.  Now apparently the question is being asked differently, can 
you show a development cost savings instead of a code efficiency benefit?

What I guess I, and a lot of other here feel is that there is no 
question there worth asking.  Comparing the cost of developing an 
incorrect version of a program to the cost of developing a correct 
version is meaningless.  And all Ada programmers know from personal 
experience that strong typing finds bugs in our code at compile time 
that would be much more difficult to find using the debugger.  In fact, 
there is a very good clue that has been intertwined with this 
discussion...  C programmers will compile their code with debugging 
options enabled, then run it first via the debugger.  Ada programmers 
tend to compile with debug options turned off, and personally I have 
never used the debugger that comes with GNAT.  (I did use the Verdix 
debugger a few times though.)

In my personal experience, I make very few coding errors that are not 
caught by the compiler, and many of these are output formatting errors. 
  When I do need to debug something, it is actually the algorithm that I 
am debugging/testing, and test cases plus occasional embedded print 
statements are IMHO the best tool for that.