Effective Perl Programming: Writing Better Programs with Perl

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 95%)
Other sellers (Paperback)
  • All (35) from $1.99   
  • New (7) from $3.65   
  • Used (28) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$3.65
Seller since 2013

Feedback rating:

(88)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
PAPERBACK New 0201419750.

Ships from: San Mateo, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$3.75
Seller since 2011

Feedback rating:

(469)

Condition: New
1998 Paperback New

Ships from: san francisco, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$3.75
Seller since 2011

Feedback rating:

(469)

Condition: New
1998 Paperback New

Ships from: san francisco, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$3.75
Seller since 2011

Feedback rating:

(469)

Condition: New
1998 Paperback New

Ships from: san francisco, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$28.84
Seller since 2007

Feedback rating:

(23298)

Condition: New
BRAND NEW

Ships from: Avenel, NJ

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
$50.00
Seller since 2010

Feedback rating:

(7)

Condition: New
12-30-97 other 1 BRAND NEW! ONLY Expedited orders are shipped with tracking number! *WE DO NOT SHIP TO PO BOX* Please allow up to 14 days delivery for order with standard ... shipping. SHIPPED FROM MULTIPLE LOCATIONS. Read more Show Less

Ships from: San Jose, CA

Usually ships in 1-2 business days

  • Canadian
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$52.85
Seller since 2013

Feedback rating:

(2)

Condition: New
New

Ships from: San Diego, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Page 1 of 1
Showing All
Close
Sort by

Overview

Powerful and flexible, Perl has established itself as a premier programming language, especially as a tool for World Wide Web development, text processing, and system administration. The language features full support for regular expressions, object-oriented modules, network programming, and process management. Perl is extensible and supports modular, cross-platform development.

In Effective Perl Programming, Perl experts Joseph Hall and Randal Schwartz share programming solutions, techniques, pointers, rules of thumb, and the pitfalls to avoid, enabling you to make the most of Perl's power and capabilities.

The authors will help you develop a knack for the right ways to do things. They show you how to solve problems with Perl and how to debug and improve your Perl programs. Offering examples, they help you learn good Perl style. Geared for programmers who have already acquired Perl basics, this book will extend your skill range, providing the tactics and deeper understanding you need to create Perl programs that are more elegant, effective, and succinct. This book also speaks to those who want to become more fluent, expressive, and individualistic Perl programmers.

To help you design and write real-world programs, Effective Perl Programming includes:

  • Perl basics
  • Idiomatic Perl
  • Regular expressions
  • Subroutines
  • References
  • Debugging
  • Usage of packages and modules
  • Object-oriented programming
  • Useful and interesting Perl miscellany

Numerous thought-provoking examples appear throughout the book, highlighting many of the subtleties that make Perl such a fascinating, fun, and powerful language to work with.

0201419750B04062001


Here is a publication very reminiscent of the "Effective C++ " genre by Scott Meyers. This is not a tutorial of Perl fundamentals but "... a book of advice and examples." This guide to efficient and robust Perl scripting practices discusses sixty specific 'items' or problems. Topics range from basics to idiomatic Perl, regular expressions, subroutines and references. Five items discuss debugging methods and techniques. Eight more cover problems of using and writing packages and modules. Examples and discussions range from command differences and invisible interfaces, to interesting Perl one-liners.

Read More Show Less

Editorial Reviews

Library Journal
Perl is an amazingly powerful language that is especially useful for web work with Common Gateway Interfaces. This is not a book for beginners but for people who have some experience being confused by Perl. Hall discusses namespace, regular expressions, references, packages, and object-oriented programming. The goal of this book is not to write clear, legible, slightly verbose Perl code but "toward something more succinct and individualistic."
Booknews
Presents programming solutions, techniques, pointers, rules of thumb, and pitfalls to avoid. Ten chapters include examples and cover basics, idiomatic Perl, regular expressions, subroutines, references, debugging, packages and modules, and object-oriented programming. Intended as a guidebook, not a manual, it is suitable for readers who have a basic understanding of Perl and a few months of practical experience. Annotation c. by Book News, Inc., Portland, Or.
Read More Show Less

Product Details

  • ISBN-13: 9780201419757
  • Publisher: Addison-Wesley
  • Publication date: 12/19/1997
  • Edition description: Subsequent
  • Pages: 288
  • Product dimensions: 7.40 (w) x 9.20 (h) x 0.80 (d)

Meet the Author

