Re: Quality systems (Was: Using Ada for device drivers? (Was: the Ada mandate, and why it collapsed and died))

[Vinzent Hoefler <ada.rocks@jlfencey.com>]

Robert A Duff wrote:

>Vinzent Hoefler <ada.rocks@jlfencey.com> writes:
>
>> Hyman Rosen wrote:
>> 
[modular arithmetic]
>But it is not implementation defined in C.  C requires unsigned
>arithmetic to wrap around.  Ada requires modular arithmetic to wrap
>around (but allows an out for ones' complement machines).
>
>Signed arithmetic is unpredictable in C (in overflow cases).

Yes, of course. I was referring to signed types only here. Sorry, if
that didn't come out clear enough.

And H.2.2 of the current C99-Standard says:

|An implementation that defines signed integer types as also being
|modulo need not detect integer overflow, in which case, only integer
|divide-by-zero need be detected.

Additionaly, J.3.5 definitely confirms that this is an implementation
defined feature in C.

>> >Doesn't Dewar rant on this subject occasionally?
>
>Yes, he does.  I agree with him -- non-binary modulii are an unnecessary
>frill, and should have been left out of Ada.

Well, although myself I've never used them thus far, I'm sure there is
something useful you can do with them. And if it's just to make the
compiler writers crazy about that they have to support it... ;)

>  Consider the weird
>semantics of "not" for non-binary modulii.

Well, you get what you've asked for. :-)

>> >> I doubt that. C just got modular types because it was convinient and
>> >> natively supported by the machine.
>> >
>> >That doesn't mean that Ada didn't copy the notion from C.
>> 
>> I still doubt that. And unless someone from the language designers can
>> definitely confirm that, I will keep doing so.
>
>OK, I was on Ada 9X design team.  The fact that other languages support
>modular arithmetic was certainly one factor in the decision.

Yes, of course. I didn't want to say that the Ada design team invented
the wheel in that particular case. I just doubt that especially C was
the main reason to have such type.

>By the way, modular types is one of my least favorite features of Ada.
>It's an odd mixture of high level and low level.  For high-level
>purposes, I'd rather have multi-word arithmetic, and do the "mod"s
>explicitly when desired, and I don't want bit-wise "and" and the like.
>For low-level purposes, I want bit-wise "and", but I don't want
>non-binary modulii.

Well, let's get an example out of my praxis. I got a kind of random
lookup table with 15 entries (yes, I know, this is silly, especially
because speed should have been a main concern when this was written
first) and I just want to go through that array in circles. So using a
modular type in that case would be what? Low level? High level?

Currently this thing is written in assembly language, but if I'd ever
reengineer that in Ada I'd definitely use a (non-binary) modular type
for the index then (and an array with 16 entries instead). Of course,
as you pointed out, I could do the modulo arithmetic by hand, but why
if I can let the compiler handle it?

>The design team actually went back and forth several times between two
>solutions: a kludgy "magic" package that supports unsigned types of
>certain sizes, pretty much like C,

Well, I guess Interfaces.C comes quite close...

>and a first-class type with syntax
>and relatively general semantics (including non-binary modulii).
>I think perhaps the magic package was the better solution.

Well, I am no compiler writer, but I wouldn't consider that a use for
another package [well, I *hate* using Interfaces.C, too ;-)]. After
all, it's still some kind of Integer. YMMV.


Vinzent.

-- 
Parents strongly cautioned  --  this  posting  is  intended for mature
audiences  over  18.  It  may  contain some material that many parents
would not find suitable for children and may include intense violence,
sexual situations, coarse language and suggestive dialogue.