Perl Trainer

A fast orientation for engineers who already program. The smallest useful script, reading a file, looping, calling a subroutine, and the built-in documentation system — enough working Perl in the first session to start reading the scripts your team actually runs.

Topics: Hello world and running a script · Counting lines in a file · Using a loop in Perl · Using subroutines in Perl · Using Perl's documentation — perldoc, perlfunc, perlvar · One-liners with -e, -n and -p

• Assignments: (1) Write a one-liner that counts occurrences by field in a log file; (2) Answer three language questions using only perldoc
• Capstone: Produce a working first script that summarises a real log file

The mechanical rules and the conventions that separate maintainable Perl from write-only Perl. Whitespace, statement termination, comments, and formatting practice — plus strict and warnings, which should be on the first two lines of everything you write.

Topics: Understanding how Perl uses whitespace · Terminating statements with semicolons · Creating comments · Best practices for formatting code · use strict and use warnings · perltidy and perlcritic as standing checks

• Assignments: (1) Add strict and warnings to a legacy script and resolve every resulting error; (2) Run perlcritic over an inherited script and triage the findings
• Capstone: Establish a house style and lint baseline for a Perl repository

Perl's type system as it really works. Scalars for numbers and strings, arrays and lists, slices, hashes as the workhorse of operational Perl, the each function, and undef — with the sigil rules that confuse everyone until they are stated explicitly.

Topics: Understanding values and variables · Declaring numeric variables · Declaring character string variables · Declaring lists and arrays · Pulling slices from arrays · Understanding hashes and associative arrays · Getting value pairs using the each function · Understanding the undef value · Sigils and why they change with usage

• Assignments: (1) Build a hash of arrays from a delimited file and query it; (2) Explain the output of ten expressions that differ only in sigil or context
• Capstone: Model a host inventory as nested Perl data and produce a grouped report

How Perl code is assembled and where a variable lives. Assignment, expressions versus statements, blocks, and lexical versus package scope — the topic that explains most action-at-a-distance bugs in inherited scripts.

Topics: Assigning values to variables · Using statements and expressions · Combining statements into blocks · Understanding scope — my, our and local · Package variables and why local is not what it sounds like · Bare blocks and scoping tricks

• Assignments: (1) Fix a script that fails because a variable is package-scoped rather than lexical; (2) Demonstrate the difference between my, our and local in one script
• Capstone: Refactor a script with global state into properly scoped, testable units

Branching, including the postfix and negated forms that make idiomatic Perl compact. if, else and elsif, postfix conditionals, unless, and the ternary operator — with guidance on which of these help readability and which hurt it in shared code.

Topics: Understanding conditional statements · Creating conditionals with if · Extending conditionals with else · Extending conditionals with elsif · Building if statements with postfix conditionals · Creating negative conditionals with unless · Using the ternary conditional operator · Truth and falsehood in Perl

• Assignments: (1) Rewrite a nested conditional chain in three styles and argue for one; (2) Find and fix a bug caused by a false-but-defined value
• Capstone: Write a validation routine that reports every failure rather than the first

Every iteration construct Perl offers and when each is the natural fit. while and until, foreach and for over lists, loop control statements with labels, and postfix loop forms — plus iterating a file one record at a time without loading it into memory.

Topics: Understanding loops · Creating loops with while · Creating loops with until · Iterating lists with foreach · Iterating lists with for · Using loop control statements — next, last, redo and labels · Building loops with postfix statements · Streaming a large file line by line

• Assignments: (1) Process a multi-gigabyte log without exhausting memory; (2) Use labelled loop control to exit a nested iteration cleanly
• Capstone: Build a streaming correlator that joins two large log sources on a key

The operator set and the punctuation variables that make existing Perl hard to read until you know them. Arithmetic, numeric and string comparison, logical operators, file test operators, ranges, concatenation, quote operators and precedence — then $_, @ARGV, %ENV, $0, $/ and the special file handles.

Topics: Performing basic math with arithmetic operators · Creating conditionals with comparison operators — numeric versus string · Combining conditionals with logical operators · Reading file metadata with file test operators · Creating a sequence with the range operator · Combining strings with the concatenation operator · Streamlining strings with quote operators — q, qq, qw · Understanding operator precedence · Understanding and using special variables · Working with special file handles — STDIN, STDOUT, STDERR, DATA · Using special constants

