[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: the forward method [dynamic vs. static typing]
On Nov 20, 2003, at 6:29 PM, Ken Shan wrote:
>> Yes, my example isn't what I was going for. Let's use a simpler
>> Let's say we have a system like Smalltalk where the base Object
>> supports a method like:
>> - forward:methodName args:arguments
>> And the way this works is that when an object is sent a message it
>> doesn't respond to, it invokes this method with the appropriate
>> Now, you'll see we have a situation where *all* objects can except
>> *all* messages. And it can only be known at runtime if they want to
>> deal with them or not.
>> How does static typing deal with this? It seems all the types in the
>> system would have to be declared to respond to all methods, in which
>> case, they tell us nothing and there is no such thing as a compile
>> type error.
> Indeed, in a system like Smalltalk, there is no such thing as a compile
> time type error.
1. forwarding is a very flexible and powerful mechanism
2. you agree that a type system is useless with forwarding
Given that there is little reason to make a fully ST language that has
forwarding (as it breaks the assumptions of ST) our choices are:
1. DT language that can support a flexible and powerful feature such as
2. ST language that cannot
So we find ourselves with an example of a form of power and flexibility
that only DT systems offer and therefore another reason to choose DT
language. (which was my original point)
Btw, there are many languages other than Smalltalk (and that are
radically different than Smalltalk) that support forwarding and more
generally, inheritance through delegation. Examples include
Prototype-based and Actor-based languages. Paradigms that I think
could, respectively, be of significant benefit to programmer
productivity and performance/scalability.