On May 29, 2008, at 3:37 AM, David A. Black wrote:

> Duck typing, as a way of thinking, meshes nicely with Ruby, as a tool,
> because of how Ruby objects are engineered: the *only* thing that you
> can measure with certainty is what an object does when you send it a
> message.

No, you cannot possibly measure with certainty what an object does  
when you send it a message. The only thing you can measure is whether  
it will throw a runtime error because it doesn't implement a method  
for the message.

> You can ask it what its class is, what its ancestors are,
> what methods it responds to, and so forth... but in the end, you hit
> the singularity: the sending of the message.

However, an object's class and ancestors _determine_ what messages an  
object responds to. That's what they're there for - to hold message  
maps.

> it stands
> to reason that a language with objects whose types can change during
> runtime would be well-served by a programming style that deals as
> directly and economically as possible with precisely that condition.

Hmmm. Is it that objects change their type, or is it that variables do?

///ark