Naw, I'm too lazy today. Suffice it to say, if shell was so easy, Perl( and other scripting languages) would never have gained so much popularity. That is proof enough.

Well as far as modifying permissions and basic sys admin tasks, yes, shell is easy. I would tend to agree, it does have its limitations though. I was just hoping for an example of one of those limitations being done better in Perl.

Well as I was dreaming last night, I felt bad about not answering better. So I thought up a typical real world problem that one might face.

The problem:

You must search thru a list of subdirs, defined by a specific alpha-numeric pattern. In each of those subdirs, you must locate a specific file (defined by another alpha-numeric pattern), and search thru that file for a specific name(s), given on the commandline as options. You must include logic to account for abbreviation of the middle initial/name. When you find those names, extract an account number, and save them. Next, go to another list of subdirs( as defined by another alpha-numeric pattern) and search all files for that account number. If that account number(s) is found, add the file to a backup tarball, then delete the account number from the file, and save the resulting file to another tarball, in a directory named based on the account number. The tarballs cannot exceed 500 megs, and must named sequentially. When done with 1 in a sequence, transfer it thru SFTP to another computer, and email the account manager.

:-)

Now, I'm sure that this can be done with a multi-line shell script full of pipes , sed, % signs, echo, and grep; but you would need one heck of alot of shell expertise, and most people would not be able to follow it's logic, with all the pipes.

In Perl however, a clear script could be written, with intermediate arrays available for debugging printouts, etc.

I will concede that shell can be faster and simpler for some simple operations, BUT in general, it is hard to follow, and full of hard_to_decipher option lists and pipes, for most real world tasks. Sure, just recursively tarring up a directory is simple with the shell, but it's the other things that are usually needed, that cast shadows over shell and make Perl shine.

---

I'm not really a human, but I play one on earth Remember How Lucky You Are

I have an upload script that uses rsync over ssh to upload files to my webhost (now that I've finally moved to one that gives me ssh access, woo-hoo!). I first wrote it as shell. It went something like this:

#! /bin/sh
cd $(dirname $0)/site

# clear out garbage
find . -name '*~' | xargs rm

# what do we want to sync?
sync=$(ls | grep -v perllib | grep -v \\.xoops_)

# what do we not want to prune remotely?
remote_keep="*.ttc *.xoops_*"
remote_keep=$(for x in $remote_keep; do echo "--exclude=$x"; done)

# sync.
rsync -avz "$@" --delete -e 'ssh -l myuser' $remote_keep $sync myhost.
+com:
[download]

#!/usr/bin/perl

use File::Spec;
use FindBin;

# make sure we're in the right directory.
chdir File::Spec->catdir($FindBin::Bin, 'site');

# clear out garbage.
use File::Find;
find(
     sub {
         /~$/ and unlink
     }, '.');

# directories we want to sync...
my @sync = grep { -d $_ and
    !/perllib/ and
        !/\.xoops_/
} glob '*';

# remote directories we don't want to prune...
my @remote_keep = map {
    '--exclude=' . $_
} qw(*.ttc *.xoops_*);

# sync...
system(#qw(/bin/echo),
       qw(/usr/bin/rsync -avz), @ARGV,
       qw(--delete -e), 'ssh -l myuser',
       @remote_keep, @sync,
       qw(mysite.com:)
      );
[download]

The shell performed adequately. The perl version uses only three processes (perl and rsync and its ssh), and is easier to add more stuff to, IMO.