Re: OO, C++, and something much better!

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Tansel said

">What is highly debatable? I have used C++ for a long time and now I am
>using Smalltalk, and there is NO comparison in development times. They
>are simply different categories. Turtle vs. Rabbit."


Yes, an apt reference to the fable, and I trust you remember who wins the
race between the Tortoise and the Hare (which is the translation of the
Greek I am used to, but I doubt we know precisely what animals Aesop was
describing to this level of detail).

In this case, the reason for the tortoise winning may well be found in
the long term maintenance and life cycle costs. Yes, langauges like
Smalltalk are certainly handy for quick prototyping, but who knows what
the long term life cycle cost effects will be -- answer: no one, because
commercial use of Smalltalk is too new to have more than scattered data.

Again, noticing that Ada is on the list of xpostings, it is interesting to
note that the first Ada translator (Ada/Ed) was written in a dynamically
typed language (SETL -- which is a very high level language oriented around
high level set operations, or more precisely ZF-set operations, where 
general mappings play a critical role. It is a garbage collected langguage
with pure value semantics (e.g. no pointers).

It is indeed a highly effective prototyping language, and allowed us to get
something working quickly. However, in retrospec, we felt one of the big
weaknesses of SETL was precisely the dynamic typing. If your data structures
are such that only an integer makes sense in a particular context, then it
is nice to have this statically checked, instead of letting an accidental
assignment of some incorrect type cause chaos down the road.

These days it is quite entertaining to see a whole new generation of 
programmers introduced for the first time to dynamic typing, but of course
it is not new at all (LISP is almost as old as Fortran), but in my opinion,
anything that the compiler can do for you is valuable. What you will find
programmers saying in the Ada and Alogol-68 worlds is that it is often hard
work to get the program past the compiler, but once past, it works the first
time.

Ada programmers often don't paricularly care about debuggers -- ask a roomful
of Ada programmers whether they find debuggers useful, and maybe half will
say they regard them as critical. By contrast, when I suggested the idea
that debuggers were not that important to Gabriel (of Lisp fame, sorry I
forget his first name) he thought it was a huge joke, the very *idea* that
someone could do without a debugger -- it actually set him laughing :-)

Someone actually posted earlier to this thread the idea that it was pretty
useless to have the compiler verify type invariants, because debugging
would find the errors easily. It is positively scary that there are
programmers around who could say this with a straight face. But then
any exposure to the general community of programmers is a very
frightening experience :-)