Path: ...!news.roellig-ltd.de!news.mb-net.net!open-news-network.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: Tim Rentsch <tr.17687@z991.linuxsc.com>
Newsgroups: comp.lang.c
Subject: Re: technology discussion =?utf-8?Q?=E2=86=92?= does the world need
 a "new" C ?
Date: Thu, 26 Sep 2024 09:37:55 -0700
Organization: A noiseless patient Spider
Lines: 350
Message-ID: <867cay74m4.fsf@linuxsc.com>
References: <v66eci$2qeee$1@dont-email.me> <87r0c1nzjj.fsf@bsb.me.uk> <v6m716$1urj4$1@dont-email.me> <87ikxconq4.fsf@bsb.me.uk> <v6n8iu$24af0$1@dont-email.me> <20240711115418.00001cdf@yahoo.com> <v6oamt$2d8nn$1@dont-email.me> <v6oct4$2djgq$2@dont-email.me> <v6of96$2ekb0$1@dont-email.me> <v6ovfc$2hcpf$1@dont-email.me> <v6p4hf$2icph$1@dont-email.me> <v6qgpu$2t6p7$3@dont-email.me> <v6r33m$30grj$1@dont-email.me> <v6r3iv$30gru$1@dont-email.me> <20240712045301.394@kylheku.com> <87sewesg89.fsf@nosuchdomain.example.com> <865xresvxz.fsf@linuxsc.com> <87h6ay3jaz.fsf@nosuchdomain.example.com> <87mskqtip3.fsf@bsb.me.uk> <8634m0ccjc.fsf@linuxsc.com> <87zfo7rija.fsf@nosuchdomain.example.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Injection-Date: Thu, 26 Sep 2024 18:37:58 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="fcae6191366e67ac7893d7838d1abab6";
	logging-data="284655"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX18O7IYexUQLtm8az286zGMt1KkrwFaLA8Q="
User-Agent: Gnus/5.11 (Gnus v5.11) Emacs/22.4 (gnu/linux)
Cancel-Lock: sha1:c0J/JyVg5fNeBGD0snW5MD//UFE=
	sha1:dFs6FwBxPduRRFXfV2e++pdTSi4=
Bytes: 17939

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>
>> Ben Bacarisse <ben@bsb.me.uk> writes:
>>
>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>>
>>>> Tim Rentsch <tr.17687@z991.linuxsc.com> writes:
>>>>
>>>>> Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

[...]

