Automotive Deals HPCC Amazon Fashion Learn more Discover it $5 Albums Fire TV Stick Health, Household and Grocery Back to School Handmade school supplies Shop-by-Room Amazon Cash Back Offer CafeSociety CafeSociety CafeSociety  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Starting at $49.99 All-New Kindle Oasis AutoRip in CDs & Vinyl Water Sports
Profile for Thing with a hook > Reviews

Browse

Thing with a hook's Profile

Customer Reviews: 67
Top Reviewer Ranking: 5,373,406
Helpful Votes: 521


Community Features
Review Discussion Boards
Top Reviewers

Guidelines: Learn more about the ins and outs of Your Profile.

Reviews Written by
Thing with a hook RSS Feed

Show:  
Page: 1 | 2 | 3 | 4 | 5 | 6 | 7
pixel
Mastering Algorithms with Perl
Mastering Algorithms with Perl
by Jon Orwant
Edition: Paperback
Price: $26.48
98 used & new from $0.01

4 of 4 people found the following review helpful
5.0 out of 5 stars Enjoyable, broad-ranging coverage of algorithms, 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.


Perl Testing: A Developer's Notebook
Perl Testing: A Developer's Notebook
by Ian Langworth
Edition: Paperback
Price: $22.25
58 used & new from $1.54

2 of 2 people found the following review helpful
4.0 out of 5 stars A brisk canter around Perl testing modules, July 23, 2007
This is a decent overview of Perl testing libraries, that goes further than the material in Intermediate Perl and the second edition of Advanced Perl Programming. It also moves pretty fast, as is the practical bent of the Developer's Notebook series. This will be welcome for any programmer familiar with testing tools in other languages, although testing newbies should be able to understand the mechanics without trouble.

Apart from the unit testing basics, it also goes over mocks, coverage, databases, webpages, testing documentation and module layout, and (most importantly for Perl) testing scripts. The Test::Class module, a xUnit-style module is also covered, although the more procedural Test::More seems to be the standard tool in Perl and is given the most attention. Code for a simple continuous integration tool is presented, which is pretty neat, given how short it is.

The emphasis in this book is very much on the how, rather than the why. Unlike many other books, you are given complete code along with how to execute the scripts and the expected output, which is very helpful. What isn't covered is any of the development methodologies that have driven the interest in testing methods. There's no discussion of Test Driven Development here, or how developer-driven unit testing meshes with the software building process, and there's only cursory or no discussion of what to test, where to start, test organisation (which IMO quickly becomes the limiting step in going test-infected), dealing with legacy code, dummies vs stubs vs mocks, white box vs black box testing etc. For the latter, you will have to consult the likes of xUnit Test Patterns, Unit Testing in Java and Test Driven Development: A Practical Guide. None of these books contain Perl code, however.

This is not a very long book, and there's not always the detail you might want for the more advanced topics. The emphasis on applications rather than principles also means that the book is a little vulnerable to API changes and newer CPAN modules. That said, part of the deal with the Developer's Notebook series is the lack of ceremony, so as long as you know what you're getting it's hard to complain, particularly as it's possible to pick up a copy at a reasonable price. Also, the writing itself is clear, direct and no-nonsense. It's a useful resource, and certainly in a more convenient format than scrolling through countless perldoc pages.


Perl Hacks: Tips & Tools for Programming, Debugging, and Surviving
Perl Hacks: Tips & Tools for Programming, Debugging, and Surviving
by Chromatic
Edition: Paperback
Price: $23.65
69 used & new from $1.54

3 of 3 people found the following review helpful
5.0 out of 5 stars Super-advanced Perl, July 21, 2007
From the title, I wasn't quite sure what to expect from Perl Hacks. Was it going to be about rummaging around in Perl's internals? Making Perl do clever, yet ultimately dumb and pointless tricks? It turns out that, while there is some fairly voodooish material here, some of it quite playful, on the whole it's a very practical book. Aimed firmly at the advanced Perl programmer who knows when it's appropriate to mess about with the symbol table, temporarily turn off warnings, or crack out one of the B:: modules, this is a collection of 101 suggestions to improve your productivity, boggle your mind about what Perl can do, or both.

The content reminds me a little of the likes of Exceptional C++ Style, a mixture of advanced best practices, and things which you may not need to know, but you'll probably still be interested in finding out how it works. For instance, have you ever considered tieing an array or hash variable to a function? Ever wanted to name a supposed anonymous subroutine? Print out the source code as well as the line number of a syntax error? Nor me, but Perl Hacks shows how it could be useful. These are illustrative of the spirit of the book.

