The Importance of Terminology's Quality - Python

Arne Vajhøj wrote:
> szr wrote:
>> Arne Vajhøj wrote:
>>> szr wrote:
>>>> Peter Duniho wrote:
>>>>> On Fri, 30 May 2008 22:40:03 -0700, szr <szrRE@szromanMO.comVE>
>>>>> wrote:
>>>>>> Arne Vajhøj wrote:
>>>>>>> Stephan Bour wrote:
>>>>>>>> Lew wrote:
>>>>>>>> } John Thingstad wrote:
>>>>>>>> } > Perl is solidly based in the UNIX world on awk, sed, } >
>>>>>>>> bash and C. I don't like the style, but many do.
>>>>>>>> }
>>>>>>>> } Please exclude the Java newsgroups from this discussion.
>>>>>>>>
>>>>>>>> Did it ever occur to you that you don't speak for entire news
>>>>>>>> groups?
>>>>>>> Did it occur to you that there are nothing about Java in the
>>>>>>> above ?
>>>>>> Looking at the original post, it doesn't appear to be about any
>>>>>> specific language.
>>>>> Indeed. That suggests it's probably off-topic in most, if not
>>>>> all, of the newsgroups to which it was posted, inasmuch as they
>>>>> exist for topics specific to a given programming language.
>>>> Perhaps - comp.programming might of been a better place, but not
>>>> all people who follow groups for specific languages follow a
>>>> general group like that - but let me ask you something. What is it
>>>> you really have against discussing topics with people of
>>>> neighboring groups? Keep in mind you don't have to read anything
>>>> you do not want to read. [1]
>>> I very much doubt that the original thread is relevant for the Java
>>> group.
>>>
>>> But the subthread Lew commente don was about Perl and Unix. That is
>>> clearly off topic.
>>
>> I agree with and understand what you are saying in general, but
>> still, isn't it possible that were are people in the java group (and
>> others) who might of been following the thread, only to discover
>> (probably not right away) that someone decided to remove the group
>> they were reading the thread from? I know I would not like that,
>> even if it wasn't on topic at the branch.
>>
>> Personally, I find it very annoying to have to switch news groups in
>> order to resume a thread and weed my way down the thread to where it
>> left off before it was cut off from the previous group.
>
> I am relative tolerant towards threads that are a bit off topic, if
> the S/N ratio overall is good.

Agreed.

[...]

If a thread, that is cross-posted, branches off on a tangent that has
nothing to do with one or more groups what so ever, then yes, it makes
sense to prune the 'newsgroup:' list / set follow ups, but in this case,
someone made one mention or so of 'Perl', which was being used as an
example, and someone (lew) moved to have the Java group removed.

There was little reason to cut off the thread, when people very well may
have been following it, over the utterance of one word, which was being
used as an example. The bulk of the thread had to do with general
programming, and suddenly writing the name of a language doesn't mean
it's way off on a tangent.

I hope this clears up some waters.

Regards.

--
szr

> From: dkco...@panix.com (David Combs)
> Lisp is *so* early a language (1960?), preceeded mainly only by
> Fortran (1957?)?, and for sure the far-and-away the first as a
> platform for *so many* concepts of computer-science, eg lexical vs
> dynamic ("special") variables, passing *unnamed* functions as
> args ... maybe is still the only one in which program and data
> have the same representation -- that it'd seem logical to use it's
> terminology in all languages.

Yeah, but why did you cross-post to so many newsgroups? Are you
trying to run a flame war between advocates of the various
languages? (Same accusation to the OP moreso!)

> From C is the very nice distinction between "formal" and "actual" args.

I think Lisp already had that nearly 50 years ago. Function
definition (lambda expression) has formal args, EVAL recursively
calls EVAL on sub-forms to create actual args and calls APPLY on
them and whatever function is named in the CAR position of the form.
Whether anybody bothered to use that specific jargon, or it was
just so obvious it didn't need jargon, I don't know.

> And from algol-60, own and local -- own sure beats "static"!

