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

[James O'Connor <joconnor@jmpstart.com>]

Robert Dewar wrote:
> 
> 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.

Yes, that was perhaps a bad anology on his part to try to prove that
point :)

For that matter, has Ada been used enough in commercial systems long
enough to have meaningful data about long-term maintanence costs?
> 
> 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 :-)

I once commented to an (Ada advocate) friend that the more dynamic your
language got, the more you needed dynamic tools to deal with it.  When I
did Ada83 years ago, I could use source code print-outs to debug my code
because every object was statically typed and every subprogram call was
statically bound.  Now that I use Smalltalk (Ada people think I've
fallen from grace, Smalltalkers think I've reached enlightenment),
source code print-outs are not as valuable because it us much harder to
derive runtime state and flow of control.  I wouldn't necessarily say
that over-reliance on dynamic debuggers is good, even in Smalltalk.  The
debuggers are verypowerful in Smalltalk, but even better is to use the
various powerful cross-referencing tools to ensure thos errors don't
happen in the first place.

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

I was on a particularly ugly project and I used to ask my co-workers "If
someone built a plane the way we're building this software, would you
get in it?"

-- 
James O'Connor 
--------------------------------------
joconnor@jmpstart.com
http://www.jmpstart.com
--------------------------------------