Re: next "big" language?? (disagree)

[ncohen@watson.ibm.com (Norman H. Cohen)]

In article <4pjl57$cn0@btmpjg.god.bel.alcatel.be>, ian@rsd.bel.alcatel.be
(Ian Ward) writes:

|> Which then brings me to Mathew B. Kennel's retort
|>
|> > And by doing so turns what would otherwise be superficial syntactic or
|> > linguistic errors into programs with run-time bugs.
|>
|> If he is talking about Ada here, then I think his argument is flawed
|> because it, in my opinion, assumes that the rate of errors per SLOC
|> a programmer makes is independent of language.
|>
|> I don't think that for every syntax error a programmer spots in
|> his code as a result of a compiler listing, another semantic error
|> is created instead, (or is even present.)
|>
|> It is more likely that a given programmer generally has N syntax
|> errors/1000SLOC and M semantic errors/1000SLOC (where M and N
|> vary on the ability of the programmer, his interest in his work,
|> and the difficulty of it.)
|>
|> In this situation, a good compiler, will point out his N syntax errors,
|> which he will correct. In the process of correcting these, it is
|> also likely that he will spot a few of the semantic errors.
|> This would then leave < M semantic errors for the programmer to
|> track down at run-time.
|>
|> All the language would then need is some kind of run time checking
|> to help him out.

The distinction between "syntax" errors "semantic" errors is misleading.
What is relevant here is the distinction between errors caught at compile
time and those caught at run time (or, worse, not caught at all).  For
example, a missing semicolon is a syntax error and a type mismatch is a
semantic error, but both are caught by an Ada compiler at compile time.

The point that Matthew was making was that Ada's strong compile-time
checks allow certain errors that might not be detected until run time, or
might not be detected until a program is in the hands of customers, to be
detected during compilation instead.  The greater number of compile-time
error messages means that more work is required to get a program to
compile, but once it compiles it is likely to have fewer run-time errors.
Thus it will take less work to get the compiled program to pass its tests
and the end product will be more reliable.

--
Norman H. Cohen    ncohen@watson.ibm.com