Re: Logic Errors and Ada (Was: A big hairy thread on Ada, Quality, and Drivers)

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

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0305181502.53703035@posting.google.com...
> That sounds to me an unrealistic level of discipline: subtyping
> to the extent that all lattitudes and longitudes (and things
> along that line) are separate types.  More common usage is that both

This is the common level of discipline in Ada programming. The reason
it has become common is that the benefits provided by these distinct
types far exceed the effort required to create them.

> will be just real numbers (floats), whatever the language chosen.  So
> academically this is an advantage, in practice it won't be there.
> (Similarly, as other messages point out, in practice, any usage of
> subranges you will see in Ada is just what you have in C++,
> int8, int16, int32.  Though in a classroom setting it may sound like
> a great advantage to be able to have my own subranges of integers
> from 1 to 9102 each and every time I need it...)

Ada user defined numeric types are more than simply the different
sized ints and floating point types in C and C++. C and C++ give you
no easy way to define a type that truly fits the problem. For instance,
if you are monitoring voltages that must always be between -5.0 and
+5.0 volts, you can define the following type:

type Voltages is digits 15 range -5.0..5.0;

This defines a floating point type with a 15 decimal digits of
precision and a valid range of values from -5.0 through 5.0.
Any attempt to evaluate a value outside that range will result in
a Constraint_Error exception being raised.

Note that the C and C++ numeric types like int8, int16, uint32,
provide much less help in matching your needs in this case.
Similarly, float and double do not help in ensuring that the data
is correctly within range. Neither to they ensure 15 decimal digits of
precision.

>
> But in any case, you sure can create Lattitude and Longitude classes
> in C++ as well if you are so disciplined, so the advantage you are
> pointing out is not very clear.

Yes, C++ does allow you to create such classes. Upon creating those
classes you also need to define all the appropriate numeric operators
for the class, as well as the logic for restricting the valid values to a
domaine-valid range. This takes a LOT more discipline and time
than achieving the same thing in Ada. The Voltages type defined above
gets all the floating point operators defined for it automatically by the
compiler. It also gets all the range checking defined automatically by the
compiler.

The Ada solution does take a bit more discipline than simply using the
predefined float or long_float types. The difference in the source code
is minimal. The real discipline comes in designing data types to satisfy
the requirements of your problem domaine. It takes some work and some
thought. This is the same level of work and thought that is needed in any
language to produce a reliable, safe, efficient design.

Ada also makes safe I/O for user defined numeric types safe and easy.
The standard generic package Ada.Text_IO.Float_IO may be instantiated
for any floating point type.

  package Voltage_IO is new Ada.Text_IO.Float_IO(Voltages);

The I/O routines in that instantiation will validate data entry over the
allowed range of values for type Voltages. Any attempt to enter an
out-of-range value will result in the Constraint_Error exception being
raised. All you need to do is write the appropriate exception handlers
for your application.

Not only is this kind of discipline common in most Ada programming
teams, many teams set up coding guidelines prohibiting the use of the
pre-defined data types.

For junior Ada programmers this approach causes problems. They find
the compiler keeps complaining about improper mixing of types. Even
the junior Ada programmers find, however, that once the program
compiles it has far fewer logic errors caused by inappropriate mixing
of variables in a calculation. This saves much more time in debugging
than was consumed in compilation. Senior Ada programmers seldom
encounter such a difficulty during compilation. They are used to the
discipline needed to avoid most compilation diagnostic messages.

Jim Rogers