Re: No call for Ada (was Re: Announcing new scripting/prototyping language)

[Jerry Coffin <jcoffin@taeus.com>]

In article <m3ptck662y.fsf@insalien.org>, ludovic.brenta@insalien.org 
says...

[ ... ]

> No, I was comparing languages not compilers.  

That may have been what you _intended_, but here's what you actually 
_said_:

	I just tried the above with gcc -Wall and got no warning.  
	This means that only a human carefully reviewing this program
	will see the mistake

I was addressing that statement, and proved it wrong.  Worse than simply 
being wrong, however, is the fallacious reasoning it represents.  You 
claim that a single example proves an entire class.  I honestly don't 
want to turn this into a personal attack, but it's difficult to take any 
of your opinions seriously when you apparently lack all grasp of logic 
or reasoning.

> As stated elsewhere, the
> C language does not require any compiler to catch the particular bug I
> used as an example.  If your compiler does, good for you, but the C
> language says you cannot assume it will.  What your compiler did was
> akin to "lint", which I referred to as using heuristics, not language
> rules.  Heuristics means that so many people were hurt by this bug
> before that it seemed like a good idea to try and catch it at compile
> (or "lint") time.

Rather the contrary: it gets caught because it's trivial to catch, and 
the market for C compilers is sufficiently competitive that nearly every 
vendor is constantly working at adding features, especially those that 
are easy to implement.
 
> The Ada language mandates that all Ada compilers must catch this bug.
> This gives much more confidence in Ada than in C.

It may give you "much more confidence in Ada", but if so, it's precisely 
the false sense of security I've pointed out a number times before. If 
you were being realistic, this would increase your confidence in Ada 
over C by approximately the number of real bugs it catches.

In my experience that would be well under one part per million -- 
probably closer to one part per billion.  I've a pretty fair amount of 
experience, and I've yet to see a real bug like this.  I don't think it 
hurts anything for the compiler to catch it, but the degree of 
confidence it should inspire is exceptionally minimal.

The sad part is that Ada is a good enough language that it deserves a 
much better defense than you're giving it.  Ada provides features that 
really can (and do) help prevent bugs that are much more common in C. 
Unfortunately, every indication you've given so far in this thread is 
that you lack sufficient insight into either language to recognize those 
areas and base your arguments on them.

On a slightly different subject, given that this is cross-posted to 
c.l.ada and c.l.c++, if you're going to advocate Ada as being superior, 
the comparison should clearly be to C++ rather than C.

-- 
    Later,
    Jerry.

The universe is a figment of its own imagination.