From: scott (scottw_at_[hidden])
Date: 2004-02-25 15:09:03
> -----Original Message-----
> From: boost-bounces_at_[hidden]
> [mailto:boost-bounces_at_[hidden]]On Behalf Of Matthew Vogt
I felt more of your points needed further acknowledgement;
> This is certainly achievable, but is it using the active
> object design? You
> can implement an exactly equivalent design using the platform
> AIO primitives,
> but this would yield code which was much harder to follow and
> than active objects communicating through function calls. If
> you want
> optimum throughput throughout the interracting components, I
> don't think
> active object is the pattern you're looking for.
I agree with (most of) what you say. As mentioned recently however,
I started this thread before I knew of active objects. My goal is
and has been the same from the beginning.
Introduction of the ActiveObject pattern into this thread has been
something of a mixed blessing. Its thoroughly considered piece of
work and well presented. But (IMHO) it is also a perfect reflection
of The ACE Orb (and CORBA); it persists with the "method call" model
of execution. Schmidt wrote ActiveObject and Schmidt wrote TAO.
Of course OMG wrote CORBA so maybe this model of execution truly
started back with them? But that is all another line of research.
You are right; I am outside the scope of the ActiveObject pattern.
Another phrasing of that might be; the ActiveObject pattern runs
out of steam in a crucial aspect of the work being considered (?).
You lost me a little with the option of "using the platfrom AIO
primitives". I can imagine something vaguely similar is possible
but the interaction of the objects in my head is not bound to IO.
A majority of interactions are simply "go ahead" signals from one
object to another - where is the IO in that?
In some senses, I can concede the "harder to follow" comment. Some
of the truth in that is due to the shift in execution model, i.e. did
you find it easy adding the "++" to your "C"? My functional
programming is non-existent; I 'm still wallowing in the wake of
Alexandrescu! OTOH, I have recently converted several sub-systems
in a large, distributed, client/server product to "the other side". Code
complexity has plummeted. I cant give you formal metrics but an informal
one might be "average maximum depth of nesting" in functions/members -
halved. Or better.
Is shorter, less tortured code "harder to follow"? :-)
You are right; the ActiveObject pattern is not the pattern I am
looking for. It is very close however, including some entities
that I had thought were original (ha!). That same closeness has
created some confusion.
The subject on recent messages has actually been yours. This
being the case I feel that the fate of this thread (and active<object>)
Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk