Computer Science & Perl Programming

Overview

In its first five years of existence, The Perl Journal ran 247 articles by over 120 authors. Every serious Perl programmer subscribed to it, and every notable Perl guru jumped at the opportunity to write for it. TPJ explained critical topics such as regular expressions, databases, and object-oriented programming, and demonstrated Perl's utility for fields as diverse as astronomy, biology, economics, AI, and games. The magazine gave birth to both the Obfuscated Perl Contest and the Perl Poetry contest, and remains...

See more details below
Paperback (1ST)
$31.16
BN.com price
(Save 37%)$49.99 List Price
Other sellers (Paperback)
  • All (23) from $1.99   
  • New (8) from $31.15   
  • Used (15) from $1.99   
Computer Science & Perl Programming: Best of The Perl Journal

Available on NOOK devices and apps  
  • NOOK Devices
  • Samsung Galaxy Tab 4 NOOK 7.0
  • Samsung Galaxy Tab 4 NOOK 10.1
  • NOOK HD Tablet
  • NOOK HD+ Tablet
  • NOOK eReaders
  • NOOK Color
  • NOOK Tablet
  • Tablet/Phone
  • NOOK for Windows 8 Tablet
  • NOOK for iOS
  • NOOK for Android
  • NOOK Kids for iPad
  • PC/Mac
  • NOOK for Windows 8
  • NOOK for PC
  • NOOK for Mac
  • NOOK for Web

Want a NOOK? Explore Now

NOOK Book (eBook)
$22.99
BN.com price
(Save 42%)$39.99 List Price

Overview

In its first five years of existence, The Perl Journal ran 247 articles by over 120 authors. Every serious Perl programmer subscribed to it, and every notable Perl guru jumped at the opportunity to write for it. TPJ explained critical topics such as regular expressions, databases, and object-oriented programming, and demonstrated Perl's utility for fields as diverse as astronomy, biology, economics, AI, and games. The magazine gave birth to both the Obfuscated Perl Contest and the Perl Poetry contest, and remains a proud and timeless achievement of Perl during one of its most exciting periods of development.Computer Science and Perl Programming is the first volume of The Best of the Perl Journal, compiled and re-edited by the original editor and publisher of The Perl Journal, Jon Orwant. In this series, we've taken the very best (and still relevant) articles published in TPJ over its 5 years of publication and immortalized them into three volumes. This volume has 70 articles devoted to hard-core computer science, advanced programming techniques, and the underlying mechanics of Perl.Here's a sample of what you'll find inside:

  • Jeffrey Friedl on Understanding Regexes
  • Mark Jason Dominus on optimizing your Perl programs with Memoization
  • Damian Conway on Parsing
  • Tim Meadowcroft on integrating Perl with Microsoft Office
  • Larry Wall on the culture of Perl
Written by 41 of the most prominent and prolific members of the closely-knit Perl community, this anthology does what no other book can, giving unique insight into the real-life applications and powerful techniques made possible by Perl.Other books tell you how to use Perl, but this book goes far beyond that: it shows you not only how to use Perl, but what you could use Perl for. This is more than just The Best of the Perl Journal — in many ways, this is the best of Perl.

These are the best and most timeless articles printed in "The Perl Journal." Topics include networking, software development, coding style, internals, and others.

Read More Show Less

Product Details

  • ISBN-13: 9780596003104
  • Publisher: O'Reilly Media, Incorporated
  • Publication date: 11/11/2002
  • Edition description: 1ST
  • Edition number: 1
  • Pages: 762
  • Product dimensions: 7.00 (w) x 9.32 (h) x 1.73 (d)

Meet the Author

Jon Orwant founded The Perl Journal and received the White Camel lifetime achievement award for contributions to Perl in 2004. He's Engineering Manager at Google, where he leads Patent Search, visualizations, and digital humanities teams. For most of his tenure at Google, Jon worked on Book Search, and he developed the widely used Google Books Ngram Viewer. Prior to Google, he was CTO of O'Reilly, Director of Research at France Telecom, and a Lecturer at MIT. Orwant received his doctorate from MIT's Electronic Publishing Group in 1999.

