Perl — Tutorials · VLSI Mentor

314Total chapters

29Modules

314Chapters live

29 / 29Active modules

Two parts, one dependency chain

Part I is a complete Perl education that stands on its own — sigils, scalar and list context, operators, quoting, arrays, hashes, references and nested data structures, subroutines, packages, file handling and command-line Perl, with no semiconductor knowledge assumed. Part II builds on it and never re-teaches it, applying the same language to RTL, verification and signoff data.

Regex and references, in full

A twenty-two-chapter regular-expression path that builds every pattern symbol by symbol from a literal match to qr// and lookaround, and a full module on references — because in Perl a hash of hashes is not possible without them. Per-chapter interview weighting marks what an established team actually asks: context, == versus eq, capture groups, autovivification, migration pitfalls.

Read → maintain → migrate

From the first regex to a per-corner STA report parser, a log-triage tool that reduces a hundred failures to a handful of signatures, a regression dashboard, and a Perl → Python migration validated byte for byte before cutover — the full lifecycle a team with legacy EDA Perl eventually owns.

Perl Complete Curriculum

Your Learning Roadmap

314 chapters · 29 modules — two parts — Perl taught from zero, then the Perl a semiconductor engineer needs for log parsing, filelists, netlists, STA and synthesis reports, regression automation and the migration path off legacy infrastructure.

314of 314 chapters live

100% complete

Part I — Perl Basics & Fundamentals

Perl taught from zero: running your first script, scalars and sigils, context, operators, strings and quoting, arrays, hashes, references and nested data structures, conditions, loops, subroutines, regular expressions, packages and modules, file handling, errors and debugging, and command-line Perl. No VLSI knowledge required.

Module 1

Introduction to Perl

1.1What Perl Is, and What It Was Built For 1.2Installing Perl and Finding the Interpreter 1.3Writing and Running Your First Script 1.4The Shebang Line and Executable Scripts 1.5How Perl Executes Your Program 1.6print and say: Making a Script Speak 1.7STDIN, STDOUT and STDERR 1.8Statements, Semicolons and Blocks 1.9Comments and Readable Perl 1.10use strict: Making Perl Refuse Your Mistakes 1.11use warnings: Letting Perl Tell You It Is Suspicious 1.12When Perl Refuses to Run: Reading the Error 1.13perl -c: Checking a Script Without Running It 1.14perldoc: The Documentation That Ships With Perl

Module 2

Variables, Scalars, and Data Types

2.1The Three Sigils: $, @ and %2.2Scalars: A Single Value 2.3my and Lexical Scope 2.4Numbers: Integers, Floats and How Perl Stores Them 2.5Strings as Scalar Values 2.6Perl Has No Separate Number and String Type 2.7undef and Definedness 2.8Truth in Perl: What Counts as False 2.9Scalar and List Context: One Value or Many 2.10Asking Perl for One Value or a List 2.11Constants: use constant and Readonly 2.12The Special Variables Worth Knowing: $_, $0, $!, $@, $?2.13Conversion Warnings and What They Really Mean

Module 3

Operators and Expressions

3.1Expressions and Evaluation Order 3.2Arithmetic Operators 3.3String Operators: . and x 3.4Assignment Operators: += .= //= and Friends 3.5Numeric vs String Comparison: == vs eq 3.6The Comparison Operators in Full 3.7The Three-Way Comparators: <=> and cmp 3.8Logical Operators: && || // and the Word Forms 3.9Statement Modifiers and the `or die` Idiom 3.10Range and Repetition Operators 3.11Bitwise Operators: & | ^ ~ << >>3.12Precedence and Saying What You Mean

Module 4

Strings and String Operations

4.1Single Quotes vs Double Quotes 4.2String Interpolation 4.3Escape Sequences and Special Characters 4.4q, qq and qw: Alternative Quoting 4.5Inspecting a String: length, index, substr 4.6Changing Case and Trimming Whitespace 4.7Splitting and Joining 4.8sprintf and printf: Formatted Output 4.9chomp and chop 4.10Heredocs for Multi-Line Text 4.11Comparing and Sorting Strings

Module 5

Arrays

5.1Arrays: Ordered Lists of Scalars 5.2Indexing, Negative Indexes and $#array 5.3Array Slices 5.4push, pop, shift and unshift 5.5splice: Insert and Remove in the Middle 5.6Lists vs Arrays 5.7Arrays in Scalar Context 5.8Turning a Line Into Fields 5.9sort and Custom Comparators 5.10grep and map 5.11Searching, Counting and Reversing 5.12Why a List Inside a List Disappears

Module 6

Hashes

6.1Hashes: Key/Value Lookup 6.2Constructing a Hash, and the Fat Comma 6.3Reading, Writing and Deleting Keys 6.4exists vs defined vs Truth 6.5keys, values and each 6.6Why Hash Order Changes Between Runs 6.7Hash Slices 6.8Counting With a Hash 6.9A Hash as a Set 6.10Turning a Hash Into a List, and Back 6.11Choosing Between an Array and a Hash

