Perl Debugged - Scott_ Peter J_.pdf - Perl Debugged (1253) - superktos86

Perl Debugged

Publisher : Addison Wesley

Pub Date : March 01, 2001

ISBN : 0-201-70054-9

Pages : 288

• Table of

Contents

"This book was a joy to read. It covered all sorts of techniques for debugging,

including 'defensive' paradigms that will eliminate bugs in the first place. As

coach of the USA Programming Team, I find the most difficult thing to teach is

debugging. This is the first text I've even heard of that attacks the problem. It

does a fine job. Please encourage these guys to write more." -Rob Kolstad

Perl Debugged provides the expertise and solutions developers require for

coding better, faster, and more reliably in Perl. Focusing on debugging, the

most vexing aspect of programming in Perl, this example-rich reference and

how-to guide minimizes development, troubleshooting, and maintenance time

resulting in the creation of elegant and error-free Perl code.

Designed for the novice to intermediate software developer, Perl Debugged

will save the programmer time and frustration in debugging Perl programs.

Based on the authors' extensive experience with the language, this book

guides developers through the entire programming process, tackling the

benefits, plights, and pitfalls of Perl programming. Beginning with a guided

tour of the Perl documentation, the book progresses to debugging, testing,

and performance issues, and also devotes a chapter to CGI programming in

Perl. Throughout the book, the authors espouse defensible paradigms for

improving the accuracy and performance of Perl code. In addition, Perl

Debugged includes Scott and Wright's "Perls of Wisdom" which summarize

key ideas from each of the chapters, and an appendix containing a

comprehensive listing of Perl debugger commands.

In this exceptional reference and debugging guide, the authors cover every

aspect of efficient Perl programming, including:

• CGI programming-special tips for debugging this type of Perl program

• How to develop the proper mindset for developing and programming

effectively in Perl

• Perl "gotchas"-how to understand them, work around them, and avoid

them

• "Antibugging"-the authors' rules of thumb on how to code defensively

• The Perl debugger -the authors' guide to using this Perl built-in

Common syntax errors and how to track down their causes

• Semantical errors-why code may appear correct but the programs do

not work

• How to improve the performance of resource-hungry programs

• Tips and advice for programmers moving to Perl from other language

By Peter Scott , Ed Wright

environments

Focusing on the process of Perl programming and guidelines for identifying

and correcting mistakes, Perl Debugged helps the developer to write better

Perl programs immediately and become better programmers in general.

Preface

"It fills my head with ideas, only I don't really know what they are."

— Alice in Through the Looking-Glass and What Alice Found There

Perlness

In the world of languages, the country of Perl is the great melting pot which welcomes all

cultures, religions, and beliefs. "Give me your tired, your poorly-supported programmers,

your huddled masses yearning to be free of artificial limitations," says Perl, and those who

land on its shores find an environment where they are no longer hampered by a language

designer's whimsical notions of elegant semantics and stifling syntactical purity.

Perl's universal availability and ease-of-use make it the most democratic programming

language. Unlike many other languages, a relative beginner can write useful programs,

whereas effective programmers in other languages normally need to spend a lot longer to

learn syntax, operators, and functions. A Perl programmer may possess such expertise, or

may be a newcomer who modified some example script to perform a new function.

But the newcomer has another problem: lack of debugging skills. Experience forces the

canny to develop an innate knack for debugging due to years of accumulated pain. We want

to minimize that pain, because we have suffered it. Perl's ease of use allows programmers

with little knowledge to create usable, if fragile, code. The amount of time it takes to debug a

Perl program can vary dramatically from person to person. Our goal is to help you minimize

the development, debugging, and maintenance time you need for your own Perl programs.

Do not take the title of this book to imply we are debugging Perl itself in these pages. What

few bugs exist in the Perl interpreter are a matter of minute exotica (or exotic minutiae),

rapidly squashed by the fine volunteer crew supporting Perl. A more accurate title would

have been Debugging Your Perl Programs , but that felt too pedestrian and loses the

"unplugged" pun.

We wrote this book because we wanted you to see the development process at work. Most

books on programming contain carefully crafted examples honed through sweaty practice to

work perfectly and stand as mute testimonial to the elegant style of the author. They don't

show you the ugly, irritating process it took to get the examples into shape; yet those

examples did not in fact spring into existence fully formed from the forehead of their creator.

Because you will experience this same process when developing your programs, we want to

guide you through it and describe various ways around the embarrassment, humiliation, and

surprising pitfalls that stand between you and Great Programming.

Within this book, we describe the most common and annoying mistakes a new Perl

