Hire the top 3% of freelance Perl developers.

Toptal is a marketplace for top Perl developers, engineers, programmers, coders, architects, and consultants. Top companies and start-ups choose Toptal Perl freelancers for their mission-critical software projects.

We’ve been blown away by the level of talent we've been able to hire through Toptal.

Brad Rozran, Optimizely
Meet our
Perl Developers
Alexis Hernandez
Software Engineer
Previously at
Anne Adams
Senior Developer
Previously at
Danilo Resende
Senior Software Engineer
Previously at
April Leone
Senior Software Developer
Previously at
Jongwook Kim
Software Engineer
Previously at
Darin Erat Sleiter
Senior Software Developer
Previously at
Trusted by leading brands and startups

Our Exclusive Network of Perl Developers

Chris Remshaw

Perl Developer
Chris is a hands-on architect and developer with many years of experience with companies large and small. With a proven record of customer satisfaction, ... Read More
Chris is a hands-on architect and developer with many years of experience with companies large and small. With a proven record of customer satisfaction, efficiency, and solution longevity, he is experienced with a variety of languages and tools and is comfortable solo, as a team member, or as a group lead/mentor. Read Less
PerlJavaSQL
View Chris's Profile

Jordan Ambra

Perl Developer
Jordan is a top-notch architect, developer, sysadmin, and entrepreneur with the passion and experience to help businesses solve complex problems. He is a... Read More
Jordan is a top-notch architect, developer, sysadmin, and entrepreneur with the passion and experience to help businesses solve complex problems. He is an expert full-stack developer, bringing projects from concept to completion, with a proven track record of delivering powerful, stable, and comprehensive solutions. Read Less
PerlPythonPHPC#+9 More
View Jordan's Profile

Genadijus Paleckis