Yeah. But now that you mention it and I think about it, what's
really meant is "private persistent". Global variables are public
persistent. Local variables and formal args to functions are
private transient (they go away as soon as the function returns).
but OWN variables are private to the function but stay around
"forever" just like globals do, so that side effects on the OWN
variables that occurred during one call can persist to affect the
next call. Lexical closures in Common Lisp go one step further,
allowing private persistent variables to be shared between several
functions. All those functions share access to the private variable
which they co-OWN. Another way in which OWN or lexical-closure
variables aren't like what the word "own" means in ordinary
language is that it's possible to transfer ownership by selling or
giving something to somebody else, but not with OWN variables or
lexical-closure variables. So even though I like the word OWN
better than the word STATIC for this meaning, I'm not totally
comfortable with that jargon. But "persistent private" is a
mouthful compared to "OWN", and I doubt anyone can find a word of
appx. 3 characters that conveys the intended meaning so we're
probably stuck with "OWN" as the best short term.

Robert Maas, http://tinyurl.com/uh3t wrote:
>> From: dkco...@panix.com (David Combs)
>> Lisp is *so* early a language (1960?), preceeded mainly only by
>> Fortran (1957?)?, and for sure the far-and-away the first as a
>> platform for *so many* concepts of computer-science, eg lexical vs
>> dynamic ("special") variables, passing *unnamed* functions as
>> args ... maybe is still the only one in which program and data
>> have the same representation -- that it'd seem logical to use it's
>> terminology in all languages.
>
> Yeah, but why did you cross-post to so many newsgroups? Are you
> trying to run a flame war between advocates of the various
> languages?

What would be the point? We all know that Java, Perl, Python and Lisp suck.
They don't even have pattern matching over algebraic sum types if you can
imagine that. How rudimentary...

--
Dr Jon D Harrop, Flying Frog Consultancy
http://www.ffconsultancy.com/products/?u

On 5 Giu, 12:37, Jon Harrop <j...@ffconsultancy.com> wrote:
> [...]

P.S. Please don't look at my profile (at google groups), thanks!

Jon Harrop

David Combs wrote:
> passing
> *unnamed* functions as args (could Algol 60 also do something like that,
> via something it maybe termed a "thunk")

No, the "thunks" were necessary at the machine-language level to
/implement/ ALGOL 60, but they could not be expressed /in/ ALGOL.

--
John W. Kennedy
"The first effect of not believing in God is to believe in anything...."
-- Emile Cammaerts, "The Laughing Prophet"

Why this response is so belated:
<http://groups.google.com/group/misc.misc/msg/cea714440e591dd2>
= <news:rem-2008jun25-003@yahoo.com>
> Date: Thu, 05 Jun 2008 11:37:48 +0100
> From: Jon Harrop <j...@ffconsultancy.com>
> We all know that Java, Perl, Python and Lisp suck.

Well at least you're three-quarters correct there.
But Lisp doesn't suck. That's where you're one quarter wrong.

> They don't even have pattern matching over algebraic sum types if
> you can imagine that.

I'm still waiting for you to precisely define what you mean by
"pattern matching" in this context. All I've heard from you so-far
are crickets. If you've set up a Web page with your personal
definition of "pattern matching" as you've been using that term
here, and you've posted its URL in a newsgroup article I didn't
happen to see, please post just the URL again here so that I might
finally see it. Or e-mail me the URL.

-
Nobody in their right mind likes spammers, nor their automated assistants.
To open an account here, you must demonstrate you're not one of them.
Please spend a few seconds to try to read the text-picture in this box:

