Re: Subject/Object Confusion Syndrome [was: Ada Objects Help]

[Robb.Nebbe@di.epfl.ch (Robb Nebbe)]

I took comp.lang.c++ off the distribution list. (If they want to read
interesting posts they can just read comp.lang.ada :-)

In article <D3H7J3.B2x@inmet.camb.inmet.com>, stt@henning.camb.inmet.com (Tucker Taft) writes:
|> 
|> Here is another analogy.  In a normal "dispatching" call, the tag
|> of the controlling parameters determines how the "order" given by
|> the calling task is carried out, but there is no doubt that something
|> will happen.  In a call on a protected object, not only is the
|> interpretation of the call up to the protected object, but whether
|> or not the "order" is carried out at all is up to the protected object.

This doesn't seem quite right. A protected object has no say about which
calls will be executed. It can enforce that it be in a certain state for
a call to take place but this is really no more than a temporal
pre-condition. In contrast a task must explicity accept a call on an
entry and has complete control over such things as the order in which
calls are accepted. A task may also perform actions that are not requested
by someone else, a protected object may not.

I think this is a case where the syntax better represents the
implementation than the semantics. However, I do appreciate that
protected subprograms requiring multiple synchronizations are probably
not "primitve" and is a good enough justification of why the current
syntax was adopted.

|> 
|> Kind of like telling a direct underling to do something, versus
|> "asking" a peer to do something ;-).  "Sorry I'm busy now" is a legitimate
|> answer in the latter case...
|> 

With the cooperative synchronization that exists between tasks this
seems right. I see the competetive synchronization involved with
protected objects as arbitrating the possesion of the object. Thus
multiple peers are competing for the right to tell the protected
object what to do. In John's terminology a protected object can never
be a subject.

Robb Nebbe