Perl

Perl is a highly capable, feature-rich programming language renowned for powerful regular expression processing, system administration automation, and robust text transformation.

When to Use

• Text Processing & Regex Data Extraction: Rapidly parsing unstructured log files, reports, and legacy data streams.
• Legacy System Administration & DevOps: Maintaining established Unix/Linux automation scripts and cron jobs.
• Bioinformatics & Scientific Data Wrangling: Processing genomic sequencing data and legacy scientific FASTA records.
• Maintaining Classic CPAN Applications: Supporting production enterprise backends built on Catalyst, Mojolicious, or Dancer.

Quick Start

#!/usr/bin/env perl
use strict;
use warnings;
use feature 'say';

my %scores = ( Alice => 95, Bob => 88, Charlie => 92 );

for my $name (sort keys %scores) {
    say "$name scored $scores{$name}";
}

Core Concepts

Regular Expressions as First-Class Language Primitives

Perl regular expressions are deeply integrated into language syntax:

use strict;
use warnings;
use v5.36;

my $log_entry = '[2026-09-27 10:15:30] ERROR: Payment gateway timeout (code 504)';

if ($log_entry =~ /\[(.*?)\]\s+(\w+):\s+(.*)/) {
    my ($timestamp, $severity, $message) = ($1, $2, $3);
    say "Timestamp: $timestamp";
    say "Severity:  $severity";
    say "Message:   $message";
}

Modern Perl (v5.36+ / v5.38+) Native Subroutine Signatures

Replaces manual @_ unpacking with native typed signatures and experimental class features:

use v5.38;
use experimental 'class';

class Account {
    field $balance :param = 0;

    method deposit($amount) {
        $balance += $amount;
        return $balance;
    }

    method get_balance() { return $balance; }
}

my $acc = Account->new(balance => 100);
$acc->deposit(50);
say "Balance: ", $acc->get_balance(); # 150

Context Awareness (Scalar vs List Context)

Functions dynamically change return values based on whether a scalar or list is expected:

my @items = ("apple", "banana", "cherry");
my $count = @items;     # Scalar context returns array count: 3
my ($first) = @items;   # List context returns first element: "apple"

Common Patterns

Robust File Parsing with Regular Expressions

Problem: Extracting structured fields from inconsistent log files.

Solution: Use strict mode with named regex capture groups:

use strict;
use warnings;
use feature 'say';

while (my $line = <DATA>) {
    chomp $line;
    if ($line =~ /^\[(?<timestamp>[^\]]+)\]\s+(?<level>INFO|WARN|ERROR)\s+(?<msg>.*)$/) {
        say "Time: $+{timestamp} | Level: $+{level} | Message: $+{msg}";
    }
}

__DATA__
[2025-03-01 12:00:00] INFO Server started successfully
[2025-03-01 12:01:23] ERROR Database connection failed

Best Practices

Do:

• Always Declare use strict; use warnings;: Eliminate dangerous silent global variables and undeclared lexical bugs.
• Use use v5.36; or Higher: Automatically enables strict, warnings, modern subroutine signatures, and say syntax.
• Use Mojolicious for Web APIs: Build modern non-blocking web backends and WebSockets with Mojolicious.
• Manage Dependencies with cpanm and Carton: Isolate project dependencies locally in local/ rather than modifying system Perl.

Don't:

• Use single-character global punctuation variables: Replace $@, $/, and $_ with readable English module aliases or modern signatures.
• Use two-argument open: Always use 3-argument open (open(my $fh, "<", $filename)) with lexical filehandles.
• Write new OO code with bare blessed hashes: Use modern use v5.38; use experimental 'class'; or Moo/Moose.

Troubleshooting

References

• Perl.org