Happy Perl Devs

I’m kinda amused to see this old post suggesting that perl developers are happier than other developers. I can well believe it. I’ve always been happy playing with perl than the other languages I know, although I’m not quite convinced by the method.

Just a thought though – personally, I’m happier on smaller code bases than larger code bases. Could it be that perl sees more use for moderately sized systems and other languages are used to create developer depressing byzantine balls of mud?


I recommend Dave Rolsky

I can’t believe Dave is still on the job market.

I don’t know him personally, but I know him by his posts and his code and I can recommend him without hesitation. The guy is one of the great thinkers of the Perl Community.

If I had hiring authority, I’d get him for my firm.

Last time, I linked to some example code that forks a bunch of processes and communicates with them via pipes. This is the main feature of the code I’m interested in, but the explanation is the article is kinda sparse so you can consider this to be supplemental.

As usual, the perl doco is pretty good for covering this stuff.

Creating a child process (a kid) involves two pipes, one for the parent to send data to the kid, and one for the kid to send data back to the parent.

One probably obvious thing to note, you can’t directly send a reference down a pipe, (well, not in any reasonable way and that’s a feature, not a bug), so you’ll be interested in serialisation modules. I’ve mentioned them in passing before and I generally use JSON::XS these days.

Another hopefully obvious thing is if the writer is buffered and the reader is waiting for something specific, there will probably be some deadlock in your future. Remember to unbuffer the writer.

I made a couple more J – comments inline:

sub create_kid {
    my $to_kid = IO::Pipe->new;
    my $from_kid = IO::Pipe->new;

    # J - Fork returns undef for failure, 0 for the child, and the
    # J - child PID for the parent

    # J - Handle fork error
    defined (my $kid = fork) or return; # if can't fork, try to make do

    unless ($kid) { # I'm the kid
      # J - The kid reads from $to_kid and writes to $from_kid

      # J - unbuffer writing to the pipes.  Otherwise may deadlock

      # J - Reset all of the signal handling
      $SIG{$_} = 'DEFAULT' for grep !/^--/, keys %SIG; # very important!
      do_kid($to_kid, $from_kid);
      exit 0; # should not be reached

    # J - parent here...
    # J - The parent reads from $from_kid and writes to $to_kid

    # J - unbuffer writing to the pipes.  Otherwise may deadlock

    $kids{$kid} = [$to_kid, $from_kid];

Parallel Tasks using Fork

Randal Schwartz wrote an example link checker which used forked processes to run tasks in parallel. Each child process created has a read pipe from and a write pipe to the parent (created with IO::Pipe).

The result is an inverted version of my preferred architecture. I like the parent to dump work on a queue and whichever child is ready to pull it off. This is pretty easy to do with threads.

In Randal’s version, the parent figures out which child is available to do work.

My grub menu finally got scrollbars so I decided to look into how to remove old linux kernels.

The easiest instructions I found are here.

I checked which kernels are installed in /boot.

$ ls /boot/vmlinuz*
/boot/vmlinuz-2.6.32-29-generic  /boot/vmlinuz-2.6.32-30-generic

And then removed everything apart from current and one version back.

sudo apt-get remove - --purge 2.6.32-28-*

My question about how windows works without fork got pointers to two useful Windows perl modules in the comments:

Spawning External Programs

(from dagolden) See Win32::Job or just use system(1, $cmd, @args)

Creating Daemons

(from Christian Walde) Use Win32::Detached

What I was really wondering about was how reliable software was written without fork. What do I mean by that?

What is the difference between?




If the child thread misbehaves – exits, dumps core, leaks memory, or whatever, that’s bad for the parent. Child processes can’t wreak quite so much havoc.

Presumably the solution adopted in Window is don’t do stuff in threads that causes them to accidentally exit [the whole process], dump core or leak memory.

How does windows work without fork? So many things start with a call to fork: starting a new process (fork/exec), creating a daemon, creating independent tasks within one program…

The nice thing about all of these things is, if a new process goes bad, it probably won’t take out the parent process. You don’t get the same safety with a thread. Therefore, fork is the basis of a lot of my reliable software.

I’m fairly confident that windows doesn’t have anything similar to fork. Otherwise the perl fork emulation could simply wrap whatever windows has. Sadly it doesn’t quite work that nicely.

While the emulation is designed to be as compatible as possible with the real fork() at the level of the Perl program, there are certain important differences that stem from the fact that all the pseudo child "processes" created this way live in the same real process as far as the operating system is concerned.

If the parent process is killed (either using Perl’s kill() builtin, or using some external means) all the pseudo-processes are killed as well, and the whole process exits.

I have been approaching this problem of reliable windows software from too low a level. Rather than copying what I do on Unix and start with fork (using Perl more or less as my OS wrapper), I now use web servers to manage my processes.