(The following is stolen from the CS 342 text.)
Consider the following session with the Little Smalltalk interpreter
----------------------
>	Object addSubClass: #C instanceVariableNames: ''
Object
>	C addSubClass: #D instanceVariableNames: ''
C
----------------------

At this point I added the following methods to class C:
----------------------
"Class C"
m1
        ^self m2

m2
        ^ #C
----------------------

and the following method to class D
------------------
"Class D"
m2
        ^ #D
------------------

Now we execute the following code:
------------------
>       x <- D new
D
>       x m1
#D
------------------

What happened?  I called the m1 method on x, which is an object of class D.
The method search starts in class D, but there is no m1 method there,
so it continues in class C, where it finds m1.  Now in that method
of class C it executes: ^ self m2 (return the value of sending m2 to self).
The method search for this begins in D again, where it finds m2, and executes
it, which returns the symbol D, which is returned from the entire call.
Try it yourself if you have trouble following this.  It's instructive to add
print statements.


Let's consider a larger example, and throw in super.
Suppose that the class C has the following instance methods
(separated here by blank lines).

------------------
"Class C"
m1
   ^ self m2

m2
   ^ 'C'

m3
   ^ 'm3'
------------------

Suppose that the class D is defined as a subclass of C,
with the following instance method definitions.

-----------------
"Class D"
m2
   ^ super m3

m3
   ^ 'E'
-----------------

Given the above class definitions,
what is the result (if any) of the following expression?
	(C new) m1
It's the string 'C'.  This should be easy by now, so I won't say why.

A harder one now, what is the result (if any)
of the following expression?
	(D new) m1
It's the string 'm3'.  If you got 'E' you don't see how super works.