Module 7

References and Nested Data Structures

7.1Why Perl Needs References 7.2Making a Reference With \7.3Dereferencing 7.4Arrow Notation, and When You Can Omit It 7.5Anonymous Arrays and Hashes: [] and {}7.6Arrays of Arrays 7.7Hashes of Arrays 7.8Hashes of Hashes 7.9How Perl Creates Nested Data Automatically 7.10Walking a Nested Structure 7.11Code References and Dispatch Tables 7.12Inspecting a Structure With Data::Dumper 7.13Copying Nested Data: What Gets Shared 7.14ref(): Asking What a Reference Points To

Module 8

Conditional Statements

8.1if / elsif / else 8.2unless and Negated Conditions 8.3Statement Modifiers: Conditions After the Action 8.4The Ternary Conditional Operator 8.5Short-Circuit Evaluation and Defaults 8.6Classifying a Verdict: PASS, FAIL or UNKNOWN

Module 9

Loops

9.1foreach and the C-Style for 9.2Changing the Loop Variable Changes the Array 9.3while and until 9.4do-while and do-until 9.5last, next and redo 9.6Labels and Nested Loops 9.7$_ : The Variable Perl Uses When You Name None 9.8Termination, Infinite Loops and Bounds 9.9Accumulating a Result in a Loop

Module 10

Subroutines and Arguments

10.1Defining and Calling a Subroutine 10.2@_ : How Perl Passes Arguments 10.3Unpacking Arguments 10.4Changing @_ Changes the Caller's Variables 10.5Named Arguments With a Hash 10.6Return Values and Context 10.7wantarray: Returning One Value or a List 10.8Returning Structures Safely 10.9Recursion 10.10Closures and Private State 10.11Signatures and Prototypes 10.12Designing a Subroutine Worth Reusing

Module 12

Modules and Packages

12.1Why Code Belongs in a Module 12.2package and Namespaces 12.3use vs require: Compile Time vs Run Time 12.4@INC and Finding a Module 12.5Writing Your First .pm File 12.6Exporting With Exporter 12.7Package Variables, our, and Why my Is Different 12.8local: Changing a Global Value Temporarily 12.9The Core Modules Worth Knowing 12.10CPAN, cpanm and the Site-Library Problem 12.11A Module With State 12.12bless: How a Perl Object Works 12.13Reading Object-Oriented Perl You Did Not Write

Module 13

File Handling

13.1open and close: The Three-Argument Form 13.2Reading a File Line by Line 13.3Reading a Whole File at Once, and When Not To 13.4Writing and Appending 13.5or die "$!": Never Let open Fail Silently 13.6File Test Operators 13.7The Diamond Operator and @ARGV 13.8Line Numbers With $. in a Read Loop 13.9Directories: opendir, readdir and mkdir 13.10Recursive Traversal With File::Find 13.11Paths With File::Basename and File::Spec 13.12Encoding, Binary Mode and Very Large Files 13.13Temporary Files and Atomic Writes 13.14Reading and Writing Delimited Text

Module 14

Errors, Warnings, and Debugging

14.1Three Kinds of Failure: Compile, Runtime, Logic 14.2warn and die 14.3$! , $@ and $? : Three Different Failures 14.4eval { }: Catching a Fatal Error 14.5Try::Tiny and Modern Error Handling 14.6Turning Specific Warnings Into Errors 14.7Decoding the Classic Warnings 14.8print-Debugging Done Properly 14.9Carp: croak, carp and confess 14.10The Perl Debugger: perl -d 14.11Logging Instead of Printing

Module 15

Command-Line Perl and Script Execution

15.1@ARGV: Reading Command-Line Arguments 15.2Getopt::Long: Real Option Parsing 15.3Validating Arguments and Printing Usage 15.4Exit Codes: Telling the Shell What Happened 15.5%ENV: Reading the Environment 15.6One-Liners: perl -e 15.7-n and -p: The Implicit Loop 15.8-a and -F: Autosplit Mode 15.9-i: In-Place Editing 15.10Running External Commands: system, backticks and exec 15.11Pipes: Reading and Writing Another Process 15.12Perl as a Filter in a Shell Pipeline

Part II — Perl for VLSI Engineering

The Perl fundamentals from Part I applied to real semiconductor engineering workflows, and never re-teaching them: engineering file trees, log parsing, RTL filelist generation, netlist processing, simulation and UVM log analysis, synthesis and STA report parsing, coverage and regression reporting, regression automation, Bash/Tcl/EDA integration, testing and maintenance, legacy migration, and end-to-end automation projects.

Module 16

Perl in Semiconductor Engineering