Re: ADA Popularity Discussion Request

[kevin.cline@gmail.com (Kevin Cline)]

"Randy Brukardt" <randy@rrsoftware.com> wrote in message news:<2L-dnRmP6qOePaLcRVn-ug@megapath.net>...
> "jayessay" <nospam@foo.com> wrote in message
> news:m3wtz7e4hd.fsf@rigel.goldenthreadtech.com...
> > kevin.cline@gmail.com (Kevin Cline) writes:
>  ...
> > > I thought so too, until I tried incremental test-first development.
> > > Retesting a unit after adding a few lines of code means that type
> > > mismatches are caught immediately with or without strong typing.  But
> > > it goes faster if you don't have to compile and link every iteration.
> >
> > Exactly.  Actually this sort of development will save you much more
> > time and money than you could ever hope for from typical static typing.
> 
> This seems like complete nonsense to me. (I'll admit that I've read other
> people making similar claims). The reason is that writing a good subprogram
> test takes on average 10 times as much code as is in the subprogram itself.

> That's because of the need to set up the needed global state for the
> preconditions, and the need to test all of the possible permutations of
> input. Making the test reusable and automatible adds even more effort.

A 10:1 ratio of test code to production code seems extremely high. 
Keeping subprograms small will reduce the number of permutations of
input that must be tested.  It's much easier to test five ten-line
subprograms taking one input each than to test one fifty-line
subprogram taking five inputs.

It's also much easier to maintain the five ten-line subprograms, and
easier to demonstrate code correctness.

Another benefit of unit-level testing is that in the absence of any
other documentation, the tests at least demonstrate correct use of the
unit.

> The best way to save time and money is to avoid the need to do that testing
> in the first place. We do that with Ada's strong compile-time and run-time
> checking, combined with occassional invariant assertions. And then we do
> extensive, repeatable system-level testing to find any logic errors. 

I do not like having only system-level testing because it makes
changes either risky or expensive, and inhibits refactoring.  It
drives developers to stick with the first code that passes tests, and
inhibits extraction of duplicated code because of the cost of
retesting.