Read More Show Less

Table of Contents

Foreword;
Preface;
Finding Perl Resources;
Conventions Used in This Book;
Comments and Questions;
Acknowledgments;
Chapter 1: Introduction;
1.1 History of TPJ;
1.2 Computer Science and Perl Programming;
Beginner Concepts;
Chapter 2: All About Arrays;
2.1 Basics;
2.2 Positions;
2.3 Position Versus Count;
2.4 Foreach Loops;
2.5 The Reverse and Sort Functions;
2.6 Slices;
2.7 Adding and Deleting Values;
2.8 Lists to Strings and Back Again;
2.9 Putting It All Together;
Chapter 3: Perfect Programming;
3.1 Warnings with -w;
3.2 The strict Pragma;
3.3 Tainting and Safe;
3.4 Checking Return Values;
3.5 Planning for Failure;
3.6 The Perl Debugger;
3.7 The Perl Profiler;
3.8 Stack Traces;
Chapter 4: Precedence;
4.1 What Is Precedence?;
4.2 Rules and More Rules;
4.3 An Explosion of Rules;
4.4 Precedence Traps and Surprises;
4.5 List Operators and Unary Operators;
4.6 Complete Rules of Precedence;
4.7 How to Remember All the Rules;
4.8 Quiz;
4.9 Answers;
Chapter 5: The Birth of a One-Liner;
Chapter 6: Comparators, Sorting, and Hashes;
6.1 Sorting;
6.2 Sorting Hashes;
6.3 Efficient Sorting;
6.4 Further Reading;
Chapter 7: What Is Truth?;
7.1 The undef Function;
7.2 Back to Truth;
7.3 Truth in Context;
7.4 Applications;
7.5 Conclusion;
Chapter 8: Using Object-Oriented Modules;
8.1 Modules and Their Functional Interfaces;
8.2 Modules with Object-Oriented Interfaces;
8.3 What Can You Do with Objects?;
8.4 What’s in an Object?;
8.5 What Is an Object Value?;
8.6 So Why Do Some Modules Use Objects?;
Chapter 9: Unreal Numbers;
9.1 A Surprising Program;
9.2 The Right Way;
Chapter 10: CryptoContext;
10.1 Context;
10.2 Prototypes;
10.3 Subroutine Calls;
10.4 Putting Them All Together;
10.5 Conclusion;
Chapter 11: References;
11.1 Who Needs Complicated Data Structures?;
11.2 The Solution;
11.3 Making References;
11.4 Using References;
11.5 An Example;
11.6 Solution;
11.7 The Rest;
11.8 In Summary;
Chapter 12: Perl Heresies;
12.1 Don’t Use -w;
12.2 Don’t Use Regular Expressions Just Because They’re Cool;
12.3 Don’t Always Use Modules;
12.4 Partial Solutions Are Okay;
Regular Expressions;
Chapter 13: Understanding Regular Expressions, Part I;
13.1 The Story of Fred;
13.2 Reality Check;
13.3 Regular Expression Background;
13.4 Perl Regex Engine Basics;
13.5 The First Real Rule of Regexes;
13.6 A Single Match Attempt;
13.7 Options, Options, Options;
13.8 How the Path Is Chosen;
13.9 That’s Pretty Much It;
Chapter 14: Understanding Regular Expressions, Part II;
14.1 Knowing Versus Knowing on Paper;
14.2 Efficiency;
14.3 Benchmarking;
14.4 Conclusion;
Chapter 15: Understanding Regular Expressions, Part III;
Chapter 16: Nibbling Strings;
16.1 The Problem;
16.2 Going on a Diet;
Chapter 17: How Regexes Work;
17.1 Machines;
17.2 Blank Arrows;
17.3 Rules Again;
17.4 How to Turn a Regex into a Penny Machine;
17.5 What Do You Mean, Done?;
17.6 The Regex Module;
17.7 Implications for Perl;
17.8 What About Backreferences?;
17.9 Internals of Regex.pm;
17.10 Lies;
17.11 Other Directions;
17.12 Bibliography;
Computer Science;
Chapter 18: Infinite Lists;
18.1 Hamming’s Problem;
18.2 Streams;
18.3 Hamming’s Problem Revisited;
18.4 Dataflow Programming;
18.5 Other Directions;
18.6 References;
Chapter 19: Compression;
19.1 Morse Code;
19.2 Ambiguous Codes;
19.3 Huffman Coding;
19.4 The Code;
19.5 The Rub;
19.6 Another Rub;
19.7 Other Methods;
19.8 Other Directions;
19.9 Bibliography;
Chapter 20: Memoization;
20.1 Recursive Functions;
20.2 The Memoize Module;
20.3 Module Internals;
20.4 Some Other Applications of Memoization;
20.5 When Memoizing Doesn’t Work;
20.6 Bibliography;
Chapter 21: Parsing;
21.1 A Sample Parse;
21.2 Formal Grammars;
21.3 The Different Types of Parsers;
21.4 Building a Parser with Parse::RecDescent;
21.5 How Parse::RecDescent Works;
21.6 An In-Depth Example;
21.7 Advanced Features of Parse::RecDescent;
21.8 Practical Applications of Parsing;
21.9 Limitations of Parse::Recdescent;
21.10 More Information;
21.11 Acknowledgments;
Chapter 22: Trees and Game Trees;
22.1 What Is a Tree?;
22.2 Formal Definition;
22.3 Markup Language Trees;
22.4 Building Your Own Trees;
22.5 An Implementation: Game Trees for Alak;
22.6 References;
Chapter 23: B_Trees;
23.1 A Review of Binary Trees;
23.2 The Problem with Binary Trees;
23.3 B-Trees Are Always Balanced;
23.4 A Guided Tour of the Program;
23.5 Moving Down;
23.6 Moving Up;
23.7 Details;
23.8 Other Directions;
23.9 Bibliography;
Chapter 24: Making Life and Death Decisions with Perl;
24.1 Probability Theory;
24.2 Whoa!;
24.3 Perl;
24.4 Last Words;
Chapter 25: Information Retrieval;
25.1 Text Searches on Manual Pages;
25.2 The Implementation;
25.3 Relevance Feedback;
25.4 “Advanced” Search Operators;
25.5 Conclusion;
25.6 References;
Chapter 26: Randomness;
26.1 Congruential Generators;
26.2 Choosing the Seed;
26.3 LFSRs;
26.4 References;
Chapter 27: Random Number Generators and XS;
27.1 Random Versus Pseudorandom Numbers;
27.2 Linear Congruential Generators Revisited;
27.3 A Better Generator for Perl;
27.4 Bridging C and Perl with XS;
27.5 Acknowledgments;
27.6 References;
Programming Techniques;
Chapter 28: Suffering from Buffering;
28.1 What Is Buffering?;
28.2 Surprise!;
28.3 Disabling Inappropriate Buffering;
28.4 Hot and Not Hot;
28.5 Other Perils of Buffering;
28.6 Flushing on Command;
28.7 Other Directions;
28.8 Summary;
Chapter 29: Scoping;
29.1 Package Variables;
29.2 The Current Package;
29.3 Package Variable Trivia;
29.4 Lexical Variables;
29.5 local and my;
29.6 What Good Is local?;
29.7 When to Use my and When to Use local;
29.8 Other Properties of my Variables;
29.9 my Variable Trivia;
29.10 Declarations;
29.11 Summary;
Chapter 30: Seven Useful Uses of local;
30.1 1. Special Variables;
30.2 2. Localized Filehandles;
30.3 3. The First Class Filehandle Trick;
30.4 4. Aliases;
30.5 5. Dynamic Scope;
30.6 6. Dynamic Scope Revisited;
30.7 7. Perl 4 and Other Relics;
30.8 Summary;
Chapter 31: Parsing Command-Line Options;
31.1 Option Parsing Conventions;
31.2 The Simplest Way;
31.3 The Easy Way;
31.4 The Advanced Way;
31.5 Other Option Handling Modules;
Chapter 32: Building a Better Hash with tie;
32.1 Introduction;
32.2 The Problem;
32.3 Discussion;
32.4 Attempted Solutions;
32.5 A Working Data Structure;
32.6 Implementation;
32.7 Implementing a Tied Hash;
32.8 Using a Tied Hash;
32.9 Testing;
32.10 Optimizations;
32.11 Making It a Module;
32.12 Summing Up;
32.13 References;
Chapter 33: Source Filters;
33.1 Concepts;
33.2 Using Filters;
33.3 Writing a Source Filter;
33.4 The Debug Filter;
33.5 Conclusion;
Chapter 34: Overloading;
34.1 Defining Your Own Types;
34.2 Adding Methods to the Date Class;
34.3 A Minor Problem;
34.4 Introducing Overloading;
34.5 Overloading More Methods;
34.6 Overloading and Associativity;
34.7 Full Overloading Implementations;
34.8 Automatically Generating Overloaded Methods;
34.9 The Fallback Mechanism;
34.10 Overloading and Inheritance;
34.11 Limitations of Operator Overloading;
34.12 Conclusion;
34.13 References;
Chapter 35: Building Objects Out of Arrays;
35.1 OO Basics;
35.2 Arrays Are Faster;
35.3 Arrays Use Less Space;
35.4 Arrays Can Prevent Attribute Collisions;
35.5 Arrays Can Prevent Misspellings;
35.6 Disadvantages;
35.7 Other Approaches;
Chapter 36: Hiding Objects with Closures;
36.1 A Simple Example;
36.2 Closures;
36.3 What About Inheritance?;
36.4 Conclusion;
Chapter 37: Multiple Dispatch in Perl;
37.1 Multiple Dispatch;
37.2 Multiple Dispatch via “Tests-in-Methods”;
37.3 Multiple Dispatch via a Table;
37.4 Comparing the Two Approaches;
37.5 Dynamic Dispatch Tables;
37.6 The Class::Multimethods Module;
Software Development;
Chapter 38: Using Other Languages from Perl;
38.1 Introducing Inline.pm;
38.2 A More Complex Example;
38.3 Calling C Functions from Perl;
38.4 Manipulating Perl’s Stack;
38.5 How Inline Works;
38.6 Creating Perl Extensions;
38.7 Inline::Config;
38.8 XS and SWIG;
38.9 Using Perl as C’s Memory Manager;
38.10 Benchmarks;
Chapter 39: SWIG;
39.1 Hooks by Hand;
39.2 Wrapping a C Function;
39.3 Interface Files;
39.4 An In-Depth Example: Emulating top;
39.5 The top Emulator;
39.6 Conclusion;
Chapter 40: Benchmarking;
40.1 The Trouble with time( );
40.2 Better Resolution with times;
40.3 The Benchmark Module;
40.4 Example: Summing an Array;
40.5 Conclusion;
Chapter 41: Building Software with Cons;
41.1 Make Doesn’t Do the Right Thing;
41.2 The Solution: Cons;
41.3 Summary;
Chapter 42: MakeMaker;
42.1 Reasons to Use MakeMaker;
42.2 h2xs;
42.3 Components of Makefile.PL;
42.4 A Deeper Example;
42.5 Advanced Makefile Features;
42.6 MakeMaker and Installation of Modules;
42.7 perllocal.pod;
Chapter 43: Autoloading Perl Code;
43.1 Why Autoload?;
43.2 Using the AutoLoader;
43.3 How Autoloading Works;
43.4 AutoSplitting Your Module;
43.5 AutoLoading Scripts;
43.6 AutoLoading C Programs;
43.7 Summary;
Chapter 44: Debugging and Devel::;
44.1 Runtime Examination of Data;
44.2 Profiling and Coverage Testing;
44.3 Reference Manipulation;
44.4 Helping C and C++ Programmers;
44.5 Rolling Your Own;
44.6 Which Should You Use?;
Networking;
Chapter 45: Email with Attachments;
45.1 What Is MIME, and Why Do I Care?;
45.2 How Does MIME Encode Data?;
45.3 Multiple Pieces of MIME;
45.4 How to Create a Mime Message;
45.5 An Alternate Route;
45.6 A Full-Blown Example;
45.7 Conclusion;
Chapter 46: Sending Mail Without sendmail;
46.1 Some Email Background;
46.2 The Mail Itself;
46.3 Sending Mail in Six Easy Steps;
46.4 What Next?;
Chapter 47: Filtering Mail;
47.1 What Is It?;
47.2 A Very Simple Mail Filter;
47.3 Separating Mail into Folders;
47.4 Mail and News;
47.5 A Complete Filter;
47.6 Caveats;
47.7 Conclusion;
Chapter 48: Net::Telnet;
48.1 The Problem;
48.2 The Solution;
48.3 Telnetting the Hard Way;
48.4 Telnetting the Easy Way;
48.5 Telnetting the Easiest Way;
48.6 Special Considerations;
48.7 Other Features;
Chapter 49: Microsoft Office;
49.1 Background;
49.2 The Problem;
49.3 The Solution;
49.4 Wait, There’s More;
Chapter 50: Client-Server Applications;
50.1 Using the inetd Super-Daemon;
50.2 A Standalone Server;
50.3 A Threaded Server;
50.4 Launching Standalone Servers from inetd;
50.5 Further Information;
Chapter 51: Managing Streaming Audio;
51.1 Playlists, Streams, and ID3 Tags;
51.2 Apache::MP3;
51.3 Conclusion;
Chapter 52: A 74-Line Ip Telephone;
52.1 Sound Cards and /dev/dsp;
52.2 The Simple Version;
52.3 Adding an MP3 Encoder;
52.4 Summary;
52.5 References;
Chapter 53: Controlling Modems;
53.1 Initializing Your Modem;
53.2 Getting Your Modem to Dial;
53.3 To Block or Not to Block?;
53.4 What’s Next?;
53.5 Afterword;
53.6 References;
Chapter 54: Using Usenet from Perl;
54.1 Finding Newsgroups;
54.2 Retrieving Articles;
54.3 Posting Articles;
Chapter 55: Transferring Files with FTP;
55.1 A Simple Example;
55.2 Multiple FTP Connections;
55.3 Transferring Files Between Servers;
Chapter 56: Spidering an FTP Site;
56.1 Motivation;
56.2 Net::FTP;
56.3 Downloading a File (the Simple Case);
56.4 Recursion;
56.5 Downloading a File Tree (the Recursive Case);
56.6 Uploading a File (the Simple Case);
56.7 Uploading a File Tree (the Recursive Case);
56.8 Applications;
Chapter 57: DNS Updates with Perl;
57.1 DNS Basics;
57.2 DNS Servers;
57.3 Dynamic Update;
57.4 Setting Up Your Nameserver;
57.5 Delegating the Zone;
57.6 Using Net::DNS::Update;
57.7 Paths for Futher Exploration;
Databases;
Chapter 58: DBI;
58.1 The Architecture of DBI;
58.2 Why DBI?;
58.3 The Modules;
58.4 Handles;
58.5 Resources;
58.6 Sample Code;
Chapter 59: Using DBI with Microsoft Access;
59.1 The Win32-Access-ODBC-DBI::DBD Checklist:;
59.2 References;
Chapter 60: DBI Caveats;
60.1 DBI and Loops;
60.2 Placeholders;
60.3 Fetches;
60.4 Bind Columns;
60.5 Error Checking;
60.6 Transactions;
60.7 References;
Chapter 61: Beyond Hardcoded Database Applications with DBIx::Recordset;
61.1 CRUD Without SQL;
61.2 Sample Usage;
61.3 A DBI Version;
61.4 Conclusion;
Chapter 62: Win32::ODBC;
62.1 Win32::ODBC Basics;
62.2 Demystifying SQL;
62.3 Installing Win32::ODBC;
62.4 Getting Started;
62.5 Debugging;
62.6 CRUD;
62.7 Transactions;
62.8 Data Sources;
62.9 Data Dictionary;
62.10 Conclusion;
Chapter 63: Net::LDAP;
63.1 What Is LDAP?;
63.2 Setting Up an OpenLDAP Server;
63.3 Loading Data into the Directory;
63.4 A Searchable Web Interface to Manage Your Directory;
63.5 Where LDAP Is Going;
63.6 References;
Chapter 64: Web Databases the Genome Project Way;
64.1 The ACEDB Database;
64.2 ACEDB Objects and Classes;
64.3 Accessing ACEDB from Perl;
64.4 ACEDB Meets the Web;
64.5 Registering ACEDB Displays;
64.6 Conclusions;
64.7 References;
Chapter 65: Spreadsheet::WriteExcel;
65.1 Using Spreadsheet::WriteExcel;
65.2 How the Spreadsheet::WriteExcel Module Works;
65.3 Alternative Ways of Writing to Excel;
65.4 Reading from Excel;
65.5 Win32::OLE;
65.6 Obtaining Spreadsheet::WriteExcel;
65.7 References;
Internals;
Chapter 66: How to Improve Perl;
Chapter 67: Components of the Perl Distribution;
67.1 The Components of Perl;
67.2 Summary;
Chapter 68: Basic Perl Anatomy;
68.1 How Perl Works;
68.2 Lexical Analysis;
68.3 Parsing;
68.4 Compilation;
68.5 Execution;
68.6 Perl Subsystems;
68.7 For Further Reading;
Chapter 69: Lexical Analysis;
69.1 Tokenizing;
69.2 Perl’s Lexer;
69.3 Lexer Variables;
69.4 Tokenizing Considerations;
69.5 Further Information;
Chapter 70: Debugging Perl Programs with -D;
70.1 What -D Does for You;
70.2 Trace Execution with -Dt;
70.3 Stack Snapshots with -Ds;
70.4 Syntax Tree Dump with -Dx;
70.5 Regular Expression Parsing and Execution with -Dr;
70.6 Method and Overloading Resolution with -Do;
70.7 Context (Loop) Stack Processing with -Dl;
70.8 Tokenizing and Parsing with -Dp;
70.9 Other -D Debugging Flags;
Chapter 71: Microperl;
71.1 Bootstrapping;
71.2 Building Microperl;
71.3 How Microperl Works;
71.4 Practical Uses for Microperl;
71.5 Problems;
71.6 Future Work;
Colophon;

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing 1 Customer Reviews
  • Anonymous

    Posted May 18, 2004

    Computer Science and Perl Programming

    Ahh how I miss The Perl Journal. This volume brings me right back to the good old days of humor and fine code. Unfortunately, The Perl Journal has been relegated to a quarterly supplement appearing in Sys Admin magazine. Thankfully, some of the knowledge found in the pages of The Perl Journal has been compiled here. Computer Science and Perl Programming is a collection of 70 articles from The Perl Journal. It is the first volume of a set of three and, in my opinion, the best volume. Jon Orwant, the original editor of The Perl Journal, has done a great job in putting together this volume. This volume is divided into tips for beginners, regular expressions, data structures, networking, databases, software development processes, object-oriented programming, and advanced Perl programming techniques. I particularly enjoyed the regular expressions, and networking sections. The data structures section was also very useful, as data structures in Perl can tend to be a bit odd. This volume has a good bit of programming knowledge crammed into it, and seems to be a bit more serious than the other two volumes. All in all, a great read and a great reference to keep around. I would definitely advise anyone interested in Perl to pick up this set, you won¿t regret it.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing 1 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)