Re: Writing an Operating System in Ada

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Mon, 18 Jan 2010 16:21:53 +0100, Georg Bauhaus wrote:

> Dmitry A. Kazakov schrieb:
>> On Mon, 18 Jan 2010 12:23:23 +0100, Georg Bauhaus wrote:
>> 
>>> (3) adding subs to T to accomodate specified processing needs
>>>     of another, later program? How?
>> 
>> By conversion of the object to another type:
>> 
>>    X : Integer;
>>    Y : Float := Float (X); -- Now we have sin, cos etc
> 
> This conversion of a (then) persistent Integer object
> to a Float object is possible because either type is known
> (and can be named).

You cannot have object of an unknown type.

> The meaning of conversion from Integer
> to Float is language defined, too.

Type-defined. Conversion of concrete types is a doubly-dispatching
primitive operation. Ada 83 didn't have dispatching operations and MD is
still 

> What a persistent O-O storage would have to offer is something
> in addition.
> 
> In Toulouse:
> 
>   X : Private_Type_A;
> begin
>   OO_Store.Put(X);
> end;

Put (OO_Store, "Some name", X);

I prefer this notation, because this operation also is doubly-dispatching.
 
> Then, where Identity is an identifier, or the object, or
> a handle, or a filename, or ...:
> 
> Pass(Identity(X), From => Toulouse, To => Hamburg);

Rather:

Put (OO_Store, Locate ("Hamburg") & "Some name", X);

you do not need to pass anything. Store it where it belongs to. The main
idea is that imperative I/O is normally not needed. "Pass" is disguised
I/O.

> In Hamburg:
> 
>   Y : Private_Type_B;
> begin
>   OO_Store.Get(Y [, <from the identity>]);
> 
> How is Hamburg enabled to learn what Toulouse.Private_Type_A
> is with the persistence layer functioning as the only source of
> information about the object?

In this case from some information outside:

   Y : Interested_In'Class := Get (OO_Store, "Some name");

> Which operations does it support?

Of the class. When you create Y in your program you know what you are going
to do with it. That is described by Interested_In. This is no different
from knowing its name "Some name". This is a-priori knowledge. For example,
a compiler expects an Ada source file.

> What kind of conversions are possible, what granularity of
> access to the object's innards might be needed to reify
> the interface of Hamburg.Private_Type_B?

There is a common ancestor for both types. What you probably had in mind
was a conversion is between types from independent hierarchies rooted on
different hosts. That normally should not be needed.

To me the problem rather is in passing the concrete type of Y, which the
program will never have to learn, but the run-time must. It will modify the
dispatching tables, take the implementations of overridden operations in
the form of some byte code (?) etc.

>> IMO the real challenge (apart from consistent
>> implementations of MI and MD) are dynamic types marshaled between the parts
>> of a distributed system. I didn't think much about that, so don't expect me
>> to answer how that should be solved. Probably others might have some
>> insights...
> 
> I guess this challenge is what some here had hoped to learn
> about. You sounded like you knew the solution :-)

I am sorry, then. There are hundreds of well paid people sitting in
universities studying and teaching OS'es and distributed systems. Why are
you asking me? Ask Andy Tannenbaum! (:-))

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de