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

[Marin David Condic <nobody@noplace.com>]

Now you're getting all theoretical on me and all I was doing was trying 
to solve a practical problem. :-) Look at it this way: What does an 
Integer do when you add one too many to it? It trips an exception that 
halts normal flow of operation. Sometimes this is the desired behavior. 
What happens when you add one too many to a Modular number? It wraps 
around and continues normal program flow. Sometimes that is the right 
accommodation. What I propose is a Saturated type that when you add one 
too many to it, it ceases to increment beyond its upper bound and normal 
program flow continues.

We're not talking about something that has to have some sort of 
mathematical, logical consistency to it. We're talking about a fault 
accommodation. Sure, whatever calculations you subsequently use the 
number in are going to be "wrong". But isn't that the case with a 
modular type that exceeded its upper bound and wrapped around? You say 
"Yes, but Modular types are useful when properly applied...." The same 
would be true for a Saturated type - properly apply it and any overflows 
that saturate will give you the desired behavior even if the answer is 
"inaccurate".

MDC


AG wrote:
> 
> 
> But that means that something somewhere
> must have an actual counter which keeps
> the actual value of what you pretend is
> a saturated integer. After all, you, as
> the user of the saturated type, don't
> (or shouldn't) know if one saturated
> number is equal to another - they are
> all equal in a sense. But whatever
> implements them obviously must. So,
> what about this (assuming X is already
> saturated and Y is the largest unsaturated
> number):
> 
> if Y = X - 1 then
> 
> Should that tell me I've got the smallest
> saturated number? Can I then count them?
> (I've got the smallest number and I have
> "+", "-", "<", ">" etc) - looks like an ordinary
> integer now. Almost.
> 
> Can I do something like
> 
> for I in X..Y  ? What would that do if
> there are several saturated values in that
> range?
> 
> It looks like what you describe is just
> a simple matter of having a much wider
> actual range but providing some sort
> of a checked conversion/mapping
> which just does the range checking
> on the number and overrides it with
> a limit if needed..
> 
> It's not hard to implement either
> as a custom code or some utility
> library. However, pushing it onto
> the compiler seems to open all
> kinds of semantic cans of worms.
> 
> Unless I misunderstood your
> point of course.
> 
> 


-- 
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jast.mil/

Send Replies To: m c o n d i c @ a c m . o r g

     "In general the art of government consists in taking as
     much money as possible from one class of citizens to give
     to the other."

         --  Voltaire
======================================================================