What would really help me is if you would rewrite

echo -e "abc\ndef\nghi\n" | perl -wlne '! /def/ and print "$_";'
[download]

for me with "-we" in place of "-wple" with all the short hand and defaults removed so I could see exactly what is going on.

Perl does that for you, at least the part after the pipe char, if you load B::Deparse (comments mine):

qwurx [shmem] ~> perl -MO=Deparse,-x -wlne '! /def/ and print "$_";'
BEGIN { $^W = 1; }                   # this is -w
BEGIN { $/ = "\n"; $\ = "\n"; }      # this is -l
LINE: while (defined($_ = <ARGV>)) { # and here is what -n does...
    chomp $_;                        # this belongs to -l
    print "$_" unless /def/;
}                                    # this belongs to -n too
-e syntax OK
[download]

The only line without comment is -e, i.e. your command line script body.

Here's another example - count lines, invented by Abigail:

perl -ne '}{ print $.'
[download]

The }{ construct - named eskimo greeting - splits the implicit while loop into a while loop block and a bare block:

perl -MO=Deparse,-x -ne '}{print$.'
LINE: while (defined($_ = <ARGV>)) {  # -n
    ();                               # script body - a noop
}                                     # script body
{                                     # script body
    print $.;                         # script body
}                                     # -n
[download]

The bare block is used to output the current line number of the (special) filehandle ARGV.

For instance, is "<>" short hand for "<STDIN>"?.

<> is a very common and useful shorthand notation. You'll often encounter this, and I recommend getting familiar with it, it really comes in handy every time you want to process user-supplied input.

The short version is that it Does What You Mean; I/O Operators has the nitty-gritty:

The null filehandle <> is special: it can be used to emulate the behavior of sed and awk, and any other Unix filter program that takes a list of filenames, doing the same to each line of input from all of them. Input from <> comes either from standard input, or from each file listed on the command line. Here's how it works: the first time <> is evaluated, the @ARGV array is checked, and if it is empty, $ARGV[0] is set to "-", which when opened gives you standard input. The @ARGV array is then processed as a list of filenames. The loop

while (<>) {
    ...            # code for each line
}
[download]

is equivalent to the following Perl-like pseudo code:

unshift(@ARGV, '-') unless @ARGV;
while ($ARGV = shift) {
    open(ARGV, $ARGV);
    while (<ARGV>) {
        ...        # code for each line
    }
}
[download]

except that it isn't so cumbersome to say, and will actually work. [...]

For the various flags to the perl executable, see perlrun. -n and -p put certain loops around your code, allowing you to write only the code inside the loop (very useful for one-liners on the command line); -l auto-chomps your input, which is useful in much the same situations.

Thank you Shmem!

I'm not shmem, but you're still welcome, partner! ;)