[25462] in Perl-Users-Digest
Perl-Users Digest, Issue: 7707 Volume: 10
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Fri Jan 28 21:10:23 2005
Date: Fri, 28 Jan 2005 18:10:17 -0800 (PST)
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, 28 Jan 2005 Volume: 10 Number: 7707
Today's topics:
Search Through List <chastaib@hotmail.com>
Re: Search Through List <bkimelman@JUNK.sympatico.ca>
Re: Search Through List <matternc@comcast.net>
Re: Search Through List <news@chaos-net.de>
Re: Search Through List <abigail@abigail.nl>
Re: Search Through List <news@chaos-net.de>
Re: Search Through List <news@chaos-net.de>
Re: Search Through List <noreply@gunnar.cc>
what's OOP's jargons and complexities? <xah@xahlee.org>
Re: what's OOP's jargons and complexities? <danperl@rogers.com>
Re: what's OOP's jargons and complexities? <danperl@rogers.com>
Re: what's OOP's jargons and complexities? <mambuhl@earthlink.net>
Re: what's OOP's jargons and complexities? <kst-u@mib.org>
Re: what's OOP's jargons and complexities? <mambuhl@earthlink.net>
Re: what's OOP's jargons and complexities? <esosman@acm-dot-org.invalid>
Digest Administrivia (Last modified: 6 Apr 01) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: 28 Jan 2005 15:12:31 -0800
From: "Gomer" <chastaib@hotmail.com>
Subject: Search Through List
Message-Id: <1106953951.344600.84260@z14g2000cwz.googlegroups.com>
How can I search through a list in PERL? For example, I want to
do something like the following:
@namelist = ('JONES', 'SMITH', 'JOHNSON');
print "Enter name of teammate whose password you need to reset, then
press the ENTER key: \n";
$teammate = <STDIN>;
if (grep ($teammate, @namelist))
{ print "I can\'t let you do that...";}
else
{ print "You are going to reset the password for $teammate";}
------------------------------------------------------------------------
So, what's the secret here?
Thanks,
Brian
------------------------------
Date: Fri, 28 Jan 2005 18:30:35 -0500
From: surfking <bkimelman@JUNK.sympatico.ca>
Subject: Re: Search Through List
Message-Id: <MPG.1c64952123d555b9989873@news1.on.sympatico.ca>
While wandering through cyberspace on 28 Jan 2005 15:12:31 -0800 Gomer
said :
> How can I search through a list in PERL? For example, I want to
> do something like the following:
>
> @namelist = ('JONES', 'SMITH', 'JOHNSON');
>
> print "Enter name of teammate whose password you need to reset, then
> press the ENTER key: \n";
> $teammate = <STDIN>;
>
> if (grep ($teammate, @namelist))
> { print "I can\'t let you do that...";}
> else
> { print "You are going to reset the password for $teammate";}
>
> ------------------------------------------------------------------------
> So, what's the secret here?
>
> Thanks,
> Brian
Perl does indeed have a "grep" builtin function, but it is for regular
expression matching, not searching for exact values in an array.
(see perldoc for some more information on regular expressions)
eg.
@list = ( "bob" , "bobby" , "fred" );
@matches = grep /bob/,@list;
# @matches would then contain "bob" and "bobby"
@list = ( "bob" , "bobby" , "fred" );
@matches = grep /^bob$/,@list;
# @matches would then contain just "bob"
or you could use a loop
$string = "bob";
for ( $count = 0 ; $count <= $#list ; ++$count )
{
if ( $string eq $list[$count] )
{
last;
}
}
if ( $count <= $#list )
{
print "I found \"$string\" in position $count\n";
}
else
{
print "\"$string\" not found\n";
}
------------------------------
Date: Fri, 28 Jan 2005 19:04:06 -0500
From: Chris Mattern <matternc@comcast.net>
Subject: Re: Search Through List
Message-Id: <08SdnT2lOZ5qT2fcRVn-hg@comcast.com>
Gomer wrote:
> How can I search through a list in PERL? For example, I want to
> do something like the following:
>
> @namelist = ('JONES', 'SMITH', 'JOHNSON');
>
> print "Enter name of teammate whose password you need to reset, then
> press the ENTER key: \n";
> $teammate = <STDIN>;
>
> if (grep ($teammate, @namelist))
> { print "I can\'t let you do that...";}
> else
> { print "You are going to reset the password for $teammate";}
>
> ------------------------------------------------------------------------
> So, what's the secret here?
>
Use a hash. You also need to chomp the newline off your input, BTW.
#!/usr/bin/perl
use strict;
use warnings;
my %namelist = (
JONES => undef,
SMITH => undef,
JOHNSON => undef
);
print "Enter name of teammate whose password you need to reset, ";
print "then press the ENTER key: \n";
chomp (my $teammate = <STDIN>);
if (exists $namelist{$teammate}) {
print "You are going to reset the password for $teammate\n"; }
else {
print "I can't let you do that...\n"; }
--
Christopher Mattern
"Which one you figure tracked us?"
"The ugly one, sir."
"...Could you be more specific?"
------------------------------
Date: Sat, 29 Jan 2005 01:26:57 +0100
From: Martin Kissner <news@chaos-net.de>
Subject: Re: Search Through List
Message-Id: <slrncvlm2h.12n.news@maki.homeunix.net>
Gomer wrote :
> How can I search through a list in PERL? For example, I want to
> do something like the following:
>
> @namelist = ('JONES', 'SMITH', 'JOHNSON');
>
> print "Enter name of teammate whose password you need to reset, then
> press the ENTER key: \n";
> $teammate = <STDIN>;
>
> if (grep ($teammate, @namelist))
> { print "I can\'t let you do that...";}
> else
> { print "You are going to reset the password for $teammate";}
>
> ------------------------------------------------------------------------
There has already been posted a solution by Chris.
I have use this question for my own practice and wrote the script below,
which gives me an error/warning before it gives the expected output.
--- output ---
"Use of uninitialized value in concatenation (.) or string at
./teammate.pl line 16, <STDIN> line 1.
You are going to reset the password for JONES"
--- end output ---
I'd appreciate if one of the regulars could explain this behaviour.
The script wotks correctly if I use a variable ($name) instead of $_,
but I would like to figure out how I can use $_
Thanks in advance
Martin
--- start ---
#!/usr/bin/perl
use warnings;
use strict;
my @namelist = ('JONES', 'SMITH', 'JOHNSON');
print "Enter name of teammate whose password you need to reset, then
press the ENTER key: ";
chomp (my $teammate = <STDIN>);
while (pop @namelist)
{
# if ($teammate eq $_ ) # Case does matter
if ($teammate =~ /\b$_\b/i ) # Case does not matter
{
print "You are going to reset the password for $teammate\n";
# do stuff
exit;
}
}
print "I can't let you do that...\n";
--- end ---
--
perl -e 'print 7.74.117.115.116.11.32.13.97.110.111.116.104.101.114.11
.32.13.112.101.114.108.11.32.13.104.97.99.107.101.114.10.7'
------------------------------
Date: 29 Jan 2005 01:04:31 GMT
From: Abigail <abigail@abigail.nl>
Subject: Re: Search Through List
Message-Id: <slrncvlo8u.a9.abigail@alexandra.abigail.nl>
Martin Kissner (news@chaos-net.de) wrote on MMMMCLXIX September MCMXCIII
in <URL:news:slrncvlm2h.12n.news@maki.homeunix.net>:
`'
`' I'd appreciate if one of the regulars could explain this behaviour.
`' The script wotks correctly if I use a variable ($name) instead of $_,
`' but I would like to figure out how I can use $_
My guess is that you do a little more than just substituting $_ by $name.
`' while (pop @namelist)
What do you think this does? It pops an element from @namelist,
looks at its true/false value, and discards it. If the value was
true, the loop is entered, else the loop quits. If @namelist was
empty, the pop returns undef.
`' {
`' # if ($teammate eq $_ ) # Case does matter
`' if ($teammate =~ /\b$_\b/i ) # Case does not matter
$_ is undefined, because you never assign a value to it. Replacing
$_ with $name isn't magically going to work.
What you probably want is:
while (@namelist) {
$_ = pop @namelist;
....
}
You need to assign to $_ (or another variable) to be able to use the
value you just popped. And note that I moved the popping out of the
while condition - otherwise you would quit processing the elements of
@namelist as soon as you encounter an element that is 0, the empty string,
the string "0", or undefined.
Abigail
--
sub camel (^#87=i@J&&&#]u'^^s]#'#={123{#}7890t[0.9]9@+*`"'***}A&&&}n2o}00}t324i;
h[{e **###{r{+P={**{e^^^#'#i@{r'^=^{l+{#}H***i[0.9]&@a5`"':&^;&^,*&^$43##@@####;
c}^^^&&&k}&&&}#=e*****[]}'r####'`=437*{#};::'1[0.9]2@43`"'*#==[[.{{],,,1278@#@);
print+((($llama=prototype'camel')=~y|+{#}$=^*&[0-9]i@:;`"',.| |d)&&$llama."\n");
------------------------------
Date: Sat, 29 Jan 2005 02:07:43 +0100
From: Martin Kissner <news@chaos-net.de>
Subject: Re: Search Through List
Message-Id: <slrncvloev.12n.news@maki.homeunix.net>
Martin Kissner wrote :
> I'd appreciate if one of the regulars could explain this behaviour.
> The script wotks correctly if I use a variable ($name) instead of $_,
> but I would like to figure out how I can use $_
Okay; I finally found out that the script I posted doesn't work
correctly at all.
Sorry for not testing thoroughly enough.
Below is a snippet of the (working) script I had in the first place.
Can someone explain if it is possible to use $_ instead of $name here at
all and if so, how it is done?
while (my $name = pop @namelist)
{
if ($teammate eq $name)
[...]
}
--
perl -e 'print 7.74.117.115.116.11.32.13.97.110.111.116.104.101.114.11
.32.13.112.101.114.108.11.32.13.104.97.99.107.101.114.10.7'
------------------------------
Date: Sat, 29 Jan 2005 02:15:28 +0100
From: Martin Kissner <news@chaos-net.de>
Subject: Re: Search Through List
Message-Id: <slrncvlotg.12n.news@maki.homeunix.net>
Abigail wrote :
> My guess is that you do a little more than just substituting $_ by $name.
You are right; I did
while (my $name = pop @namelist)
{
if ($teammate eq $name)
{
...
}
}
> You need to assign to $_ (or another variable) to be able to use the
> value you just popped. And note that I moved the popping out of the
> while condition - otherwise you would quit processing the elements of
> @namelist as soon as you encounter an element that is 0, the empty string,
> the string "0", or undefined.
Thanks for all your explanations.
This has clarified things.
Best regards
Martin
--
perl -e 'print 7.74.117.115.116.11.32.13.97.110.111.116.104.101.114.11
.32.13.112.101.114.108.11.32.13.104.97.99.107.101.114.10.7'
------------------------------
Date: Sat, 29 Jan 2005 02:26:48 +0100
From: Gunnar Hjalmarsson <noreply@gunnar.cc>
Subject: Re: Search Through List
Message-Id: <360735F4r9dpnU1@individual.net>
surfking wrote:
> Gomer said :
>>How can I search through a list in PERL? For example, I want to
>>do something like the following:
>>
>>@namelist = ('JONES', 'SMITH', 'JOHNSON');
>>
>>print "Enter name of teammate whose password you need to reset, then
>>press the ENTER key: \n";
>>$teammate = <STDIN>;
>>
>>if (grep ($teammate, @namelist))
>>{ print "I can\'t let you do that...";}
>>else
>>{ print "You are going to reset the password for $teammate";}
>>
>>------------------------------------------------------------------------
>>So, what's the secret here?
>
> Perl does indeed have a "grep" builtin function, but it is for regular
> expression matching, not searching for exact values in an array.
What makes you believe that the BLOCK or EXPR that grep() evaluates only
may contain regular expressions??
perldoc -f grep
> @list = ( "bob" , "bobby" , "fred" );
> @matches = grep /bob/,@list;
Or:
@matches = grep index($_, 'bob') == 0, @list;
> # @matches would then contain "bob" and "bobby"
>
> @list = ( "bob" , "bobby" , "fred" );
> @matches = grep /^bob$/,@list;
Or:
@matches = grep $_ eq 'bob', @list;
> # @matches would then contain just "bob"
--
Gunnar Hjalmarsson
Email: http://www.gunnar.cc/cgi-bin/contact.pl
------------------------------
Date: 28 Jan 2005 15:10:49 -0800
From: "Xah Lee" <xah@xahlee.org>
Subject: what's OOP's jargons and complexities?
Message-Id: <1106953849.915440.134710@f14g2000cwb.googlegroups.com>
in computer languages, often a function definition looks like this:
subroutine f (x1, x2, ...) {
variables ...
do this or that
}
in advanced languages such as LISP family, it is not uncommon to define
functions inside a function. For example:
subroutine f (x1, x2, ...) {
variables...
subroutine f1 (x1...) {...}
subroutine f2 (x1...) {...}
}
often these f1 f2 inner functions are used inside f, and are not
relevant outside of f. Such power of the language gradually developed
into a style of programing. For example:
subroutine a_surface () {
coordinatesList = ...;
subroutine translate (distance) {...}
subroutine rotate (angle) {..}
}
such a style is that the a_surface is no longer viewed as a function.
But instead, a boxed set of functions, centered around a piece of data.
And, all functions for manipulating this piece of data are all embodied
in this function. For example:
subroutine a_surface (arg) {
coordinatesList = ...
subroutine translate (distance) {set coordinatesList to translated
version}
subroutine rotate (angle) {set coordinatesList to rotated version}
subroutine return () {return coordinatesList}
if (no arg) {return coordinatesList}
else { apply arg to coordinatesList }
}
In this way, one uses a_surface as a data, which comes with its owe set
of functions:
mySurface = a_surface();
a_surface(rotate(angle)); # now the surface data has been rotated
a_surface(translate(distance)); # now its translated
myNewSurface = a_surface(return())
So now, a_surface is no longer viewed as a subroutine, but a boxed set
of things centered around a piece of data. All functions that work on
the data are included in the boxed set. This paradigm available in
functional languages has refined so much so that it spread to other
groups that it became knows as Object Oriented Programing, and complete
languages with new syntax catered to such scheme emerged.
In such languages, instead of writing them like this:
mySurface = a_surface();
a_surface(rotate(angle));
the syntax is changed to like this, for example:
mySurface = new a_surface();
mySurfaceRotated = mySurface.rotate(angle);
In such languages, the super subroutine a_surface is no longer called a
function or subroutine. They are now called a "Class". And now the
variable "mySurface = a_surface()" is now called a "Object". The
subroutines inside the function a_surface() is no longer called
inner-subroutines. They are called "Methods".
This style of programing and language have become so fanatical that in
such dedicated languages like Java, everything in the language are
"Classes". One can no longer just define a variable or subroutine.
Instead, one creates these meta-subroutine "Classes". Everything one do
are inside Classes. And one assign variables inside these Classes to
create "Objects". And one uses "Methods" to manipulate Objects. In this
fashion, even data types like numbers, strings, and lists are no longer
atomic data types. They are now Classes.
For example, in Java, a string is a class String. And inside the class
String, there are Methods to manipulate strings, such as finding the
number of chars, or extracting parts of the string. This can get very
complicated. For example, in Java, there are actually two Classes of
strings: One is String, and the other is StringBuffer. Which one to use
depends on whether you intend to change the data.
So, a simple code like this in normal languages:
a = "a string";
b = "another one";
c = join(a,b);
print c;
or in lisp style
(set a "a string")
(set b "another one")
(set c (join a b))
(print c)
becomes in pure OOP languages:
public class test {
public static void main(String[] args) {
String a = new String("a string");
String b = new String("another one");
StringBuffer c = new StringBuffer(40);
c.append(a); c.append(b);
System.out.println(c.toString());
}
}
here, the "new String" creates a String object. The "new
StringBuffer(40)"
creates the changeable string object StringBuffer, with room for 40
chars. "append" is a method of StringBuffer. It is used to join two
Strings.
Notice the syntax "c.append(a)", which we can view it as calling a
inner subroutine "append", on a super subroutine that has been assigned
to c, where, the inner subroutine modifies the inner data by appending
a to it.
And in the above Java example, StringBuffer class has another method
"toString()" used to convert this into a String Class, necessary
because System.out.println's parameter requires a String type, not
StringBuffer.
For a example of the complexity of classes and methods, see the Java
documentation for the StringBuffer class at
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/StringBuffer.html
in the same way, numbers in Java have become a formalization of many
classes: Double, Float, Integer, Long... and each has a bunch of
"methods" to operate or convert from one to the other.
Instead of
aNumber = 3;
print aNumber^3;
in Java the programer needs to master the ins and outs of the several
number classes, and decide which one to use. (and if a program later
needs to change from one type of number to another, it is often
cumbersome.)
This Object Oriented Programing style and dedicated languages (such as
C++, Java) have become a fad like wild fire among the programing
ignoramus mass in the industry. Partly because of the data-centric new
perspective, partly because the novelty and mysticism of new syntax and
jargonization.
It is especially hyped by the opportunist Sun Microsystems with the
inception of Java, internet, and web applications booms around 1995. At
those times, OOP (and Java) were thought to revolutionize the industry
and solve all software engineering problems, in particular by certain
"reuse of components" concept that was thought to come with OOP.
As part of this new syntax and purity, where everything in a program is
of Classes and Objects and Methods, many many complex issues and
concept have arisen in OOP.
we now know that the jargon Class is originally and effectively just a
boxed set of data and subroutines, all defined inside a subroutine. And
the jargon "Object" is just a variable that has been set to this super
subroutine. And the inner subroutines are what's called Methods.
-----------------
because of psychological push for purity, in Java there are no longer
plain subroutines. Everything is a method of some class. Standard
functions like opening a file, square root a number, for loop thru a
list, if else branching statements, or simple arithmetic operations...
must now some how become a method of some class. In this way, the OOP
Hierarchy is born.
Basic data types such as now the various classes of numbers, are now
grouped into a Number class hierarchy, each class having their own set
of methods. The characters, string or other data types, are lumped into
one hierarchy class of data types. Many types of lists (variously known
as arrays, vectors, lists, hashes...), are lumped into a one hierarchy,
with each node Classe having their own set methods as appropriate. Math
functions, are lumped into some math class hierarchy.
Now suppose the plus operation +, where does it go? Should it become
methods of the various classes under Number headings, or should it be
methods of the Math class set? Each language deals with these issues
differently. As a example, see this page for the hierarchy of Java's
core language classes:
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/package-tree.html
The hierarchy concept is so entangled in pure OOP such that OOP is
erroneously thought of as languages with a hierarchy. (there are now
also so-called Object-Oriented databases that are centered on the
concept of all data are trees ...)
Normally in a program, when we want to do some operation we just call
the subroutine on some data. Such as
open(this_file)
square(4)
But now with the pure OOP style, there can no longer be just a number
or this_file path, because everything now must be a Object. So, the
"this_file", usually being just a string representing the path to a
file on the disk, is now some "file object". Initiated by something
like
this_file = new File("path to file");
where this file class has a bunch of methods such as reading or writing
to it.
see this page for the complexity of the IO tree
http://java.sun.com/j2se/1.4.2/docs/api/java/io/package-tree.html
see this page for the documentation of the File class itself, along
with its 40 or so methods and other things.
http://java.sun.com/j2se/1.4.2/docs/api/java/io/File.html
Tomorrow i shall cover more manmade jargons and complexities arising
out of the OOP hype, in particular Java.
instantiation
initializer, constructor, assessor
access level specifier
abstract class and abstract methods
instance methods and class methods
interface, inheritance, polymorphism.
Xah
xah@xahlee.org
http://xahlee.org/PageTwo_dir/more.html
------------------------------
Date: Fri, 28 Jan 2005 18:40:33 -0500
From: "Dan Perl" <danperl@rogers.com>
Subject: Re: what's OOP's jargons and complexities?
Message-Id: <U9udnT2lOZ7rUGfcRVn-uA@rogers.com>
"Xah Lee" <xah@xahlee.org> wrote in message
news:1106953849.915440.134710@f14g2000cwb.googlegroups.com...
> public class test {
> public static void main(String[] args) {
> String a = new String("a string");
> String b = new String("another one");
> StringBuffer c = new StringBuffer(40);
> c.append(a); c.append(b);
> System.out.println(c.toString());
> }
> }
Actually, it can be as simple as:
public class test {
public static void main(String[] args) {
String c = new String("a string"+" another one");
System.out.println(c);
}
}
I will not get into your "history" of the "OOP hype".
------------------------------
Date: Fri, 28 Jan 2005 18:44:14 -0500
From: "Dan Perl" <danperl@rogers.com>
Subject: Re: what's OOP's jargons and complexities?
Message-Id: <lbGdnWA8a7HOU2fcRVn-rA@rogers.com>
"Dan Perl" <danperl@rogers.com> wrote in message
news:U9udnT2lOZ7rUGfcRVn-uA@rogers.com...
> Actually, it can be as simple as:
> public class test {
> public static void main(String[] args) {
> String c = new String("a string"+" another one");
> System.out.println(c);
> }
> }
I forgot. It can be even simpler:
public class test {
public static void main(String[] args) {
System.out.println("a string"+" another one");
}
}
------------------------------
Date: Fri, 28 Jan 2005 19:02:07 -0500
From: Martin Ambuhl <mambuhl@earthlink.net>
Subject: Re: what's OOP's jargons and complexities?
Message-Id: <360244F4lolueU1@individual.net>
Dan Perl wrote:
> Actually, it can be as simple as:
> public class test {
There is no "public" or "class" in C. Please don't post such trash to
comp.lang.c. In fact, C++ is not topical in any of the five newsgroups
you posted to. I don't know where you're posting from, so I apologize to
the perl, python, lisp, scheme, and C people who see this in their
newsgroups. Followup-To set to comp.lang.c++ where you can play with
your bloated language all you wish.
------------------------------
Date: Sat, 29 Jan 2005 00:06:39 GMT
From: Keith Thompson <kst-u@mib.org>
Subject: Re: what's OOP's jargons and complexities?
Message-Id: <ln7jlxp08h.fsf@nuthaus.mib.org>
"Xah Lee" <xah@xahlee.org> writes:
[snip]
If you must post a followup to this, please drop comp.lang.c from the
newsgroups header. I can't speak for the other newsgroups, but it's
definitely off-topic here in comp.lang.c. Thank you.
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
------------------------------
Date: Fri, 28 Jan 2005 19:09:17 -0500
From: Martin Ambuhl <mambuhl@earthlink.net>
Subject: Re: what's OOP's jargons and complexities?
Message-Id: <3602hiF4tvskbU1@individual.net>
Xah Lee wrote his usual masturbatory crap:
Lisp is not topical in 3 of the 5 newsgroups you spewed on.
Java is not topical in 5 of the 5 newsgroups you spewed on.
Get your head out your butt and post to Java newsgroups if you want and
they'll have you. Are you inflicting this crap on the rest of us
because the Java people know you to be a troll?
Followup-to set to comp.lang.java.advocacy where it might belong.
------------------------------
Date: Fri, 28 Jan 2005 20:19:19 -0500
From: Eric Sosman <esosman@acm-dot-org.invalid>
Subject: Re: what's OOP's jargons and complexities?
Message-Id: <kuSdnb05PpgDeWfcRVn-pA@comcast.com>
Xah Lee wrote:
> [...]
> Tomorrow i shall cover more manmade jargons and complexities arising
> out of the OOP hype, in particular Java. [...]
I hope you will not, or that if you do so you will
do it elsewhere. Go pound sand.
--
Eric Sosman
esosman@acm-dot-org.invalid
------------------------------
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 V10 Issue 7707
***************************************
