Xref: utzoo comp.lang.misc:4213 comp.software-eng:2922
Path: utzoo!utgpu!jarvis.csri.toronto.edu!cs.utexas.edu!uunet!mcsun!ukc!edcastle!aiai!jeff
From: jeff@aiai.ed.ac.uk (Jeff Dalton)
Newsgroups: comp.lang.misc,comp.software-eng
Subject: Re: An Interesting View of "Strong" Vs. "Weak" Typing
Keywords: typing, Ada, Lisp, definitions, evidence
Message-ID: <1821@skye.ed.ac.uk>
Date: 22 Feb 90 21:20:39 GMT
References: <2197@ecs.soton.ac.uk> <12820@cbnewsc.ATT.COM>
Reply-To: jeff@aiai.UUCP (Jeff Dalton)
Organization: AIAI, University of Edinburgh, Scotland
Lines: 35

In article <12820@cbnewsc.ATT.COM> lgm@cbnewsc.ATT.COM (lawrence.g.mayka,ihp,) writes:
 >Gries and Gehani bring up the alternative of run-time typed
 >languages (the authors call them "typeless") in a single paragraph
 >at the end of their article.  Interestingly, they mention as
 >examples APL and Snobol but omit Lisp, which I suspect was the
 >most widely used of the three even in those days.  (The Interlisp
 >and MIT Lisp machine programming environments already existed in
 >1977, though they were perhaps not yet well known.) The authors
 >reject such languages for three reasons.  First, Gries and Gehani
 >complain of interpretive implementations.  This accusation no
 >longer applies - not to Common Lisp, anyway. 

Lisp, and Lisp compilers, have been around since at least the early
60's.  It's strange how some people think certain languages are
inherently interpreted even though there is evidence to the contrary
for anyone who cares to look.  For example, the Dartmouth
implementations of Basic were always compilers.

>Second, the authors mention the unparsability of APL. 

As if this was because it was "typeless".  

>The authors' third reason for rejecting run-time typing is that
>"one cannot tell just by looking at a procedure just what it does;
>it will depend too heavily on the inputs to that procedure."

I wonder how many procedures they actually looked at.  In many cases,
it's clear what sorts of objects are involved, either because there
are explicit tests or because type-specific procedures are called.
Of course, being sure that the argument types will really be what
they should be is another matter.

Besides, knowing the types of the parameters doesn't tell you what
the procedure does.  It helps in some cases, but hardly matters at
all in others.