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 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: <87r0c1nzjj.fsf@bsb.me.uk> <87ikxconq4.fsf@bsb.me.uk> <20240711115418.00001cdf@yahoo.com> <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 writes: > Tim Rentsch writes: > >> Ben Bacarisse writes: >> >>> Keith Thompson writes: >>> >>>> Tim Rentsch writes: >>>> >>>>> Keith Thompson 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 ==========