Joseph N. Hall is a software designer with interests in object-oriented languages, compilers, and graphical user interfaces. He teaches Perl and World Wide Web classes in association with Stonehenge Consulting, a leading provider of Perl Instruction.

0201419750AB04062001

Read More Show Less

Read an Excerpt

I used to write a lot of C and C++. My last major project before stepping into the world of Perl full time was an interpreted language that, among other things, drew diagrams, computed probabilities, and generated entire FrameMaker books. It comprised over 50,000 lines of platform-independent C++, and it had all kinds of interesting internal features. It was a fun project. It also took two years to write.

It seems to me that most interesting projects in C and/or C++ take months or years to complete. But it also seems to me that a whole lot of ideas that start out being mundane and uninteresting become interesting three-month projects when they are expressed in an ordinary high-level language.

This is one of the reasons why I originally became interested in Perl. I had heard that Perl was an excellent scripting language with powerful string handling, regular expression, and process control features. I learned Perl, and learned to like it, when I was thrown into a project in which most of my work involved slinging around text files. I quickly found myself spending hours writing Perl programs that would have taken me days or weeks to write in a different language. Who should read this book

Effective Perl Programming is a book of advice and examples. It derives from my experience as a Perl programmer and—especially—as a Perl instructor. The book is suitable for readers who have a basic understanding of Perl and a few months of practical experience programming in it. Because Effective Perl Programming is a guidebook, not a manual, readers will need access to a comprehensive reference. I recommend either the Perl man pages (freely available in manyforms, including Unix man and HTML) or Programming Perl.

Although I use a lot of Unix-derived examples in this book, most of what appears here is not specific to Unix. I thought about including Win32 Perl and MacPerl examples but eventually decided that the book would have more integrity and consistency if it didn't stray from Perl's "native" operating system. I do encourage non-Unix developers to read Effective Perl Programming, or at least to give it a careful look. How and why I wrote this book

I've always wanted to be a writer. In childhood I was obsessed with science fiction. I read constantly, sometimes three paperbacks a day, and every so often, wrote some (bad) stories myself. In 1985, I attended the Clarion Science Fiction Writers' workshop in East Lansing, Michigan. Afterward, I spent a year or so occasionally working on short story manuscripts, but never published any fiction. (Not yet, anyway!)

Later on, when I had settled down into a career in software, I met Randal Schwartz. I hired him as a contractor on an engineering project and worked with him for over a year. Eventually he left to pursue teaching Perl full time. After a while, so did I.

In May 1996, I had a conversation with Keith Wollman at a developer's conference in San Jose. When we drifted onto the topic of Perl, he asked me what I would think of a book called Effective Perl. I liked the idea. Scott Meyers's Effective C++ was one of my favorite books on C++, and extending the series to cover Perl would obviously be useful. I couldn't get Keith's idea out of my head. With some help from Randal, I worked out a proposal for the book, and Addison-Wesley accepted it.

The rest—well, that was the fun part. I spent many 12-hour days and nights with FrameMaker in front of the computer screen, asked lots of annoying questions on the Perl 5 Porters list, posted many bug reports to the same list, looked through dozens of books and manuals, wrote many, many little snippets of Perl code, and drank many, many cans of Diet Coke and Diet Pepsi. I even had an occasional epiphany as I discovered very basic things about Perl I had never realized I was missing. After a while, a manuscript emerged.

This book is my attempt to share with the rest of you some of the fun and stimulation I experienced while learning the power of Perl. I certainly appreciate you taking the time to read it, and I hope you will find it useful and enjoyable.

Joseph N. Hall
Chandler, Arizona

Read More Show Less

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

Read More Show Less

First Chapter


Basics

If you are experienced in other languages but new to Perl, you are probably still discovering Perl's idiosyncrasies. This section deals with some of those idiosyncrasies. In particular, it addresses those that can bedevil newly minted Perl programmers who are still attuned to other languages.

For example, you should already know that Perl's variables are generally made up of some piece of punctuation like $ or @ followed by an identifier. But do you know whether different types of variables with the same name, such as $a and @a, are completely independent of one another? They are see Item 1.

You should know that @a is an array, but do you know the difference between $a[$i] and @a[$i]? The latter is a slice-see Item 2.

You should know that the number 0 is false, and that the empty string, "", is false, but do you know whether the string consisting of a single space, " ", is false? It's true-see Item 5.

If you are a more experienced Perl programmer, these first few Items will be mostly review for you. However, you may find some interesting details toward the end of some Items in this section.

