[30276] in Perl-Users-Digest
Perl-Users Digest, Issue: 1519 Volume: 11
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Thu May 8 06:14:17 2008
Date: Thu, 8 May 2008 03:14:10 -0700 (PDT)
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Thu, 8 May 2008 Volume: 11 Number: 1519
Today's topics:
Re: The Importance of Terminology's Quality <KyleMcG@gmail.com>
Re: The Importance of Terminology's Quality <gneuner2/@/comcast.net>
Re: The Importance of Terminology's Quality <jurgenex@hotmail.com>
Re: The Importance of Terminology's Quality <jpthing@online.no>
Re: The Importance of Terminology's Quality kodifik@eurogaran.com
Using Win32::OLE(’in’) <XXjbhuntxx@white-star.com>
Re: Why doesn't Perl complain about this bareword? <whynot@pozharski.name>
Re: Why doesn't Perl complain about this bareword? <ben@morrow.me.uk>
Re: Why doesn't Perl complain about this bareword? sheinrich@my-deja.com
Re: Why doesn't Perl complain about this bareword? <ro.naldfi.scher@gmail.com>
Digest Administrivia (Last modified: 6 Apr 01) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: Wed, 7 May 2008 19:14:35 -0700 (PDT)
From: Kyle McGivney <KyleMcG@gmail.com>
Subject: Re: The Importance of Terminology's Quality
Message-Id: <e04ba51f-30a0-44fa-aade-c2fb6c99f944@26g2000hsk.googlegroups.com>
> =95 Module, Block, in Mathematica is in lisp's various =93let*=94. The
> lisp's keywords =93let=94, is based on the English word =93let=94. That wo=
rd
> is one of the English word with multitudes of meanings. If you look up
> its definition in a dictionary, you'll see that it means many
> disparate things. One of them, as in =93let's go=94, has the meaning of
> =93permit; to cause to; allow=94. This meaning is rather vague from a
> mathematical sense. Mathematica's choice of Module, Block, is based on
> the idea that it builds a self-contained segment of code. (however,
> the choice of Block as keyword here isn't perfect, since the word also
> has meanings like =93obstruct; jam=94)
If the purpose of let is to introduce one or more variable bindings,
then I don't see how changing to block or module would improve
anything. I've always found it fairly intuitive to parse (let ((x
5)) ...) to "let x be five". Additionally, replacing let with the
synonyms you provided would approximately yield "permit x to be five"
or "allow x to be five". In my mind you have constructed an argument
in favor of let here (obviously it's better than block, because
nobody's going to come along and be confused about whether let will
"obstruct" or "jam" them :)
There are many easy targets to poke at in the CL spec. let isn't one
of those.
------------------------------
Date: Thu, 08 May 2008 01:05:34 -0400
From: George Neuner <gneuner2/@/comcast.net>
Subject: Re: The Importance of Terminology's Quality
Message-Id: <lmu424djdnfsb6nbqjgo4kebrpmn7vm4p9@4ax.com>
On Wed, 7 May 2008 16:13:36 -0700 (PDT), "xahlee@gmail.com"
<xahlee@gmail.com> wrote:
>I'd like to introduce a blog post by Stephen Wolfram, on the design
>process of Mathematica. In particular, he touches on the importance of
>naming of functions.
>
>• Ten Thousand Hours of Design Reviews (2008 Jan 10) by Stephen
>Wolfram
> http://blog.wolfram.com/2008/01/10/ten-thousand-hours-of-design-reviews/
>
>The issue is fitting here today, in our discussion of “closure”
>terminology recently, as well the jargons “lisp 1 vs lisp2” (multi-
>meaning space vs single-meaning space), “tail recursion”, “currying”,
>“lambda”, that perennially crop up here and elsewhere in computer
>language forums in wild misunderstanding and brouhaha.
>
>The functions in Mathematica, are usually very well-name, in contrast
>to most other computing languages. In particular, the naming in
>Mathematica, as Stephen Wolfram implied in his blog above, takes the
>perspective of naming by capturing the essense, or mathematical
>essence, of the keyword in question. (as opposed to, naming it
>according to convention, which often came from historical happenings)
>When a thing is well-named from the perspective of what it actually
>“mathematically” is, as opposed to historical developments, it avoids
>vast amount of potential confusion.
>
>Let me give a few example.
>
>• “lambda”, widely used as a keyword in functional languages, is named
>just “Function” in Mathematica. The “lambda” happend to be called so
>in the field of symbolic logic, is due to use of the greek letter
>lambda “?” by happenstance. The word does not convey what it means.
>While, the name “Function”, stands for the mathematical concept of
>“function” as is.
Lambda is not a function - it is a function constructor. A better
name for it might be MAKE-FUNCTION.
I (and probably anyone else you might ask) will agree that the term
"lambda" is not indicative of it's meaning, but it's meaning is not
synonymous with "function" as you suggest.
I suspect Mathematica of just following historical convention itself.
Mathematica uses the term inappropriately just as it was (ab)used in
Pascal (circa 1970). I'm not aware of earlier (ab)uses but there
probably were some.
>• Module, Block, in Mathematica is in lisp's various “let*”. The
>lisp's keywords “let”, is based on the English word “let”. That word
>is one of the English word with multitudes of meanings. If you look up
>its definition in a dictionary, you'll see that it means many
>disparate things. One of them, as in “let's go”, has the meaning of
>“permit; to cause to; allow”. This meaning is rather vague from a
>mathematical sense. Mathematica's choice of Module, Block, is based on
>the idea that it builds a self-contained segment of code. (however,
>the choice of Block as keyword here isn't perfect, since the word also
>has meanings like “obstruct; jam”)
"Let" is the preferred mathematical term for introducing a variable.
Lisp uses it in that meaning. What a word means or doesn't in English
is not particularly relevant to its use in another language. There
are many instances of two human languages using identical looking
words with very different meanings. Why should computer languages be
immune?
>• Functions that takes elements out of list are variously named First,
>Rest, Last, Extract, Part, Take, Select, Cases, DeleteCases... as
>opposed to “car”, “cdr”, “filter”, “filter”, “pop”, “shift”,
>“unshift”, in lisps and perl and other langs.
Lisp has "first" and "rest" - which are just synonyms for "car" and
"cdr". Older programmers typically prefer car and cdr for historical
reasons, but few object to the use of first and rest except for
semantic reasons - Lisp does not have a list data type, lists are
aggregates constructed from a primitive pair data type. Pairs can be
used to construct trees as well as lists and "rest" has little meaning
for a tree. When used with lists, first and rest are meaningful terms
and no one will object to them.
Besides which, you easily create synonyms for car and cdr (and
virtually any other Lisp function) with no more burden on the reader
of your code than using a C macro. You can call them "first and
rest", or "first and second", or "left and right", or "red and black"
or whatever else makes sense for your data.
People coming to Lisp from other languages often complain of macros
that they have to learn "a new language" every time they read a
program. But in fact, the same is true in all languages - the reader
always has to learn the user-defined functions and how they are used
to make sense of the code. In that sense Lisp is no different from
any other language.
Common Lisp doesn't have "filter". Even so, with respect to the
merits of calling a function "extract" or "select" versus "filter", I
think that's just a matter of familiarity. The term "filter" conveys
a more general idea than the others and can, by parameterization,
perform either function.
>The above are some examples. The thing to note is that, Mathematica's
>choices are often such that the word stands for the meaning themselves
>in some logical and independent way as much as possible, without
>having dependent on a particular computer science field's context or
>history. One easy way to confirm this, is taking a keyword and ask a
>wide audience, who doesn't know about the language or even unfamiliar
>of computer programing, to guess what it means. The wide audience can
>be made up of mathematicians, scientists, engineers, programers,
>laymen. This general audience, are more likely to guess correctly what
>Mathematica's keyword is meant in the language, than the the name used
>in other computer languages who's naming choices goes by convention or
>context.
>
>(for example, Perl's naming heavily relies on unix culture (grep,
>pipe, hash...), while functional lang's namings are typically heavily
>based on the field of mathematical logic (e.g. lambda, currying,
>closure, monad, ...). Lisp's cons, car, cdr, are based on computer
>hardware (this particular naming, caused a major damage to the lisp
>language to this day). (Other examples: pop, shift are based on
>computer science jargon of “stack”. Grep is from Global Regular
>Expression Print, while Regular Expression is from theoretical
>computer science of Automata... The name regex has done major hidden
>damage to the computing industry, in the sense that if it have just
>called it “string patterns”, then a lot explanations, literatures,
>confusions, would have been avoided.))
>
>(Note: Keywords or functions in Mathematica are not necessarily always
>best named. Nor are there always one absolute choice as best, as there
>are many other considerations, such as the force of wide existing
>convention, the context where the function are used, brevity,
>limitations of English language, different scientific context (e.g.
>math, physics, engineering), or even human preferences.)
>
>----------------------------
>
>Many of the issues regarding the importance and effects of
>terminology's quality, i've wrote about since about 2000. Here are the
>relevant essays:
>
>• Jargons of Info Tech Industry
> http://xahlee.org/UnixResource_dir/writ/jargons.html
>
>• The Jargon “Lisp1” vs “Lisp2”
> http://xahlee.org/emacs/lisp1_vs_lisp2.html
>
>• The Term Curring In Computer Science
> http://xahlee.org/UnixResource_dir/writ/currying.html
>
>• What Is Closure In A Programing Language
> http://xahlee.org/UnixResource_dir/writ/closure.html
>
>• What are OOP's Jargons and Complexities
> http://xahlee.org/Periodic_dosage_dir/t2/oop.html
>
>• Sun Microsystem's abuse of term “API” and “Interface”
> http://xahlee.org/java-a-day/interface.html
>
>• Math Terminology and Naming of Things
> http://xahlee.org/cmaci/notation/math_namings.html
>
> Xah
> xah@xahlee.org
>? http://xahlee.org/
>
>?
George
--
for email reply remove "/" from address
------------------------------
Date: Thu, 08 May 2008 06:05:20 GMT
From: Jürgen Exner <jurgenex@hotmail.com>
Subject: Re: The Importance of Terminology's Quality
Message-Id: <fm55241ivmal876v6nrnrh4s56t3jl3dtb@4ax.com>
George Neuner <gneuner2/@/comcast.net> wrote:
>On Wed, 7 May 2008 16:13:36 -0700 (PDT), "xahlee@gmail.com"
><xahlee@gmail.com> wrote:
+-------------------+ .:\:\:/:/:.
| PLEASE DO NOT | :.:\:\:/:/:.:
| FEED THE TROLLS | :=.' - - '.=:
| | '=(\ 9 9 /)='
| Thank you, | ( (_) )
| Management | /`-vvv-'\
+-------------------+ / \
| | @@@ / /|,,,,,|\ \
| | @@@ /_// /^\ \\_\
@x@@x@ | | |/ WW( ( ) )WW
\||||/ | | \| __\,,\ /,,/__
\||/ | | | jgs (______Y______)
/\/\/\/\/\/\/\/\//\/\\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
==============================================================
jue
------------------------------
Date: Thu, 08 May 2008 10:05:36 +0200
From: "John Thingstad" <jpthing@online.no>
Subject: Re: The Importance of Terminology's Quality
Message-Id: <op.uatsrmq2ut4oq5@pandora.alfanett.no>
PĂĄ Thu, 08 May 2008 04:14:35 +0200, skrev Kyle McGivney
<KyleMcG@gmail.com>:
>> • Module, Block, in Mathematica is in lisp's various “let*”. The
>> lisp's keywords “let”, is based on the English word “let”. That word
>> is one of the English word with multitudes of meanings. If you look up
>> its definition in a dictionary, you'll see that it means many
>> disparate things. One of them, as in “let's go”, has the meaning of
>> “permit; to cause to; allow”. This meaning is rather vague from a
>> mathematical sense. Mathematica's choice of Module, Block, is based on
>> the idea that it builds a self-contained segment of code. (however,
>> the choice of Block as keyword here isn't perfect, since the word also
>> has meanings like “obstruct; jam”)
>
> If the purpose of let is to introduce one or more variable bindings,
> then I don't see how changing to block or module would improve
> anything. I've always found it fairly intuitive to parse (let ((x
> 5)) ...) to "let x be five". Additionally, replacing let with the
> synonyms you provided would approximately yield "permit x to be five"
> or "allow x to be five". In my mind you have constructed an argument
> in favor of let here (obviously it's better than block, because
> nobody's going to come along and be confused about whether let will
> "obstruct" or "jam" them :)
How about bind?
(bind ((v f (mod i)) ((a b) list) (t (rem q)))
1. is a multiple-value-bind
2. is a destructuring-bind
3. is a let
http://common-lisp.net/project/metabang-bind/
To me this is a example of where the ANSI group could have spent more time
on naming.
--------------
John Thingstad
------------------------------
Date: Thu, 8 May 2008 01:12:27 -0700 (PDT)
From: kodifik@eurogaran.com
Subject: Re: The Importance of Terminology's Quality
Message-Id: <b8637c52-fad4-4b96-a100-510e0228aa3f@y38g2000hsy.googlegroups.com>
> =A0 =A0 =A0 =A0 =A0| =A0 PLEASE DO NOT =A0 | =A0 =A0 =A0 =A0 =A0 =A0:.:\:\=
:/:/:.:
> =A0 =A0 =A0 =A0 =A0| =A0FEED THE TROLLS =A0| =A0 =A0 =A0 =A0 =A0 :=3D.' - =
=A0 - '.=3D:
I don't think Xah is trolling here (contrary to his/her habit)
but posing an interesting matter of discussion.
Don't know to which point it fits, but I would like to do some rather
novel comment on operator naming:
As a non native english speaker, the first time I ever encountered the
word "if" was when learning to program. The same can be said of the
other words (for, then, else...) This caused my brain to adscribe them
meanings completely outside the context of everyday language. My point
is that perhaps this is advantageous. So, contrary to tradition (which
considers a desirable goal to write programs as close as possible to
everyday english), I found convenient that programming languages use
words different from the words of my native tongue. I suspect that is
why car and cdr have caught on vs. first end rest.
------------------------------
Date: Thu, 08 May 2008 02:39:54 GMT
From: Cosmic Cruizer <XXjbhuntxx@white-star.com>
Subject: Using Win32::OLE(’in’)
Message-Id: <Xns9A97C7F156137ccruizermydejacom@207.115.17.102>
Everyday I'm finding out more and more I can do with Win32::OLE(’in’) to
help me manage and review remote servers. It's turning out to be a great
tool to gather information for documentation and troubleshooting.
With everything I've already done, I know there must be a huge number of
other objects I don't even know exist. Is there somewhere online that lists
all of the objects and gives a brief description on each one?
------------------------------
Date: Wed, 07 May 2008 21:29:03 +0300
From: Eric Pozharski <whynot@pozharski.name>
Subject: Re: Why doesn't Perl complain about this bareword?
Message-Id: <f099f5xc0e.ln2@orphan.zombinet>
A. Sinan Unur <1usa@llenroc.ude.invalid> wrote:
> sheinrich@my-deja.com wrote in
> news:764d756d-1678-422e-b813-7b39dedc0e3b@34g2000hsh.googlegroups.com:
> C:\t> perl -w -Mstrict -e "print Does-Not-Exist, qq{\n}"
> Bareword "Exist" not allowed while "strict subs" in use at -e line 1.
> Execution of -e aborted due to compilation errors.
> Note no complaint about Does and Not. I don't know why.
21:16:29 71 [1:9]$ perl -w -Mstrict -e "print Does - Not - Exist,
qq{\n}"
Bareword "Exist" not allowed while "strict subs" in use at -e line 1.
Execution of -e aborted due to compilation errors.
> C:\t> perl -w -Mstrict -e "print Does+Not+Exist, qq{\n}"
> Bareword "Not" not allowed while "strict subs" in use at -e line 1.
> Bareword "Exist" not allowed while "strict subs" in use at -e line 1.
> Execution of -e aborted due to compilation errors.
> Note no complaint about Does. I don't know why.
21:17:35 72 [1:9]$ perl -w -Mstrict -e "print Does + Not + Exist,
qq{\n}"
Bareword "Not" not allowed while "strict subs" in use at -e line 1.
Bareword "Exist" not allowed while "strict subs" in use at -e line 1.
Execution of -e aborted due to compilation errors.
I believe, that's something with association and/or precedence magic.
And why in first case B<perl> chockes on right C<->, yet in second case
on left C<+>. Perl is full of magic. It makes feel wizardish.
--
Torvalds' goal for Linux is very simple: World Domination
------------------------------
Date: Thu, 8 May 2008 04:06:27 +0100
From: Ben Morrow <ben@morrow.me.uk>
Subject: Re: Why doesn't Perl complain about this bareword?
Message-Id: <ja7af5-mma1.ln1@osiris.mauzo.dyndns.org>
Quoth Eric Pozharski <whynot@pozharski.name>:
>
> 21:16:29 71 [1:9]$ perl -w -Mstrict -e "print Does - Not - Exist,
> qq{\n}"
> Bareword "Exist" not allowed while "strict subs" in use at -e line 1.
> Execution of -e aborted due to compilation errors.
<snip>
>
> 21:17:35 72 [1:9]$ perl -w -Mstrict -e "print Does + Not + Exist,
> qq{\n}"
> Bareword "Not" not allowed while "strict subs" in use at -e line 1.
> Bareword "Exist" not allowed while "strict subs" in use at -e line 1.
> Execution of -e aborted due to compilation errors.
>
> I believe, that's something with association and/or precedence magic.
> And why in first case B<perl> chockes on right C<->, yet in second case
> on left C<+>.
The two '-'s are not the same operator:
~% perl -Mstrict -MO=Deparse,-p -e'print Does - Not - Exist, "\n"'
Bareword "Exist" not allowed while "strict subs" in use at -e line
1.
-e had compilation errors.
use strict 'refs';
print(Does ((-'Not') - 'Exist'), "\n");
Since 'Does' is a filehandle, the first is a unary minus and the second
a binary. To allow for modules like Tk which take args (-like =>
'this'), unary minus applies the same autoquoting rules to its (single)
operand as => applies to its left, and (-('String')) is special-cased to
return '-String' (a comment in the source indicates that this behaviour
was specifically added for Tk's benefit).
The two '+'s aren't the same either:
~% perl -Mstrict -MO=Deparse,-p -e'print Does + Not + Exist, "\n"'
Bareword "Not" not allowed while "strict subs" in use at -e line 1.
Bareword "Exist" not allowed while "strict subs" in use at -e line
1.
-e had compilation errors.
use strict 'refs';
print(Does ('Not' + 'Exist'), "\n");
but since unary + is strictly a no-op (it doesn't even show up in the
Deparse output) and doesn't have the same autoquoting behaviour, this
still throws a 'strict' error.
> Perl is full of magic. It makes feel wizardish.
Yes. The details of how perl disambiguates filehandles, sub-calls-
without-parens, barewords-used-as-class-names, and barewords-that-
are-strict-errors are really truly evil, and you *will* go insane if you
try too hard to make sense of it :). IMHO it's best to stick to naming
subs and methods in lowercase, classes and packages with initial caps,
and filehandles in all caps; that way you won't get any surprise
misinterpretations.
Ben
--
Heracles: Vulture! Here's a titbit for you / A few dried molecules of the gall
From the liver of a friend of yours. / Excuse the arrow but I have no spoon.
(Ted Hughes, [ Heracles shoots Vulture with arrow. Vulture bursts into ]
'Alcestis') [ flame, and falls out of sight. ] ben@morrow.me.uk
------------------------------
Date: Thu, 8 May 2008 02:26:30 -0700 (PDT)
From: sheinrich@my-deja.com
Subject: Re: Why doesn't Perl complain about this bareword?
Message-Id: <94a940b6-6e67-4982-97de-99296c4b0459@a23g2000hsc.googlegroups.com>
On May 7, 9:21 pm, "A. Sinan Unur" <1...@llenroc.ude.invalid> wrote:
> sheinr...@my-deja.com wrote in news:41f43d75-d4cb-4633-95a9-
> e5b76af6a...@c58g2000hsc.googlegroups.com:
>
> > On May 7, 1:45 pm, "A. Sinan Unur" <1...@llenroc.ude.invalid> wrote:
>
> > ...
> >> Note the following cases:
>
> >> C:\t> perl -w -Mstrict -e "print Does,Not,Exist, qq{\n}"
> >> No comma allowed after filehandle at -e line 1.
>
> >> In this case, Does has a valid interpretation as a
> >> bareword filehandle. Thus, strict does not kick in.
>
> > But why is the first argument being taken here for a filehandle, in
> > spite of the comma, and not considered as namespace, as in your other
> > example?
>
> Well, it is a bareword. The most natural use of a bareword found
> following print is to specify a filehandle in the current package.
>
> The alternative to giving an error message would have been to print Does
> which is not what the programmer wanted in 99.9999% of cases of a
> bareword following a print followed by a comma.
>
> > It seems like only Strings containing :: (or ' ) qualify as possible
> > package names.
>
> No. DoESnoTExiST is also a valid package name. However, only ' and ::
> can be used as separators in a package name.
>
That was my point above. (At least I meant it to be ;-)
And because of that I expected Perl to show the same behaviour,
regardless of :: or '.
As we both agree and leaving the comma aside, the first argument could
be a filehandle, a package name or a bareword, just from the look at
it. '::' doesn't change that.
IMHO the actual nature of the beast (or programmer's intention) cannot
be guessed from a following comma but must be determined by a look
into the symbol table.
And if this fails it has to be a bareword and appropriate warning
should be given.
BTW, it could also be a subroutine (with or without a comma
following).
C:\t>perl -w -Mstrict -e "sub DoesExist {} print DoesExist, qq{\n}"
C:\t>perl -w -Mstrict -e "sub DoesExist {} print DoesExist qq{\n}"
C:\t>perl -w -Mstrict -e "print DoesNotExist(), qq{\n}"
Undefined subroutine &main::DoesNotExist called at -e line 1.
Since Perl, in its warnings, never even seems to consider a subroutine
as long as there are no brackets (or '&' sigel), it must already have
taken a look into the symbol table. But why do the warnings elaborate
on all other possibilities?
And why on the other hand, after all other possibilities failed, the
bareword is treated as ordinary string and only if it contains
'::' (the OP's issue).
C:\t>perl -w -Mstrict -e "print DoesNotExist, qq{\n}"
No comma allowed after filehandle at -e line 1.
And why it says "No comma allowed after filehandle" even if it is no
filehandle?
I still find this bahaviour confusing for the user and like Ben Morrow
elsethread, think that it must be caused by some gloomy parts of perl
which we normal users rather shouldn't dare think about.
Cheers, Steffen
------------------------------
Date: Thu, 8 May 2008 02:31:39 -0700 (PDT)
From: Ronny <ro.naldfi.scher@gmail.com>
Subject: Re: Why doesn't Perl complain about this bareword?
Message-Id: <ffa30e2e-9cd9-49bf-919f-83fe75ee459b@x35g2000hsb.googlegroups.com>
On 7 Mai, 13:45, "A. Sinan Unur" <1...@llenroc.ude.invalid> wrote:
> sheinr...@my-deja.com wrote innews:764d756d-1678-422e-b813-7b39dedc0e3b@34g2000hsh.googlegroups.com:
> > On May 7, 6:31 am, benkasminbull...@gmail.com (Ben Bullock) wrote:
> >> Ronny <ro.naldfi.sc...@gmail.com> wrote:
> >> > By chance I found out that no error is issued on the following
> >> > program:
>
> >> > perl -w -e 'use strict; print(Does::Not::Exist,"\n")'
>
> >> > Instead, "Does::Not::Exist" is printed. Shouldn't there be a
> >> > warning about
> >> > the improper use of a bareword?
>
> >> It seems to be a bug in Perl.
>
> > Even stranger:
>
> > scripts>perl -we "use strict; print(Does::Not::Exist);"
> > Name "Does::Not::Exist" used only once: possible typo at -e line 1.
> > print() on unopened filehandle Exist at -e line 1.
>
> Note that the issue only arises with print. In the case above,
> Does::Not::Exist is being taken to refer to a bareword filehandle Exist
> in the package Does::Not. It then seems like print wants to print $_ to
> this filehandle.
I think the basic reason is that this is simply a bug, as has been
suggested
already. The Perl parser should recognize it as incorrect bareword,
but doesn't,
so it interprets it more or less "by chance" differently:
In the case of print having only this bareword argument, it seems to
consider
it as a filehandle, but even this would be illegal due to parentheses,
as you
can see when you use a valid file handle:
$ perl -we "use strict; print(STDOUT);"
Use of uninitialized value in print at -e line 1.
And, in the examples I gave (using print and system), the bareword
was clearly taken as a string, not as a filehandle.
I sent a bug report to perl.
Ronald
------------------------------
Date: 6 Apr 2001 21:33:47 GMT (Last modified)
From: Perl-Users-Request@ruby.oce.orst.edu (Perl-Users-Digest Admin)
Subject: Digest Administrivia (Last modified: 6 Apr 01)
Message-Id: <null>
Administrivia:
#The Perl-Users Digest is a retransmission of the USENET newsgroup
#comp.lang.perl.misc. For subscription or unsubscription requests, send
#the single line:
#
# subscribe perl-users
#or:
# unsubscribe perl-users
#
#to almanac@ruby.oce.orst.edu.
NOTE: due to the current flood of worm email banging on ruby, the smtp
server on ruby has been shut off until further notice.
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
#To request back copies (available for a week or so), send your request
#to almanac@ruby.oce.orst.edu with the command "send perl-users x.y",
#where x is the volume number and y is the issue number.
#For other requests pertaining to the digest, send mail to
#perl-users-request@ruby.oce.orst.edu. Do not waste your time or mine
#sending perl questions to the -request address, I don't have time to
#answer them even if I did know the answer.
------------------------------
End of Perl-Users Digest V11 Issue 1519
***************************************
