In "Re[2]: multiple interfaces with same method names" on Apr 24, you write:

>      I'm not familiar with those languages... and not too familiar with the 
>      concept of mixins...

The term "mixins" (and the OO language "Flavors" from the '70s) came
from Steve's Ice Cream at MIT. There you could purchase one of just a
few flavors of ice cream. But you could have various goodies such as
nuts, m+m's, fudge, fruit, mixed into your base flavor. You couldn't
order a bowl of fudge or nuts, however.

The analogy in OOP is that a regular base class (the "first" parent in
MI) is something that is an object that can be instantiated in its own
right, similar to the base ice cream flavors. A mixin (the "second"
parent in MI) is a characteristic, not an object, and can add behavior
to multiple kinds of base objects.

For instance, you might have various base window types, and a mixin
called "Scrollable". Adding this to the base window types gives them a
scroll bar and associated behavior. In Java I might like to make a
mixin called "CanDragAndDrop". It defines an action() method that
watches the mouse location, draws a box around itself when the mouse
enters, and creates a mouseDrag() method that moves itself to the new
location. You could mix this in to new classes of components to make
them able to be dragged and dropped.

In intelligent simulation systems on which I've worked, there is a
concept of enemy and friendly ships and submarines. Enemy ships are
colored differently, monitored, etc. This can be done simply by mixing
in a "Enemy" mixin with associated methods defined on it.

Mixins are useful not only for things that correspond to "real life"
objects and characteristics, but also for internal data
structures. One library I have in Lisp has a bookkeeping mixin
type. All objects created in a system are given this as a parent,
which adds a unique Name field to the object, and automatically
records the instances of each class in a hash table so that you can
later retrieve a list of all instances of a given class.

Mixins are a very convenient use of MI, and have the added advantage
that there is almost never a conflict of method or instance variable
names, since you are inheriting from non-overlapping sets of
characteristics. They are used like interfaces except with real
inheritance. 

Cheers-
						- Marty
http://www.apl.jhu.edu/~hall