Perl Developer
Genadijus has over 15 years of experience as a developer. He can execute programming tasks using a range of programming languages including (but not limi... Read More
Genadijus has over 15 years of experience as a developer. He can execute programming tasks using a range of programming languages including (but not limited to) JavaScript, PHP, C, and Perl. For the past few years, he's been focusing mainly on Angular and test-driven development. Read Less
PerlFreeBSDOpenBSDLinux
View Genadijus's Profile

Flavio de Sousa

Perl Developer
Flavio is a top architect/programmer with a long track record of successfully delivering projects for companies ranging from Big Four consulting firms, l... Read More
Flavio is a top architect/programmer with a long track record of successfully delivering projects for companies ranging from Big Four consulting firms, large telecoms, and government agencies to small team startups. He's eager to design and deliver efficient application architectures. Read Less
PerlC#CUnix+3 More
View Flavio's Profile

Ken Whaley

Perl Developer
Ken is a top architect, engineer, and developer with over 30 years of experience in the field. He has a proven ability to understand, optimize, enhance,... Read More
Ken is a top architect, engineer, and developer with over 30 years of experience in the field. He has a proven ability to understand, optimize, enhance, and create from scratch significant software tools and workflows with large user bases that greatly magnify productivity for large groups of engineers. Ken is eager to take on new challenges and has done so with teams of all sizes and compositions.  Read Less
PerlHTML5PythonC+++6 More
View Ken's Profile

Tom Stanik

Perl Developer
Tom is a seasoned electrical/computer engineer with 15+ years of industrial engineering and coding experience, beginning with work at AT&T/Bell. He is a ... Read More
Tom is a seasoned electrical/computer engineer with 15+ years of industrial engineering and coding experience, beginning with work at AT&T/Bell. He is a dedicated, top-notch problem solver with proven ability to get the job done. Read Less
PerlCAWKJira+2 More
View Tom's Profile

Andrii Kostenko

Perl Developer
Andrii is an accomplished software engineer experienced in creating large-scale, complex applications. He has worked both as a back-end and front-end eng... Read More
Andrii is an accomplished software engineer experienced in creating large-scale, complex applications. He has worked both as a back-end and front-end engineer. He excels at planning and implementing intricate solutions to technical problems, including determining which technologies should be used. Read Less
PerlDjangoPostgreSQL
View Andrii's Profile

Sam Varshavchik

Perl Developer
Sam is a senior freelance developer and architect with over 20 years of experience developing in the financial industry.
PerlC++jQueryLinux+5 More
View Sam's Profile
Sign up now to see
more profiles.
Get Started

Hear From Our Clients

Hire Perl Developers Seamlessly with Toptal

1
Talk to One of Our Industry Experts
A Toptal Director of Engineering will work with you to understand your goals, technical needs, and team dynamics.
2
Work with Hand‑Selected Talent
Within days, we'll introduce you to the right Perl developer for your project. Average time to match is under 24 hours.
3
The Right Fit, Guaranteed
Work with your new Perl developer for a trial period (pay only if satisfied), ensuring they're the right fit before starting the engagement.

Tap Into World‑Class Talent

Trusted Experts Only
All of our talent are seasoned experts who ramp up quickly, readily contribute as core team members, and work with you to minimize onboarding time.
Your New Team Member
We are so sure you will love your new team member, than you can try working with them for a few days. Pay only if satisfied.
Scale as Needed
Hire talent within 48 hours. Scale your team up or down exactly when you need it, no strings attached.
Seamless Hiring
We handle all aspects of billing, payments and NDA's. Let us take care of the overhead while you focus on building great products.
Flexible Engagements
Choose the engagement type that suits your needs – hourly, part-time, or full-time – with the ability to change anytime.
Expert Talent Matcher
Focus on your project and enjoy support from your dedicated account executive and expert talent matcher.

Guide to Hiring a Great Perl Developer

Perl, the tried and true predecessor of modern day dynamic languages, still retains its title as one of the best text processing languages out there and remains the chosen language of many corporate applications. To help you find developers that truly understand this once revolutionary language, follow this hiring guide through the topics and questions that Perl experts should know well.

How to Hire a Great Perl Developer

While Perl may not be as popular as it had once been, many of the dynamic languages that power the web today—such as JavaScript, PHP, Python, and Ruby—were all influenced by Perl. You can still see the design decisions that were made in Perl 30 years ago present in those languages today.

First released in the late 1980s by creator Larry Wall, Perl was in the right place at the right time and quickly became a major player in the development of the internet. As one of the first dynamically typed languages, it gave developers the tools to quickly do things that couldn’t be done before. No longer would they need to pre-allocate memory or keep track of which data type a variable stored.

Perl still remains one of the best programming languages for text processing with regular expressions, which makes it very easy to use for processing file input and output.

If you are looking to hire Perl developers, it’s probably because you have a legacy Perl application or you’re looking to take advantage of the power of its regular expressions engine. This hiring guide covers the basic, key aspects that every Perl developer should know inside and out.

References

As mentioned before, Perl brought on a major shift in programming and heralded an evolution from statically typed to dynamically typed languages. One of the other shifts it ushered in was the way references are used. The concept of pointers, common in predecessor languages like C and C++, were confusing to many developers, so Perl did away with pointers and instead introduced references, which simplified memory management for the developer.

References are used frequently and extensively in Perl code. They’re very important for a Perl developer to understand, as the syntax of element access changes depending on whether you have a reference or direct access.

Q: In Perl, how do you initialize the following?

  • an array

  • an array reference

  • A hash

  • A hash reference

Furthermore, how would you change an array to an array reference, a hash to a hash reference, and vice versa? How do you access elements from within these variables?

A: The use of hash and array references is a pretty basic concept for any experienced Perl developer, but it may syntactically trip up some newer Perl developers or developers who never really grasped the underlying basics.

Initializing an Array:

my @arr = (0, 1, 2);

An array is initialized with an @ symbol prefixed to the variable name, which denotes the variable type as an array; its elements are placed in parentheses.

Initializing an Array Reference:

my $arr_ref = [0, 1, 2];

With an array reference, you use the $ symbol, which denotes ‘scalar’, and the elements are placed in square brackets. The reference isn’t specified as an array, just as a scalar, so you have to be careful to handle the variable type appropriately.

With hashes, the syntax is similar.

Initializing a Hash:

my %hash = (0 => 'First', 1 => 'Second', 2 => 'Third');

Just as with an array, the elements of a hash are defined with parentheses, but since the variable is a hash, it’s prefixed with a %.

Initializing an Array Reference:

my $hash_ref = {0 => 'First', 1 => 'Second', 2 => 'Third'};

Like an array reference, a hash reference variable is prefixed with a $, but the elements are placed in curly braces.

Referencing a Hash or an Array

Referencing an array or hash is pretty straightforward. In Perl, a backslash in front of a variable will return the reference to it. You should expect something like the following:

my $arr_ref = \@arr;

my $hash_ref = \%hash;

Dereferencing

Dereferencing a referenced variable is as easy as reassigning it with the appropriate variable identifier. For example, here’s how you would dereference arrays and hashes:

my @arr = @$arr_ref;

my %hash = %$hash_ref;

Accessing Elements

The differences between accessing elements of these variable types and their reference versions is another area where amateur developers may get tripped up.

# to access an element of an array
my $element = $arr[0];

Notice that for an array you are not using the @ prefix but rather the $ to denote a scalar, which is the type returned when accessing any element of an array. Accessing the elements of an array reference, a hash, and a hash reference follows a similar syntax:

# to access an element of an array reference
my $element = ${$array_ref}[0];


# to access an element of a hash
my $element = $hash{0};


# to access an element of a hash reference
my $element = $hash_ref->{0};

Special Variables

One of the things unique to Perl is the number of special variables it provides. While this can make Perl code very concise, it also makes it rather cryptic to new developers. While only those with expert Perl knowledge will know most (or all) of the special variables, there are some key ones that every Perl developer, regardless of skill level, should be familiar with.

Q: Using $_: Verbally explain the functionality of the following example code snippet:

my @new = map { $_ + 1 } @values;

A: The map function will loop through each element in the @values array and $_ will be set to the element of each iteration. This is equivalent to the following more common and verbose code:

my @new = ();
foreach (@values) {
	push(@new, $_ + 1);
}

or

my @new = ();
foreach my $value (@values) {
	push(@new, $value + 1);
}

Q: Using @_: Within the following routine, explain the value of @_:

sub my_subroutine {}

A: @_ will be set to any parameters that are passed into the subroutine.

So, for example, if the subroutine is called as follows:

my_subroutine(1, 'string', 2);

…then @_ will be an array containing the elements (1, 'string', 2).

Regular Expressions

Perl provides a powerful and easy way to work with regular expressions. Even if developers are not doing text processing, they will no doubt come across situations in Perl where regular expressions are the best fit for the job.

Q: Explain what the following code does, in detail:

$str =~ s/-//g;

A: It removes all hyphens (- characters) from the string.

Here we have the variable $str which contains a string.

The =~ is the Perl operator for performing a regular expression.

The s on the left side indicates that we are going to perform a substitution.

The slashes after the s respectively demarcate the regular expression pattern to match and its replacement. After the slashes come any optional modifiers. Let’s take it apart piece by piece:

In this example, - is matching all hyphens.

The second set of slashes, //, is empty, so the matching hyphens in the first part are being replaced by nothing (i.e., deleted.)

The g is a modifier telling the regular expression engine to execute this globally on the string; without the g modifier, only the first hyphen would be removed.

Q: Write a script that takes a list of file names as command-line arguments. Its processing will take these log files of errors and count how many errors occurred on specific days.

For any line that starts with a timestamp in the format of YYYY-MM-DD, increment the counter for that day and print a summary, in ascending date order, like the following:

Example output:

2016-06-01: 3
2016-06-02: 4
2016-06-04: 1

Days that don’t appear in the log file do not need to appear in the output.

A: One concise answer would look like the following:

my %counts = ();
while (<>) {
	if (/^(\d{4}-\d{2}-\d{2})/) {
		$counts{$1}++;
	}
}

for ( sort { $a cmp $b } keys %counts) {
	print "$_: $counts{$_}\n";
}

The diamond operator (<>) in the while loop is another example of a special operator in Perl. It will loop through the @ARGV array, which are the arguments passed into the script (in this case the file names), open the files, and read through the lines.

The if statement contains a regular expression which is implicitly checking against the $_ special variable, and the while loop sets $_ to each line as it loops through. In Perl, the $_ can usually be inferred and this is one such case.

The regular expression itself is doing the following:

The caret ^ is the character used to represent the start of a line, meaning that the match must begin with the start of a line.

When parentheses are used in a regular expression, the part of the string matched by the part of the regular expression inside the parentheses will be “captured” (i.e., stored in a temporary variable) if a match occurs. There can be multiple parentheses in a regular expression. The part of the string matching the first set of parentheses will be stored in the temporary variable $1, the second will be stored in $2, and so on. In the above example, there is only one set of parentheses, so $1 will be set to that match.

The match we’re checking for, \d{4}-\d{2}-\d{2}, consists of 4 digits followed by a dash, followed by 2 digits, followed by a dash, finally followed by 2 digits.

If we find that match, then we increment the %counts hash by one, where the key is the date that was matched. We don’t need to initialize the values the first time a key is found because Perl automatically sets the value to 0, so we can simply use the ++ operator to increment the counter for the date.

In Perl, you don't have to set a value the first time you use a key in a hash; Perl automatically sets this value to 0, so you can use the `++` operator to increment.

In the for statement, we are once again making use of the $_ special variable by not explicitly naming the value for each loop. Starting on the right side:

  • The keys %counts statement returns an array of the keys from the hash. These will be the dates that we previously encountered.

  • The sort function goes through the key array and uses the string comparison function cmp to sort the array in ascending order.

  • The resulting array is then used in the for loop where the output is printed out with the date, followed by a colon. Then we access the value from the %counts hash for the date (the number of times an error was logged), and append that, followed by a new line.

Common Functions

As with most modern programming languages, hashes and arrays are a big part of programming in Perl. Developers may find data stored in one structure or the other, but may need to retrieve it in a specific format. Perl provides very concise and powerful functions to do this retrieval; functions with which experienced Perl developers must be familiar.

These questions are designed to test just how comfortable the candidate is with common Perl functions. Qualified candidates should have an understanding of common functions like map and grep. If the candidate solves the question using one function, ask them to solve it using the other function.

A junior-level programmer might write code that creates a separate array and then uses a `for` loop to add the value to a hash.

Q: Given an array, how would you get an array of just the unique elements?

A: The standard technique is as follows:

my %uniq_hash = map { $_ => 1 } @input;
my @uniq = keys %uniq_hash;

Here you are taking the @input array, and using map to create a hash with its keys set to the values of @input. Since a hash only allows for unique keys, there will be no duplicates. To get an array back, you just use the keys function to get the keys of the hash in array form.

Q: Write some code that prints ‘yes’ if the value 3 is in an array.

A: You could use the same procedure as above and then simply do:

my %uniq_hash = map { $_ => 1 } @input;
if ($uniq_hash{3}) { print 'yes'; }

This just checks the hash you created to see if there is a key set to 3 and, if there is, prints “yes”.

You could achieve the same effect with grep, which loops through the @input array and tests each value against your statement, as follows:

if (grep $_ eq 3, @input) { print 'yes'; }

While either approach will work, a developer would be better off using the first technique if multiple values need to be checked in order to avoid looping through the array multiple times. For a one-off check, though, this would not be an issue, in which case both ways would normally be acceptable.

Q: Given a string of key-value pairs in the example of the format key1=value1&key2=value2&key3=value3, how would you turn it into a hash?

A: While the answer is a single line, this question tests the candidate’s ability to understand the split function and how arrays are converted into hashes in Perl:

my %hash = split /[=&]/, $str;

The function split takes the input string and splits it into an array wherever the match occurs (in this case either an equal sign or ampersand). In this case, the resulting array would be [key1, value1, key2, value2, key3, value3].

Perl converts arrays to hashes by taking the first element as the key and second element as the value, then the third as the key and fourth as the value and so on.

Storing the result of the split function into a hash type, you will get the following:

{
	key1 => value1,
	key2 => value2,
	key3 => value3
}

There’s More Than One Way to Do It

Perl prides itself on providing multiple ways to accomplish the same programming task. As such, keep an open mind about a candidate’s answers. Try to understand the reasoning behind their approach.

Some senior candidates may fully grasp the concise ways of programming in Perl but choose to write out code in a more verbose way for easier readability. These developers might, for example, actively avoid using the special $_ variable because it takes time to figure out what it is actually referring to. They might therefore opt to use a named variable instead. The alternative might be a developer with a strong command of the language, but who writes code that is unreadable by junior-level developers.

By taking the time to understand the thinking behind the answers, you’ll gain a deep insight into the candidate’s thought process and find those that understand the long-term implications of the code that they write.