NetNews Usenet Archive 1992 #27/NN_1992_27.iso/spool/comp/lang/misc/3732

Text File | 1992-11-17 | 3.2 KB | 71 lines

Newsgroups: comp.lang.misc
Path: sparky!uunet!mcsun!news.funet.fi!network.jyu.fi!sakkinen
From: [e-mail] (Markku Sakkinen)
Subject: Re: Pointers
Message-ID: <[e-mail]>
Organization: University of Jyvaskyla, Finland
References: <[e-mail]> <[e-mail]> <[e-mail]>
Date: Tue, 17 Nov 1992 09:59:55 GMT
Lines: 60

In article <[e-mail]> [e-mail] (John Haxby) writes:
>In article <[e-mail]>, [e-mail] (Markku Sakkinen) writes:
>
>|> [ ... ] I cannot see any semantic
>|> difference between CLU variables (of non-atomic types) and reference
>|> (or pointer) variables in many other languages.  'By sharing' is
>|> exactly the same as 'by reference'.
>
>In CLU, x in
>
>    p1 = proc (x: int) ... end p1
>and
>    p2 = proc (x: string) ... end p2
>
>is passed by sharing.  In the VAX implementation, the p1 has its
>argument passed by value, the second by reference (in the grubby
>depths).  In the PCLU implementation, both procedure calls pass
>a CLUREF structure (by value) which contains the value of an integer
>or a pointer to string data.  `By sharing' allows the implementation of
>the compiler to choose the mechanism for passing the parameter to
>a procedure, the only requirement is that changing the contents of a
                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^
>mutable argument is reflected in all instances of the argument.
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>
>Don't mix implementation strategies with language semantics.

Sorry, but seems like you are discussing implementation strategies,
not I.  The marked quote above says that the semantic effect is _as if_
the parameter were passed by reference;  I couldn't care less how
a particular compiler actually implements it.  (I have just pointed
out in another thread, in comp.lang.modula2, that by-value and
by-reference are equivalent for immutable parameters, so we have
no argument about that.)

I would say that LISP, CLU etc. are _not_ simpler than Pascal, Ada etc.
because they have no explicit pointers -- but they are simpler because
they have essentially _only_ pointers.  There are no value assignments
for complex objects, as a primitive language feature.

The drawback of that simplicity is that you get a lot of potential
aliassing problems, which would not be necessary in those languages
in which value semantics is available.  In a fashion, C and its derivatives
have the worst of both worlds.  On one hand, you must explicitly take care
of pointers.  On the other hand, value semantics isn't applicable to arrays.
(Jim Giles has posted sufficiently about the drawbacks of C arrays,
so I need not repeat any of that.)

Well, I think I have beaten this subject to death for my part.
Sorry for boring the audience.

----------------------------------------------------------------------
Markku Sakkinen ([e-mail])
       [e-mail] (alternative network address)
Department of Computer Science and Information Systems
University of Jyvaskyla (a's with umlauts)
PL 35
SF-40351 Jyvaskyla (umlauts again)
Finland
----------------------------------------------------------------------