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

[Eric Clayberg <clayberg@parcplace.com>]

David Hanley wrote:
> To people who understand programming, and, in particualr, static typing.

That's a mighty arrogant assertion on your part. Are you saying that
folks who use Smalltalk (or, in general, folks who don't agree with your
particular world view), don't understand programming or static typing
for that matter? I understand them both quite well, thank you. Most of
the Smalltalk developers who have entered this thread (myself included)
have extensive programming experience with statically typed languages as
well as Smalltalk. As Terry Raymond said elsewhere in this thread:

"Again, it is not that we think strong typing has no benefit, but we
think that with Smalltalk and its environment the benefit of enforced
strong typing is not worth the cost."

I couldn't agree more.

> Another quick scan of this group would make it equally obvious that
> while some may find these claims intuitive, many other find the same
> claims counterintuitive, and contrary to thier experience.  If we all
> found it intuitive, there's be no discussion, right?

Very true. In fact, it looks like number of folks who find the claims
intuitive and the number who don't are roughly the same in this
discussion. From my point of view, the answer is not as clear cut as you
would like us to believe.

> > OK, then, back it up. So far, *you* haven't *proven* anything.
> I have.

Where? All I see is the same assertion over and over again.

> All other things being equal, there are fewer errors that can
> happen in a static typed system, as opposed to a dynamially typed
> system.  Your refusal to accept this simple arguement makes you appear
> as if you have some kind of religous attachment to your system.

Not at all. It's simply that your "argument" isn't that simple. While
static typed systems will, in fact, prevent certain classes of errors,
you have not proven that dynamically typed languages (like Smalltalk)
don't *also* prevent certain classes of errors. Thus the issue of
"fewer" errors is not very clean cut at all. If you are merely arguing
that a static typed system will have fewer *type* errors in it, then
fine, I can buy that. If you are asserting that this means that there
are fewer errors over all, then you haven't proved anything at all. So,
once again, I ask, where is your proof that Smalltalk is somehow less
reliable for building applications than any arbitrary statically typed
language?

In your prior message you said:

> A good proof would be there the set of errors which can happen in a
> statically typed system, as opposed to a dynamically typed syatem, are
> fewer.

Since you say that this would be a good proof, then why don't you
present the "set of errors" that you see on both sides of the coin and
let us all take a crack at it? Without that, your argument degrades to
so much empty sophistry.

-Eric