Misconception: "Learning Perl Has No Career Value"

Part II · Module 16 · Chapter 16.9 · Misconception: "Learning Perl Has No Career Value"

1. The Claim Is About Writing

Split the claim in two and it stops being contentious.

"Learning to write new Perl has limited value." Broadly true. Chapter 16.4 reached that conclusion from measurements rather than taste, and nothing in Part II recommends starting a new project in Perl. If you are choosing one language to learn deeply for a career in this field, it is not this one.

"Learning to read Perl has limited value." This is the part that is wrong, and it is wrong for a reason that has nothing to do with Perl's merits. The code exists, it runs tonight, and somebody has to be able to open it.

So the question is not is Perl worth learning. It is what does it cost not to be able to read it — and that is measurable.

2. Measure the Reading Cost

Here is a short script of exactly the kind Chapter 16.3 said you will meet in your first month. Nothing in it is clever or obfuscated; it is ordinary, idiomatic Perl written by somebody competent.

use strict;
use warnings;
use File::Temp qw(tempdir);
use File::Spec;

my $dir = tempdir(CLEANUP => 1);
my $legacy = File::Spec->catfile($dir, "worst_path.pl");
open my $w, ">", $legacy or die "cannot write: $!\n";
print $w <<'LEGACY';
#!/usr/bin/perl
use strict;
my %dom;
while (<>) {
    next if /^\s*(?:#|$)/;
    chomp;
    my @f = split;
    next unless @f >= 3;
    my ($clk, $pin, $slack) = @f[0 .. 2];
    push @{ $dom{$clk} }, [ $pin, $slack ];
    $dom{$clk}[-1][1] =~ s/ns$//;
}
for my $c (sort keys %dom) {
    my @s = sort { $a->[1] <=> $b->[1] } @{ $dom{$c} };
    printf "%-10s %s %s\n", $c, $s[0][0], $s[0][1];
    print "-" x 30, "\n" if @s > 2;
}
exit(scalar(grep { $dom{$_}[0][1] < 0 } keys %dom) ? 1 : 0);
LEGACY
close $w;

open my $r, "<", $legacy or die "cannot read: $!\n";
my @line = <$r>;
close $r;
my $src = join "", @line;

# each row: an idiom a reader must ALREADY know, and the Part I chapter that
# teaches it. Every chapter number below was checked against the registry.
my @idiom = (
 [ '$_ used implicitly',          qr/while\s*\(<|^\s*next if \/|^\s*chomp;|\bsplit;/m, '9.7'  ],
 [ 'the bare <> diamond',         qr/<>/,                                              '15.1' ],
 [ 'split with no arguments',     qr/\bsplit\s*;/,                                      '15.8' ],
 [ 'array slice @f[0..2]',        qr/\@\w+\[[^\]]*\.\.[^\]]*\]/,                        '5.3'  ],
 [ 'hash of arrays, push @{...}', qr/push\s+\@\{/,                                      '7.7'  ],
 [ 'negative index [-1]',         qr/\[-1\]/,                                           '5.2'  ],
 [ 'chained subscripts [-1][1]',  qr/\]\s*\[/,                                          '7.4'  ],
 [ 'sort with $a and $b',         qr/sort\s*\{[^}]*<=>/,                                '5.9'  ],
 [ 'arrow omitted between subs',  qr/\$\w+\{\w*\}\[/,                                   '7.4'  ],
 [ 'string repetition with x',    qr/["'][^"']*["']\s*x\s*\d/,                          '3.10' ],
 [ 'grep in boolean context',     qr/\bgrep\s*\{/,                                      '5.10' ],
 [ 'exit with an expression',     qr/exit\s*\(/,                                        '15.4' ],
 [ 's/// on a nested lvalue',     qr/\$\w+\{[^}]*\}\[[^\]]*\]\[[^\]]*\]\s*=~/,          '11.13'],
 [ 'a regex as a bare condition', qr/^\s*next (?:if|unless) \//m,                       '11.2' ],
);

printf "%-32s %-9s %s\n", "PERL IDIOM A READER MUST KNOW", "present", "taught in";
my $need = 0;
for my $i (@idiom) {
    my ($label, $re, $ch) = @$i;
    my $hit = $src =~ $re ? "yes" : "-";
    $need++ if $hit eq "yes";
    my $row = sprintf("%-32s %-9s %s", $label, $hit, ($hit eq "yes" ? "Chapter $ch" : ""));
    $row =~ s/\s+\z//;
    print "$row\n";
}
my $loc = grep { /\S/ && !/^\s*#/ } @line;
printf "\n  %d lines of code; %d distinct idioms a reader must already know\n", $loc, $need;
printf "  = %.1f idioms per line\n\n", $need / $loc;

# and it is a real program: run it
open my $in, ">", File::Spec->catfile($dir, "sta.rpt") or die "cannot write: $!\n";
print $in "clk_core U1/Q 0.44ns\nclk_core U2/D -0.03ns\nclk_ddr U3/X -0.21ns\n";
close $in;
my $out = `cd '$dir' && perl worst_path.pl sta.rpt`;
my $rc  = $? >> 8;
print "  it runs, and this is what it does:\n";
print "     $_\n" for split /\n/, $out;
printf "     exit status %d (non-zero: a domain has negative slack)\n", $rc;

PERL IDIOM A READER MUST KNOW    present   taught in
$_ used implicitly               yes       Chapter 9.7
the bare <> diamond              yes       Chapter 15.1
split with no arguments          yes       Chapter 15.8
array slice @f[0..2]             yes       Chapter 5.3
hash of arrays, push @{...}      yes       Chapter 7.7
negative index [-1]              yes       Chapter 5.2
chained subscripts [-1][1]       yes       Chapter 7.4
sort with $a and $b              yes       Chapter 5.9
arrow omitted between subs       -
string repetition with x         yes       Chapter 3.10
grep in boolean context          yes       Chapter 5.10
exit with an expression          yes       Chapter 15.4
s/// on a nested lvalue          yes       Chapter 11.13
a regex as a bare condition      yes       Chapter 11.2

  17 lines of code; 13 distinct idioms a reader must already know
  = 0.8 idioms per line

  it runs, and this is what it does:
     clk_core   U2/D -0.03
     clk_ddr    U3/X -0.21
     exit status 1 (non-zero: a domain has negative slack)

Seventeen lines of code. Thirteen distinct idioms. Just under one per line.

And the point is not that Perl is cryptic. Look at what the list contains: an array slice, a negative index, a hash of arrays, a custom sort, grep, string repetition. Those are not obscure corners — they are the basic vocabulary, and the equivalents exist in every language. The difficulty is that Perl's spellings for them are specific to Perl, and a reader who does not know the spelling cannot guess it.

Three lines illustrate the whole problem:

while (<>) {

Reads every file named on the command line, or standard input if there are none, assigning each line to $_. Chapter 15.1 measured that it also empties @ARGV as it goes. None of that is visible in the six characters.

push @{ $dom{$clk} }, [ $pin, $slack ];

Appends an anonymous two-element array to an array that Perl creates automatically if $dom{$clk} did not exist. That autovivification is Chapter 7.9, and a reader who does not know it will look for the code that initialises the hash and not find any.

$dom{$clk}[-1][1] =~ s/ns$//;

Takes the pair just pushed, reaches into its second element, and strips a trailing ns in place. Three separate ideas — the omitted arrow, the negative index, substitution on a nested lvalue — in twenty-eight characters.

3. Why What Remains Is the Hardest Perl

This follows from Chapter 16.7's measurement rather than from any opinion, and it is the core of the answer.

A migration takes the scripts with the smallest interfaces first. Measured there: of four scripts, the one that goes first had an interface score of zero and the one that never gets done scored 32. So as a migration progresses, the average difficulty of the remaining Perl rises.

Put the two measurements together:

• the Perl that is left is the Perl that scored highest on replacement difficulty
• and a seventeen-line example of ordinary Perl already needs thirteen idioms

The surviving scripts are longer than seventeen lines, were written over two decades by several people, and are the ones whose behaviour nothing documents. They are harder than the example, not easier.

Meanwhile the number of people on the team who read Perl fluently is falling, because the new engineers learned Python. The supply of the skill drops exactly as the difficulty of the remaining code rises. That is the whole argument, and both halves of it are measurements from this module rather than assertions.

4. What the Value Actually Is, Concretely

This chapter will not estimate a salary effect or count job postings — nothing on this machine can check such a number, and Chapter 16.1 explained why this module does not publish figures it cannot verify. What it can do is name the concrete situations, which is more useful anyway.

You can diagnose a flow failure instead of escalating it. The regression reports a failure that is not a design bug. Being able to read the driver and see that it misinterpreted a log line is the difference between fixing it in an hour and waiting two days for the one person who knows.

You can answer questions about the flow in a review. "Why does this count as a failure?" has an answer in a script, and the person who can open the script is the person who answers.

You stop being blocked by infrastructure. This is the practical one. An engineer who cannot read the tools around their work is dependent on somebody else for a whole category of problem.

You can migrate it responsibly. Chapter 16.2's strangling requires reading the original well enough to record what it does. You cannot replace what you cannot read, and the attempt is how a rewrite ends up subtly different.

It is a one-time cost. Part I is fifteen modules and it is the whole language. Reading fluency does not need maintenance the way an evolving framework does — Perl 5 is stable, and what you learn stays true.

5. What To Remember

• The claim is about writing, and about writing it is broadly right. Chapter 16.4 agreed on measurement.
• Reading is a different skill, and the question is what it costs not to have it.
• Measured: a 17-line ordinary flow script needs 13 distinct Perl idioms — just under one per line.
• The idioms are basic vocabulary, not obscure corners: a slice, a negative index, a hash of arrays, a custom sort, grep, repetition.
• The difficulty is the spelling, not the concept. A reader who does not know Perl's spelling cannot guess it.
• while (<>) hides three behaviours in six characters, including emptying @ARGV.
• push @{ $dom{$clk} }, [...] relies on autovivification — a reader looks for the initialisation and finds none.
• The census under-counts — one idiom present did not fire. Thirteen is a floor.
• What remains after a migration is the hardest Perl, which follows from 16.7's scoring, not from opinion.
• Supply falls as difficulty rises — both halves measured in this module.
• No salary or job-posting figures appear here, deliberately; nothing available can verify one.
• Concretely it means: diagnosing instead of escalating, answering flow questions in a review, not being blocked, and migrating responsibly.
• You cannot replace what you cannot read — that is how a rewrite ends up subtly different.
• It is a one-time cost. Perl 5 is stable and what you learn stays true.
• Do not become the Perl person. Reading fluency is for not being blocked, not an identity.

Chapter 16.10 closes the module and opens the rest of Part II. Every tool built from here meets the same five conditions, and agreeing on that contract before building anything is what makes the tools reusable rather than a collection of scripts.