[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: the forward method [dynamic vs. static typing]

On 2003-11-25T22:26:47-0800, Steve Dekorte wrote:
> 1. forwarding is a very flexible and powerful mechanism

Perhaps, but you haven't argued that, much less proven it.  Indeed, you
have not even defined what you mean by forwarding except by referring
to Smalltalk, so there is no way to compare a language with forwarding
against "the equivalent language without forwarding".

> 2. you agree that a type system is useless with forwarding

No, I don't.  I only said that there is no such thing as a compile-time
type error in a system like Smalltalk.

> 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 
> forwarding
> 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)

Given how little you have defined forwarding so far, the only language
that we know offers it is Smalltalk.  The only way for us to know
whether a language supports forwarding is by checking for it in a list
that you might provide.  Such a list would exclude many dynamically
as well as statically typed languages (is Scheme on it? Io? System
F-omega?).  So we find ourselves with something, whose meaning you have
not defined and whose power and flexibility you have not argued, that
only one system is known to offer and therefore at most possibly another
reason to choose Smalltalk.  That was not your 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.

Once again, you have not specified what forwarding and inheritance
through delegation mean; in other words, you have not defined, given
an arbitrary programming language, whether it supports forwarding and
inheritance through delegation (or for that matter, whether it supports
objects and messages).  Thus it is meaningless for you to even claim by
divine inspiration that such support is of any significant benefit.


Edit this signature at http://www.digitas.harvard.edu/cgi-bin/ken/sig
Sexy types in action: http://www.eecs.harvard.edu/~ccshan/cs252/usage.pdf
new journal Physical Biology: http://sansom.biop.ox.ac.uk/images/physbio.gif
What if All Chemists Went on Strike? (science fiction):

Attachment: signature.asc
Description: Digital signature