My favourite material was probably the chapter on modules. Included are how-tos for outputting all the modules used in a package, automatically reloading modules in running code, shortening long package names with the CPAN 'aliased' module, and making up your own bundle of modules for easy installation. There's also an interesting object chapter with subjects such as: inside out objects, using YAML for serialisation, using traits and autogeneration of accessors.

Additionally, there's a little on using those scary B:: packages, using modules which use the B:: packages or other dark magic (e.g. peeking inside closures), some fairly hardcore tracing and profiling, that touches on some Perl VM internals. Also worth mentioning is the hack that hijacks the angle bracket glob operator to create Haskell/Python-style list comprehensions.

You are going to have to be one scarily gifted Perl hacker not to find something useful or at least thought-provoking at regular intervals throughout this book. My only complaint is that the hack format, which the blurb on the back of the book describes as a "short lesson", does not lend itself equally well to all hacks. While I liked the chapter on objects, some of the hacks (in particular the traits hack, some of the testing material) were too short.

If you like the sound of a book that's somewhere between Perl Cookbook, Perl Best Practices and the second edition of Advanced Perl Programming, you're going to love this.


Data Munging with Perl
Data Munging with Perl
by David Cross
Edition: Paperback
38 used & new from $4.85

5 of 5 people found the following review helpful
4.0 out of 5 stars No-nonsense resource for meat and potatoes Perl scripting, July 21, 2007
This review is from: Data Munging with Perl (Paperback)
The quintessential Perl activity is data processing, particularly in a Unix environment, where output is piped into a script from some other program, transformed, and spat out again. Many people's first encounter with Perl will probably be in this task. David Cross's book shows how to do this with the minimum of fuss and the maximum of flexibility. It's not a Perl tutorial however, so you will need some basic knowledge of Perl, having read The Llama is enough. There is an appendix of 'essential Perl' to refresh your memory if you're a bit rusty.

The book begins by revising some of those basic Perl practices that come in handy for scripting, e.g. command line options, regular expressions and sorting. The second part of the book deals with parsing fairly simple data: traditional fixed-width record data (e.g. the column-based stuff that you often find as the output of old Fortran and C programs), unstructured data (e.g. doing word counts on text files), and formats such as CSV, PNG and MP3. This is the strongest section of the book, and contains lots of useful hands-on information.

The third part of the book deals with more modern forms of data files, in the shape of XML. Parsing HTML also gets a chapter to itself, after the author usefully demonstrates the limitations of any simple solution (e.g. using regexes), which provides pretty strong evidence in favour of the standard 'don't try it yourself, use a CPAN module' argument. The XML chapter itself covers the XML::Parser module in reasonable detail. However, there are now many more XML parsers in Perl out there, and XML::Parser is probably no longer the best solution (Grant McClean's Perl XML FAQ on the net has a good overview of the options). Excluding the seemingly obligatory 'here's a bunch of books and websites to learn more' chapter, the last proper chapter is on parsing, and the Rec::Descent module, and it's a very good gentle introduction.

If you're not working in a command line environment, there's not a whole lot here you're going to need. Equally, if you've been doing this sort of thing for a while, there's not much here that will be new to you, not all the subjects are explored in any great depth. And some of it (particularly the XML chapter) is a bit outdated and superficial, so I would knock off a star from my rating if you're more interested in the XML/HTML chapters.

But for the simpler tasks, e.g. parsing column based data, this is recommended. You're shown all the handy tricks you need such as piping, taking input from standard in as well as files, slurping paragraphs etc. My 4-star rating applies if this sounds like what you need: it's a clear, short and to-the-point book, which is definitely taking with you on your first journey into data munging.


Groovy in Action
Groovy in Action
by Dierk König
Edition: Paperback
Price: $37.36
90 used & new from $0.01

2 of 2 people found the following review helpful
5.0 out of 5 stars Cracking stuff, July 19, 2007
This review is from: Groovy in Action (Paperback)
Whatever you think about the merits of Groovy as a language, a serious contender on the JVM, or a complete mess, you couldn't hope to find a better advocate for Groovy than this book.

