Re: ADA Popularity Discussion Request

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

Lionel Draghi <Lionel.nospam.Draghi@Ada-France.org> wrote in message news:<4140b5cc$0$17701$626a14ce@news.free.fr>...
> Kevin Cline wrote:
> ...
> > I code test-first, and the amount of test code is relatively
> > independent of the language.
> OK, because in test-first you write typical use-cases
> narrowed to the tested component. Tested features are the same whatever
> is the language.
> 
> ...
> > The first version leaves me wondering if the comment is correct.
> > The second version leaves me wondering if it sometimes throws
> > Constraint_Error.  There's no way to verify that A always returns a
> > value from 1 to 10 or to verify that B never throws Constraint_Error
> > without inspecting the function body.
> I was not discussing about code correctness (althrough the typed version
> correctness is easier to proof with static analisys tools).
> 
> The big difference is that the typed version will raise the default 
> obvious as soon as possible, the other not. To reach the same behaviour 
> without typing, you need to do more work.
> 
> > I'm also wondering what happens when you write Random_Index +
> > Random_Index ?
> > Or Random_Index * Random_Index ?
> Yet another advantage of typing: you wonder about problems that also 
> exist without typing
> I was not aware of this advantage :-)
> 
> >>On the other hand, in the A version, I need to check the return value on 
> >>each call.
>  
> > That's silly.
> In my simple example, yes. It's much simpler to put some assertion in 
> the code.
> But once more, there is more code to write without typing.
> 
>  > You have to trust functions to satisfy their
> > postconditions.
> I trust the code generated by the compiler to check an assertion or a 
> range, I trust a formal tool that certifies to me that returned value 
> will always be in range, but I don't trust a comment.
> 
> > Even in Ada relatively few post-conditions can be
> > handled by type checks.
> But whatever is the proportion, why would you renonce to this advantage?
> Typing has no cost, no drawback, only advantages. So, why should we 
> discuss on what typing can't do?

Explicit static typing ala Ada and C++ definitely has a cost, because
it makes the code longer, and also makes it more brittle.  Often I
don't really care what type a variable has as long as it is the same
type as the value it takes.  But with explicit typing a simple type
change can ripple through the application forcing the change of many
other functions.  Simply changing the return type of a commonly used
function from single precision to double precision may require every
call of that function to be changed.  That takes time that could be
better spent on higher level pursuits.

Besides the additional time to write all those declarations and keep
them synchronized with the bodies and keep all the callers
synchronized, there is the time lost waiting for compilation and
linking, and worse the loss in concentration when developers go off
surfing the web waiting for the compile to finish.

> Anyway, I enter in this thread because of the claim that typing has much 
> less value than test-first.
> I still wait for any illustration of this claim.
> 
> (and I feel that I will wait for a long time)

I don't think you will wait all that long.  Test-first development is
no longer a radical idea.  Increasing numbers of serious software
development shops, like SABRE, are getting good results from
test-first development.