Johan Fabry johan.fabry@vub.ac.be wrote:
ProtoObject "minimal amount of messages" Debuggable(Proto)Object "messages used by debugger (instVarAt: ..) but nothing else" Object
I dont think I get the point here... What would be the behaviour of the debugger for ProtoObject subclasses? Forward everything? So when you need to debug the proxy, you would need to change its class?
The point is that if a proxy really needs to be without #instVarAt: then it can inherit ProtoObject and will be difficult to debug. But in many cases, proxies can inherit DebuggableProtoObject instead which implement, by definition, the messages sent by the debugger but nothing else, and that should work.
I think there is a distinction to be made: - some proxies like ObjectOut becomes their real objects. They inherit ProtoObject directly and will turn into their real object when debugged. (Probably before that). - others like a decorator will remain a distinct object and never become what they proxy. These would be very difficult to debug unless they handled the debugger messages themselves so should inherit DebuggableProtoObject.
So it seems to me, but I'm rather new to these kinds of questions.
/Mats
On Mon, 28 Aug 2000 19:14:48, Mats Nygren nygren@sics.se wrote:
I think there is a distinction to be made:
- some proxies like ObjectOut becomes their real objects. They inherit ProtoObject directly and will turn into their real object when debugged. (Probably before that).
- others like a decorator will remain a distinct object and never become what they proxy. These would be very difficult to debug unless they handled the debugger messages themselves so should inherit DebuggableProtoObject.
My feeling is that proxies should be as transparent as much as they can be. If you're debugging proxies, and it shouldn't happen very often, you can afford to do a little nastiness.
You don't want to have to go through hoops to debug your application, which is hopefully where most of the bugs are.
Later, Jon
-------------------------------------------------------------- Jon Hylands Jon@huv.com http://www.huv.com/jon
Project: Micro Seeker (Micro Autonomous Underwater Vehicle) http://www.huv.com
Jon Hylands wrote:
I think there is a distinction to be made:
- some proxies like ObjectOut becomes their real objects. They inherit ProtoObject directly and will turn into their real object when debugged. (Probably before that).
- others like a decorator will remain a distinct object and never become what they proxy. These would be very difficult to debug unless they handled the debugger messages themselves so should inherit DebuggableProtoObject.
My feeling is that proxies should be as transparent as much as they can be. If you're debugging proxies, and it shouldn't happen very often, you can afford to do a little nastiness.
You don't want to have to go through hoops to debug your application, which is hopefully where most of the bugs are.
I think I agree with Jon here. I doubt that I would subclass DebuggableProtoObject for use in Remote Message Passing, as my proxies do need to be completely transparent.
Hmmm ... remote debugging through RMP ... sounds yummy.
-- "You are more than the sum Johan Fabry - Johan.Fabry@vub.ac.be of what you consume. Vrije Universiteit Brussel Desire is not an occupation." Programming Technology Lab, Room 10F709 -- KMFDM Pleinlaan 2, 1050 Brussels, Belgium
squeak-dev@lists.squeakfoundation.org