Your textbook…
Effective Perl Programming: Writing Better Programs with Perl
ISBN-10: 0-201-41975-0
ISBN-13: 978-0-201-41975-7
Published by Addison-Wesley Professional
© 1998
Pub. Date: Dec 30, 1997
Format: Paper
Table of Contents
Foreword.
Preface.
Acknowledgements.
Introduction.
Basics.
Item 1: Know your namespaces.
Item 2: Avoid using a slice when you want an element.
Item 3: Don’t assign undef when you want an empty list.
Item 4: String and numeric comparisons are different.
Item 5: Remember that 0 and “” are false.
Item 6: Understand conversions between strings and numbers.
Idiomatic Perl.
Item 7: Use $_ for elegance.
Item 8: Know the other default arguments: @_, @ARGV, STDIN.
Item 9: Know common shorthands and syntax quirks.
Item 10: Avoid excessive punctuation.
Item 11: Consider different ways of reading from a stream.
Item 12: Use foreach, map and grep as appropriate.
Item 13: Don’t misquote.
Item 14: Learn the myriad ways of sorting.
Regular Expressions.
Item 15: Know the precedence of regular expression operators.
Item 16: Use regular expression memory.
Item 17: Avoid greed when parsimony is best.
Item 18: Remember that whitespace is not a word boundary.
Item 19: Use split for clarity, unpack for efficiency.
Item 20: Avoid using regular expressions for simple string operations.
Item 21: Make regular expressions readable.
Item 22: Make regular expressions efficient.
Subroutines.
Item 23: Understand the difference between my and local.
Item 24: Avoid using @_ directly - unless you have to.
Item 25: Use wantarray to write subroutines returning lists.
Item 26: Pass references instead of copies.
Item 27: Use hashes to pass named parameters.
Item 28: Use prototypes to get special argument parsing.
Item 29: Use subroutines to create other subroutines.
References.
Item 30: Understand references and reference syntax.
Item 31: Create lists of lists with references.
Item 32: Don’t confuse anonymous arrays with list literals.
Item 33: Build C-style structs with anonymous hashes.
Item 34: Be careful with circular data structures.
Item 35: Use map and grep to manipulate complex data structures.
Debugging.
Item 36: Enable static and/or run-time checks.
Item 37: Use debugging and profiling modules.
Item 38: Learn to use a debugging version of Perl.
Item 39: Test things by using the debugger as a Perl shell.
Item 40: Don’t debug too much at once.
Using Packages and Modules.
Item 41: Don’t reinvent the wheel - use Perl modules.
Item 42: Understand packages and modules.
Item 43: Make sure Perl can find the modules you are using.
Item 44: Use perldoc to extract documentation for installed modules.
Writing Packages and Modules.
Item 45: Use h2xs to generate module boilerplate.
Item 46: Embed your documentation with POD.
Item 47: Use XS for low-level interfaces and/or speed.
Item 48: Submit your useful modules to the CPAN.
Object-Oriented Programming.
Item 49: Consider using Perl’s object-oriented programming features.
Item 50: Understand method inheritance in Perl.
Item 51: Inherit data explicitly.
Item 52: Create invisible interfaces with tied variables.
Miscellany.
Item 53: Use pack and unpack for data munging.
Item 54: Know how and when to use eval, require, and do.
Item 55: Know when, and when not, to write networking code.
Item 56: Don’t forget the file test operators.
Item 57: Access the symbol table with typeglobs.
Item 58: Use @{[Ó]} or a tied hash to evaluate expressions inside strings.
Item 59: Initialize with BEGIN; finish with END.
Item 60: Some interesting Perl one-liners.
Appendix A: sprintf.
Appendix B: Perl Resources.
Index. 0201419750T04062001