Item 1: Know your namespaces.

There are seven separate kinds of variables or variable-like things in Perl: scalar variables, array variables, hash variables, subroutine names, format names, filehandles, and directory handles.

Each of these different kinds of variables has its own namespace. Changing the value of one kind of variable does not in any way affect the value of another kind of variable with the same name. For example, the scalar variable $a is independent of the array variable @a:

$a = 42; Set scalar $a = 42.

Also, each package (see Item 42) in a Perl program defines its own set of namespaces. For example, $a in package main is independent of $a in package foo:

$a = 1; Assuming we start in package main, set scalar $main::a = 1.
package foo; Default package is now foo.
$a = 3.1416; $foo::a is 3.1416; $main::a is still 1.

You have to look to the right as well as the left of an identifier, as Perl does, to determine what kind of variable the identifier refers to. For example, the syntax for accessing elements of arrays and hashes begins with $, not @ or %. The $ means that the result is a scalar value, not that you are refer-ring to a scalar variable:

Not all variable-like things in Perl are prefixed with punctuation characters. Subroutine names can be prefixed with an ampersand, but the ampersand is generally optional. In some cases, parentheses around the subroutine arguments can also be omitted:

Filehandles, format names, and directory handles are not prefixed with punctuation characters, but are recognized in context:

It's not necessarily bad programming style to take advantage of Perl's independent namespaces by giving two different kinds of variables the same name. Sometimes it even seems like the sensible thing to do:

Item 2: Avoid using a slice when you want an element.

Is @a[1] an array element? Or an array slice?

It's a slice.

One of the counterintuitive things encountered by people just beginning to learn Perl is the difference between array elements and array slices. Even after you know the difference, it's not hard to type @ instead of $.

An introductory book or course about Perl will typically begin by telling you that scalar variable names begin with $, and array variable names begin with @. This is, of course, an oversimplification, which is corrected in the next step of the introduction, where you learn that to access element $n of array @a, you use the syntax $a[$n], not @a[$n]. This may seem peculiar. However, it is a consistent syntax. Scalar values, not variables, begin with $, even when those values come from an array or hash.

Therefore, @a[$n] doesn't mean element $n of array @a. Rather, it is something different, called a slice. A slice is a shortcut way of writing a list of elements:

A slice has all the characteristics of a list of variable names. You can even use it on the left-hand side of an assignment expression, or in other places where an lvalue is required:

Now, @a[1] is as much a slice as are @a[1, 2], @a[2, 10], @a[5, 3, 1], @a[3..7], and so on. @a[1] is a list, not a scalar value. It is a list of one element.

These single-element slices are something you should watch out for. They are dangerous critters if not used properly. A slice used in a scalar context returns the last value in the slice, which makes single-element slices work like scalar values, in some cases. For example:

Probably what was intended here was $jolly = $giant[3]. The single element slice @giant[3] is still OK, sort of, since @giant[3] in a scalar context evaluates to its last (and in this case only) element, $giant[3].

Although single-element slices work somewhat like array elements on the right side of assignments, they behave very differently on the left-hand side of assignments. Because a single-element slice is a list, an assignment to a single-element slice is a list assignment, and thus the right-hand side of the assignment is evaluated in a list context. Unintentionally evaluating an operator in a list context can produce dramatic (and unfortunate) results. A good example is the line input operator, :

This reads all the lines from standard input, assigns the first one to element 0 of @info, and ignores the rest! Assigning to @info[3] evaluates in a list context. In a list context, reads all the lines from standard input and returns them as a list.

One more difference between slices and elements is that the expression in the brackets of an element access is evaluated in a scalar context, whereas for slices it is evaluated in a list context. This leads to another example of bizarre behavior that is more difficult to explain: The array @text inside the brackets above is interpreted in a list context. In a scalar context it returns the number of elements in @text, but in a list context it returns the contents of the array itself. The result is a slice with as many elements are there are lines.

The contents of the lines are interpreted as integer indices-if they're text they will likely all turn out to be zero, so the slice will look like @text[0, 0, 0, 0, 0, ...]. Then 'EOF' is assigned to the first element of the slice, and undef to all the rest, which means that this will probably just over-write the first element of @text with undef, leaving everything else alone.

What a mess!