>>>>>> I know that "call by reference" is the usual formal term, but
>>>>>> I personally prefer "pass by reference".
>>>>>>
>>>>>> The terms "call by reference" and "call by value" emphasize
>>>>>> the call, implying that all arguments in a given call are
>>>>>> passed with the same mechanism.  In some languages that's
>>>>>> true (C argument passing is purely by value, and Fortran, as
>>>>>> I understand it, is purely by reference), but in others (C++,
>>>>>> Pascal, Ada) you can select by-value or by-reference for each
>>>>>> parameter.  "Pass by (reference|value)" feels more precise.
>>>>>>
>>>>>> I haven't checked, but I suspect the terms "call by
>>>>>> (reference|value)" predate languages that allowed the
>>>>>> mechanism to be specified for each parameter.
>>>>>
>>>>> I suspect that your guess here is influenced more by what
>>>>> you would like to be true than what is likely to be true.
>>>>
>>>> I was influenced by what I thought made the most sense.
>>>>
>>>>> What is likely to be true is that these terms entered the
>>>>> language at essentially the same time as the original Algol.
>>>>> Algol 60 has both call by name and call by value, referred to
>>>>> by those names in the Algol 60 Report, and selectable on a
>>>>> per-parameter basis.
>>>>>
>>>>> By contrast the precursor to Algol 60, the International
>>>>> Algebraic Language or IAL for short (and referred to after the
>>>>> fact as Algol 58) did not use either term, and described the
>>>>> coupling between arguments and parameters only in somewhat
>>>>> vague English prose that left unclear exactly what the binding
>>>>> mechanism(s) were to be.  (There was a description for
>>>>> functions and a separate description for procedures, not quite
>>>>> the same, and both not completely clear exactly what the
>>>>> mechanism was meant to be.)
>>>>>
>>>>> Thus it seems likely that the terms call by name, call by
>>>>> value, and perhaps other similar terms, first arose during the
>>>>> discussions of the Algol 60 working group in the late 1950s,
>>>>> and entered the general lexicon with or perhaps slightly before
>>>>> the publication of the Algol 60 Report, which describes and
>>>>> allows both call by name and call by value, selectable on a
>>>>> per-parameter base, and referred to by those names in the
>>>>> published Algol 60 Report.
>>>>
>>>> Yes, that does seem likely.
>>>>
>>>> I'm mildly disappointed.  Since arguments are *passed* and
>>>> functions/procedures are *called*, surely it would have made
>>>> more sense to use "pass by value" rather than "call by value",
>>>> especially in a language where the mechanism can vary per
>>>> parameter.
>>>
>>> All that is, I think, due to subsequent changes in (English)
>>> language use.  In Algol 60, procedures were invoked and
>>> /parameters/ were called by value or name.  Maybe the term was
>>> intended to reflect the idea that the code in the body "called
>>> for the value" of the parameter.
>>>
>>> The word "call" now refers, almost universally, to invoking a
>>> function or procedure.  As a result, the idea of "calling a
>>> parameter" reads oddly, but at the time I'm sure it seemed
>>> perfectly reasonable.
>>
>> This view simply doesn't match the language and phrasing used
>> during the time Algol was being developed.  Both the Algol 60
>> report and the preliminary IAL report (aka Algol 58) routinely
>> use the word call in connection with outside use of a procedure.
>> Algol 60 uses the word "invoke" exactly twice:  once in relation
>> to procedures (where "call" is also used), and once in relation
>> to functions.  Algol 58 uses the word call pretty much the same
>> way that Algol 60 does, but doesn't use the word "invoke" at all;
>> the verb "initiate" a procedure in Algol 58 turned into "invoke"
>> a procedure in Algol 60.  Clearly using "call" was already well
>> established in the late 1950s, and "invoke" came later.
>>
>> Algol 58 (loosely) defined the semantics of procedure call by
>> textual expansion of the procedure body at the call site,
>> substituting the text of actual parameters for each occurrence of
>> the corresponding formal parameter in the procedure body.  The
>> actual rules are more complicated, due to there being different
>> "styles" (my word) of parameters, and because there were output
>> parameters as well as input parameters.  Basically though the
>> meaning was what would later be termed "call by name", with some
>> restrictions on what forms of actual parameters were allowed.
>>
>> Algol 60 simplified the rules by reducing the number of cases to
>> just two:  either the actual parameter was textually substituted
>> for the formal parameter in the expansion (call by name), or the
>> value of the actual parameter expression was in effect assigned
>> to a local variable corresponding to the formal parameter (call
>> by value), which did not have a corresponding case in Algol 58.
>> The "call by" in "call by name" and "call by value" refers to how
>> the expansion is done in elaborating the procedure call.  The
>> "call by" is not what sort of thing is passed, but what action is
>> taken in doing the substitution/expansion.
>>
>>>> (Yes, this is my opinion.)
>>>>
>>>> If there's some reason why "call by value" actually made more
>>>> sense than "pass by value", I'm not aware of it.
>>>>
>>>> Since the phrase "pass by value" is now in common use, I'll
>>>> continue to use that term in preference to "call by value"
>>>> (likewise "by reference").
>>>
>>> I use those terms too.  It would be confusing these days to talk
>>> about calling a parameter, and the phrase "call by value" suggests
>>> (as it never did at the time) something so do with the function
>>> calling mechanism in general.
>>
>> Yes it did.  It is only now that we have a different idea about
>> how functions and procedures are called that it seems like it
>> doesn't.  But in Algol 60 it certainly did have something to do
>> with how a function reference was elaborated (aka called).
>>
>>> This is compounded by the fact that modern programming languages
>>> has almost universally settled on calling all parameters by value
>>> (to the use the old phrase) so, usually, the terms can, in fact,
>>> be used to talk about the function calling mechanism.
>>
>> The rationale here seems circular to me, and also not an accurate
>> picture of the programming language landscape.
>>
>> Passing a pointer by value is not the same as a call be reference.
>>
>> Passing a lambda by value is not the same as a call by name.
>>
>> Shortly after Algol 60, FORTRAN adopted call by value/result,
>> also called call by copy in/copy out.  Ada has INOUT, does
>> it not?
>>
>> Logic programming languages have call by unification.
>>
>> All of these cases show why "pass by" is not a good universal
>> fit.
>
> How?  All I see is that you've used the word "call" rather than
> "pass" in each instance -- and in each instance, I find "pass"
> clearer (except perhaps in the case of "call by name", for reasons
> I won't go into for the moment).
>
>> At their lowest level, computers are simply slinging bits around.
>> In some sense everything is done in terms of "values".  Thinking
>> in terms of what "value" is "passed" serves to reinforce an
>> imperative mind set, and there is already too much of that.  For
>> these reasons and more I disdain the hoi polloi phrasing of "pass
>> by" for distinguishing different parameter modalities.
>
> I honestly do not understand the argument you're making in favor of
> "call by" over "pass by".  ("Hoi polloi"?  Seriously?)
>
> Procedures and functions are "called", yes?  They're not "passed",
> except perhaps as an argument to another procedure or function.
>
> Arguments to procedures and functions are "passed", yes?  Would it
> make sense to say that an argument is "called"?  (I note that the
> Algol 60 report never refers to parameters being "called" other than
> in the phrases "call by value" and "call by name".)
>
> If you think that "calling an argument" or "calling a parameter"
> makes sense, perhaps that's the root of the disagreement.  Do you?
>
> In most languages that supports by both by-value and by-reference
> mechanisms, a single call can have one by-value argument and one
> by-reference argument, or any other combination.  Using C++ as a
========== REMAINDER OF ARTICLE TRUNCATED ==========