Newsgroups: comp.lang.c++,comp.lang.smalltalk,comp.lang.eiffel,comp.lang.ada,comp.object
Path: cantaloupe.srv.cs.cmu.edu!das-news2.harvard.edu!news.dfci.harvard.edu!camelot.ccs.neu.edu!nntp.neu.edu!grapevine.lcs.mit.edu!bloom-beacon.mit.edu!howland.erols.net!news.mathworks.com!uunet!in2.uu.net!uucp5.uu.net!alexandria.organon.com!alexandria!jsa
From: jsa@alexandria (Jon S Anthony)
Subject: Re: OO, C++, and something much better!
In-Reply-To: Alan Lovejoy's message of Sat, 01 Feb 1997 11:59:33 -0800
Message-ID: <JSA.97Feb3175254@alexandria>
Sender: news@organon.com (news)
Organization: Organon Motives, Inc.
References: <JSA.97Jan16141937@alexandria> <E44u82.6uB@syd.csa.com.au>
	<mheaney-ya023280001601972303180001@news.ni.net>
	<32DF458F.4D5C@concentric.net> <32DF94DC.6FF8@watson.ibm.com>
	<32DFD972.37E4@concentric.net> <5bphq4$5js@mulga.cs.mu.OZ.AU>
	<32E05FAF.47BA@concentric.net> <5buodl$bci@boursy.news.erols.com>
	<32E2FEC7.2F7B@concentric.net> <5bvncj$gqg$1@A-abe.resnet.ucsb.edu>
	<32E47B4B.56D9@concentric.net> <5c4fr0$27j@mulga.cs.mu.OZ.AU>
	<32E67751.4AFC@parcplace.com> <5caqo5$k5l@mulga.cs.mu.OZ.AU> <32E
	<5ce8t3$6gv@mulga.cs.mu.OZ.AU> <32EEC23E.4F1A@concentric.net>
	<5cmv1v$13b@mulga.cs.mu.OZ.AU> <32F07418.29FC@concentric.net>
	<JSA.97Jan30214043@alexandria> <32F3A0A5.7394@concentric.net>
Date: Mon, 3 Feb 1997 22:52:54 GMT
Lines: 64
Xref: glinda.oz.cs.cmu.edu comp.lang.c++:245252 comp.lang.smalltalk:50839 comp.lang.eiffel:18160 comp.lang.ada:57114 comp.object:60782

In article <32F3A0A5.7394@concentric.net> Alan Lovejoy <alovejoy@concentric.net> writes:

> Jon S Anthony wrote:
> > 
> > Well, you've just moved into Humpty Dumpty land.  Such "groups" are
> > exactly how one facet of typing is defined/works in class based
> > systems.  So why invent yet another term?
> 
> To highlight the fact that a rather important facet of what is **called** 
> "static typing" has nothing whatsoever to do with the **type** of a value 
> or object.

Fair enough.  That's a good answer.


> > > There are other ways to enforce useful invariants and constraints
> > > than using a type system.  Smalltalk is very good at constructing
> > > such constraint-enforcement mechanisms and abstractions.
> > 
> > I don't think anyone would/has disagreed with this.
>
> That's not the point.  The issue is not agreement, but awareness.

Well, it should be the point.  You need to control the number of
variables involved before you can say anything.  Once a given aspect
has been resolved (say static vs dynamic checking in error rates) then
you can move on to other aspects.  Those which would be tradeoffs and
have their own value.  You can then try to compare these various bits
and the tradeoffs involved for any given specific task.


> > But this sort of thing is widely available to statically checked
> > languages as well (and has been for some time) in various
> > sophisticated IDEs.  So this is a wash.
> 

> Again, the issue is not "can statically-typed languages do this
> too?"  Rather, it is "are dynamically-typed languages too unsafe for
> general use in (for example) business programming?".

First, this just confuses the issue (which was simply effect of
static/dynamic checking on runtime error numbers).  Second, _of
course_ a dynamically checked language _isn't_ "too unsafe" for such
use without considering other aspects/tradeoffs.  But those other
aspects will likely not have a lot to do with runtime error rates.

> If you wanted to know what dynamically-typed languages can do that
> statically-typed ones cannot, there have been examples given already
> in this and the other related threads that should not need to be
> repeated.

Actually, I don't particularly care because I _do_ have a good idea of
what they can do and where/why they would be the _clear_ choice over
statically checked ones.  But it hasn't much to do with error rates.

/Jon

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

