[32174] in Perl-Users-Digest
Perl-Users Digest, Issue: 3439 Volume: 11
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Sat Jul 9 00:09:20 2011
Date: Fri, 8 Jul 2011 21:09:03 -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 Fri, 8 Jul 2011 Volume: 11 Number: 3439
Today's topics:
Re: Perl hashes and structs question <rweikusat@mssgmbh.com>
Re: Perl hashes and structs question <ralph@happydays.com>
Re: sort scientific notation value after alphabet <rweikusat@mssgmbh.com>
Re: sort scientific notation value after alphabet <willem@turtle.stack.nl>
Re: sort scientific notation value after alphabet <rweikusat@mssgmbh.com>
Re: sort scientific notation value after alphabet <willem@turtle.stack.nl>
Re: test two hash(refs) for equality <jondk@FAKE.EMAIL.net>
Re: test two hash(refs) for equality <rweikusat@mssgmbh.com>
Re: test two hash(refs) for equality <uri@StemSystems.com>
Re: test two hash(refs) for equality <rweikusat@mssgmbh.com>
Re: test two hash(refs) for equality <uri@StemSystems.com>
Re: test two hash(refs) for equality <rweikusat@mssgmbh.com>
Re: test two hash(refs) for equality <uri@StemSystems.com>
Re: test two hash(refs) for equality <jwkrahn@example.com>
Digest Administrivia (Last modified: 6 Apr 01) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: Fri, 08 Jul 2011 16:17:46 +0100
From: Rainer Weikusat <rweikusat@mssgmbh.com>
Subject: Re: Perl hashes and structs question
Message-Id: <87iprciyxx.fsf@sapphire.mobileactivedefense.com>
ccc31807 <cartercc@gmail.com> writes:
> This question arise out of a conversation with a friend who does Lisp.
> I noticed that she uses a lot of structs in her code, and was
> surprised that I don't use structs in Perl, but make heavy use of
> hashes of hashes. So, I'm just asking:
>
> (1) Do Perl hashes of hashes serve the same purpose as structs? I
> think they do.
According to CLtLv2,
Structures are instances of user-defined data types that have
a fixed number of named components. They are analogous to
records in Pascal.
http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node39.html#SECTION006120000000000000000
This implies that Perl hashes (or arrays, combined with named
constants) can serve some purposes of structures/ records: The Perl
values can be used as 'value with named [sub-]components' and can't
serve some others, namely, the declarative aspects of structures,
except some amount of smoke and mirrors is added to Perl in order to
make it appear as if it supported user-declared types.
> (2) Does Perl have a data structure similar to a struct? Outside of OO
> Perl, I don't think so.
Perl doesn't and 'OO Perl' is just Perl in this respect: Any amount of
overhead can be added to code working with Perl container types
(arrays and hashes) in order to make that look more similar to code
written in languages with actual support for structure types but that
doesn't cause anything to become different.
------------------------------
Date: Fri, 08 Jul 2011 11:27:23 -0400
From: Ralph Malph <ralph@happydays.com>
Subject: Re: Perl hashes and structs question
Message-Id: <4c950$4e1721e3$ce534406$30716@news.eurofeeds.com>
pg 336 of "The Camel Book" 3rd edition mentions the very nice
module Class::Struct for struct-like data structures in Perl. This is a
standard module so you'll have it already.
On 7/8/2011 10:10 AM, ccc31807 wrote:
> This question arise out of a conversation with a friend who does Lisp.
> I noticed that she uses a lot of structs in her code, and was
> surprised that I don't use structs in Perl, but make heavy use of
> hashes of hashes. So, I'm just asking:
>
> (1) Do Perl hashes of hashes serve the same purpose as structs? I
> think they do.
> (2) Does Perl have a data structure similar to a struct? Outside of OO
> Perl, I don't think so.
>
> If a struct is a reference to an object that contains references to
> other objects, and a hash-of-hashes item is a reference to an
> anonymous hash that contains references to other objects, then the two
> kinds of data structures serve the same purpose. It just surprises me
> that Perl, given its specialization for the extraction and reporting
> of data, doesn't have a struct type, which leads me to the third
> question:
>
> (3) Why doesn't Perl have a struct type, if it in fact does not have
> one? The obvious answer is that it doesn't need one, but sometimes the
> obvious answer is wrong.
>
> CC.
------------------------------
Date: Fri, 08 Jul 2011 16:30:28 +0100
From: Rainer Weikusat <rweikusat@mssgmbh.com>
Subject: Re: sort scientific notation value after alphabet
Message-Id: <87box4iycr.fsf@sapphire.mobileactivedefense.com>
Willem <willem@turtle.stack.nl> writes:
> Uri Guttman wrote:
> ) i am not being foolishly consistant. you are just being lazy in
> ) declaring now and maybe using them later. it is a case of attitude
> ) towards the quality of your code. my claim is misleading the reader is a
> ) bad thing.
>
> You haven't established that declaring unused variables is misleading to
> the reader, except when the reader expects all declared variables to be
> used. Which is a circular argument.
To quote someone famous: "Getretener Quark wird breit, nicht
stark".
(a) A reader will have been misled when things he expected to be true
turn out to be false.
(b) Given a set of variable declarations occuring in front of some
otherwise unknown code text, a reader has no way to correctly expect
the used variables to be used and the unused variables to be unused
=> This reader will be misled of both unused and used variables exist.
------------------------------
Date: Fri, 8 Jul 2011 19:32:58 +0000 (UTC)
From: Willem <willem@turtle.stack.nl>
Subject: Re: sort scientific notation value after alphabet
Message-Id: <slrnj1emr9.2vqr.willem@turtle.stack.nl>
Rainer Weikusat wrote:
) Willem <willem@turtle.stack.nl> writes:
)> You haven't established that declaring unused variables is misleading to
)> the reader, except when the reader expects all declared variables to be
)> used. Which is a circular argument.
)
) To quote someone famous: "Getretener Quark wird breit, nicht
) stark".
)
) (a) A reader will have been misled when things he expected to be true
) turn out to be false.
)
) (b) Given a set of variable declarations occuring in front of some
) otherwise unknown code text, a reader has no way to correctly expect
) the used variables to be used and the unused variables to be unused
)
)=> This reader will be misled of both unused and used variables exist.
Why would a reader need to expect that a variable is used or not?
This is just the same circular argument in a different guise.
SaSW, Willem
--
Disclaimer: I am in no way responsible for any of the statements
made in the above text. For all I know I might be
drugged or something..
No I'm not paranoid. You all think I'm paranoid, don't you !
#EOT
------------------------------
Date: Fri, 08 Jul 2011 20:53:05 +0100
From: Rainer Weikusat <rweikusat@mssgmbh.com>
Subject: Re: sort scientific notation value after alphabet
Message-Id: <87d3hk1rdq.fsf@sapphire.mobileactivedefense.com>
Willem <willem@turtle.stack.nl> writes:
> Rainer Weikusat wrote:
> ) Willem <willem@turtle.stack.nl> writes:
> )> You haven't established that declaring unused variables is misleading to
> )> the reader, except when the reader expects all declared variables to be
> )> used. Which is a circular argument.
> )
> ) To quote someone famous: "Getretener Quark wird breit, nicht
> ) stark".
> )
> ) (a) A reader will have been misled when things he expected to be true
> ) turn out to be false.
> )
> ) (b) Given a set of variable declarations occuring in front of some
> ) otherwise unknown code text, a reader has no way to correctly expect
> ) the used variables to be used and the unused variables to be unused
> )
> )=> This reader will be misled of both unused and used variables exist.
>
> Why would a reader need to expect that a variable is used or not?
Even a reader who assumed that declarations communicate exactly
nothing about anything except themselves will be misled except nothing
which is actually used is ever declared. Not that this would be a
particularly sensible assumption, given that it is the purpose of
declarations to provide information about what will be used by the
code.
> This is just the same circular argument in a different guise.
A circular argument would be one where the conclusion and at least one
of the premises are identical. But you didn't claim this. You were
disputing the second premise. Consequently, you counterstatetment does
not demonstrate that the argument is circular.
------------------------------
Date: Fri, 8 Jul 2011 21:52:21 +0000 (UTC)
From: Willem <willem@turtle.stack.nl>
Subject: Re: sort scientific notation value after alphabet
Message-Id: <slrnj1ev0l.135.willem@turtle.stack.nl>
Rainer Weikusat wrote:
) Willem <willem@turtle.stack.nl> writes:
)> Why would a reader need to expect that a variable is used or not?
)
) Even a reader who assumed that declarations communicate exactly
) nothing about anything except themselves will be misled except nothing
) which is actually used is ever declared.
Why?
) Not that this would be a
) particularly sensible assumption, given that it is the purpose of
) declarations to provide information about what will be used by the
) code.
That is not a given, that is your opinion.
It is the purpose of declarations to define the scope of a variable.
(In Perl. In some languages they define types or ranges.)
)> This is just the same circular argument in a different guise.
)
) A circular argument would be one where the conclusion and at least one
) of the premises are identical. But you didn't claim this. You were
) disputing the second premise. Consequently, you counterstatetment does
) not demonstrate that the argument is circular.
The second premise is that readers expect that a variable is used
The conclusion is that it is misleading to declare unused variables.
The premise follows logically from the conclusion.
That makes it a circular argument.
The guise is that you added 'need to' and 'or not'.
SaSW, Willem
--
Disclaimer: I am in no way responsible for any of the statements
made in the above text. For all I know I might be
drugged or something..
No I'm not paranoid. You all think I'm paranoid, don't you !
#EOT
------------------------------
Date: Fri, 08 Jul 2011 11:30:52 -0400
From: Jon Du Kim <jondk@FAKE.EMAIL.net>
Subject: Re: test two hash(refs) for equality
Message-Id: <d0282$4e1722b3$ce534406$32578@news.eurofeeds.com>
On 7/8/2011 5:06 AM, Rainer Weikusat wrote:
> "Uri Guttman"<uri@StemSystems.com> writes:
>
>>>>>>> "RW" == Rainer Weikusat<rweikusat@mssgmbh.com> writes:
>
> [...]
>
>> RW> sub cmp_href($$)
>> RW> {
>> RW> my ($a, $b) = @_;
>> >>
>> >> don't use $a and $b for vars. they are reserved for use by sort.
>>
>> RW> They are not reserved. The sort routine uses two variables with names
>> RW> $a and $b in the symbol table of the module sort is invoked in (as far
>> RW> as I understand the documentation). These $a and $b therefore don't
>> RW> collide with lexical variables and they also don't collided with other
>> RW> 'package global' variables because sort localizes them (as it shoud do)
>>
>> it is a convention. do you even care what other coders do or care about?
>> it is just a bad idea. don't use $a and $b outside of sort. can you even
>> allow this into your head?
>
> There are exactly two cases in which I'd agree with an opinion of
> yours, namely
>
> 1. I happen to hold the same opinion.
> 2. You've convinced me with an argument.
>
> and one additional case where I would behave according to it,
>
> 3. You are in a position to give orders to me.
The problem you are facing is a strange one in the Perl community.
The spirit of Perl has long been "ThereIsMoreThanOneWayToDoIt" TIMTOWTDI.
Larry Walls' irc handle is TimToady. This is the true spirit of Perl.
Sadly, there seems to be a sub-cult of people hawking their idea of
"standards". They
are trying to make Perl code conform to some invented corporate style
coding standard.
These are small minded people that like to be forced to do things a
certain way.
Uri is one of these people. There are others.
What you are doing is fine, as you clearly know. What is not fine are
false self described
authorities trying to invent some bland corporate coding style for the
community.
------------------------------
Date: Fri, 08 Jul 2011 21:38:45 +0100
From: Rainer Weikusat <rweikusat@mssgmbh.com>
Subject: Re: test two hash(refs) for equality
Message-Id: <878vs81p9m.fsf@sapphire.mobileactivedefense.com>
Rainer Weikusat <rweikusat@mssgmbh.com> writes:
> Jürgen Exner <jurgenex@hotmail.com> writes:
[...]
>> As a first step I would compare the size of the two hashes and then
>> check the value for each key (untested, algorithmic sketch only):
>>
>> my ($h1, $h2) = @_;
>> return 0 unless scalar(keys(%$h1)) == scalar(keys(%$h2));
>> #yes, scalar() is redundant, but this makes it very explicit
>> foreach (my $elem = keys %$h1) {
>> return 0 unless exists %$h2{$elem} # see note 1
>> and %$h1{$elem} == %$h2{$elem} # see note 2
>> }
>> return 1;
>>
>> 1: This not only checks if each key from h1 exists in h2, too, (i.e.
>> keys(h1) is subset of keys(h2)), but because h1 and h2 also have the
>> same number of elements then the two sets of keys are identical.
[...]
> That's similar to my 'naive' first implementation. Provided the hashes
> are small and they a rather different than identical, it is not bad.
As it turned out to be, this idea wasn't really grounded in reality
but rather in a copy'n'paste-botched benchmark :-) and except for
insanely large hashes (>= 500,000 entries), traversing a hash by
building a list of keys via keys is going to be faster then doing the
same with repeated each-calls. This implies that the most sensible way
to perform this operation (known to me) is indeed Juergens suggestion
above. With a couple of other wrong assumptions removed, the resulting
code looks/ could look like this:
sub cmp_href_0($$)
{
my ($a, $b) = @_;
return unless keys(%$a) == keys(%$b);
exists($b->{$_}) && $b->{$_} eq $a->{$_} || return
for (keys(%$a));
return 1;
}
------------------------------
Date: Fri, 08 Jul 2011 16:56:00 -0400
From: "Uri Guttman" <uri@StemSystems.com>
Subject: Re: test two hash(refs) for equality
Message-Id: <87sjqgze3j.fsf@quad.sysarch.com>
>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
RW> sub cmp_href_0($$)
that prototype is useless. it doesn't do anything worth the
bother. prototypes are about only useful when you need to pass a whole
hash/array or a code block and you need conversion to refs.
RW> {
RW> my ($a, $b) = @_;
regardless of your views, i say this for others, don't use $a and $b in
your code, lexically or otherwise. it is a CONVENTION that all decent
perl hackers are expected to do.
RW> return unless keys(%$a) == keys(%$b);
which i suggested at the beginning but it was tossed aside. something
about not understanding the problem. or maybe you didn't know how fast
keys is in a scalar context?
uri
--
Uri Guttman -- uri AT perlhunter DOT com --- http://www.perlhunter.com --
------------ Perl Developer Recruiting and Placement Services -------------
----- Perl Code Review, Architecture, Development, Training, Support -------
------------------------------
Date: Fri, 08 Jul 2011 22:27:43 +0100
From: Rainer Weikusat <rweikusat@mssgmbh.com>
Subject: Re: test two hash(refs) for equality
Message-Id: <874o2w1n00.fsf@sapphire.mobileactivedefense.com>
"Uri Guttman" <uri@StemSystems.com> writes:
>>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
>
> RW> sub cmp_href_0($$)
>
> that prototype is useless. it doesn't do anything worth the
> bother.
It provides at least some sort of compile-time checking of function
calls and that's something I decidedly want to have ...
> prototypes are about only useful when you need to pass a whole
> hash/array or a code block and you need conversion to refs.
... while this is something I don't. It means that someone who looks
at a function invocation needs to be aware of the function declaration
in order to know what it will do to its arguments and I think this is
bad.
> RW> {
> RW> my ($a, $b) = @_;
>
> regardless of your views, i say this for others, don't use $a and $b in
> your code, lexically or otherwise. it is a CONVENTION that all decent
> perl hackers are expected to do.
This is now actually a circular: Decent perl programmers
don't use variables named $a and $b because nobody who does is a
decent perl programmer.
> RW> return unless keys(%$a) == keys(%$b);
>
> which i suggested at the beginning but it was tossed aside.
> something about not understanding the problem. or maybe you didn't
> know how fast keys is in a scalar context?
You didn't bother to provide an explanation despite you now suggest
that you could have done so and I was (as I wrote in the text you have
chosen to delete) under the impression of having some experimentally
acquired data demonstrating that this pretty obvious check was
actually a bad idea.
------------------------------
Date: Fri, 08 Jul 2011 17:52:32 -0400
From: "Uri Guttman" <uri@StemSystems.com>
Subject: Re: test two hash(refs) for equality
Message-Id: <8762nczbhb.fsf@quad.sysarch.com>
>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
RW> "Uri Guttman" <uri@StemSystems.com> writes:
>>>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
>>
RW> sub cmp_href_0($$)
>>
>> that prototype is useless. it doesn't do anything worth the
>> bother.
RW> It provides at least some sort of compile-time checking of function
RW> calls and that's something I decidedly want to have ...
barely and it can be bypassed with calls like &foo. stick to your style
if you want but even larry (yes, wall) deprecates prototypes for
checking stuff. it is best used to make syntax changes for sub calls.
>> prototypes are about only useful when you need to pass a whole
>> hash/array or a code block and you need conversion to refs.
RW> ... while this is something I don't. It means that someone who looks
RW> at a function invocation needs to be aware of the function declaration
RW> in order to know what it will do to its arguments and I think this is
RW> bad.
RW> {
RW> my ($a, $b) = @_;
>>
>> regardless of your views, i say this for others, don't use $a and $b in
>> your code, lexically or otherwise. it is a CONVENTION that all decent
>> perl hackers are expected to do.
RW> This is now actually a circular: Decent perl programmers
RW> don't use variables named $a and $b because nobody who does is a
RW> decent perl programmer.
you seem to come back to circular as your attack and defense. that in
itself is circular. me thinks thou dost not know what it means. the key
word i emphasized is convention. look it up.
RW> return unless keys(%$a) == keys(%$b);
>>
>> which i suggested at the beginning but it was tossed aside.
>> something about not understanding the problem. or maybe you didn't
>> know how fast keys is in a scalar context?
RW> You didn't bother to provide an explanation despite you now suggest
RW> that you could have done so and I was (as I wrote in the text you have
RW> chosen to delete) under the impression of having some experimentally
RW> acquired data demonstrating that this pretty obvious check was
RW> actually a bad idea.
no, i didn't need to provide one. i said it was a better first pass
check and i was right. you ignored it. simple. you ignore stuff that you
shouldn't ignore. as for your experimentally acquired data, why didn't
YOU publish it? it would have been more authorative from you but you ask
for that from me. circular again. me thinks you are a round file.
uri
--
Uri Guttman -- uri AT perlhunter DOT com --- http://www.perlhunter.com --
------------ Perl Developer Recruiting and Placement Services -------------
----- Perl Code Review, Architecture, Development, Training, Support -------
------------------------------
Date: Fri, 08 Jul 2011 23:20:15 +0100
From: Rainer Weikusat <rweikusat@mssgmbh.com>
Subject: Re: test two hash(refs) for equality
Message-Id: <874o2w9zz4.fsf@sapphire.mobileactivedefense.com>
"Uri Guttman" <uri@StemSystems.com> writes:
>>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
>
> RW> "Uri Guttman" <uri@StemSystems.com> writes:
> >>>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
> >>
> RW> sub cmp_href_0($$)
> >>
> >> that prototype is useless. it doesn't do anything worth the
> >> bother.
>
> RW> It provides at least some sort of compile-time checking of function
> RW> calls and that's something I decidedly want to have ...
>
> barely and it can be bypassed with calls like &foo.
It will cause the compiler to make noises when a function is called
with less arguments than the prototype said it should have. I found
this to be useful to me.
[...]
> RW> This is now actually a circular: Decent perl programmers
> RW> don't use variables named $a and $b because nobody who does is a
> RW> decent perl programmer.
>
> you seem to come back to circular as your attack and defense. that in
> itself is circular. me thinks thou dost not know what it means.
You thinks wrong in this case, as any definition of petitio principii/
begging the question will tell you. In case you don't know where to
find one:
http://philosophy.lander.edu/logic/circular.html
IMHO, the whole thing is worth a read.
[...]
> RW> You didn't bother to provide an explanation despite you now suggest
> RW> that you could have done so and I was (as I wrote in the text you have
> RW> chosen to delete) under the impression of having some experimentally
> RW> acquired data demonstrating that this pretty obvious check was
> RW> actually a bad idea.
>
> no, i didn't need to provide one. i said it was a better first pass
> check and i was right. you ignored it.
Trying to distinguish between gods who don't speak and real stones is
a waste of time. Feel free to behave like a stone and be ignored like
one.
------------------------------
Date: Fri, 08 Jul 2011 18:31:04 -0400
From: "Uri Guttman" <uri@StemSystems.com>
Subject: Re: test two hash(refs) for equality
Message-Id: <87tyawxv4n.fsf@quad.sysarch.com>
>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
RW> "Uri Guttman" <uri@StemSystems.com> writes:
>>>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
>>
RW> "Uri Guttman" <uri@StemSystems.com> writes:
>> >>>>>>> "RW" == Rainer Weikusat <rweikusat@mssgmbh.com> writes:
>> >>
RW> sub cmp_href_0($$)
>> >>
>> >> that prototype is useless. it doesn't do anything worth the
>> >> bother.
>>
RW> It provides at least some sort of compile-time checking of function
RW> calls and that's something I decidedly want to have ...
>>
>> barely and it can be bypassed with calls like &foo.
RW> It will cause the compiler to make noises when a function is called
RW> with less arguments than the prototype said it should have. I found
RW> this to be useful to me.
and to few other people. also it doesn't work at all with methods and
most perl code is OO these days.
RW> You didn't bother to provide an explanation despite you now suggest
RW> that you could have done so and I was (as I wrote in the text you have
RW> chosen to delete) under the impression of having some experimentally
RW> acquired data demonstrating that this pretty obvious check was
RW> actually a bad idea.
>>
>> no, i didn't need to provide one. i said it was a better first pass
>> check and i was right. you ignored it.
RW> Trying to distinguish between gods who don't speak and real stones is
RW> a waste of time. Feel free to behave like a stone and be ignored like
RW> one.
heh. ignorance is your area it seems. feel free to ignore all others
too.
uri
--
Uri Guttman -- uri AT perlhunter DOT com --- http://www.perlhunter.com --
------------ Perl Developer Recruiting and Placement Services -------------
----- Perl Code Review, Architecture, Development, Training, Support -------
------------------------------
Date: Fri, 08 Jul 2011 19:56:56 -0700
From: "John W. Krahn" <jwkrahn@example.com>
Subject: Re: test two hash(refs) for equality
Message-Id: <ZrPRp.23564$Mo3.5052@newsfe15.iad>
Rainer Weikusat wrote:
> "Uri Guttman"<uri@StemSystems.com> writes:
>>>>>>> "RW" == Rainer Weikusat<rweikusat@mssgmbh.com> writes:
>>
>> RW> "Uri Guttman"<uri@StemSystems.com> writes:
>> >>>>>>> "RW" == Rainer Weikusat<rweikusat@mssgmbh.com> writes:
>> >>
>> RW> sub cmp_href_0($$)
>> >>
>> >> that prototype is useless. it doesn't do anything worth the
>> >> bother.
>>
>> RW> It provides at least some sort of compile-time checking of function
>> RW> calls and that's something I decidedly want to have ...
>>
>> barely and it can be bypassed with calls like&foo.
>
> It will cause the compiler to make noises when a function is called
> with less arguments than the prototype said it should have. I found
> this to be useful to me.
$ perl -le'
my %x = "a" .. "z";
my %y = "A" .. "Z";
my @refs = ( \%x, \%y );
sub cmp_href_0 ($$) {
my ( $a, $b ) = @_;
print %$a, %$b;
}
cmp_href_0( @refs );
'
Not enough arguments for main::cmp_href_0 at -e line 9, near "@refs )"
Execution of -e aborted due to compilation errors.
But I passed an array containing two elements. Why doesn't it work?
John
--
Any intelligent fool can make things bigger and
more complex... It takes a touch of genius -
and a lot of courage to move in the opposite
direction. -- Albert Einstein
------------------------------
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:
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
Back issues are available via anonymous ftp from
ftp://cil-www.oce.orst.edu/pub/perl/old-digests.
#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 3439
***************************************
