Re: High-Integrity OO and controlled types

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 5/3/11 6:28 PM, Dmitry A. Kazakov wrote:

>>> Actions as amorphous chunks of code tossed here and there depending on
>>> scope is a way different ["anisotropic"] approach. In particular it does
>>> not fit into safe modular software design, because of this "anisotropy".
>>
>> What will type-object/module code look like if it is equivalent
>> to its nested analog?  Better?
>
> Analogue of what? The point is that "finally" cannot replace initialization
> and finalization of objects, specific or class-wide.


Could there be a workable design that lifts these two
events (entry, exit) to proper, programmable, abstractions
and how would they be connected to all of the language,
not just the types section?

By analog I meant this: The way a nested object goes out of
scope may influence objects in some less nested scope.
Then, is it (a) possible, (b) feasible, (c) good ROI
to design types that are interconnected to reflect all
possible effects between types, in the types?  Wouldn't this
design mix aspects of operation that should be kept in a different,
yet connected formalisms that makes explicit use of scopes?

As a simple example, I had been considering a relatively global
array or set shared between two procedures or tasks;
each proc/task would be responsible for part of the
elements in the shared data structure.  When one fails,
the the "exit action" is to "reset" its share of slots/
elements.  This sounds like one could design types that
do(!) just this as part of their finalization.  But it does
seem like an awful lot of overhead, and is essentially
a type that is-a procedure.  My question then is whether
or not this overhead is worth it, at least at this fairly
low level of small algorithm writing, not system design.