/----------------------------------------------------------------------------\
| ,-.-. | |
| | | |, . ,---.,---.,---. ,---.,---.,---.,---|,---. |
| | | || | `---.| || | | ||---'|---'| |`---. |
| ` ' '`---| `---'`---'` ' ` '`---'`---'`---'`---' |
| `---' |
| | | o | | |
| |---.,---.| ,---. .,---. ,---.| ,---.,---. |---.,---.,---. |
| | ||---'| | | || | ,---|| | ||---'---| || ,---| |
| ` '`---'`---'|---' `` ' `---^`---'`---|`---' `---'` `---^ | |
| | `---' ' |
| | | | |
| ,---.,---.|--- . . .,---.,---.,---|,---.,---. |---.,---.,---. |
| | || || | | || || || ||---'| ---| || ,---| |
| ` '`---'`---' `-'-'`---'` '`---'`---'` `---'` `---^o |
\--------(Rendered by means of <http://www.schnoggo.com/figlet.html>)--------/
(You don't need JavaScript or images to see that ASCII-text image!!
You just need to view this in a fixed-pitch font such as Monaco.)

Then enter your best guess of the text (40-50 chars) into this TextField:
+--------------------------------------------------+
| |
+--------------------------------------------------+

Robert Maas wrote:
> /----------------------------------------------------------------------------\
> | ,-.-. | |
> | | | |, . ,---.,---.,---. ,---.,---.,---.,---|,---. |
> | | | || | `---.| || | | ||---'|---'| |`---. |
> | ` ' '`---| `---'`---'` ' ` '`---'`---'`---'`---' |
> | `---' |
> | | | o | | |
> | |---.,---.| ,---. .,---. ,---.| ,---.,---. |---.,---.,---. |
> | | ||---'| | | || | ,---|| | ||---'---| || ,---| |
> | ` '`---'`---'|---' `` ' `---^`---'`---|`---' `---'` `---^ | |
> | | `---' ' |
> | | | | |
> | ,---.,---.|--- . . .,---.,---.,---|,---.,---. |---.,---.,---. |
> | | || || | | || || || ||---'| ---| || ,---| |
> | ` '`---'`---' `-'-'`---'` '`---'`---'` `---'` `---^o |
> \--------(Rendered by means of <http://www.sc*****************.html>)--------/
> (You don't need JavaScript or images to see that ASCII-text image!!
> You just need to view this in a fixed-pitch font such as Monaco.)
>
> Then enter your best guess of the text (40-50 chars) into this TextField:
> +--------------------------------------------------+
> | Your son totally needs a Wonder-Bra(r), double-D |
> +--------------------------------------------------+

--
Lew

Robert Maas, http://tinyurl.com/uh3t wrote:
> Why this response is so belated:
> <http://groups.google.com/group/misc.misc/msg/cea714440e591dd2>
> = <news:rem-2008jun25-003@yahoo.com>
>> Date: Tue, 24 Jun 2008 18:42:15 -0400
>> From: John W Kennedy <jwke...@attglobal.net>
>> ... the "thunks" were necessary at the machine-language level to
>> /implement/ ALGOL 60, but they could not be expressed /in/ ALGOL.
>
> Ah, thanks for the clarification. Is that info in the appropriate
> WikiPedia page? If not, maybe you would edit it in?

It is explained s.v. "thunk", which is referenced from "ALGOL 60". The
ALGOL "pass-by-name" argument/parameter matching was perhaps the most
extreme example ever of a language feature that was "elegant" but
insane. What it meant, in effect, was that, unless otherwise marked,
every argument was passed as two closures, one that returned a fresh
evaluation of the expression given as the argument, which was called
every time the parameter was read, and one that set the argument to a
new value, which was called every time the parameter was set.

See <URL:http://www.cs.sfu.ca/~cameron/Teaching/383/PassByName.html>.

ALGOL 60 could not create generalized user-written closures, but could
create one no more complex than a single expression with no arguments of
its own simply by passing the expression as an argument. But it was not
thought of as a closure; that was just how ALGOL 60 did arguments.
--
John W. Kennedy
"Give up vows and dogmas, and fixed things, and you may grow like
That. ...you may come to think a blow bad, because it hurts, and not
because it humiliates. You may come to think murder wrong, because it
is violent, and not because it is unjust."
-- G. K. Chesterton. "The Ball and the Cross"

Why this response is so belated:
<http://groups.google.com/group/misc.misc/msg/cea714440e591dd2>
= <news:rem-2008jun25-003@yahoo.com>
> Date: Thu, 5 Jun 2008 06:17:01 -0700 (PDT)
> From: jon.harrop.ms.sh...@gmail.com
> P.S. Please don't look at my profile (at google groups), thanks!

Please don't look at the orange and green checkered elephant
playing a harp off-key while sitting on a toilet and passing wind.