Bob Arning wrote:
> 
> Granted that these may not be obvious to the new user, but they are not far off the beaten path. Do you see a way that
> - they could be useful to you?
> - they could be made more accessible?
> 
> Cheers,
> Bob

Well, YES. Paff. What you wrote was all new to me. Also Marcus Denker's
"view on the world" opened my eyes. You both revealed some key-items to
me that I haven't seen all that time. I really really think that this
solves LOTS of problems that I have encountered over the time. Thanks
and thanks again, both.

Luckily my ignorance has also been the occasion for thoughts on
"overviewing Squeak". I guess that what Marcus calls relationship, the
OO bookstore calls "aggregation". Objects are being aggregated by having
other objects as their instance variables, e.g. a window has an related
rectangle etc. (right?). Morphs have submorhps to solve this.

I think this (new-to-me) Explorer utility is a good starting point for
creating a system overview. Although the current implementation seems a
little heavy-duty on first view (much numbers, not much words), it is
actually a good tool for an "end user". It shows relations in a quite
good manner (submorphs and instance variables). When this interface is
combined with that of Whisker (good for finding class methods IMHO), you
could get an interface that tells of each object _individually_  its
current methods and variables.

This point of view on objects reminds me of the Self discussion we had
lately. Self ignores the idea of classes, and this Object Inspector (the
Explorer-Whisker combination) does that, too. IMHO, this is more
"object-oriented" because now you can inspect all of an object by
inspecting the object itself, not its class, nor its parents.

This object inspector could live in peace next to the classic class
browser. This would provide a class-based approach and an object-based
approach. As said in the Self discussion, classes can be helpful for a
system overview. They are an easy and overviewable way of defining the
system and expanding it. So the class browser is still a good thing. But
once you have created an object, you want to treat it individually,
without having to fall back on its class or parents anymore (although it
must still remain clear to the user that the object is actually an
instance of some class). That is where the Object Inspector should come
in.

This Object Inspector should show any selected object _complete_,
without bothering the technical constructs of inheritance and classes.
But including all its methods and aggregations (instance variables),
also those that it had inherited off course. This should also
(particularly?) be useable for overviews of Morphs.

The current tiling system does try to show a Morph. My problem with it
is that it doesn't show a Morph _complete_, like in a class browser
combined with an object explorer. But it could possibly be extended to
suit this. The other possibility would be to extend the object explorer
to also display the object's methods.

Hope this is useful to some of you.

Greets,

Stefan

(one P.S.: how come the "explore" method can show an object's instance
variables? I thought they were private to the object?)