• Assignments: (1) Explain a dense idiomatic script line by line, naming every special variable; (2) Fix a comparison bug caused by using == where eq was needed
• Capstone: Write a filter that behaves correctly as both a pipeline stage and a file argument tool

The reason Perl exists in operations. Matching and substitution, capture groups, wildcards and character classes, split for turning text into lists, and the practical concerns — anchoring, greediness, and patterns that backtrack catastrophically on real input.

Topics: Understanding regular expressions · Searching and replacing text with regular expressions · Extracting matches with parentheses · Matching wildcards · Matching classes of characters · Creating arrays with split · Anchors, quantifiers and greedy versus lazy matching · Modifiers — global, case-insensitive, multiline and /x · Catastrophic backtracking and how to avoid it

• Assignments: (1) Parse four different log formats into a single normalised record structure; (2) Rewrite a pattern that backtracks catastrophically on long lines
• Capstone: Build a log analyser that extracts, aggregates and reports across mixed formats

How Perl builds anything more complicated than a flat list. Defining and calling subroutines, arguments via @_, lexical variables, return values, then references — the concept that unlocks arrays of hashes, hashes of arrays and the arbitrarily nested structures real scripts carry.

Topics: Understanding subroutines · Defining and calling subroutines · Using arguments with subroutines · Understanding scope and my variables · Returning values from a subroutine — including context sensitivity · Understanding values and references · Defining array references · Defining hash references · Building mixed data structures · Dereferencing syntax and arrow notation · Data::Dumper for inspecting what you actually built

• Assignments: (1) Convert a flat parallel-array script to a single array of hash references; (2) Write a recursive routine that walks an arbitrarily nested structure
• Capstone: Build a configuration model as nested references, with a validating accessor layer

Getting data in and out, and the built-in library that covers most of what a script needs. Streams and file handles including the lexical and object-oriented forms, binary files, then the string, numeric, list and time functions that remove the need for most helper code.

Topics: Understanding streams and files · Using file handles — bareword, lexical and three-argument open · Using the object-oriented interface for handling files · Working with binary files and layers · Manipulating strings with built-in functions · Working with numbers · Manipulating lists and arrays with built-in functions — sort, grep, map, join · Retrieving and formatting time · Reading and writing safely: error checking, locking, atomic replace

• Assignments: (1) Rewrite a script using three-argument lexical open with full error checking; (2) Replace a hand-written loop with sort, grep and map and compare readability
• Capstone: Build a file-processing tool with atomic writes and resumable state

Turning a script into something a team can depend on. Packaging code as modules, procedural versus object-oriented module styles, object and instance data, installing dependencies from CPAN on Unix and Windows, and documenting with POD so the next engineer does not have to reverse-engineer it.

Topics: Leveraging code with modules · Understanding object-oriented and procedural modules · Creating modules · Understanding object and instance data · Installing modules from CPAN on Mac and Unix · Installing modules from CPAN on Windows · Dependency management with cpanm, local::lib and carton · Understanding POD · Documenting with POD · Exploring a POD document

• Assignments: (1) Extract shared logic from three scripts into a module and install it locally; (2) Add complete POD to an inherited script and generate its manual page
• Capstone: Ship a documented, dependency-pinned internal Perl module with a test file

The features added from Perl 5.10 onward, and how Perl connects to everything around it. say, given/when and state variables, then databases, HTTP and web endpoints — plus an honest section on assessing legacy scripts for maintenance, refactoring or migration.

Topics: Using Perl 5.10 and later · Displaying text with say · Selecting from multiple choices with given and when · Keeping persistent variables with state · Exploring web development with Perl · Talking to databases with DBI · Making HTTP requests and consuming APIs · Testing with Test::More and prove · Assessing a legacy script: maintain, refactor or migrate

• Assignments: (1) Write a test suite for an inherited script before changing a line of it; (2) Produce a migration assessment for one real legacy Perl job
• Capstone: Take one production Perl job, test it, document it, and deliver a maintenance or migration plan