A whirlwind tour of the modules that any perl hacker, from beginner to experienced, should use and why. Handout: List of modules in the talk along with many more: https://sites.google.com/site/perlhercynium/TEPHT-List2.pdf?attredirects=0

1. The Essential Perl
Hacker's Toolkit
Stephen R. Scaffidi
stephen@scaffidi.net
YAPC::NA 2012

2. Thanks for coming!

3. Contents
Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

4. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

5. This is a talk about the essentials

6. essential to...

7. getting my job done

8. getting my job done better

9. getting my job done faster

10. so I can go out and drink beer

11. so I can go out and drink beer
spend time posting on reddit

12. so I can go out and drink beer
spend time posting on reddit
watching youtube

13. so I can go out and drink beer
spend time posting on reddit
watching youtube
DANCING WITH THE STARS

14. the editor of the previous three slides has
been sacked

15. I <3 Task::Kensho

16. This talk != Task::Kensho

17. But it is essential

18. So look it up:
Task::Kensho

19. my @essentials

20. Modules and tools I depend on

21. make my job easier

22. make my code better

23. easier to write

24. easier to read

25. easier to maintain

26. fewer bugs

27. because...

28. this is the code I don't write

29. I'm not that good.

30. Neither are you*

31. Neither are you*
*with several exceptions, half of them probably
leaving this room right now...

32. Previous iterations of this talk...

33. touchy-feely

34. waxed poetic about community

35. gushed about the CPAN

36. but...

37. there's simply no time

38. too many modules

39. too many modules
(on the dance floor)

40. I prefer Perl because of this
variety

41. No language is perfect

42. but...

43. Perl has the CPAN

44. And the CPAN gives us many,
many ways to improve Perl

45. mst once said...

46. Perl is my VM
CPAN is my language

47. so...

48. let's learn about some of the best
parts of this language we call the
CPAN

49. Allow me some hubris...
for the next 40 minutes or so.

51. Bring out the modules!

52. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

53. strict
warnings

54. really?

55. experience tells me the answer is
yes.

56. English

57. Get English versions of Perl's
“punctuation vars”

58. use English qw( -no_match_vars );

59. Examples
$#@^ English
$ $OUTPUT_RECORD_SEPARATOR
$$ $PID
$^O $OSNAME
$+ $LAST_PAREN_MATCH
$! $OS_ERROR
$? $CHILD_ERROR

60. perldoc perlvar

61. autodie

62. Does what it says on the tin...

63. # overrides various built-ins...
use autodie;
# Now, they all succeed or die!
open my $foo, '>', 'file.txt';
chdir 'foo/bar';
pipe my($baz), my($buh);
readline $foo;
print “Do you ever check for print
errors???”;

64. autodie is indispensable.
Why write an “or die” clause after
every open() when you no
longer have to???

65. Data::Dumper

66. Better than print().

67. Data::Dump::Streamer

68. Better than Data::Dumper!

69. List::Util

70. List::Util
List::MoreUtils

71. List::Util
List::MoreUtils
Scalar::Util

72. For those go to Steve Lembark's
talk on Util modules tomorrow
morning.

73. parent

74. Stop messing with @ISA

75. # sets up @ISA for you
use parent qw(Some::Base Other::Base);

76. Clear and declarative!

77. Try::Tiny

78. Stop messing with eval {} for
exception handling.

79. use Try::Tiny;
try {
something_that_might_die();
}
catch {
handle_error($_); # note: not $@
}
finally {
clean_up();
};

80. IO::All

81. Maybe not essential

82. But damn handy!

83. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

84. Not just modules

85. App::cpanminus

86. A light-weight cpan client that
understands local::lib

87. App::Ack

88. ack is better than grep

89. Devel::NYTProf

90. Hands-down, the best profiler for
Perl

91. Devel::Cover

92. Tells you how well your tests
cover your code

93. Speaking of tests...

94. prove

95. use it to run your tests

96. Lots of things under Test::

97. Test::More
and/or
Test::Most

98. Many, many others...

99. Perl::Critic

100. Make sure your code confirms to
certain quality standards.

101. You do use coding standards,
right??

102. Moose
and/or
Mouse / Moo / Any::Moose

103. Stop writing your own OO layers

104. Stop doing it inconsistently

105. Stop messing up inheritance,
destructors, accessors and all
those little things that you have to
write over and over and over
again...

106. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

107. File::Spec

