[12009] in Perl-Users-Digest
Perl-Users Digest, Issue: 5610 Volume: 8
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Sun May 9 23:07:17 1999
Date: Sun, 9 May 99 20:01:27 -0700
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Sun, 9 May 1999 Volume: 8 Number: 5610
Today's topics:
Re: Sorting is too slow for finding top N keys... - UPD (Larry Rosler)
Re: Sorting is too slow for finding top N keys... - UPD (Sam Holden)
Re: Sorting is too slow for finding top N keys... - UPD (Michel Dalle)
Re: Sorting is too slow for finding top N keys... - UPD (Bart Lateur)
Re: Sorting is too slow for finding top N keys... - UPD (Larry Rosler)
Re: Sorting is too slow for finding top N keys... - UPD (Michel Dalle)
Re: Sorting is too slow for finding top N keys... - UPD (Larry Rosler)
String manipulation... <fdjohns@home.com>
Re: String manipulation... <wyzelli@yahoo.com>
Re: String manipulation... <gellyfish@gellyfish.com>
Re: undefined statements in perl?? (Larry Rosler)
Re: using $, (was Re: having problems) (Kevin Reid)
Re: what does the following do? (Larry Rosler)
Re: Why does NT server return the actual script, not th <wyzelli@yahoo.com>
Re: Why does NT server return the actual script, not th (R. S.)
Special: Digest Administrivia (Last modified: 12 Dec 98 (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: Sun, 9 May 1999 00:24:20 -0700
From: lr@hpl.hp.com (Larry Rosler)
Subject: Re: Sorting is too slow for finding top N keys... - UPDATE
Message-Id: <MPG.119ed7eeab3e6d6e989a17@nntp.hpl.hp.com>
In article <MPG.119e6dcfb2e6900c989a14@nntp.hpl.hp.com> on Sat, 8 May
1999 16:51:14 -0700, Larry Rosler <lr@hpl.hp.com> says...
...
> Just for fun, I recoded your algorithm a bit more compactly. It seems
> to work fine with small artificial data sets. I'd be interested in how
> it works on your big hash.
<SNIP of first draft of function>
> Yum. That looks like something for the Perl Function Repository. If
> time permits, I'll write up the description and submit it, with due
> credit for your ideas.
Time did permit! Here is the second draft of the function, with several
generalizations. Either arrays or hashes can be sorted; either
lexicographic or numeric sorting can be specified; either the minima or
the maxima may be extracted.
Anyone who is interested, please review and suggest improvements in the
code and the description. Are there similar capabilities in CPAN?
***********************************************************************
#!/usr/local/bin/perl -w
use strict;
my @array = ( 'A' .. 'Z', 'A' .. 'Z' );
print extremes(\@array, 20), "\n"; # lexicographic, minima
my %hash;
@hash{ 'a' .. 'z', 'A' .. 'Z' } = ( 1 .. 26, 1 .. 26 );
print extremes(\%hash, 20, 1, 1), "\n"; # numeric, maxima
sub extremes {
my ($ref, $n, $num, $max) = @_;
$max = $max ? -1 : +1;
my @out;
if (ref $ref eq 'ARRAY') {
for (my $j = 0; $j < @$ref; ++$j) { # Get one element at a time.
my $val = $ref->[$j];
next if @out == $n && $max == ($num ? $val <=> $out[-1]
: $val cmp $out[-1]);
my $i = 0;
++$i while $i < @out && $max == ($num ? $val <=> $out[$i]
: $val cmp $out[$i]);
splice @out, $i, 0, $val;
--$#out if @out > $n;
}
} elsif (ref $ref eq 'HASH') {
while (my ($key, $val) = each %$ref) {
next if @out == $n &&
$max == ($num ? $val <=> $ref->{$out[-1]}
: $val cmp $ref->{$out[-1]});
my $i = 0;
++$i while $i < @out &&
$max == ($num ? $val <=> $ref->{$out[$i]}
: $val cmp $ref->{$out[$i]});
splice @out, $i, 0, $key;
--$#out if @out > $n;
}
}
@out
}
# extremes() returns the extreme N values of a list, or the keys of the
# extreme N values of a hash. When the aggregate is very large and the
# number of values N is relatively small, this function is much more
# efficient than sorting the entire aggregate and returning a slice from
# the appropriate end of the sorted list.
#
# extremes(ref, n, num, max)
# ref = reference to array or hash
# n = maximum number of elements to return
# num = sort numeric if TRUE, sort lexicographic if FALSE
# max = maxima descending if TRUE, minima ascending if FALSE
#
# Trailing FALSE arguments may be omitted. More complex sorting
# comparisons may be inserted into the code of the function.
#
# The algorithm for this function, and an initial implementation, were
# presented by Michel Dalle, 8 May 1999.
#
# Larry Rosler, 9 May 1999
__END__
Output:
AABBCCDDEEFFGGHHIIJJ
zZyYxXwWvVuUtTsSrRqQ
--
(Just Another Larry) Rosler
Hewlett-Packard Company
http://www.hpl.hp.com/personal/Larry_Rosler/
lr@hpl.hp.com
------------------------------
Date: 9 May 1999 08:07:33 GMT
From: sholden@pgrad.cs.usyd.edu.au (Sam Holden)
Subject: Re: Sorting is too slow for finding top N keys... - UPDATE
Message-Id: <slrn7jagi5.3sp.sholden@pgrad.cs.usyd.edu.au>
On Sun, 9 May 1999 00:24:20 -0700, Larry Rosler <lr@hpl.hp.com> wrote:
>In article <MPG.119e6dcfb2e6900c989a14@nntp.hpl.hp.com> on Sat, 8 May
>
>Time did permit! Here is the second draft of the function, with several
>generalizations. Either arrays or hashes can be sorted; either
>lexicographic or numeric sorting can be specified; either the minima or
>the maxima may be extracted.
>
>Anyone who is interested, please review and suggest improvements in the
>code and the description. Are there similar capabilities in CPAN?
What about being taking a coderef to do the comparison, instead of
only being able to use numeric or lexical order. Keeping those when
no coderef is provided would be nice too (since it would be much
faster I suspect without a sub call for every comparison). That would
make it more like the sort function, and possibly more useful.
--
Sam
Many modern computer languages aspire to be minimalistic. They either
succeed in being minimalistic, in which case they're relatively useless,
or they don't succeed in being truly minimalistic, in which case you can
actually solve real problems with them. --Larry Wall
------------------------------
Date: Sun, 09 May 1999 10:24:17 GMT
From: michel.dalle@usa.net (Michel Dalle)
Subject: Re: Sorting is too slow for finding top N keys... - UPDATE
Message-Id: <7h3nn1$68t$1@xenon.inbe.net>
In article <MPG.119e6dcfb2e6900c989a14@nntp.hpl.hp.com>, lr@hpl.hp.com (Larry Rosler) wrote:
>[Posted and a courtesy copy sent.]
>
>In article <7h260m$t07$1@xenon.inbe.net> on Sat, 08 May 1999 20:16:09
>GMT, Michel Dalle <michel.dalle@usa.net> says...
>> In article <7h24na$sfp$1@xenon.inbe.net>, michel.dalle@usa.net (Michel Dalle)
> wrote:
>....
>> >Here's what happened : I have a hash with about 30.000 entries,
>> >I want to sort them by value and extract the top N elements.
>> >The hash contains about 500 different values, and the majority
>> >of values are all the same (=heavy-tailed distribution?).
>....
>> 3) forget about the sort in Perl, and build my own :
[code snipped]
>> This one sorts my 30.000+ hash in 3 seconds, the previous one in 45 seconds,
>> and the first one in xxx minutes, for a top 20.
>>
>> Any comments ?
>
>Yes.
>
>The complexity of the Perl quicksort is O(M log M) where M is the number
>of elements in the hash (you said about 30_000).
>
>The complexity of your repeated insertion sorts is O(M N**2) where N is
>the number of elements in the topN list (you said 20).
>
>Clearly, for large enough M and small enough N, your algorithm will be
>faster than sorting the entire input and selecting the top N elements.
>Equally clearly, your M is large enough and your N is small enough. :-)
>
>Just for fun, I recoded your algorithm a bit more compactly. It seems
>to work fine with small artificial data sets. I'd be interested in how
>it works on your big hash.
[code snipped]
Well, Larry's takes 5 seconds, while mine takes 3 seconds. But it's a
lot more Perl-like :-)
Sorry that I'm not another Perl hacker, but where does the $topn[-1] come from
?
BTW, I understand the O(M log M), but why does it take seconds to
sort a list with random numbers between 1 and 30000, and minutes
to sort a list with a lot of equal numbers ?
The distribution of the data I use is the following :
<value> <number times in the hash>
1 22879
2 4721
3 1571
4 667
5 361
6 219
7 130
8 99
9 62
10 47
11 44
12 29
13 29
14 28
15 22
16 21
17 11
20 9
22 9
18 7
28 6
21 4
27 4
31 4
23 3
25 3
30 3
37 3
19 2
24 2
29 2
32 2
41 2
26 1
33 1
50 1
52 1
56 1
59 1
79 1
(that's 31012 entries)
Thanks for that generic code,
Michel.
--
aWebVisit - extracts visitor information from WWW logfiles and shows
the top entry, transit, exit and 'hit&run' pages, the links followed
inside your website, the time spent per page, the visit duration etc.
For more details, see http://gallery.uunet.be/Michel.Dalle/awv.html
------------------------------
Date: Sun, 09 May 1999 10:39:25 GMT
From: bart.lateur@skynet.be (Bart Lateur)
Subject: Re: Sorting is too slow for finding top N keys... - UPDATE
Message-Id: <373662ea.3864468@news.skynet.be>
Michel Dalle wrote:
>>Here's what happened : I have a hash with about 30.000 entries,
>>I want to sort them by value and extract the top N elements.
>>The hash contains about 500 different values, and the majority
>>of values are all the same (=heavy-tailed distribution?).
>>
>>1) the simple (obvious) way would be to let Perl do the job :
>>
>>@topn = (sort {$hash{$b} <=> $hash{$a}} keys %hash)[0..$n];
>>
>>This works fine for random values (a few seconds), but for the
>>hash I have, it takes several minutes !!
Since you have far fewer values than keys, it might be a good idea to
alter the problem space, so that you group the keys per value (invert
the hash), sort those values, and then get the associated keys back.
%hash = ( one => 1, two => 2, three => 3,
un => 1, deux => 2, trois => 3);
my %keys;
foreach(keys %hash) {
push @{$keys{$hash{$_}}},$_;
}
@sortedvalues = sort { $a <=> $b } keys %keys;
local($\,$,) = ("\n",": "); #prinout formatting
foreach $value (@sortedvalues) {
foreach $key (@{$keys{$value}}) {
print $key,$value;
}
}
Bart.
------------------------------
Date: Sun, 9 May 1999 04:29:31 -0700
From: lr@hpl.hp.com (Larry Rosler)
Subject: Re: Sorting is too slow for finding top N keys... - UPDATE
Message-Id: <MPG.119f1175446df28e989a18@nntp.hpl.hp.com>
In article <slrn7jagi5.3sp.sholden@pgrad.cs.usyd.edu.au> on 9 May 1999
08:07:33 GMT, Sam Holden <sholden@pgrad.cs.usyd.edu.au> says...
> On Sun, 9 May 1999 00:24:20 -0700, Larry Rosler <lr@hpl.hp.com> wrote:
> >In article <MPG.119e6dcfb2e6900c989a14@nntp.hpl.hp.com> on Sat, 8 May
> >
> >Time did permit! Here is the second draft of the function, with several
> >generalizations. Either arrays or hashes can be sorted; either
> >lexicographic or numeric sorting can be specified; either the minima or
> >the maxima may be extracted.
> >
> >Anyone who is interested, please review and suggest improvements in the
> >code and the description. Are there similar capabilities in CPAN?
>
> What about being taking a coderef to do the comparison, instead of
> only being able to use numeric or lexical order. Keeping those when
> no coderef is provided would be nice too (since it would be much
> faster I suspect without a sub call for every comparison). That would
> make it more like the sort function, and possibly more useful.
I agree with your suggestion. I decided to hold that for the third
draft. It was very late when I decided to post what I had (and now it's
very early. :-).
I imagine it entails using the global variables $a and $b as aliases to
the operands being compared (so the function will look like sort(), as
you say). If anyone has done something similar, I'd appreciate a few
pointers or hints, so I have one fewer wheel to reinvent.
In the meantime, as I commented, one can edit the source code to suit.
--
(Just Another Larry) Rosler
Hewlett-Packard Company
http://www.hpl.hp.com/personal/Larry_Rosler/
lr@hpl.hp.com
------------------------------
Date: Sun, 09 May 1999 11:57:38 GMT
From: michel.dalle@usa.net (Michel Dalle)
Subject: Re: Sorting is too slow for finding top N keys... - UPDATE
Message-Id: <7h3t61$98b$1@xenon.inbe.net>
In article <373662ea.3864468@news.skynet.be>, bart.lateur@skynet.be (Bart Lateur) wrote:
[snip]
>Since you have far fewer values than keys, it might be a good idea to
>alter the problem space, so that you group the keys per value (invert
>the hash), sort those values, and then get the associated keys back.
>
> %hash = ( one => 1, two => 2, three => 3,
> un => 1, deux => 2, trois => 3);
>
> my %keys;
> foreach(keys %hash) {
> push @{$keys{$hash{$_}}},$_;
> }
>
> @sortedvalues = sort { $a <=> $b } keys %keys;
>
> local($\,$,) = ("\n",": "); #prinout formatting
> foreach $value (@sortedvalues) {
> foreach $key (@{$keys{$value}}) {
> print $key,$value;
> }
> }
>
> Bart.
Excellent ! I didn't think of that little trick...
This takes between 2 and 3 seconds (= at least as good as my solution 3),
and it sorts the whole thing rather than just the top N. The only drawback
I see is that you need another hash as big as the first one, rather than
just an array of size N, and that may be a problem (for me at least).
The results so far (on my home PC) :
Michel1 --> xx minutes
Michel2 --> 45 seconds
Michel3 --> 3 seconds
Larry1 --> 5 seconds
Larry2 --> untested (but same approach as Larry1)
Bart1 --> 2-3 seconds
Andy1 --> untested (but similar to Michel2)
I'll do some more detailed benchmarks when I get back to a decent computer,
and post the results later on...
Meanwhile, if you have any other approaches, feel free to post them :-)
Michel.
--
aWebVisit - extracts visitor information from WWW logfiles and shows
the top entry, transit, exit and 'hit&run' pages, the links followed
inside your website, the time spent per page, the visit duration etc.
For more details, see http://gallery.uunet.be/Michel.Dalle/awv.html
------------------------------
Date: Sun, 9 May 1999 04:52:09 -0700
From: lr@hpl.hp.com (Larry Rosler)
Subject: Re: Sorting is too slow for finding top N keys... - UPDATE
Message-Id: <MPG.119f16c8bafa2538989a19@nntp.hpl.hp.com>
[Posted and a courtesy copy sent.]
In article <7h3nn1$68t$1@xenon.inbe.net> on Sun, 09 May 1999 10:24:17
GMT, Michel Dalle <michel.dalle@usa.net> says...
> In article <MPG.119e6dcfb2e6900c989a14@nntp.hpl.hp.com>, lr@hpl.hp.com (Larry Rosler) wrote:
...
> >Just for fun, I recoded your algorithm a bit more compactly. It seems
> >to work fine with small artificial data sets. I'd be interested in how
> >it works on your big hash.
> [code snipped]
>
> Well, Larry's takes 5 seconds, while mine takes 3 seconds. But it's a
> lot more Perl-like :-)
The hit may come from the extra tests for direction and type of
comparison that are added to the main inner loop in the second draft.
This is part of the price for generality. Perhaps if you tailor your
copy back to the original simplicity, the speed will improve.
> Sorry that I'm not another Perl hacker, but where does the $topn[-1] come from
> ?
Negative indexes count down from the end of an array. So $topn[-1] is
the same as $topn[$#topn], just a bit more esthetic.
This question makes me think you tested the first draft, which doesn't
have the generality I referred to above. I would like to follow up on 5
sec vs 3 sec, because speed is what we're after here.
> BTW, I understand the O(M log M), but why does it take seconds to
> sort a list with random numbers between 1 and 30000, and minutes
> to sort a list with a lot of equal numbers ?
<SNIP distribution, but thanks. Those are concrete data to play with --
but not right now. :->
The O(M log M) behavior for quicksort is an average for random data.
The worst-case behavior for pathological data is O(M**2). Without my
Knuth or Sedgewick at hand, I recall that already sorted data is a
pathological case. Perhaps highly duplicated data is also.
> Thanks for that generic code,
That sounds like the second draft after all!
> Michel.
Larry
--
(Just Another Larry) Rosler
Hewlett-Packard Company
http://www.hpl.hp.com/personal/Larry_Rosler/
lr@hpl.hp.com
------------------------------
Date: Sun, 09 May 1999 09:06:55 GMT
From: "Forest Johns" <fdjohns@home.com>
Subject: String manipulation...
Message-Id: <PecZ2.16065$362.20002@news.rdc1.bc.wave.home.com>
If I had the following string: 164651_54464_154
How would I 'trim' it so that only the 154 remained in the variable? I have
been trying to find a good operator tutorial but can't seem to locate one.
Any ideas?
Thanks,
fdjohns@home.com
------------------------------
Date: Sun, 9 May 1999 19:21:41 +0930
From: "Wyzelli" <wyzelli@yahoo.com>
Subject: Re: String manipulation...
Message-Id: <6VcZ2.3$Mm3.717@vic.nntp.telstra.net>
Forest Johns <fdjohns@home.com> wrote in message
news:PecZ2.16065$362.20002@news.rdc1.bc.wave.home.com...
> If I had the following string: 164651_54464_154
>
> How would I 'trim' it so that only the 154 remained in the variable? I
have
> been trying to find a good operator tutorial but can't seem to locate one.
> Any ideas?
>
> Thanks,
> fdjohns@home.com
>
>
split on underscore and discard all but the last variable??
:^)
Wyzelli
------------------------------
Date: 9 May 1999 11:43:05 -0000
From: Jonathan Stowe <gellyfish@gellyfish.com>
Subject: Re: String manipulation...
Message-Id: <7h3sc9$4lm$1@gellyfish.btinternet.com>
On Sun, 09 May 1999 09:06:55 GMT Forest Johns wrote:
> If I had the following string: 164651_54464_154
>
> How would I 'trim' it so that only the 154 remained in the variable?
$string = '164651_54464_154';
$string = $1 if ( $string = /_(\d+)$/ );
Or
@array = split /_/,$string;
$string = $array[$#array];
Or
$string = substr($string,rindex($string,'_') + 1 );
Or
@array = split //,$string;
while(($char = pop @array ) ne '_' )
{
unshift @array2,$char;
}
$string = join '',@array2;
And so on ...
> I have
> been trying to find a good operator tutorial but can't seem to locate one.
> Any ideas?
>
perldoc perlop
/J\
--
Jonathan Stowe <jns@gellyfish.com>
Some of your questions answered:
<URL:http://www.btinternet.com/~gellyfish/resources/wwwfaq.htm>
Hastings: <URL:http://www.newhoo.com/Regional/UK/England/East_Sussex/Hastings>
------------------------------
Date: Sun, 9 May 1999 18:35:57 -0700
From: lr@hpl.hp.com (Larry Rosler)
Subject: Re: undefined statements in perl??
Message-Id: <MPG.119fd7d44f145411989a21@nntp.hpl.hp.com>
In article <373625A0.30F80392@erols.com> on Sun, 09 May 1999 20:17:36 -
0400, Matthew O. Persico <mpersico@erols.com> says...
...
> Now, if you had $n = $i++/$i++, you might have a quandry as there may be
> no standard as to which $i++ is performed first. For multiplication (or
> addition), who cares? 2 * 3 = 3 * 2. For division (or subtraction), it
> does make a difference as 2/3 != 3/2.
2/3 != 3/2 != 2/2 !!!
For multiplication, how would you like the result to be 2 * 2? This
would be perfectly acceptable in Standard C: Do the multiplication
first, then do an increment on each of the factors.
In Standard C, the results of these operations with side effects between
sequence points is not 'implementation-defined'. It is 'unspecified',
which means -- in essence -- anything goes. So don't write such
expressions.
The same assumption should be made about Perl.
--
(Just Another Larry) Rosler
Hewlett-Packard Company
http://www.hpl.hp.com/personal/Larry_Rosler/
lr@hpl.hp.com
------------------------------
Date: Sun, 9 May 1999 21:59:26 -0400
From: kpreid@ibm.net (Kevin Reid)
Subject: Re: using $, (was Re: having problems)
Message-Id: <1drhgdn.18u6h7p1m6gaf6N@[192.168.0.1]>
Larry Rosler <lr@hpl.hp.com> wrote:
> > >NUL is the PoB name for /dev/null. If you are using Unix, use
> > >'/dev/null' and there will be no file to write or remove.
> >
> > So you need OS dependant code.
>
> Yes, until someone writes File::Bitbucket. Most filenames are OS
> dependent.
package File::Bitbucket;
require Exporter;
@ISA = Exporter;
@EXPORT = qw($Bucket);
open BUCKET, (
$^O =~ /Win/i ? '> NUL' :
$^O =~ /MacOS/i ? '> Dev:Null' :
'> /dev/null'
) or die "Couldn't open bucket: $!";
$Bucket = *BUCKET{IO};
END {close BUCKET}
__END__
#!perl -w
use File::Bitbucket;
print $Bucket "bits...";
__END__
--
Kevin Reid: | Macintosh:
"I'm me." | Think different.
------------------------------
Date: Sun, 9 May 1999 18:38:52 -0700
From: lr@hpl.hp.com (Larry Rosler)
Subject: Re: what does the following do?
Message-Id: <MPG.119fd87e7982270b989a23@nntp.hpl.hp.com>
> In article <7h59gl$a87@catapult.gatech.edu> on 10 May 1999 00:33:25 GMT,
> Rahim Aladin <gt4530e@acmey.gatech.edu> says...
> > my($x, $y, $z) = (1,2,3);
> > (($x=$y) = $z);
> > ($x = ($y = $z));
> >
> > ok, i know the last two statements are both valid, but could someone tell
> > me what each of the last two statments actually do?? what is actually
> > going on in the two statements??
Just what they look like!
(($x=$y) = $z);
Assign $y to $x; lvalue is $x; assign $z to $x. x y z = 3 2 3
($x = ($y = $z));
Assign $z to $y; assign $y to $x. x y z = 3 3 3
The outer parentheses don't matter in either case; no parentheses matter
in the second case.
Cross-posted and followups set to comp.lang.perl.misc, because there's
no modules in here no-how!
--
(Just Another Larry) Rosler
Hewlett-Packard Company
http://www.hpl.hp.com/personal/Larry_Rosler/
lr@hpl.hp.com
------------------------------
Date: Sun, 9 May 1999 18:53:30 +0930
From: "Wyzelli" <wyzelli@yahoo.com>
Subject: Re: Why does NT server return the actual script, not the print items.
Message-Id: <PucZ2.2$Mm3.653@vic.nntp.telstra.net>
R. S. <rstacy@nf.sympatico.ca> wrote in message
news:3734ef5a.114521820@news1.sympatico.ca...
> I am attempting to have a perl script return anything to a browser but
> all I can get is the actual script itself. The .pl is associated with
> the perl.exe on the server and works when executed on the server but
> when I execute the script from a browser I get a copy of the script
> itself.
Ensure you have the 'run script' option enabled for the directory which
holds the script file.
Wyzelli
------------------------------
Date: Sun, 09 May 1999 10:46:17 GMT
From: rstacy@nf.sympatico.ca (R. S.)
Subject: Re: Why does NT server return the actual script, not the print items.
Message-Id: <37356431.144437315@news1.sympatico.ca>
On Sun, 9 May 1999 18:53:30 +0930, "Wyzelli" <wyzelli@yahoo.com>
wrote:
>R. S. <rstacy@nf.sympatico.ca> wrote in message
>news:3734ef5a.114521820@news1.sympatico.ca...
>> I am attempting to have a perl script return anything to a browser but
>> all I can get is the actual script itself. The .pl is associated with
>> the perl.exe on the server and works when executed on the server but
>> when I execute the script from a browser I get a copy of the script
>> itself.
>
>Ensure you have the 'run script' option enabled for the directory which
>holds the script file.
>
The server machine is NT4 with all permissions set for all
everyone,and all groups. I am assuming this is the run script
permission you are refering to.
I do suspect it is a MIME related setting on the Nt machine.
I read a ref taht I should add an entry in the registry something like
.pl: REG_SZ: C:\Reskit\Perl\BIN\perl.exe %s %s
The first %s being the path of the script and the second %s the query
string (comand line if + not used)
If anyone can enlighten me as to how this gets added ( Regedit can
mess up a system real bad) I would appreciate it .
I hve associated teh .pl extension in the "File Type" with my path to
Perl.exe which I again assume is what the registry entry does.
BTW I know the answer lies in reading the material which I will do
over the next few weeks. I am laying out some labs and need to set up
simple demos using both win32(NT) and UNIX(Linux) to demonstrate CGI,
ASP, DB, HTML & security...by tomorrow! All help greatly appreciated.
>Wyzelli
>
>
------------------------------
Date: 12 Dec 98 21:33:47 GMT (Last modified)
From: Perl-Request@ruby.oce.orst.edu (Perl-Users-Digest Admin)
Subject: Special: Digest Administrivia (Last modified: 12 Dec 98)
Message-Id: <null>
Administrivia:
Well, after 6 months, here's the answer to the quiz: what do we do about
comp.lang.perl.moderated. Answer: nothing.
]From: Russ Allbery <rra@stanford.edu>
]Date: 21 Sep 1998 19:53:43 -0700
]Subject: comp.lang.perl.moderated available via e-mail
]
]It is possible to subscribe to comp.lang.perl.moderated as a mailing list.
]To do so, send mail to majordomo@eyrie.org with "subscribe clpm" in the
]body. Majordomo will then send you instructions on how to confirm your
]subscription. This is provided as a general service for those people who
]cannot receive the newsgroup for whatever reason or who just prefer to
]receive messages via e-mail.
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.
To submit articles to comp.lang.perl.misc (and this Digest), send your
article to perl-users@ruby.oce.orst.edu.
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.
The Meta-FAQ, an article containing information about the FAQ, is
available by requesting "send perl-users meta-faq". The real FAQ, as it
appeared last in the newsgroup, can be retrieved with the request "send
perl-users FAQ". Due to their sizes, neither the Meta-FAQ nor the FAQ
are included in the digest.
The "mini-FAQ", which is an updated version of the Meta-FAQ, is
available by requesting "send perl-users mini-faq". It appears twice
weekly in the group, but is not distributed in the digest.
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 V8 Issue 5610
**************************************