One of the secrets of GinA's success is that it assumes the reader is already proficient with Java development, including Swing, Ant and JUnit. It would also help to know about XML, SQL, HTML, JSP and a vague idea of how MVC applies to web apps. You don't need to be an expert in these areas, though. If you've sufficient knowledge to decode the preceeding alphabet soup of initialisations, you'll be ok.

The reward for possessing this background knowledge is that GinA doesn't waste time with trivial examples, and barrels through Groovy the language in the first part, leveraging your existing knowledge of Java to highlight the important differences in Groovy. In particular, the advantages of interpolating strings, simple hash and array construction syntax, optional typing and metaprogramming are stressed. The big win in Groovy over Java is the use of closures and their used in a block-based approach to iteration, which is as well motivated here as the material in, say, The Pickaxe is for Ruby.

The second part of the book provides examples of the Groovy library. It begins with an excellent chapter on Groovy's Builders, which provide a very neat, uncluttered syntax for putting together hierarchical structures. An obvious application is XML, and by extension Ant scripts, which appears to have some major advantages compared to the challenging readability of vanilla Ant. Even more impressive is the SwingBuilder example, which builds a GUI with the minimum of fuss and a complete lack of anonymous inner classes.

Beyond the Builders, there are also compelling chapters on templating HTML and server side Groovy (Groovlets), writing DAOs and DTOs in Groovy to simplify database programming, and a chapter on XML, which even manages to find the space to introduce Groovy for SOAP, XML-RPC and REST web services.

The final part of the book describes some non-core libraries and other applications of Groovy. The chapter on Groovy extensions to JUnit is interesting, although perhaps this is one place where it assumes too little on behalf of the reader. I would have assumed that the average developer sufficiently motivated to pick up a book on Groovy knows enough about unit testing and JUnit that more space could have been given to the advanced topics. Particularly appealing is the idea of testing Java code with dynamically typed Groovy unit tests, which would make mocking and stubbing more palatable; I would have liked more on that subject.

Another noteworthy chapter is the last one, which introduces the web app framework Grails. This has a different style to the other chapters, being a dialogue between two of the authors as they build a simple app. This reader admits to finding it a little bit naff, but it does usefully demonstrate the grails way (which is a lot like Rails).

If you have the slightest interest in Groovy, alternatives to Java on the JVM, or dynamic languages, GinA makes the perfect case for Groovy as a first class integration language for all the bits of Java where you really wish you were working with something like Perl, Ruby or Python. It's well-written, with good examples, clear explanations, and it's relentlessly practical, never forgetting its target audience. It's all the more impressive given lead author Dierk Konig's comment in the preface that English is not his first language. Kudos to him and his co-authors for what they've delivered.

One can only wish that every language had its GinA. Outstanding.


Perl Medic: Transforming Legacy Code
Perl Medic: Transforming Legacy Code
by Peter Scott
Edition: Paperback
Price: $39.99
41 used & new from $0.26

4.0 out of 5 stars Bad title, good contents, July 17, 2007
Like author Peter Scott's previous book (co-written with Ed Wright), Perl Debugged, Perl Medic is rather inaccurately titled. Both books are collections of advice and tips on best practices and idioms in Perl, like Effective Perl Programming and Perl Best Practices. You can think of Perl Medic as a sequel to Perl Debugged. You definitely don't need to have read the former, but if you have, you should have a good idea about the format and contents you can expect here.

There is more advice on code style, low-level stuff like brace indentation and choosing decent variable names. Additionally, tracing, profiling, benchmarking and logging are again introduced. Some of this is admittedly rather reminiscent of what appeared in Perl Debugged. Happily, also present is the clear writing, which is informal without ever talking down to the reader.

Perl Medic, however, has a more agile flavour than Perl Debugged. Again, there is a chapter on unit testing, but it's much more fleshed out in this book, featuring far more modules, and providing an entire Test Driven Development example of a bounds-checked array.

Also, some refactorings are introduced, such as inlining temporary variables and extracting subroutines. The final chapter of the book is a refactoring example on some ancient Perl 4 cgi code, that pulls together most of the themes of the book.

There's also an in-depth discussion of what the strict and warnings pragmas entail, beyond that provided by most books. Also worthy of note is the chapter on 'cargo cult' Perl, where the author's pet peeves about non-idiomatic Perl code are explored, from practices which are merely pointless to the downright wrong.

Much of this material is general good practice. However, there are some chapters that help to justify the 'legacy code' approach. Chapter 7 provides a potted history of the different versions of Perl from Perl 4 onwards, and how to spot which version a program was targetted at. There is some mention of legacy code in the unit testing chapter, but not much.

