-----BEGIN PGP SIGNED MESSAGE-----
I started writing a long post about this, and deleted it because I don't
want to wade too far into this flame war. I'd just like to point out
that, ultimately, language design is a trade-off.
If you are using a runtime-typed language, you are gambling that the
upfront time saved on coding will be greater than the possible increase in
time spent debugging.
If you are using a statically-typed language, you are spending more time
fighting with the compiler and/or writing out class hierarchies, but
gambling that the extra upfront coding time will result in less time spent
I would say that as the size of a project grows, the amount of time typing
in code increases linearly, but the amount of potential debugging
increasing geometrically, as the number of interacting
statements/functions/classes/modules increases. Thus, techniques that
reduce debugging time are going to be proportionally more effective than
techniques that reduce upfront design time.
That said, there's probably a crossing-over point, where projects below
some size are better served with a dynamic type system, and projects above
that size are better server with a static type system. The point could
also be made that certain dynamically typed languages are more powerful
(they can acomplish more per line of code) which raises the bar.
To some extent given the original discussion this is even a false
dichotomy, because people often embed dynamic typing systems into
statically typed languages (i.e. VOS metaobjects) and furthermore
langauges like C# have an extensive reflection API which allows you to do
things like invoke methods with a certain name, signature or attribute
regardless of its actual class type.
So while you can do dynamic type checking in a mostly static language,
typically you can't do static type checking in a dynamic langauge. In the
end this seems less powerful to me.
- - Pete
(or maybe I just don't like Python's force indentation very much :-)
On Mon, 13 Mar 2006, Hugh Perkins wrote:
Yes, you're right that dynamic typing is very cool.
I guess the thing that I find tricky in Python is that it is possible to
accidentally add unintended properties to a class by misspelling the
intended one, and sometimes it's tricky to catch this. For example (my
Python syntax might be a little rusty..):
def __constructor__(self, name):
self.name = name
print "My name is " + self.myname
myobject = new MyClass("Tom")
C:\> python test.py
My name is
... because we wrote self.myname instead of self.name.
Obviously in this somewhat trivial example it's easy to debug, but the point
is that this introduces logical errors into the code, that are never caught
by the interpeter itself, only by seeing that the results are not what we
[ Peter Amstutz ][ [EMAIL PROTECTED] ][ [EMAIL PROTECTED] ]
[Lead Programmer][Interreality Project][Virtual Reality for the Internet]
[ VOS: Next Generation Internet Communication][ http://interreality.org ]
[ http://interreality.org/~tetron ][ pgpkey: pgpkeys.mit.edu 18C21DF7 ]
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.1 (GNU/Linux)
-----END PGP SIGNATURE-----
vos-d mailing list