Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10 5/3/83; site utcsrgv.UUCP
Path: utzoo!utcsrgv!donald
From: donald@utcsrgv.UUCP (Don Chan)
Newsgroups: net.lang
Subject: Strong Typing and Ignorance
Message-ID: <2892@utcsrgv.UUCP>
Date: Sun, 4-Dec-83 17:09:20 EST
Article-I.D.: utcsrgv.2892
Posted: Sun Dec  4 17:09:20 1983
Date-Received: Sun, 4-Dec-83 17:41:28 EST
Organization: CSRG, University of Toronto
Lines: 46

It would be nice if someone would define what "strong typing" is.
Everybody seems to think "strong typing" is just Pascal's types, e.g.
"strong typing" implies fixed array bounds, etc.

Nonsense.  This is burning paper tigers-- nobody ever claimed Pascal's
types are perfect, or that they define "strong typing".  Notice I quote
"strong typing".  I don't use the term myself; I think it is an
ill-defined term used by people who don't quite know what they're
talking about (like "Object-orientation").

Part of the problem is confusion in the meaning of "type".  The type
systems of various languages are really not type *definition* systems
but type *representation* systems, and we're basically arguing the form
that such representation systems ought to take.  If you're lost at this
point I can suggest the section on types in the book "Programming
Methodology:  A Collection of Papers by IFIP WG2.3", edited by Gries.
Gries's overview and Guttag's paper are good intros to the nature of
types.

About the only reasonable meaning I can ascribe to "strong typing" is
"compile-time type-checking".  This still leaves a lot of leeway for
expansion!  In CLU if you don't like the system-provided arrays you can
make your own arrays (perhaps optimized for sparse matrices) and use
them just like the system arrays.  CLU still manages to do all its
type-checking at compile time.

Sometimes the compile-time checking constraint seems inconvenient for
the programmer, but it does have its advantages, just like forbidding
GOTOs seems inconvenient, but has advantages.

BTW, it may surprise some people that C is "strongly typed".  Read the
reference manual if you don't believe it.  Don't confuse lax compilers
with a vague language definition.

I find it amusing that the people who think "Actor" (what the heck are
they?) languages have a superior notion of types, have never actually
used them.  Having read some SmallTalk and Flavoured Lisp documents, it
seems that their main advantage is deferral of type-checking until run
time and good parameterization.  Nice at times, but certainly not superior
(or inferior).

As always, some more precision in this discussion would be appreciated.
-- 
Don Chan, University of Toronto Department of Computer Science
{ utzoo linus ihnp4 floyd allegra uw-beaver
  ubc-vision cornell watmath hcr decwrl }!utcsrgv!donald