Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!uunet!mcsun!ukc!keele!nott-cs!ucl-cs!news
From: G.Joly@cs.ucl.ac.uk (Gordon Joly)
Newsgroups: comp.software-eng
Subject: Re: Tolerance (was Re: Reusability considered harmful??(!!))
Message-ID: <1427@ucl-cs.uucp>
Date: 7 Feb 91 16:16:46 GMT
Sender: news@cs.ucl.ac.uk
Lines: 75


dave@cs.arizona.edu (Dave P. Schaumann) writes 
 
> Ok, so I stand corrected.  There are a lot of applications out there that
> don't need exact answers.  But my question was in the context of code re-use.
> How could you say something like, "well, I really need a stack, but I'll
> settle for something sort of stacky"?  Will we see code like this in the
> future:
> 
>   assert( stackyness(re_used_type) > 0.9 ) ; /* stackyness(a real stack)=1.0 */
> 
> I can't see how the "tolerence paradigm" could possibly lead to a reasonable
> means of code re-use.
> 
> Dave Schaumann		|  And then -- what then?  Then, future...
> dave@cs.arizona.edu	|  		-Weather Report

Returning to the idea of the idea of a engine piston, a piston made in
one factory must fit into the engine block made in another. The
machining of the cylinder piston must be correct to within so many
thousandths of an inch.

The post and pre conditions associated with this stack, written in
SOLVE, suggest that you could have a tolerance associated with ``what
happens when you attempt to push an stack to overflow''. The "amount"
of action could be set in the Error Method called.

However, more generally it seems that the notion of a "metric" is
basic to setting a tolerance gap of any sort.

--*98--*98--*98--*98--*98--*98--*98--*98--*98--*98--*98--*98--*98--*98

Signature Stack

SuperTypes (Object)

InstanceOperations

  push : (<Integer>) -> <Stack>
     precondition
     [ size [ (self <- size) <- lt(self <- maxsize) ]]
     postcondition
     [ cont [ (self <- top) <- eq(result) ]]
     
  pop  : ()-><Integer>
  top  : ()-><Integer>
  isEmpty : ()-><Boolean>
  size    : ()-><Integer>
  maxsize : ()-><Integer>

TypeOperations
  new: (<Type>)-><Stack>

Equations

TemporalProtocol
nonEmpty [ tr 
           inwhich $a
           iff $a!send(pop) <= $a!send(push) ]

End

--*89--*89--*89--*89--*89--*89--*89--*89--*89--*89--*89--*89--*89--*89

Another example of fault tolerance; computerised telephone exchanges,
which can fail to route 1/100 calls, say, but must never crash
completely. The reason that one in a hundred is OK is that human
originated misdials (eg slippery fingers) can account for 1/10
failures.

Gordon Joly                                       +44 71 387 7050 ext 3716
Internet: G.Joly@cs.ucl.ac.uk          UUCP: ...!{uunet,ukc}!ucl-cs!G.Joly
Computer Science, University College London, Gower Street, LONDON WC1E 6BT

           Email: Les jeux sans frontiers du monde