Re: C is 'better' than Ada because...

[brennanw@pond.com (William C Brennan)]

In article <321AE6D8.41C67EA6@mailgw.sanders.lockheed.com>, Mike Roske
<mroske@mailgw.sanders.lockheed.com> wrote:

> Adam Beneschan wrote:
> > Having the same information in two or more places in the program has
> > long been recognized as a major source of errors introduced during
> > maintenance.
> 
> Exactly.  And this same problem occurs in both C _AND_ Ada language
> programs.  Ada gives you a nice way to avoid it, but engineers who
> write structured software will use preprocessor definitions in C to
> define _in ONE PLACE_ size (and other) information about data structures.
> 
> Ergo, as both languages provide a mechanism to solve the single
> definition problem, neither is "better" in this category.

Well, both C and Ada do supply a mechanism to support a centralized, 
single-point name definition for the upper-bound or size of an array 
(or of an enumeration type, etc).  But this does not mean that C's and Ada's
mechanisms are equally "good".

The C mechanism requires the programmer to define new names for the
upper-bound and size.  For one thing, this just unnecessarily pollutes the
name space.  It also puts the extra onus on the programmer to maintain
the connection between an array type name and its upper-bound name.
Standards may be employed by the staff to make this a simple mapping
(e.g., "NameArray" and "NameArrayMax"), but I've never seen standards like
this actively enforced in a project.  

One reason it isn't even this simple has to do with C's 
null-terminated strings. where you may need up to three constants:
size of the array, upper-bound of the array, maximum number of
non-null characters in the array.  This sometimes means making up 
3 names and keeping their uses all straight.

The Ada mechanism embeds the naming convention into the language,
so that its use is consistent throughout (e.g., "NameArray" and
"NameArray'Last").
The compiler actually understands the meaning of "NameArray'Last", it's not
some relationship the programmer needs to maintain as in C.

The Ada mechanism enforces consistency, and keeps the size of the 
name-space down.  This is cleaner and to my mind "better".

-- 
Bill Brennan
brennanw@pond.com