108. my $path = join '/', qw(foo bar baz)

109. What if it runs on Windows?
Or VMS?
Or early MacOS?
AcornOS?
QNX?

110. use File::Spec;
my $correct_path =
File::Spec->catdir qw(foo bar
baz);

111. use File::Spec::Functions qw(catdir);
my $path = catdir qw(foo bar baz);

112. Declarative and correct

113. Lots of other functions, too:
● canonpath ● splitpath
● catfile ● splitdir
● rootdir ● catpath
● updir ● abs2rel
● devnull ● rel2abs
● tmpdir ● file_name_is_absolute
● curdir ● case_tolerant

114. Path::Class

115. use Path::Class qw(dir file);
# create dir and file objects...
my $dir = dir('foo', 'bar');
my $file = file('bob', 'file.txt');
# Stringifies with proper separator on
# each supported platform
print "dir: $dirn";
print "file: $filen";
# methods do what you expect...
my $subdir = $dir->subdir('baz');
my $parent = $subdir->parent;
my $dir2 = $file->dir;

116. File::Find

117. Traversing directories in a
filesystem is tricky.
You're not that good.

118. File::Find::Rules

119. If you don't like File::Find,
File::Find::Rules has some very
nice functionality. Try it.

120. File::Touch

121. For when you need to touch a
file. Simple, and works cross-
platform.

122. File::Basename

123. same as the system's basename
and dirname commands.

124. File::Slurp

125. Simple thing... but which is more
readable?

126. my $text =
do { local(@ARGV, $/) = "file.txt"; <> };
or
my $text = read_file 'file.txt';

127. File::ReadBackwards

128. When you need it... you DON'T
want to do it yourself!

129. File::Temp

130. Let this module handle temp files
and directories for you and stop
doing it wrong.

131. File::HomeDir

132. Don't try to find a user's home
directory on your own.

133. File::Which

134. Why are you shelling out to
which?
STOP IT!

135. File::Copy

136. Don't shell out to the system.
Don't write your own copy
routine.
Please, PLEASE, just use
File::Copy.

137. File::LibMagic
and/or
File::MimeInfo

138. If you need to recognize a
common file type...
STOP DOING IT YOURSELF!!!

139. If one doesn't work for you, try
the other.

140. File::Path

141. recursively create and remove
directories

142. File::stat

143. Can you remember this?
my ($dev, $ino, $mode, $nlink, $uid,
$gid, $rdev, $size, $atime, $mtime,
$ctime, $blksize, $blocks) =
stat $file;

144. Maybe this?
my $dev = (stat $file)[0];
my $ino = (stat $file)[1];
my $mode = (stat $file)[2];
my $nlink = (stat $file)[3];
my $uid = (stat $file)[4];
my $gid = (stat $file)[5];
my $rdev = (stat $file)[6];
my $size = (stat $file)[7];
# etc...

145. Try this, instead...
use File::stat;
my $s = stat $file;
$s->dev;
$s->ino;
$s->size;
Much nicer, no?

146. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

147. Tie::IxHash
or
Tie::StoredOrderHash

148. Building your own sucks

149. Try this:
use Tie::StoredOrderHash qw(ordered);
my $hash = ordered [
one => 1, two => 2, three => 3
];
while (my($k, $v) = each %$hash) {
print "$k: $v ";
} # one: 1 two: 2 three: 3

150. Hash::Merge::Simple

151. Recursively merge hash
structures

152. use Hash::Merge::Simple qw(merge);
my $a = {
a => 1, c => 3,
d => { i => 2 }, r => {}
};
my $b = {
b => 2, a => 100,
d => { l => 4 }
};
my $c = merge $a, $b;
# $c is now {
# a => 100, b => 2, c => 3,
# d => { i => 2, l => 4 }, r => {} }

153. Simple, declarative and
correct.

154. Params::Util

155. use Params::Util qw(_SCALAR _HASH _INSTANCE);
sub foo {
my $object = _INSTANCE(shift, 'Foo') or die;
my $image = _SCALAR(shift) or die;
my $opts = _HASHLIKE(shift) || {};
}

156. Sure, it's ugly...

157. But focused on correctly doing
something common and
(surprisingly) tricky

158. Params::Validate

159. The de-facto standard in
parameter validation.

160. Algorithm::Combinatorics

161. Don't do combinatorics on your
own. Your code will be wrong. It
will be slow. It will suck.

162. Set::CrossProduct
or
Set::CartesianProduct::Lazy

