Re: Any research putting c above ada?

["James S. Rogers" <JimMaureenRogers@worldnet.att.net>]

Matthew Givens wrote:
> 
> Roy Grimm <ragrimm@cca.rockwell.com> wrote:
> >
> <<<<< SNIP >>>>>
> >
> >There is a subtle difference you are missing here.  In Ada, any type
> >_difference_ will cause a compile time error.  In C, the type
> >_incompatibilities_ are the only things to be caught.  What is the
> point
> >of defining different types if you can freely assign between them?
> >Different types are used for different purposes.  Removing that
> checking
> >eliminates the structure that makes Ada so much easier to debug.
> >
> 
> Hmmmmm, the other side of that coin is that an integer is an integer,
> whether it's called an integer or "timer" or whatever other name the
> programmer selected for the new type.  If both types can contain the same
> data, then why shouldn't you be able to mix these types?  It's a matter
> of preferences.  Some prefer a rigid, well-enforced environment, and
> others prefer a looser one.

Even in C it is not a good thing to assume an integer is an integer.
A pointer value is an integer.  No experienced C programmer would 
multiply a vote count with a pointer value, assigning the result to
the pointer.  Speaking of pointers as integers, what about that special
pointer value 0?  Why are there no negative pointer values?  After all,
an integer is an integer.

Why is there a difference in the C specification between characters and
longs?  Certainly they are both forms of integers in C.  They must,
by your logic, be completely inter-convertable.

Why does C++ not allow the implicit conversion between enum types and
int which is allowed in C?  The reason is that such a conversion will
easily and quickly lead to undefined results for the enum type.  Such
undefined results cannot be easily caught by a C compiler.  Even lint
is of little use in detecting this error.

Of course there are different types which use any integer-like
representation.  That does not make the types even approximately 
compatible.  Incompatible types should not be masked by using one
single integer representation for all of them.  

Strong typing as found in Ada can be difficult to deal with.  It can
be difficult because it forces the designer to understand the 
behavior and limitations of the design in great detail.  Weak typing
allows the designer to ignore many behavior and limitation details.
When design ignores behavior and limitation details the door is opened
for catastrophic failure.  It is usually very difficult to detect these
problems in formal testing, leaving major defects in the delivered
product code.  Such defects are more and more frequently exposing
software developers to serious legal actions including criminal charges
and civil suits.

Jim Rogers
Colorado Springs, Colorado
--------------------------
Team Ada