on December 18, 1999
After reading rave reviews about this book all over the net, I decided to check it out. I found it a bit disappointing for several reasons. First, there appear to be type setting errors that are distracting. For example, there are sections with example code with text that follows, only the text that follows appears to be introducing the next code snippet, but is actually describing the snippet above (off by 1 error?) Indeed the final code snippet in a section has no following explanatory text.
This is only a problem early on though because as the book progresses, the authors stop describing the code examples! In fact, I found myself trying to figure out what the text was doing in the chapters since all of the concepts were explained in code (without full explanations in the text). <this is a minor exaggeration>
In addition, I found the unrelated annecdotes and allusions and obscure literary quotes a further distraction. I'm sure there is a certain academic audience that would appreciate this, but I hate having to look up words only to find out I didn't really need to look them up ;-).
Some other things I disliked were the absence of hashes in the data structures section (perl has built in hashes, so you'd think a discussion on what a hash is, and hashing algorithms would be included in a perl algorithms book), and the description of algorithm analysis was too short.
On the up side, the sorting and searching sections are very thorough (the perl code implementing them, not the text explaining the code), as are the other sections. If its perl your after, this book has some of the best perl code in print (save for Joseph Hall's "Effective Perl").
In summary, if you already understand these topics, then this book will show you some excellent perl code to implement them. If you do not understand the data structures and algorithms already, I don't think this book is going to make them crystal clear (though the authors are good about referring the reader to other sources).
4 camels for the high quality perl code and thoroughness, but it could have been 5 if the authors followed through with the type of supporting text that Hall did in EP.
This book ia fairly good introduction to the use of PERL in developing and implementing various algorithms, including scientific and cryptographic ones. Fortunately, source is included, setting the book apart from the usual books on computer algorithms.
The first few chapters outline PERL data structures, with the built-in data structures discussed, along with a discussion of how to create new ones. The dynamic nature of arrays in PERL is emphasized, and this is a feature that sets PERL way above other languages, such as C and C++. Linked lists are given a detailed treatment along with garbage collection in PERL. The authors are careful to point out that reference counting in PERL will fail when one is dealing with a circle of reference values.
A discussion of sorting follows, with radix and hybrid sorts being the most useful of the algorithms discussed. The authors give a useful comparison study of the running time of the sorting algorithms. This is followed by a discussion of searching algorithms, which unfortunately omits any details of dynamic programming, which is useful in applying PERL to areas such as computational biology.
The authors give a very interesting treatment of how to do set operations using PERL in the next chapter. They did not treat the case of fuzzy sets in detail though, unfortunately.
Matrix algorithms are discussed next, with the PERL modules MatrixRead and PDL integrated into the discussion. I have only used PDL and its graphic library PGPLOT and have had varying degress of success with it. PERL still has a long way to go before it is accepted as a language suitable for numerical computations.
Graph algorithms are the subject of the next chapter. The most useful section is the one on minimum spanning trees, so useful in network routing algorithms.
This is followed by a thorough discussion of string algorithms in Chapter 9. These algorithms are extremely important in current applications, such as string matching and alignment in computational biology. That the authors give the source code for the algorithms is extremely helpful to those who need to apply these algorithms.
The authors return to geometric algorithms in the next chapter, with only elementary ones being discussed, with brief overviews of PERL graphics modules available.
Number systems and numerical precision are taken up in the next chapter, with 32 bit precision implemented in the discussion. The authors do however discuss how large number arithmetic can be implemented in PERL via the BigFloat and BigInt modules. This is followed by modular arithmetic and number theory , with PERL code given for the Miller-Rabin primality test. This chapter is very short, but it sets up the next chapter on cryptography, which begins with a discussion of passwords, with a PERL program given that checks valid passwords. Then, interestingly, a PERL 1-liner is given for cracking a password list. The discussion on passwords should be of interest to individuals first entering the field of computer security. This is followed by a fairly complete elaboration on authentication and checksums. Encryption of data is discussed in the next section, along with a brief mention of the AES, which at the time of publication of this book, was not settled. The RSA algorithm is discussed also, with a 3-line PERL code given for it, along with a more instructive version later. Only one section on steganography is included, and since this is a subject of intense research with useful applications, this is somewhat disappointing.
The last three chapters covers probability and statistics and numerical analysis, and given the growing use of PDL in astrophysics and other areas of science, this is a fitting way to end the book. PERL code is given for the most popular probability distributions, and also for some of the standard statistical tests. Only some rudimentary algorithms are given for calculus and data interpolation, but the discussion should prepare the reader for more advanced reading in numerical algorithms using PERL and the use of PDL.
on October 28, 1999
When I heard that O'Reilly was publishing a book on Algorithms in Perl I couldn't wait to get my hands on it. Well last month I did and it was great!
The clearly written text contains the usual light, easy-reading tone and occasional humorous elements found in most O'Reilly books. The authors include plenty of pictures and diagrams for those who learn visually (rather then by reciting words out loud). The Perl code within is concise, with comments when necessary, and makes use of the objects when possible. If you plan to read this book you should know Perl because the more advanced level of the code could cause problems for the non-Perl or beginning Perl Programmer. However, to a Perl programmer who is comfortable with the language the code reads clean and understandably - sometimes it's even more clear then pseudocode.
The text covers a broad range of topics (with varying levels of complexity). When I was reading I recalled things I learned in college classes such as: Data Structures, Algorithm Analysis, Discrete Math, Calculous, Linear Algebra, Statistics, Compiler Design, Signal Processing, and even some good old fashion high school geometry. I found this extremely helpful because the broad nature of the book doesn't allow the authors to cover a topic in great detail. They do review each topic area giving the proper terminology used along with background of how the field developed.
Within the different chapters the authors present various code segments. For some segments the authors have written there own code to implement the algorithms. In other cases, as is Perl custom, the authors have searched CPAN for the modules that implement the algorithm. Then the example code demonstrates the proper use of that module.
One of the features I really enjoyed is that each chapter can stand on its own as a nice review of the algorithms in that section. (In cases where they build on other sections you are reminded where to go and read.) Another great feature the authors include is the references - all the web sites and books you'll need are listed in Appendix A, by topic area.
The only thing I really felt was missing was a discussion on some AI topics such as Neural Networks and Genetic Programming. (If you're interesting Neural Networks in general check out The Linux Journal July 1999 p 44. For Genetic Programming in Perl check out The Perl Journal Fall 1999 p 34)
Overall, this book explains methods of implementing Algorithms with Perl blending custom techniques with resources available (CPAN) in a "learn by example" approach. It contains 16 great chapters of background, theory, sample code, diagrams, and discussion. It has a good Appendix A (for additional info on algorithms) and a useful ASCII table in Appendix B. If you want to learn good ways to implement specific Algorithms with Perl - Read this book!
on January 20, 2003
Mastering Algorithms with Perl is an intermediate to advanced text describing traditional algorithms and data structures through Perl. It assumes a basic understanding of Perl. And while the average reader will be able to progress through the better part of the book with no background in computer science, the last third of the book requires at least a passing familiarity with Calculus, advanced mathematical notation, and covers topics from the vantage those already initiated to Probability, Statistics, Cryptology, and Number Theory.
That said, the book has something for everyone. Beginner and Intermediate level Perl programmers will find the book's materials information dense but approachable. Advanced programmers will find a well written refresher illustrating familiar concepts in Perl. Given the breadth of the book and the language specific insights, even experience Perl programmers should expect to learn a thing or two.
Topics covered include: linked lists, circular linked lists, garbage collection, doubly-linked lists, infinite lists, binary trees, heaps, binary heaps, janus heaps, sorting, searching, sets, matrices, graphs, strings, geometric algorithms, number systems, number theory, cryptography, probability, statistics, and numerical analysis.
I've found that while the book is somewhat daunting, it goes down best a little bit at a time: read a chapter, then work through the examples. The first time I attempted to read the book I got about a third of the way through before stopping, scanning the rest, and putting it back on the shelf. A couple months later as I was working on a problem involving graphs and trees, the book came back down. And as interesting and complicated problems present themselves, I often find myself reaching for it.
It covers an awful lot in 701 tightly packed pages. Have you ever wondered how regular expressions work? Hashes? Insights into their internal workings are in there. It is an excellent reference and fills a much needed gap. No other Perl book comes close to the breadth and depth coverage of these materials. That said, early printings of the first edition had a tremendous number of errors and typos. If you buy it used, I would highly recommend visiting the O'Reilly site to read the errata. ...
on January 22, 2001
This book is certainly not meant for learning Perl nor being read from the first page to the last...it's a compilation of some of the advanced features of Perl aimed at resolving very specific algorithmic problems.
Two examples :
1) i had an efficiency problem with my code that required boosting some subroutines that were heavily used but could not be easily implemented with a data structure...so i discovered the "Memoize" module that performs caching on subroutines, allowing me to speed up my code by a factor of 10 !
2) i had to find the maximum likelihood estimation of several probability distributions on some important amount of data, and for multi-parameter distributions. I just used the complex module and LU decomposition to find the roots of my non-linear systems, which can be "easily" done by specifying the equations to be resolved (expressed as subroutines which values are instanciated by the resolver) and applying a heuristic root finding algorithm based on Newton's method combined with LU decomposition. It would have taken several days or even weeks to write it from scratch in C or C++, but most of the code already existed so it was written within one day !
Of course, it's not a general-purpose book on Perl programming but rather a cookbook for some very specific utilization of Perl like "non-linear equations systems root finding" or graphs theory problems...so don't expect this to be a well-organized book since it's not intended to be that way !
on July 23, 2007
This is a very accessible introduction to data structures and algorithms in Perl. It doesn't go into a lot of theory, it isn't going to answer your computer science homework, but it does give a good feel for the various applications of algorithm research.
Plus, the code is all in Perl, which is not as unreadable as received wisdom asserts. It's certainly more accessible for the interested Perl-savvy amateur than the pseudocode in Introduction to Algorithms.
Obviously, you're going to have to move onto the likes of Cormen et al, if you're really serious about this stuff. And practically speaking, yes, most of this can be found in CPAN without you having to worry your pretty little head about the mechanics. If just getting something done is your main concern, then this is not the book for you.
Plus, it must be admitted that the level of detail varies across the chapters, and some of the explanations can be opaque, even for the simple stuff. I felt I had to work unnecessarily hard to comprehend some of the material: the discussion of the A* algorithm, some of the tree-related algorithms and the section on compression all suffered from this to varying degrees. This is the sort of book which requires concentration (plus copious scrap paper for scribbling down arrows and boxes) to get anything from.
But to complain that Perl doesn't need you to write these data structures from scratch, and it isn't a suitable language for this sort of thing anyway, is to miss the point of at least part of the book. It's about communicating the intellectual pleasure of wrapping your head around these fundamental bits of computer science, and in that respect it succeeds admirably. If you're looking for an introduction to the area, this is definitely worth getting hold of.
It's another one of those useful blue O'Reilly books with an animal on the front. A wolf, in this case. This one starts with basic data structures in Perl and then presents reusable algorithms of increasing complexity. The authors intend it for two types of readers: "...those who want to cut and paste solutions and those who want to hone their programming skills." Attempting to serve both audiences, the authors attempt to be both practical and theoretical.
The book begins with basic and advanced data structures. The next series of chapters each address basic programming tasks such as sorting, searching, and working with sets, matrices, graphs, and strings. The final set of chapters is organized by topic area, covering geometric algorithms, number systems, number theory, cryptography, probability, statistics, and numerical analysis. A concluding appendix suggests additional readings.
The format and quality are familiar to readers of other O'Reilly books. It is a good, readable exploration of algorithms implemented in Perl. You will need to get the latest version of Perl on your own. No problems with that, either.
on December 18, 2015
Orwant. Monte Hall. Leonard Euler. Radix Sort. The Travelling Salesman Problem. B-Trees, Red-Black Trees, Bushier Trees. you might actually have to think! No, in fact you definitely will:
"you wrap in exponential time, and I'm Big O of log n"
If you don't understand that statement, well, monzy is cool, and this book will end the crumby state of affairs forever.
Once you read this, you can't go back.. you'll understand Algorithms sort of.. so be warned
If you have ever studied algorithms and data structures, then balanced trees and O(N) notation may still be a painful memory. Also, part of Perl's strength is in its built in parsing and sorting features so why would you need to know other ways of doing the same job? If your work does not challenge Perl's features then you probably do not need this book. However, if you have no computer science background and Perl is your language of choice then this book requires serious consideration.
The book is concise and the advice given in concepts like choosing an appropriate data structure or in benchmarking your program is actually quite sound. It covers a wide number of topics such as sorting, searching, sets and matrices together with material you may not find in a data structures book like geometry, cryptography and statistics.
Your choice depends on the task at hand. If you're looking for a Perl book where you can find routines to encrypt a string or find the maximum distance between two points then this book will not disappoint. Indeed, I believe that anyone serious about programming would benefit greatly from some of the Computer Science subjects discussed and implemented in Perl that are offered in this book.
on October 16, 2015
If you have to learn Perl in your production life for any reason, I think this book would be one of the best option that you can have. At least, you can enrich your knowledge of algorithms, and that is worth to pay for.