In general, I think a lot of the suggestions will be obvious to anyone with experience with Perl, or experience with another modern programming language: use new modules from CPAN where you can, use lexically scoped (my) variables and localise global access and, of course, turn on strict and warnings. Overall, I wasn't much convinced with the 'legacy code' aspect of the book and the strained medical metaphor renders many of the chapter names nonsensical.

Another slight problem I had is that, like Perl Debugged, there can be a lack of flow between (and sometimes within) chapters. Chapter 10, nominally about maintainability, starts with assertions and Eiffel-style contract programming, and then goes onto logging, tieing, overloading, POD and version control integration. It's hard to see this as a cohesive whole.

If you're looking for a book on dealing with legacy code, Michael Feathers' Working Effectively with Legacy Code provides more bang for your buck -- although it's not Perl-specific (in fact, I'm pretty sure there's no Perl code in it at all). However, if you're a budding agilist looking for Perl-based examples of refactoring and TDD, then this is a good choice. Less experienced Perl programmers should definitely consider this, especially alongside Perl Debugged, as it provides both a good grounding in best practices, and more advanced development skills such as profiling and code coverage.


Perl Debugged
Perl Debugged
by Peter Scott
Edition: Paperback
32 used & new from $2.14

3 of 3 people found the following review helpful
4.0 out of 5 stars Ideal for the neophyte programmer, July 16, 2007
This review is from: Perl Debugged (Paperback)
The ideal reader of this book would be someone who's been exposed to most of Perl and knows about packages, modules and references (the Llama/Alpaca combo, for instance), but who isn't necessarily experienced with other languages. If you are that sort of person, this should be close to the top of your Perl reading list.

There's an abundance of good material to be found here -- yes, there's an entire chapter on working the Perl debugger, but don't let the book's title fool you, it's not just about debugging. There's also advice on code style and layout, common idioms and features of Perl such as the behaviour of $_, autovivification, local, and optional parentheses.