programmer might make, and then detail the procedures to identify and correct those bugs

and any others. You should have some knowledge of Perl; several fine tutorials exist to free

us from the onerous responsibility of explaining scalars and arrays and hashes and the like.

This preface includes a few references to some of the most useful of these tutorials.

We will not attempt to define or describe a proper programming " style . " Style is as unique as

an individual—but a few general rules create a common reference so that we can easily read

each other's programs.

Neither is this a "how to program" book. Although we will probe into the mechanics and

underpinnings of the general principle of programming at times, it is not our intention to

inculcate a complete newcomer with the mindset of the programmer's discipline.

Who Are You?

If you've been programming in Perl anywhere from a week to a year and want to speed up

your development cycle, this book is for you. We'll also address some issues related to

developing in a team. This book is intended to assist those who have started learning Perl by

providing practical advice on development practices.

What This Book Covers

Here's what you'll find in the rest of this book:

• Chapter 1 : Introduction and a guided tour of the Perl documentation

• Chapter 2 : Developing the right mindset for programming and developing effectively

• Chapter 3 : "Gotchas" in Perl: Working your way around some of the tricky things to

understand or get right in Perl programming

• Chapter 4 : Antibugging: How to code defensively

• Chapter 5 : How to instrument your code

• Chapter 6 : How to test your Perl programs

• Chapter 7 : A tour of the perl debugger: our guide to using this built-in tool

• Chapter 8 : Types of syntax error and how to track down their causes

• Chapter 9 : Run-time errors

• Chapter 10 : Semantical errors: When your program appears to work but doesn't do

the right thing

• Chapter 11 : How to improve the performance of a resource-hungry (memory, CPU

cycles, and so on) program

• Chapter 12 : Tips and pitfalls for people coming to Perl from other languages

• Chapter 13 : Common Gateway Interface (CGI) programming: special tips for

debugging this type of Perl program

• Chapter 14 : Conclusion

• Appendix A : Reference for the Perl debugger commands

• Appendix B : List of our " Perls of Wisdom "

We will spend a lot of time going through examples of problems and how you might debug

them.

Getting Perl

While this isn't a book about how to install or build perl, [ 1] we owe you at least rudimentary

instructions on how to get a perl of your own.

[1] That's not a typo. By convention, big-P Perl refers to the language in the abstract, whereas little-p perl

refers to the program that runs Perl programs.

• For Windows machines, get the free ActivePerl distribution:

http://www.activeState.com/ActivePerl/download.ht m

• For Macintoshes:

http://www.cpan.org/ports/index.html#ma c

• For binary distributions for all other machines:

http://www.cpan.org/ports /

• For the source of perl itself:

http://www.cpan.org/src /

Building perl from source on a supported Unix architecture requires just these commands

after you download and unpack the right file:

./Configure

make

make test

make install # if the make test succeeds

The Configure step asks you zillions of questions, and most people won't have a clue

what many of those questions are talking about; but the default answers Configure

recommends are usually correct.

For educational purposes, you may want to build a perl that has debugging enabled. (Here

we refer to a perl that lets you use the special -D flag to enable the output of information that

tells you what perl is doing with your program. This has nothing to do with Perl's built-in

interactive debugger—which we discuss in Chapter 7 —all perls have that.) If you want to do

that, build perl from the source, and when Configure asks, " Any additional cc

flags? " paste in whatever it already shows between brackets as a default and add " -

DDEBUGGING ". See the perlrun POD page (explained later) for more information.

We occasionally refer to modules that are not part of the core Perl distribution but that can be

found on the Comprehensive Perl Archive Network (CPAN). For instructions on how to find,

download, and install a module from CPAN, see http://www.cpan.org/misc/cpan-faq.htm l .

Typographical Conventions

We use the following conventions in this book:

• Standard text: Times Roman

• Author's comments: Arial

• Code examples and URLs: Courier

• User input: bold Courier

Sometimes our code examples have line breaks where none existed in the original. In places

where these line breaks would cause problems or aren't obvious, we've put a backslash ( \ )

at the end of the line to indicate that the line should be joined with the next one.

Occasionally, we want you to know which of us is talking to you, so we

have this style of comment to let you know. (This is Ed, by the way.)

Those marginal icons are part of the terrific artwork created by my wife's

sister, Ann Palmer, for this book. (This is Peter, by the way.)

For Further Reference

Visit this book's Web site at http://www.perldebugged.co m .

Get introductions to Perl programming from the following (in rough order of usefulness):

Perl Debugged - Scott_ Peter J_.pdf

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: