Newsgroups: comp.object,comp.lang.c++,comp.lang.ada,comp.lang.smalltalk,comp.lang.eiffel
Path: cantaloupe.srv.cs.cmu.edu!rochester!cornellcs!newsstand.cit.cornell.edu!portc01.blue.aol.com!newsxfer3.itd.umich.edu!newsfeed.internetmci.com!metro.atlanta.com!uunet!in1.uu.net!uucp2.uu.net!alexandria.organon.com!alexandria!jsa
From: jsa@alexandria (Jon S Anthony)
Subject: Re: OO, C++, and something much better!
In-Reply-To: Eric Clayberg's message of Wed, 29 Jan 1997 13:33:16 -0500
Message-ID: <JSA.97Jan30201212@alexandria>
Sender: news@organon.com (news)
Organization: Organon Motives, Inc.
References: <JSA.97Jan16141937@alexandria> <5buodl$bci@boursy.news.erols.com>
	<32E2FEC7.2F7B@concentric.net> <5bvncj$gqg$1@A-abe.resnet.ucsb.edu>
	<32E47B4B.56D9@concentric.net> <6PI998tV3RB@herold.franken.de>
	<32E68D40.65EC@parcplace.com> <JSA.97Jan24191048@alexandria>
	<32E999AE.2F68@parcplace.com> <32ED02EE.22E2@netright.com>
	<32ED2448.685A@parcplace.com> <JSA.97Jan28203152@alexandria>
	<32EF97EC.755C@parcplace.com>
Date: Fri, 31 Jan 1997 01:12:12 GMT
Lines: 122
Xref: glinda.oz.cs.cmu.edu comp.object:60637 comp.lang.c++:244571 comp.lang.ada:56934 comp.lang.smalltalk:50586 comp.lang.eiffel:18042

In article <32EF97EC.755C@parcplace.com> Eric Clayberg <clayberg@parcplace.com> writes:

> Jon S Anthony wrote:
> > Well, clearly from the messages, the most likely description for "who"
> > here is "someone familiar with strong type systems - static or
> > otherwise".  The Smalltalk aspect seems irrelevant.
> 
> It seemed relevant since David explicitly mentioned it in his comment.
> In fact, since the claims seemed to be quite intuitive to the folks
> familiar with static type systems *and* Smalltalk, I was left to
> conclude that they were only counterintuitive to those who were familiar
> with static type systems who were *not* familiar with Smalltalk.

Unfortunately, that is not exactly a good deduction from the evidence.


> > The claim is not that ST isn't less reliable or that it is somehow
> > impossible to make a program in ST as reliable as a statically checked
> > strongly typed example.
> 
> Good. Several folks seemed to have adopted that position. I only entered

Actually, _from what I saw_, this was pretty much _always_ the
position being presented.


> this discussion to begin with based on comments to the effect that
> Smalltalk was not a reliable language due to its lack of static typing. 

"reliable language" makes no sense here.  Basically, the situation
revolves around given any two instances of a program (one statically
checked and one not) is there any greater likely hood _in general_
that the non-statically checked one will have a higher number of
runtime errors?  The answer does seem to be _yes_ - for the reasons I
presented. But it can't be asserted as _always_ the case (or
equivalently, as a certainty).


> > However, it _is_ evidence for the claim that "all things being equal"
> > (which they seldom are), statically checked, strongly typed systems
> > will exhibit fewer runtime errors than those which aren't.
> 
> Well, since, as you point out, all things are seldom equal, it is only
> evidence that "statically checked, strongly typed systems will exhibit
> fewer *type-related* runtime errors than those which aren't". It says
> nothing about fewer errors overall or about the ultimate reliability of
> the delivered systems.

The problem here is that _in this discussion_ you _have_ to assume
"all other things being equal" - otherwise you have too goddamn many
irrelevant variables flying around to be able to say anything at all.

Any time you start doing that, you end up with what this discussion
has become - meaningless "yes it is!  no it isn't!" claims which are
based on totally different sets of controls.  The discussion really is:

Keeping all other things equal (admittedly somewhat fuzzy notion) does
a statically checked system result in fewer runtime errors than one
that isn't?  The evidence _strongly_ suggests that the answer is "in
_general_ (though it can't be *proved* to be certain in all cases),
YES".  This is a useful bit of information!  It may not be the be all
and end all, but it is at least _something_.

Introducing this other stuff (and implicitly and without reason) about
the possibility that _maybe_ certain other factors involved in _some_
instances of _some_ dyanamically checked systems can change the
_overall error rate_ of the result vs. that of a statically checked
system just confuses the issue and leads off into ridiculous
situations where noone knows what the hell the other party is talking
about.

If you want to discuss these possibilities, then _state_ them and give
a rundown on why/how they do what you claim for them (in a fashioin
similar to what I did for the statically checked type case).  You
certainly won't be able to offer any *proof*, because as we all know
there isn't any.  And you won't be able to offer any good hard
experimental evidence either - because as we all know _there isn't
any_.  So, you are going to have to do something like present the
"feature/aspect/whatever" and give a reasonably decent analysis as to
how/why it prevents some group of errors.  Actually, based on your
posts so far and others, I can't even make out what the hell these
other things even _are_, much less how they supposedly work and
whether that is convincing or even believable.


> > And neither have you.  So?
> 
> Since I have only been arguing *against* the negative (i.e., "Smalltalk
> is less reliable"), the burden of proof was on the other side. That

No it is _not_.  First there is no *proof*, so if you insist on that
you've succeeded in "blocking the opponent", but with the price that
"nobody can say _anything_ useful".  That's too high a price.

Second, in the _relevant context_ (see limiting variables stuff above)
the result - dyanamic systems will have more runtime errors - _has_
been given good evidence.  You've merely been _confusing_ the issue
with irrelevant side issues.


> proof has not been forthcoming. And, as you so clearly point out, such
> "proof" is virtually impossible to obtain anyway.

Great.  So, your position is that we can't say anything on the
subject?  Or more to the point, anyone can claim anything they want
and always take cover behind this impenetrable defense.  That's pretty
much what you are saying here, because no one is going to be able to
*prove* anything in this context - or, for that matter, in most
contexts concerning software construction.  I suppose you can
certainly take that stance, but why bother?  What's the point?  That
software is a joke?  Well, OK, maybe that _is_ a point.  Is that what
you mean?


/Jon
-- 
Jon Anthony
Organon Motives, Inc.
Belmont, MA 02178
617.484.3383
jsa@organon.com

