Here is the actual code of the entry:

  {do($_=qq($/(.+),$"h.+),local$/=join($,,@{[split($,,unpack("u*",
  ".<&]N9&5R+FUI+VQA<W$^P`"))]}[map{hex$_}split($,,"0139045A71382CDBAA6013"
  )]));open(_,$INC{$/});($_)=<_>=~$_}foreach($,,){$_=unpack("u*",
  q"05&AE(&QR95`@2F]U<FYA;```")};print"$_$/";

This is a slightly more verbose version of the same code:

  {
    # I split @a and @b up into separate variables
    # instead of just using them inline below...
    my @a = split($, , unpack("u*",".<&]N9&5R+FUI+VQA<W$^P`"));
    my @b = map { hex $_ } split($, , "0139045A71382CDBAA6013");
    do($_ = qq($/(.+),$"h.+),
       local $/ = join($, , @a[@b])
    );
    open(_,$INC{$/});
    ($_) = <_> =~ $_;
  }
  foreach($, ,) {
    $_ = unpack("u*", q"05&AE(&QR95`@2F]U<FYA;```")
  };
  print"$_$/";

The  print statement  on  the last  line  appears to  be printing  the
contents of  $_, followed by $/,  which contains "\n"  by default.  At
this  point you  must assume  that $_  contains the  string  "The Perl
Journal".   Looking at  the previous  block,  it would  seem that  the
unpack() statement  is returning the uuencoded version  of this string
and placing it into $_.  However, as you can see:

  $ perl -e 'print unpack("u*", q"05&AE(&QR95`@2F]U<FYA;```"),"\n";'
  The lreP Journal

This  $_  assignment is  actually  red  herring.   The foreach()  loop
aliases $_ to $, so $, is set to this string.

As you look farther up the code, you can see that $_ is assigned the
following statement:

  ($_) = <_> =~ $_;

This actually assigns $_ to  $1 returned from matching everything read
from the _ filehandle  against the regular expression that's currently
in $_. ($/ has  been set to a string that will  not be matched, so the
entire file will be read in).

The _ filehandle  is opened to the file stored  in $INC{$/}.  The do()
statement above  is what actually  sets $INC{$/}.  The  do() statement
has two arguments.   The first argument will assign  $_ to the regular
expression /\n(.+), h.+/ ($/ still  contains the newline at this point
and $" evaluates to an empty  space).  The second argument will set $/
to a  string concatenating the  values of @a  at each index in  @b ($,
contains  an  empty string  at  this  point).   Even though  the  do()
statement gets  two string  values, only the  second will be  found in
@INC, read, and executed.  When the file is found, it's full path will
be stored  in $INC{"file"},  which is where  the open() gets  the full
path.

$/ is  now set to a string  produced from some manipulation  of @a and
@b.  @a contains a list of characters in the decoding of the uuencoded
string ".<&]N9&5R+FUI+VQA<W$^P`":

  $ perl -e 'print unpack("u*", ".<&]N9&5R+FUI+VQA<W$^P`"),"\n";'
  ponder.mi/last

Although seeing this  string might make you think  you're on the wrong
track,  @a now  contains all  of  the different  characters needed  to
construct $/.   It's at this  point where you'll probably  realize why
this program  does not work  from the debugger (assuming  you've tried
that  and  haven't  already  figured  this  out).   Unlike  the  other
uuencoded  string,  this one  uses  regular  double-quotes which  will
interpolate the $^P in the string.  This will evaluate to 0 outside of
the debugger  and the uuencoded string  will be valid,  but inside the
debugger $^P will be a different numeric value.

@b actually  contains a list  of the indexes  of @a at this  point, as
decoded     from    the     hex     string    "0139045A71382CDBAA6013"
(0,1,3,9,0,4,5,10,7,1,3,8,2,12,13,11,10,10,6,0,1,3).   This  makes  $/
evaluate to the string "pod/perlmodinstall.pod":

ponder.mi/last
00000000001111
01234567890123

pod/perlmodinstall.pod
0000000100000111110000
0139045072382231006013

So,  do("pod/perlmodinstall.pod")   compiles  and  runs   a  POD  file
installed  along with  Perl (I  hope).  This  doesn't do  much, except
having the side effect  that $INC{'pod/perlmodinstall.pod'} is now set
to the full  path.  The open() below loads that  file, and the regular
expression /\n(.+),  h.+/ parses  out the one  time in this  file that
"The Perl Journal"  is mentioned.  The $/ assignment  is local to that
block so it is  returned to its original value of "\n"  for use in the
print statement.

There... wasn't that simple? :-)

The following assumptions are made about the environment in which the
screen is run:
  1) $/ contains something that will cause a line break on your system.
  2) $, is set to "".
  3) $" is set to " ".
  4) You have the perlmodinstall.pod page in a directory called pod
     somewhere in your @INC.