Get in the habit of looking for single-element slices like @a[0] in your pro-grams. Single-element slices are generally not what you want (though they're handy for tricks now and then), and a single-element slice on the left-hand side of an assignment is almost certainly wrong. The -w command line option (see Item 36) will flag many suspect uses of slices.

Slicing for fun and profit

Beginning Perl programmers generally do not (intentionally) use slices, except to select elements from a result: However, slices can be put to some pretty interesting (and weird) uses. For example:

They make a handy way to swap two elements:

Slices are also used in sorting (see Item 14):

You can use hash slices to create hashes from two lists, to overlay the con-tents of one hash onto another, and to "subtract" one hash from another:

Read More Show Less

Preface

I used to write a lot of C and C++. My last major project before stepping into the world of Perl full time was an interpreted language that, among other things, drew diagrams, computed probabilities, and generated entire FrameMaker books. It comprised over 50,000 lines of platform-independent C++, and it had all kinds of interesting internal features. It was a fun project. It also took two years to write.

It seems to me that most interesting projects in C and/or C++ take months or years to complete. But it also seems to me that a whole lot of ideas that start out being mundane and uninteresting become interesting three-month projects when they are expressed in an ordinary high-level language.

This is one of the reasons why I originally became interested in Perl. I had heard that Perl was an excellent scripting language with powerful string handling, regular expression, and process control features. I learned Perl, and learned to like it, when I was thrown into a project in which most of my work involved slinging around text files. I quickly found myself spending hours writing Perl programs that would have taken me days or weeks to write in a different language.

Who should read this book

Effective Perl Programming is a book of advice and examples. It derives from my experience as a Perl programmer and--especially--as a Perl instructor. The book is suitable for readers who have a basic understanding of Perl and a few months of practical experience programming in it. Because Effective Perl Programming is a guidebook, not a manual, readers will need access to a comprehensive reference. I recommend either the Perl man pages (freely available in many forms, including Unix man and HTML) or Programming Perl.

Although I use a lot of Unix-derived examples in this book, most of what appears here is not specific to Unix. I thought about including Win32 Perl and MacPerl examples but eventually decided that the book would have more integrity and consistency if it didn't stray from Perl's "native" operating system. I do encourage non-Unix developers to read Effective Perl Programming, or at least to give it a careful look.

How and why I wrote this book

I've always wanted to be a writer. In childhood I was obsessed with science fiction. I read constantly, sometimes three paperbacks a day, and every so often, wrote some (bad) stories myself. In 1985, I attended the Clarion Science Fiction Writers' workshop in East Lansing, Michigan. Afterward, I spent a year or so occasionally working on short story manuscripts, but never published any fiction. (Not yet, anyway!)

Later on, when I had settled down into a career in software, I met Randal Schwartz. I hired him as a contractor on an engineering project and worked with him for over a year. Eventually he left to pursue teaching Perl full time. After a while, so did I.

In May 1996, I had a conversation with Keith Wollman at a developer's conference in San Jose. When we drifted onto the topic of Perl, he asked me what I would think of a book called Effective Perl. I liked the idea. Scott Meyers's Effective C++ was one of my favorite books on C++, and extending the series to cover Perl would obviously be useful. I couldn't get Keith's idea out of my head. With some help from Randal, I worked out a proposal for the book, and Addison-Wesley accepted it.

The rest--well, that was the fun part. I spent many 12-hour days and nights with FrameMaker in front of the computer screen, asked lots of annoying questions on the Perl 5 Porters list, posted many bug reports to the same list, looked through dozens of books and manuals, wrote many, many little snippets of Perl code, and drank many, many cans of Diet Coke and Diet Pepsi. I even had an occasional epiphany as I discovered very basic things about Perl I had never realized I was missing. After a while, a manuscript emerged.

This book is my attempt to share with the rest of you some of the fun and stimulation I experienced while learning the power of Perl. I certainly appreciate you taking the time to read it, and I hope you will find it useful and enjoyable.

Joseph N. Hall
Chandler, Arizona

0201419750P04062001

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 all of 2 Customer Reviews
  • Anonymous

    Posted April 9, 2003

    Very Helpful

    Very useful tips and techniques. Whether you need help dealing with Perl's 'idiosyncrasies' or making your Perl code run more efficiently, you'll find this book very helpful.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted April 20, 2000

    Expand and Enhance your Perl technique

    Effective Perl Programming gives excellent advice on how to use some intermediate to advanced Perl concepts. While not completely exhaustive on most topics, Hall creates a good foundation that can be easily followed up by Perl's included documentation. A fun read that is excellent for taking a beginner or intermediate Perl programmer's skills to the next level.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing all of 2 Customer Reviews

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