163. Just here for shameless self-
promotion.

164. Data::Compare

165. Recursively and correctly
compare data structures.

166. Test::Deep::NoTest

167. More functionality than
Data::Compare.

168. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

169. DateTime

170. The most correct handling of
dates and times in Perl. Use it.

171. DateTime::Format::Strptime
and/or
DateTime::Format::DateManip

172. Use these to transform various
time formats from strings into
DateTime objects

173. Time::Piece

174. Make localtime() and gmtime()
return objects...
use Time::Piece;
my $t = localtime;
print "Time is $tn";
print "Year is ", $t->year, "n";

175. Time::Local

176. Gives you inverse functions for
localtime() and gmtime()
use Time::Local qw(timelocal timegm);
my $localtime = timelocal(
$sec, $min, $hour, $mday, $mon, $year);
my $gmtime = timegm(
$sec, $min, $hour, $mday, $mon, $year);

177. DateTime::Tiny
(and friends)

178. If DateTime is too “heavy” for
you, at least use
DateTime::Tiny, or Date::Tiny
or Time::Tiny

179. Time::ParseDate

180. Parsing dates and times is a
PITA. Use a module...
use Time::ParseDate qw(parsedate);
$epoch_time =
parsedate("12/11/94 2pm", %options)

181. Date::Extract

182. When you need to extract dates
and times from arbitrary blocks of
text...

183. But it tries hard to avoid false-
positives

184. Date::Extract::Surprise

185. For when you're willing to be
surprised at the dates found!

186. Simply works harder to find dates
and times in text, at the cost of
possibly false-positives.

187. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

188. YAML::Any

189. use YAML::Any qw(Dump Load);
$YAML::Indent = 3;
my $yaml = Dump(@objects);
my @objects = Load($yaml);

190. JSON

191. use JSON qw(to_json from_json);
my $json = to_json($perl_scalar);
my $perl_scalar = from_json($json);

192. Text::CSV

193. use Text::CSV;
my $csv = Text::CSV->new({ binary => 1 });
open my $fh, "<:encoding(utf8)", "test.csv";
while ( my $row = $csv->getline( $fh ) ) {
$row->[2] =~ m/pattern/ or next;
push @rows, $row;
}

194. URI
URI::Split
URI::Escape

195. Spreadsheet::Read

196. Parse and read in a bunch of
different spreadsheet formats,
including Excel.

197. XML::Simple

198. For simply reading in and parsing
some XML into a data structure.
For non-simple stuff, look at
Task::Kensho!

199. Check Task::Kensho for more
XML essentials.

200. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

201. Module::Runtime

202. safely and properly load
modules at run-time

203. IO::Interactive

204. Do you know how to properly
test for an interactive terminal?
DOUBTFUL

205. IPC::Run

206. The grand-daddy of running
external commands and
controlling the IO

207. Capture::Tiny

208. Capture stdout and stderr of any
code

209. It Just Plain Works(tm)

210. Net::Server
or
Net::Daemon

211. Writing daemons properly is hard

212. String::ShellQuote

213. (my $unsafe_string =
q{string you're passing to system})
=~ s/([/;()])/$1/g

214. Unsafe, incorrect, and ugly.

215. use String::ShellQuote qw(shell_quote);
my $safe_string = shell_quote
q{something you might pass to
system};

216. Much safer and more correct

217. IPC::System::Simple

218. Make using system() and output
capturing (a-la backticks) safer

219. use IPC::System::Simple
qw(system systemx);
# overrides system() built-in...
# Succeed or die, avoid shell if @args
system("some_command",@args);
# NEVER invokes the shell
systemx("some_command",@args);

220. use IPC::System::Simple
qw(capture capturex);
# Use capture() instead of backticks:
(also works in list context)
# Succeeds or dies,
# avoids shell if @args
my $output =
capture("some_command",@args);
# NEVER invokes the shell
My $output =
capturex("some_command",@args);

221. Introduction
The Little Things
Slightly Bigger Things
Handling Files and Filesystems
Wrangling Data Structures and Types
Dealing with Dates and Times
Reading and Writing File Formats
Potpourri
Conclusion

222. Don't take my word for it

223. Explore the CPAN for yourself

224. Create your own toolkit

225. Be consistent

226. be thoughtful

227. Share what you learn

228. Contribute and help this
language grow!

229. Thanks again.
I'm hercynium on IRC and
twitter.