This document provides an introduction to Perl programming by discussing what Perl is used for, why it is useful, and how to get started with the language. It covers installing Perl on Windows and Linux, using variables and data structures like scalars, arrays, hashes, and references. It also demonstrates basic Perl syntax like conditional statements, loops, file I/O, and running commands. The goal is to get readers writing basic Perl code quickly while highlighting some key features of the language.

1. Introductory Perl
AKA LET'S WRITE SOME FUCKING PERL
by William Orr

2. What do I use Perl for?
• Scripting
• Applications
• Web programming
• Pretty much everything you could want

3. Why?
• Perl has a very, very large set of available
libraries through CPAN
• TIMTOWTDI
• Language is very flexible - many modules on
CPAN influence behavior of language

4. How to get Perl - Windows
• dwimperl.com
• Comes with Padre (a Perl "IDE") as well as
tons of useful Perl modules, and an old-ish
version Strawberry Perl

5. How to get Perl - OSX and Linux
You already have it.

6. Multiple Perl Installs (you want this)
# cpan
cpan> install App::perlbrew
$ perlbrew init
$ perlbrew install perl-5.16.2
$ perlbrew switch perl-5.16.2
Install other listed modules

7. How to make Perl more useful
Install some modules
• App::perlbrew
• App::cpanminus
• Const::Fast
• Try::Tiny
• Devel::REPL

8. Documentation - perldoc
$ perldoc -f <functionname>
$ perldoc <modulename>
$ man perl

9. Documentation - MetaCPAN
• All the perldoc documentation online and
searchable
• Includes 3rd party docs, links to the bug
tracker, automated testing platforms, authors
website, etc.

10. Let's write some fucking code
use strict;
use warnings;
use v5.10;
say "WUT UP WRRRRLD";
print "WUT UP WRRRRLDn";

11. Let's write some fucking code
Things to notice
• use strict
• use warnings
• use v5.10
• say

12. Let's use some fucking variables
my $first_variable = "This is a scalar";
my $second_variable = 5;
say $first_variable;
say("This is also a scalar: $second_variable");
my $third_variable = 4.5;
say "Guess what else is a fucking scalar?
$third_variable";
my $fourth_variable = qr| d{1,2} / d{1,2} / d{2,4} |x;
say "Also a scalar: $fourth_variable";

13. Let's use some fucking variables
Things to notice here
• Scalars!
• Interpolation
• Parentheses are optional

14. Interpolation
• Variables resolve to their value in strings
quoted with "", `` and most other quote-like
operators

15. I want a lot of scalars!
my @lets_talk_about_arrays = ( "an", "array", "is", "a",
"set", "of", "scalars", "only");
say "@lets_talk_about_arrays";
# We can index into them!
say $lets_talk_about_arrays[1];
# We can do ranges!
say @lets_talk_about_arrays[6..7];
# We can call functions on them!
say join " ", map { uc } @lets_talk_about_arrays[6..7];
say(join(" ", map({ uc } @lets_talk_about_arrays[6..7])));

16. I want a lot of scalars!
Things to notice here:
• Array declaration & initialization
• Ranges with ..

17. How do we get array length?
my $array_size = @lets_talk_about_arrays;
say $array_size;

18. Context
• Functions and operators impose context on
the variables you use
• Context determines result of expression
• Three kinds of context
o scalar
o list
o void

19. Context
# Scalar context
my $now = localtime;
say $now;
# List context
my @now = localtime;
say "(" . join(", ", @now) . ")";

20. Context
To review:
• Operators and functions impose context
• Values of expression depend on context
• Arrays used in scalar context return size
• Can force scalar context with scalar()
• Can force list context with ()=
• Documentation!

21. Dictionar-err, hashes!
my %hash = ( key => "value", other_key => 3, "new key",
5.2 );
say %hash;
say "$hash{key}";
say "$hash{other_key}";
say "$hash{new_key}";
# Scalar context?
say scalar %hash;
# WOAH
my %empty_hash;
say scalar %empty_hash;

22. Let's talk about operators
• They're all pretty much the same as you're
used to!
• Except for the new ones!

23. New operators
• . x
• <=>
• cmp, lt, gt, lte, gte, eq, ne
• //
• =~, !~
• or, and, not, xor
• ...
open my $fh, ">", "filename" or die $@;

24. Control flow - loops
my @some_array = 1..10;
foreach my $iter (@some_array) {
say $iter;
}
my $done = 0;
while (not $done) {
$done = int rand 2;
say $done;
}

25. Control flow - if
if ($some_var ne "done") {
} elsif ($other_var == 5) {
} else {
}

26. Control flow - switch
given ($foo) {
when (1) {
}
when (2) {
}
when ("45hundred") {
}
default {
}
}

27. Special operator - ~~
• Smart match operator
• Returns true based on various, sensible
conditions
• Full table in perlsyn - /Smart matching in
detail

28. FUCKIT LET'S WRITE SOME
FUNCTIONS
sub my_func {
my ($first, $second, $third) = @_;
return $first + $second + $third;
}
my_func 1, 2, 3
# Array is flattened - will return 6
my @arr = (1, 2, 3, 4, 5, 6);
# NEVER &my_func

29. SHIT HOW DO I NOT FLATTEN
ARRAYS IN FUNCTION CALLS?!
• or also "HOW THE HELL CAN I HAVE
COMPOSITE DATA STRUCTURES?!"

30. Let's talk about references
• Can pass around references to _anything_
o this includes functions
• A reference is a scalar - can pop arrays into
arrays
• When you modify the value of a reference, it
modifies the original variable

31. Let's talk about references
my @arr = ( 1 .. 10 );
# This won't compile
#my @two_d_arr = ( @arr, @arr );
my @two_d_arr = ( @arr, @arr );
# We'll see some reference addresses
say "@two_d_arr";
# One reference address
say $two_d_arr[0];
# Dereferencing
say "@{$two_d_arr[0]}";

32. Let's talk about references
# Hashes?
# YOU'RE DAMN RIGHT
my %hash;
$hash{first} = @arr;
say $hash{first}->[0];
# OR
say ${hash{first}}->[0];
# Lets get fancy
$hash{second} = %hash;
say $hash{second}->{first}->[0];

33. Let's talk about references
sub print_shit {
say "shit";
}
$hash{third} = &print_shit;
$hash{third}->();

34. Anonymous references
my $arr_ref = [ 1, 2, 3, 4 ];
say @$arr_ref;
say scalar @$arr_ref;
say $arr_ref->[1]
my $hash_ref = { key => 1, other_key => 5 };
say %$hash_ref;
say $hash_ref->{key};
my $sub_ref = sub { say "foo"; }
$sub_ref->();

35. Anonymous references
• anonymous array references declared with []
• anon hash refs declared with {}
• anon sub refs declared with sub { }

36. File I/O
open(my $fh, "<", "testfile") or die "Could not open file
for reading";
foreach my $line (<$fh>) {
print $line;
}
close($fh);
open($fh, ">>", "testfile") or die "Could not open file
for writing";
say $fh "let's append a message";
close($fh);

37. Let's run some commands
open(my $cmd, "-|", "ls") or die "Could not run ls";
foreach my $line (<$cmd>) {
print $line;
}
close($cmd);
open($cmd, "|-", "cat") or die "Could not run cat";
say $cmd "cat'd output";
close($cmd);
my $output = qx/ls/; # `` also works
foreach my $line (split /n/, $output) {
say $line;
}

38. In conclusion
This is some basic Perl, and is not even close
to conclusive