Perl programmers live in regular expressions. It's home to us. We aren't afraid of them, and do stuff with them that other programmers pale at.

From what I can tell based on the contents of Javascript manuals including such esteemed works as O'Reilly books, Javascript programmers are terrified of regular expressions. They are mentioned briefly and only demonstrated in the most absolute simple sense.

Perl programmers will thus be annoyed when trying to work out how to do them and use them, but they're there and while Javascripts way of dealing with them is a little bit convoluted, it's no slouch in doing them.

Okay, I've decided I need to learn Javascript. I mean, I can write a fair amount of it and all, but it'd be nicer to not feel like I'm hacking it and actually fully *understand* it.

One thing I wish there were books on is how to program in language X if you already know language Y. Unfortunately, there aren't any out there that I know of. I think such books would sell. C++ for Visual Basic programmers, or Java for C++ programmers, etc, etc. Some might reach being esoterica. PHP for Ruby developers wouldn't have a huge market, I'll admit. But it'd still sell better than Pike for Lispers.

But no dice. So in the interests of making myself actually *grasp* Javascript better, I'm going through a book on it starting with the absolute basics, even shit I already know -- BUT, it's good to start, and maybe if other perl programmers stubmie across this it'll help them too, and then I'm being nice.

So, without further ado, here we go starting with just strings.

On http://hell.jedicoder.net/?p=82 the poster mentions spawning a bunch of child processes and waiting for them all to finish, but you use an array to store them and then call waitpid on each in turn.

The thing is, this is at least to me a little counterintuitive. If the first child process takes a lot longer than the later called ones, it could lead to a 'sudden blast' when the slow process returns and then the others do (in case you wanted to do certain things after each one). Also you only know when it's all done, really. There are ways to code to make it obvious what's finishing that I prefer.

The approach I take is more like this:

my %kids;

my $subs = {one => sub { print "One!\n"},
            two => sub { print "Two!\n"},
            three => sub { print "Three vonderful anonymous functions!\n" }};
 
for my $s (qw(one two three)) {
    my $pid = fork;
    die "Can't fork!\n" unless defined $pid;
    if ($pid) { # parent
        $kids{$pid} = $s;
    }
    else { # child
        &{$subs->{$s}};
        exit;
    }
}

while (keys $kids) {
    my $dead = wait;
    print "   Watcher loop sez: Finished $kids{$dead}\n";
    delete $kids{$dead};
}

print "Mwa Ha Ha Ha Ha! *thunder*\n";