Hi Folks  --  this is an interesting discussion  :-)

Dwight Hughes [dwighth at ipa.net] wrote:

The real source of hard coupling in Squeak/Smalltalk is not in the
fundamental object/message concept, nor in the class/inheritance
structure, but in the specificity of message sending - *an* object sends
*a* message to *an* object which must return *a* result. THIS is where
the limitation is. This is what makes coordinated system-wide behaviors
so difficult - why large-scale emergent behaviors from tiny low-level
behaviors are so hard to create. Objects should swim in a flowing river
of messages, responding to those they understand, ignoring those they
don't, adding their own messages to the river as they wish. Some groups
of objects - organisms/organs - surround themselves with a membrane -
filter/interface - to only allow certain sorts of messages through:
those meaningful to the organism as a whole, not its individual
parts....

~~~~~~~~~~~~~~~~~~

It is interesting that you should bring this idea up, Dwight, as I recently
participated in several lengthy discussions about this same concept.  I
presented the idea of the "inert" object to some fellow developers.  As I
described it, the "inert" object is an object that doesn't have to know
anything about the other objects in its environment; it simply relates to
other objects, and they relate to it, symbiotically.

For example, consider the common baseball.  A baseball is an "inert" object
that doesn't know anything about any other objects, and yet it seems to
respond properly with everything else in its environment.  I may not know
what a baseball is, but if somebody throws a baseball at me, I will respond
to it by either intentionally avoiding it or I will simply get hit and I
will develop all kinds of unpleasant side affects.  :-)  Likewise, the
baseball doesn't know anything about me, but it relates to me in its own
fashion (maybe it gets scuffed or maybe it gets a shiny red coat).

I think it might interesting to consider an object oriented system that
models the "inert" object approach for all objects.  Objects MIGHT know
about other objects, but they WOULDN'T HAVE to know about the other objects
in their environment in order to be successful in their tasks (much like the
way we operate in the "real world"  :-).

Then again, maybe there are already systems that work like this.  My
experience, by necessity, has been limited to only a few languages.

---==> Chris