Additionally, there are introductions to logging (in the context of debug flags), unit testing, code coverage, and error handling. Rounding off the book are chapters on benchmarking, profiling and some simple optimisation techniques (e.g. don't shell out to an external program if you can do the task in perl, use pipes and fork instead of writing to a temporary file), a chapter of tips for programmers coming to Perl from Java, shell scripting, C, C++ and Fortran. Finally there's a chapter covering debugging CGI programs.

Throughout, there's also some more philosophical (or touchy-feely) material, with exhortations to being a good citizen of the Republic of Perl and your work environment. If you're a more experienced developer, and you've read the likes of Code Complete and Refactoring, much of this is either obvious or has been given in more detail in other books, which is why I think the less experienced you are, the more you'll get out of it.

If you've been around the block a couple of times, I think you'll find that while there is a lot of ground covered, it's not particular deep. It's good to have issues like unit testing, profiling, benchmarking and logging introduced, but you'll quickly have to look elsewhere for more detailed (not to mention up-to-date) information for use in your own code. If you've read the likes of Effective Perl Programming, Perl Testing and of course, the mighty Perl Best Practices, there's not a lot left to see. However, chapter 8 presents some neat puzzlers, where a seemingly innocuous piece of code is suffering from a missing, misplaced or transposed character, and some useful tips for interpreting the syntax errors are presented.

Overall, this is nicely written in an unfussy, friendly style which assumes the reader is not a complete beginner. Ungrizzled non-veterans of Perl should consider this well worth taking a look at, especially as a companion to Perl Medic.


Effective Perl Programming: Writing Better Programs with Perl
Effective Perl Programming: Writing Better Programs with Perl
by Randal Schwartz
Edition: Paperback
Price: $44.99
79 used & new from $0.01

3 of 3 people found the following review helpful
4.0 out of 5 stars A fast track to idiomatic Perl, July 16, 2007
This is a good book for getting a handle on intermediate level Perl and its idiomatic uses, arranged as a series of 60 'items' -- the debt to Effective C++ is obvious. This is not a tutorial on Perl, you should at least be at the level of The Llama and ideally be somewhat acquainted with the material covered in The Alpaca, too. Although similar ground is covered in this book to the latter, I would treat this book as a way to shore up your previous knowledge, rather than learning it for the first time.

The content holds up surprisingly well for 1997. The opening chapters cover a lot of the oddities and gotchas of life with Perl, such as slicing, the various connotations of undef, a persuasive defence of $_ and where + is necessary to disambiguate. The final 'miscellany' chapter also contains useful information in a similar vein. And this also appears to be one of the first books to detail the now famous Schwartzian transform and the Orcish manoeuvre for sorting, so it has a certain historical appeal.

Equally, the chapters on debugging, references, regular expressions and object oriented programming are also pretty good. It's just that there are now several other books that cover these topics. If you only want one book in this style, Perl Best Practices bestrides the field like a colossus, being more comprehensive, and better written. Not that there's anything wrong with the writing here, it's never boring as such, but it does feel flat.

Nonetheless, Effective Perl Programming does the job it sets out to do fairly well, and I find you can never have too much help in explaining the nooks and crannies of idiomatic Perl, so this is still worth getting hold of, particularly because you can find it at an extremely reasonable price.


Advanced Perl Programming
Advanced Perl Programming
by Simon Cozens
Edition: Paperback
Price: $33.53
72 used & new from $1.65

4.0 out of 5 stars A very different beast to the first edition, July 15, 2007
As other reviewers have noted, there's not a whole lot in common with the first edition of this book, either in feel or content. It's rather questionable whether this merits being called a second edition. Something like 'Problem solving with CPAN' would be a more accurate title (then again, perhaps it's just as well I don't work in the publishing industry).

It does still cover some of the material of the first edition, such as globs, closures, AUTOLOAD, the Perl class model, and some Perl internals, but it's all been compressed into one chapter.

The other chapters discuss various subjects using CPAN modules and gives some insight into how the material from the first chapter was used to solve these problems. A wide variety of issues are discussed, including serialization and object relational mapping, natural language parsing, templating and unicode. Some superficially similar material could be found in Perl Cookbook, but the discussion here is deeper (and more up to date), there's very little overlap.

Exactly how much you get out of the book will probably be dependent on how well you know the innards of CPAN and how interesting you find the topics. I liked the parsing and natural language processing chapters a lot, and the chapter on inlining code from other languages was diverting; conversely, I can't bring myself to find Unicode even remotely stimulating, and the POE (some sort of event-based framework) chapter didn't do much for me. The testing chapter is a solid addition to the material in Intermediate Perl, and I picked up some pointers to modules to check out, but it didn't feel all that advanced.

This is a book that fits in quite nicely with Intermediate Perl and Programming Perl -- it cleans up a few niggling details not well discussed in the former book, without having the intimidating heft of the latter, and also provides a wide ranging overview of several topics and the CPAN solutions for them. As such, it will bring an intermediate programmer up a few notches.

Already advanced Perl programmers may be disappointed, and those hoping for an updated version of the first edition will definitely be out of luck, but if you know what you're getting, and evaluate it on those terms, rather than what the title suggests, I think you'll enjoy it.


Advanced Perl Programming (Perl Series)
Advanced Perl Programming (Perl Series)
by Sriram Srinivasan
Edition: Paperback
83 used & new from $0.01

0 of 1 people found the following review helpful
3.0 out of 5 stars Interesting in parts, outdated in others, July 15, 2007
From the perspective of 2007, this book suffers from not being all that advanced. Also, some of the examples, particularly in the opening chapters, suffer from being a bit meaningless, e.g. code like $spud = "Wow!" -- er, right.

That said, the opening chapters do contain some pretty useful material which wasn't present in The Llama and which you wouldn't want to slog through The Camel for, including good stuff on references, closures, typeglobs, the symbol table, tied variables and persistence and serialization. There's also an introduction to OO with Perl.

The middle part of the book contains 50 pages on Tk. Useful if you need it, I suppose. But is this advanced?

The last part goes into detail in getting Perl to talk to C, and the internals of Perl. The latter is pretty interesting in a geeky sort of way, and definitely qualifies as 'advanced'. Not many other books about go into this level of detail.

The first 150 pages of this book maintains its relevance for the most part, although much of it (e.g. references and objects) is no longer considered advanced, and you can find discussions elsewhere, e.g. Object Oriented Perl or The Alpaca. The section on Perl internals is probably still of use if you're into that sort of thing. Elsewhere, however, the march of time and reliance on CPAN modules has reduced the vitality of the material.

Worth picking up on the cheap for the earlier chapters.


Page: 1 | 2 | 3 | 4 | 5 | 6 | 7