Perl Interview Questions

Analogy categoryAnalogies

Why Perl Interviews Focus on Context and References

Perl interviewers disproportionately probe two areas that trip up even experienced developers coming from other languages: context sensitivity and references. Context sensitivity means the very same expression, such as calling a function or evaluating an array, produces a different result depending on whether Perl expects a scalar or a list at that point in the code. For example, my @arr = (1,2,3); my $count = @arr; assigns 3 (the array's length) to $count, because assignment to a scalar imposes scalar context, while my ($first) = @arr; imposes list context and assigns only the value 1. References are Perl's mechanism for building nested data structures like arrays of hashes or hashes of arrays, created with the backslash operator (\@array, \%hash) or anonymous constructors ([ ] and { } ), and dereferenced with arrow syntax or sigil-prefixed blocks. Interviewers test these topics because misunderstanding them is the single most common source of subtle runtime bugs in real Perl codebases.

🏏

Cricket analogy: Context sensitivity is like the same shot selection meaning something different depending on the format: a lofted six in T20 is aggressive intent, while the identical shot in a Test match session might be reckless risk-taking.

Common Data Structure and Reference Questions

A frequent interview question is: 'How do you create an array of hashes in Perl, and how do you access a value inside it?' The answer involves an array of anonymous hash references: my @users = ({name => 'Ann', age => 30}, {name => 'Ben', age => 25});, and accessing a nested value with $users[0]{name} (arrow between subscripts is optional after the first one). Another very common question asks the difference between my $ref = \@array; and my $ref = [@array];, testing whether the candidate understands that the first creates a reference to the original array (mutations through $ref affect @array), while the second creates a reference to a new anonymous array that is a shallow copy of @array's current contents at that moment. Interviewers also frequently ask candidates to explain the difference between local and my, since local dynamically scopes a global variable's value (saving and restoring it, useful for temporarily overriding a package variable) while my creates a genuinely new lexically scoped variable.

🏏

Cricket analogy: An array of hashes is like a scorecard where each array slot is one player's row and each hash key (runs, balls, fours) is a labeled column within that row, giving structured access to nested stats.

Object-Oriented and Behavioral Questions

Object-oriented interview questions typically ask candidates to explain how Perl implements objects without a dedicated 'class' keyword in classic Perl 5 (bless() associates a reference, usually a hash reference, with a package name, and method calls use the arrow operator which looks up the method in the package's @ISA inheritance chain). A related question asks about the difference between @ISA-based inheritance and Moose/Moo's 'extends' keyword, testing whether the candidate knows that extends is syntactic sugar that manages @ISA and adds attribute inheritance and method modifiers on top of it. Behavioral or scenario questions are also common, such as 'a script works when run directly but fails silently under cron' -- the expected answer discusses environment differences (PATH, working directory, missing environment variables) and recommends always using absolute paths and explicit use strict/warnings with output captured to a log file (e.g., via a wrapper redirecting STDOUT/STDERR) so cron failures are diagnosable instead of silent.

🏏

Cricket analogy: bless() associating a hash reference with a package is like a franchise auction assigning a player to a specific team roster, after which every subsequent selector (method call) knows which team's playbook to consult.

A great way to prepare is to be able to explain, out loud and from memory, the difference between my, our, and local -- this trio comes up in nearly every Perl interview and demonstrates whether a candidate truly understands Perl's scoping model versus having memorized syntax.

Avoid answering 'What does use strict do?' with only 'it makes Perl stricter' -- interviewers are listening for the specific mechanism: it disables symbolic references, requires variable declaration (my/our/local), and requires bareword function calls to be predeclared or quoted, catching an entire class of typo-driven bugs at compile time.

perl

# Common interview snippet: array of hashes + reference behavior
use strict;
use warnings;

my @orig = (1, 2, 3);
my $ref_to_orig = \@orig;      # reference to the SAME array
my $copy_ref     = [@orig];    # reference to a NEW, copied array

push @$ref_to_orig, 4;         # modifies @orig too
push @$copy_ref, 99;           # does NOT affect @orig

print "orig: @orig\n";          # orig: 1 2 3 4
print "copy: @$copy_ref\n";     # copy: 1 2 3 99

# Interview favorite: bless-based OO
package Animal;
sub new   { my ($class, %args) = @_; return bless { %args }, $class; }
sub speak { my $self = shift; return "$self->{name} says $self->{sound}"; }

package main;
my $dog = Animal->new(name => 'Rex', sound => 'Woof');
print $dog->speak, "\n";

Context sensitivity (scalar vs list) is one of the most frequently tested Perl concepts in interviews.
\@array references the original array; [@array] creates a reference to a shallow copy.
local dynamically scopes and restores a global/package variable; my creates a new lexical variable.
Classic Perl OO uses bless() to associate a reference with a package, and @ISA drives method resolution.
Moose/Moo's 'extends' keyword is syntactic sugar over @ISA that adds attribute inheritance and method modifiers.
Cron-vs-interactive failures usually trace back to environment differences: PATH, working directory, or missing env vars.
Be ready to explain use strict's exact mechanisms, not just that it 'makes Perl stricter'.