-----Original Message----- From: boost-bounces@lists.boost.org [mailto:boost-bounces@lists.boost.org]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 implement 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>) is yours. Kindly, Scott