5 comments about Perl Hacks: Tips & Tools for Programming, Debugging, and Surviving (Hacks).

1. In a time when new computer languages are dime a dozen, perl unquestionably retains its beauty. Keeping with the philosophy of perl - there is more than one way to do it - the book shows you ingenious ways to work with this powerful language. This is a true hacks book and meant mostly for the advanced user. Before reading this book, I didn't even realize what I didn't know and I rate myself just short of contributing to CPAN. Even if you have read all the popular books - Perl Programming, Perl Best Practices etc. you'll still find a lot of gems.
   
   Simply put if you like perl, you'll love this book. Welcome to the next level...



2. To be completely honest, this isn't the book I thought it was going to be. Most O'Reilly Hacks books start off pretty simply and in a few chapters take you to the further reaches of their subject area. Whilst this is a great way to quickly get a good taste of a particular topic, it has the occasional disadvantage that for subjects that you know well, the first couple of chapters can seem a bit basic. As I know Perl pretty well, I thought I would be on familiar ground for at least half of the book.
   
   I was wrong.
   
   Oh, it started off easily enough. Making use of various browser and command line tools to get easy access to Perl documentation, creating some useful shell aliases to cut down typing for your most common tasks. "Oh yes", I thought smugly to myself, "I know all that". But by about Hack 5 I was reading about little tweaks that I didn't know about. I'd start a hack thinking that I knew everything that the authors were going to cover and end up frustrated that I was on the tube and couldn't immediately try out the new trick I had just learnt.
   
   It's really that kind of book. Pretty much everyone who reads it will pick up something that will it easier for them to get their job done (well, assuming that their job involves writing Perl code!) And, of course, looking at the list of authors, that's only to be expected. The three authors listed on the cover are three of the Perl communities most respected members. And the list of other contributers reads like a who's who of people who are doing interesting things with Perl - people whose use.perl journals are always interesting or whose posts on Perl Monks are worth reading before other people's. Luckily, it turns out that all these excellent programmers can also explain what they are doing (and why they are doing it) very clearly.
   
   Like all books in the Hacks series, it's a little bitty. The hacks are organised into nine broad chapters, but the connections between hacks in the same chapter can sometimes be a bit hard to see. But I enjoyed that. In places it made the book a bit of a rollercoaster ride. You're never quite sure what is coming next, but you know it's going to be fun.
   
   In fact, the more I think about it, the more apt the fairground analogy seems. When you ask Perl programmers what they like about Perl, you'll often hear "fun" mentioned near the top of the list. People use Perl because they enjoy it. And the authors' enjoyment of Perl really comes through in the book. It's obvious that they really wanted to show people the things that they thought were really cool.
   
   Although I did learn useful tips from the earlier part of the book, it was really the last three chapters that were the most useful for me. Chapter 7, Developer Tricks, had a lot of useful things to say about testing, Chapter 8, Know Thy Code, contains a lot of information on using Perl to examine your Perl code and Chapter 9, Expand Your Perl Foo was a grab-bag of obscure (but still useful) Perl tricks.
   
   So where does this book fit in to O'Reilly's Perl canon? I can't recommend it for beginners. But if you're a working Perl programmer with a couple of years' experience then I'd be very surprised if you didn't pick up something that will be useful to you. And don't worry about it overlapping with other books in your Perl library - offhand I can't think of anything in the book that has been covered in any previous Perl book.
   
   All in all, this would make a very useful addition to your Perl library.



3. I received this book as a token of appreciation for my contributions to
   the 2006 Perl Advent Calendar. It's the first book I read as part of the
   O'Reilly Hacks' series of books, and it proved to be a light yet informative and entertaining
   read.
   
   The book covers various useful "hacks" or small tricks that allow one to
   achieve a lot of cool tasks when working with Perl. These tricks are unorthodox
   and stretch the limit of one's Perl knowledge. Since they require an advanced
   knowledge and understanding of Perl, I would recommend this book only for Perl
   experts. Some of the B:: using modules were even too high-level for me to
   understand how they worked internally. However, I understood the purpose of the
   code in all cases, even if I didn't understand the code itself.
   
   So it is a recommended read for people who've worked with Perl a lot,
   and wish to learn many new and useful tricks. Perl Hacks for Perl hackers,
   indeed!



4. 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.



5. Perl is my workhorse language. I've written more Perl code, both personally and professionally, than any other language I've learned. Whenever I receive a new project, I immediately think of how I would accomplish it quickly in Perl. I've also been a fan of O'Reilly's "Hacks" series of books. When I heard of the marriage of Perl and O'Reilly's "Hacks" series in the book Perl Hacks, I knew I had to pick up a copy. It was a match made in heaven. The nature of Perl for terse, yet powerful constructs, and the hackish nature of the "Hacks" series makes for one of my favorite books in this series. The collection of articles in Perl Hacks are great for putting more productivity into your programming experience.
   
   Those of you not familiar with O'Reilly's "Hacks" Series may need an introduction. The "Hacks" Series is an ever-growing set of books with focused attention on a particular topic, like Astronomy, Mental Improvement, or even Halo 2. The books are generally short, and contain article-length "hacks" of varying difficulty, noted by a thermometer next to the hack number and description. These "hacks" fall into several categories; the non-obvious solution to a problem, the performance improvement, and the "gee, I didn't know it could do that" oddity. What makes this series special compared with other books is the willingness to "void the warranty" on a particular product, and get straight to the internals, whether they lay in hardware or software. If something can be made better by opening the covers, or twiddling with the program layout, then its eligible for inclusion in these books. The series lends itself to a wide range of topics, and the format is great for a quick read, or for (my favorite) just randomly opening the book and reading what's there.
   
   Perl Hacks is not a book that you'd find yourself reading straight through (although you do want to make sure you visit every hack in the book at least once). The book is divided into nine chapters: Productivity Hacks, User Interaction, Data Munging, Working with Modules, Object Hacks, Debugging, Developer Tricks, Know Thy Code, and Expand Your Perl Foo. There are 101 hacks in this book, ranging from the simple (Reading files backward, or managing your module paths) to the truly perverse (Replacing bad code without touching it by substituting the system-wide exit call with your own[...]. Each hack title is listed in the table of contents, with both the page number and the hack number. Each hack contains a graphic of a thermometer next to the number to show the relative difficulty of the hack (higher temperatures = more difficult hacks). There quite a variety of hacks placed throughout the book. Not once did I feel that the book was padded with something that really didn't belong in the book. If anything Perl Hacks opened my eyes to things that I would never have thought to do, but could easily see as being useful. I wouldn't have thought to create my own personal module bundles for moving my Perl programs between machines (I've always done it the old fashioned way: run, cpan install, repeat), but hack #31 makes it so "of course" that I'm thinking of including this in all of my Perl code that I ship. Hack #74 shows how to trace all of the modules your program uses (and all of their modules, too). Hack #52 is a simple hack ("Make Invisible Characters Apparent") but I can see this saving a developer or two some time when figuring out why their code isn't behaving properly. Of course, not all hacks in the book are productive (at least, not while you're programming). Hack #37, "Drink to the CPAN" is a drinking game you and your Perl buddies may want to try.
   
   Perl Hacks is a short book, at less than 300 pages, but it's loaded with incredibly useful information. Much like the "Perl Cookbook" (also from O'Reilly) you'll find lots of useful items hidden in their pages. Many times I started with one hack, and finished the chapter reading the rest of the hacks because there were just that interesting. Perl Hacks is highly recommended for any Perl programmer to have on their programmer book shelf. Sure, you might be able to find some of the hacks out there on the net, but I think you'll find as I have that this is more of a go-to reference for finding out some of the more interesting corners of Perl.

5 comments about SQL: Visual QuickStart Guide (3rd Edition) (Visual QuickStart Guide).

1. I am an IT instructor and don't usually have good things to say about computer books. But I couldn't keep quiet about this book which works well in my SQL for SQL Server class and would work just as well in a SQL for MySQL class. Beginning students don't have many choices in SQL books that help them learn the ropes and then don't stop at the definition / syntax level. After several other tries, this one hit the sweet spot of practicality, theory, data, examples, curriculum breadth for a basic SQL course, depth for advanced students, and supplemental information.



2. A terribly written book but has many useful examples and only costs $20. The author has no command of the English language at all. The only reason why such poor writing got past the editors in the first place was probably because they had no idea what the hell the author was talking about and thought it was hopeless to fix. Beware.



3. In my opinion, a technical author's writing ability is just as important as his knowledge of the subject material. I've been disappointed in so many books where the author is undoubtedly an expert in his field, but couldn't effectively organize and translate his thoughts in a way that made sense to me. Based on the review by "Dave" below, I almost lumped this book into that unfortunate category. I'm so glad I happened to flip through a copy of it, because this is a fantastic book. In fact, it's one of the best technical books I've ever owned.
   
   Fehily's writing style is clear and concise. In a typical chapter, he gives an overview of the topic, then demonstrates it with many relevant and progressively complex example queries. This teaching style works so well for so many people--give us a basic idea of what's going on, then SHOW us how it works in the real world. All of the examples are based on a simple but effective sample database that can be downloaded from the publisher's website (you can download an Access database, or scripts that will create the appropriate tables in the RDBMS of your choice).
   
   True to the Visual QuickStart approach to teaching, the layout of this book is highly effective. Most pages have plenty of whitespace. There are no long, rambling paragraphs. Instead, there are lots of summary tables, bulleted lists, and, as mentioned earlier, example queries. And it's the example queries that set this book apart from other introductory SQL books. There are literally hundreds of examples that you'll actually refer to regularly when you start writing your own SQL statements. Even Dave acknowledges that! I also own Ben Forta's excellent "Teach Yourself SQL in 10 Minutes," but this book is much, much better.
   
   All of the usual introductory SQL topics are covered (SELECTs/INSERTs/UPDATEs, functions, joins, grouping, subqueries, etc.), but they are covered so thoroughly and effectively that calling this a beginner's book seems like an understatement. Admittedly, I'm only a casual SQL user, but this book is now the only one I go to when I need to brush up on a topic or find an example query to help get me going.



4. SQL Second edition,
   
   The book starts out fairly basic by covering what a DBMS is and what a forward slash versus a back slash means in terms of file path and how they relate to different operating systems. From there you get into the fundamentals of database building. From there you get into the command line utility (still an important function technology).
   
   The meat of the book really starts in chapter 2 where you will learn about relational databases and what a key is. Primary keys are essential in the relational database. You will also learn about tables and their importance.
   
   Chapter 3 you are back to the basics of SQL. You will learn more about syntax and how to decipher common syntax errors. Data types are also covered to some extent.
   
   Chapter 4 is all about tables, how to construct them, keep them clean, filtering them, sort them and how to retrieve the information you are looking for. You will learn the basics of conditional statements.
   
   Chapter 5 Lets have some fun with operators (no not the kind that you talk to on the phone but the kind you build using expressions to extract information also known as the function. Creating strings; who thought it could be so much fun. In this chapter we also get top create, change and clean up strings and their friends from next door the substrings.
   
   Chapter 6 It's party time with Aggregate functions and expressions. While were at it we can summarize some data using statistics and aggregate values. While were at it we can filter a little more.
   
   Chapter 7 Lets do some JOINing. Here we learn about creating table aliases and then joining the tables. The importance of the operator WHERE instead of JOIN syntax. And then there's the CROSS JOIN lurking in the background just waiting to return all possible combinations of rows between two tables. This chapter covers many different JOIN syntax's'
   
   Chapter 8 The child to the query also known as the sub querie (inner query of an outer query, how sub queries work with other sub queries, comparing sub queries. ) This chapter is all about sub queries
   
   Chapter 9 Lets join a UNION of sorts. Not the dues paying kind but the kind the compares the results with queries. You can learn how to create a EXCEPT operator for finding differences in rows of the queries that you are combining.
   
   In chapter 10 we learn about INSERTing, DELETE(ing), UPDATE(ing) it's all about the rows in tables and using syntax to alter them.
   
   Chapter 11 Is about creating tables, working with Nulls, specifying values, specifying keys.
   
   
   Chapter 12 we learn about indexes, creating them and dropping them.
   
   Chapter 13 covers setting up the view. You will learning about updating a view and dropping a view.
   
   Chapter we learn about executions- executing transactions that is.
   
   I have been using this book for a couple months now. When I started using it my skill level was somewhere between beginner and intermediate. After having used this book I feel pretty secure in saying that I am now at the intermediate skill level. I achieved this through the use of this book. It's very well written, easy to follow. Each chapter has these cool little tips for getting things done.
   
   Everything the book walks you through it walks you through doing it in MySQL, postgre05, Microsoft SQL server and Oracle.



5. Most of the titles in the Visual Quickstart Guide series that I've acquired have been very useful and "SQL" by Chris Fehily is no exception. I use SQL relatively rarely and this book is an excellent reference and refresher when I need a fast immersion in SQL.
   
   The Visual Quickstart Guides teach by - you guessed it - visual examples and this is no exception. Fehily's writing style is spare and direct with few wasted words. There is a somewhat generalized introduction to the nature of SQL. The Introduction is actually a model of what such a chapter should be like. It is direct, to the point and covers the major things, in general, that you need to know about SQL.
   
   He then moves deeper into the basics of SQL before advancing on basic SQL operations, such as retrieving data from a table, operators and functions, summarizing and grouping data and so on. Reading this book alone will not make you an expert SQL programmer, but it will certainly help you do more than muddle through basic SQL operations, which generally are all you need.
   
   I've had this book on my shelf for a long time and, as I said, when the need for me to deal with SQL arises, it's the first reference I pick up.
   
   Jerry

2 comments about Beginning JSP™, JSF™ and Tomcat™ Web Development: From Novice to Professional (Beginning from Novice to Professional).

1. From what I have read so far, this book is really good. It starts with a good introduction then moves into a thorough explanation with a useable example.



2. Okay, I haven't touched JavaServer Pages in some time and this book got me back up to speed pretty quickly. Adding in JSF was easy, which I hadn't used before. It does start a little too basic for my needs and doesn't go quite as deep as I'd like, but overall will have you using JSP and JSF with MySQL within Tomcat pretty quickly. The title is Beginning JSP..., so not going as deep as I'd like is not the book's problem, but more now its time for me to go to the next level and probably look into one of the Pro books.
   
   One complaint with the book is the excessive appendices, almost half. Maybe it is just me, but I think eight pages to specify HTML characters and another 40 pages for an HTML reference seems excessive for the book's topic. With Beginning in the title, I was thinking more beginning JSP and JSF, not beginning HTML.

3 comments about VBScript Pocket Reference.

1. I like the O'Reilly pocket reference series. They don't take up a lot of desk real estate, and you can generally find what you need to know in a hurry.

   From the perspective of a programmer who hasn't touched basic since he had a Sinclair Spectrum, I found this book got me up to speed reasonbly quickly. However I suspect it will attract a fairly small audience - a non programmer would find it too terse to be a good learning book, and an experienced VB programmer would probably be better off with a book specific to the environment they're using (eg, ASP) because this book does not cover any enviroment specific objects, and VBScript has no enviroment specific functions. It does however cover the filesystem objects and the dictionary object, which is handy.

   Every now and then I get frustrated with the book when I can't find a function that I want, but then I usually discover that the function doesn't exist in VBScript, which is really such a trivial language that a pocket reference can cover it more or less completely.




2. It you want to learn VBScript go elsewhere. However, if you just want a quick reference that you can take anywhere this is the only book for you. It is remarkably concise and very well written. Its perfect for the VBScritp programmer that needs a little help from time to time looking up a hard to remember command and its syntax.



3. The reference material seems accurate but I have found more detail in the free help file that comes with VBS 5.6. Return values and types and the actual values of the builtin constants, which I didn't find in the book.
   
   I apparently overlooked the note that this book was based on VBS 5.5 when I ordered it. I have several pocket references and this is the first that fell short of my needs.

3 comments about Open Source Development with LAMP: Using Linux, Apache, MySQL, Perl, and PHP.

1. Open Source Development with LAMP (hereafter "OSWB") is the perfect book to learn a wide variety of server technologies that will have you writing useful, clean, fast, and productive websites before you finish reading.

   I was one of the technical editors of this book, and was able to watch it evolve as they wrote. The authors have made a huge effort to make the book appropriate for multiple Linux distributions, and they have achieved the highest degree of technical accuracy.

   OSWB covers many different technologies, some complementary, some discreet. By showing you many of the possible tools, this book lets you decide which is best for the job at hand.

   The theory behind OSWB is that knowledge of 20% of a tool's capabilities will let you accomplish 80% of the tasks you face. OSWB does a superb job of giving the user a sizable introduction to webserver technologies that will be sufficient for most rojects, and tells you where you can get information for advanced needs...This is the first book I know of that has written their website with the exact same tools they teach you in the book, and they offer the entire source of their website for download for your investigation and reference.

   The gold in this book is not just the descriptions of how the languages work, but how you can use them singly or together to create interactive websites. Their are many sample projects which let you see how everything fits together, and much of the ode can be adapted immediately to your needs. The book is extremely well integrated and organized.

   I have used some of the languages described in this book, while others were completely new to me. I am definitely not a web design person, preferring to write back-end server software. owever while reading OSWB, I was charged with creating a MySQL database with a customizable web interface for my alumni organization. Using only this book and a few perldoc commands, I was able to create an interactive mod_perl website in a few days.

   This book offers something to everyone, even advanced web designers. If you are starting out in Web technologies, or are curious about other ways you can get the job done, this is the book for you.





2. Open Source Web Development with LAMP is a very long title, but an absolutely killer book. LAMP is Linux (OS), Apache (web server) MySQL (database), Perl and PHP (scripting). This book also includes many languages not covered in other titles. I was particularly glad to see WML (Website Meta Language) which is useful for generating static pages through a robust programming construct. Static pages load faster and without any security concerns that you have with dynamic scripting languages like perl, php, embperl, or mason, all of which are covered extreemly well in this book.

   I've been doing web development for about 8 years, which probably makes me pretty old in the business. I've seen the dynamic web content languages from infancy, but I've never seen a good way of learning them until now. OSWD w/ LAMP is absolutely fabulous.




3. If you want an interactive database-based web site without spending hours and hours wading through dozens of books to figure out how to do it, then you will want "Open Source Web Development with LAMP". The book starts with the very basics and proceeds step by step so you can get your web site up as quickly as possible and with a minimum of problems. So what exactly is LAMP? It stands for the four components of a LAMP server - Linux operating system, Apache web server, MySQL database server, and the Perl programming language.

   The book is divided into four distinct parts and organized in an unexpected way. Instead of giving each part of LAMP its own section the four sections focus on structure (getting them all up and working together), static web pages (creating and using them), dynamic web pages (getting the pages to do something via Perl and MySQL), and embedded programs (to make the whole system run quicker). Each section covers all the components of LAMP as applied to that section. For example, the structural section examines installation, configuration, security, and basic usage of Linux, Apache, MySQL, and Perl. For Perl it includes a discussion of variables, arrays, operators, flow-control, regular expressions, functions, and file input/output. For MySQL it includes working with tables, insert, select, update, and similar basic commands. This is a very well done section and gives all the basic information necessary to get each of the components up and working with each other. The section on static web pages mainly covers the use of Website META Language (WML) to generate a consistent look and feel across all the web pages on the server. The part on dynamic web pages covers CGI and mod-perl so you can process information submitted by an html page or other CGI script. It also includes information on using Perl to access the MySQL server and generate dynamic information. The final section examines embedded programs such as Server Side Includes (SSI), embedded Perl, MASON, and PHP and how they are used to make a faster dynamic web site.

   I have to say that I really liked this structure. Once a system is set up it is rare to have to refer to the installation information again. If it were organized by Linux, Apache, MySQL and Perl then I would have to flip to what I assume is the appropriate section turn past the installation portion and try to locate what I am looking for. This way, since it is organized by the various stages of getting the system up and running it is easier to find what I want.

   The text includes lots of example coding so you can actually write and test it right away. This is a great way to learn the basics. It is not a thorough course in any of the four components but it does give you enough of a background to do most of what you might need to do. Of course, what makes it really valuable is the fact that it covers how to get each of the components to work together without problems. There are good books on each of these components but it is rare to find one that focuses on the interrelationships between them. "Open Source Web Development with LAMP" is highly recommended for anyone who wants to set up a LAMP server or needing to work with one.

5 comments about Expert Spring MVC and Web Flow (Expert).

1. As computer books continue their never ending slide into the abyss, Apress and Manning seem to be leading the way. This book is one of the best works of fiction ever written. From incomplete and non-working examples to the many errors, the publishers would be better served by pulling this tome off the market and starting over. There is nothing "expert" in this text nor is there anything the least bit helpful. Well, ok, I will admit the UML diagrams are nice.
   
   Avoid this book at all costs.



2. The book provides really good information and I was able to build out an application after reading it. The only problem is the editing and I hope a 2nd edition is released with fixes and updates for Spring 2.0. There are good PDF presentations out there that give a quick overview and one good tutorial that's a working example. I would google for those and read them alongside with this book.



3. I completely agree with the reviewer who points out how almost chaotically the information is delivered in this book - for the most part. Generally, you need to skip from section to section and back a few times before you can get all the pieces together. That's unacceptable. It's impossible to use this book as a convenient reference since each example generally provides only partial answers, and you have to scan back and forth through the pages to look for the clarification on the missing pieces. Often, the coverage is quite superficial. The official Spring Reference Guide on the Spring site does not get into too much detail on Spring MVC, leaving out lots of important and interesting details. Nevertheless, much more - and better - information is indeed available on-line today - at no cost. I haven't yet seen a perfect one-stop source for Spring MVC, but this book is definitely a waste of money. It may have been okay a couple of years ago when much less info was available online, but certainly not today.
   
   The only part of this book that is very well written is the chapters on Spring Web Flow. Indeed, it appears that the chapters were written by someone other than the authors of the rest of the book. Someone who understood and appreciated the importance of a very thoughtfully organized FLOW of any sequence of logical steps, be it a software application, or a flow of information such as an instructions manual, or a tutorial. That's why Colin Yates, the apparent main contributor to Chapters 11 and 12 (on Spring Web Flow), does a much better job than the rest of the authors. Unfortunately, those Web Flow chapters are largely obsolete today. Some code in the book won't work. You'll immediately see that the classes in the org.springframework.webflow.test package you get with your latest Webflow distribution differ from the ones used in the book's examples. What's even worse is that the flow configuration XML files in the examples apparently use the old/obsolete XML schema. That means you shouldn't use them as examples for your own code. Just compare the code from the latest Spring [on-line] Reference Guide and the examples in the book and you will instantly see the difference.
   
   For a very good introduction to Spring Web Flow, see the Spring Reference Guide (http://static.springframework.org/spring-webflow/docs/1.0.x/reference/introduction.html) and the article by the author of Spring Web Flow at http://www.ervacon.com/products/swf/intro/index.html, which is excellent.
   
   Do not waste money on this book! Honestly. ;)



4. The book was great pre-release book, but like most programming books for specific frameworks becomes almost useless within a few months



5. I bought this book with the hope of getting a better idea of how I should build the Web Flow flows in my Grails ( [...]) application. I know it is my own fault, and that I should have more carefully read the excellent reviews of this book, but I was a little disappointed to discover Web Flow was the topic in just two of twelve chapters when it is approximately 50% of the book's title.
   
   If anyone knows a good source of reference on how to design Web Flow flows so that my web app has a nice natural user experience (e.g. able to use the browser 'back' button having gone though a flow's end state without getting in a mess) then please let me know. I want to aim for the sort of experience I have when using the amazon dot com shopping cart, not the sort of experience I have when using an ERP solution. So far with Web Flow my efforts have tended towards ERP quality :(

5 comments about Next Generation Java Testing: TestNG and Advanced Concepts.

1. College-level libraries strong in Java programming guides need NEXT GENERATION JAVA TESTING: unlike many Java programmer's guides, it provides a pragmatic discussion for Java developers interested in building stronger code for applications, and packs in chapters discussing testing methods, tradeoffs associated with testing, applications of testing theory and rules, analysis of partial failures and remote invocation, and more. In-depth and extensive code examples throughout also differentiate NEXT GENERATION JAVA TESTING from competitors, making it a top recommendation.
   
   Diane C. Donovan
   California Bookwatch



2. At last a book that deals with testing applications (in java) that seems to be written by author's who have worked with real life, non trivial projects(TDD with adding two money objects together, anyone?).
   This book describes using TestNG along with some advanced TestNG concepts and goes on to show how to use the framework to test out JEE projects. There are also chapters showing the developer how to integrate TestNG with other frameworks (like spring, DBUnit, jwebunit etc) which is useful as this is perhaps the only place where JUnit is better than TestNG. Inspite of the fact that TestNG documentation is pretty good, this book is worthwile buying (even if you use JUnit as your testing tool of choice).
   There is useful coding and refactoring advice along the way(also a commentary on TDD), and a miscellaneous chapter of sorts which seems to have been written by Hani and edited by Cedric to remove all profanities!.
   I do hope the author's expand the testing enterprise application bits to cover more testing scenarios and examples in later additions.



3. Very nicely written keeping real world requirements in mind. Could have had some more examples.



4. This book is not really about testng. it's more about the author's opinions about testing, which are for the most part valid, but I bought this book mostly for the testng part, and I guess I'll have to wait to find something more targeted towards teaching just testng.



5. This book does a great job of introducing TestNG, showing how to use its features to set up tests for code that (inevitably) depends on various JEE APIs, and how to perform different kinds of testing (browser, database, performance etc).
   
   There are some claims that I found hard to follow: For example, the authors advise against using mock objects to stub out external classes, then later state that servlets are hard to test outside of a container because they depend on a few external classes -- never mind that these are simple to mock out, and that the Spring testing library (which they mention elsewhere) even provides mock implementations for these classes. There are also some minor factual errors that should have been caught in the reviewing process (e.g. contrary to what is claimed, annotations can be inherited).
   
   Then there is the "Digressions" chapter, which, as others have pointed out, should have been posted as a series of blog posts. Instead, there are some areas where more detail could have been provided. e.g. on how groups work in TestNG, or the exact semantics of the parallel test execution options. Now that TestNG has been out for a while and gained a lot of popularity, I'm sure there is also a lot more information on common problems that could be included in a future 2nd edition!

5 comments about Holub on Patterns: Learning Design Patterns by Looking at Code.

1. I have been programming procedurally for over 6 years, this book was my plunge into the object oriented world. This books starts out with an enlightening introduction to object oriented concepts, this makes it accessible to people with incomplete knowledge of OO techniques.
   Until I read this book I thought I knew OO and was convinced that I was practicing it for the last couple of years, turns out I was deeply mistaken and this book taught me just how little I know.
   Two involved examples are given; my initial reaction to the UML and pattern diagrams given was that of confusion. But as Allen walked me through, the confusion faded and I was struck by the depth of their meaning, from then on I use UML a lot more extensively.
   At the end of the book there is a short reference to all of the patterns, this 50 page reference is worth the price of the book just by itself.
   Awesome stuff, this book is a must read for anybody looking to take the plunge into OO, it has definitely made me a much better programmer. I have read it twice and intend to read it a few more times in the future.



2. „Holub on Patterns" by Allen Holub is a complement book to the well-known GoF's Design Patterns book.
   
   Allen starts with on overview of object orientation and design patterns and basic design principals like programming with interfaces and define patterns versus idioms.
   
   In the main part of the book all 23 design patterns grouped in creational, structural and behavioral patterns are introduced while setting up two applications: „The Game of Life" and „Implementing Embedded SQL". During designing these applications the author discusses the design patterns in a practical way giving many detailed code snippets and UML diagrams.
   
   The appendix lists all patterns in a brief overview with the most important facts: the context, what problem does it solve, pros and cons, often confused with, reference to similar patterns and implementation notes and examples.
   
   The 432 pages are full of helpful information understanding the well-known design patterns and seeing them in practical usage accompanying with each other. Allen gives very valuable hints to understand the backgrounds and the details of all patterns.
   
   Allen assumes the reader to have basic java and UML knowledge. This book serves a wide audience: beginners and also experts will find very valuable information.
   
   The author also gives very specific information and hints on design flaws like the design of the JEditor Pane in Java Swing. He also gives an excellent own solution how he would design the component. Also he does not hide his opinion e.g. about Microsoft technology.
   
   This wonderful book did a great job for me. I read Allen's point of view with his clear words. The book is a real discussion not only a boring list of patterns. I love the practical usage in the given scenarios. Although in my opininion the two example applications are growing to big.
   
   I really hope the author writes other books. I love his style and would like to further profit from his knowledge.
   
   The book published by the excellent publisher Apress is an absolutely must-have!



3. I have read so far only one chapter out of the four of this book I may update my review later.
   
   This book has a lot of very good material. It does require you to know how to program in Java in order to follow Allen's thread as the book is written as a series of monologues where intimate Java knowledge is assumed. The tone is engaging, however the book goes downhill when Allen uses dumb examples about Microsoft and Bill Gates which only reflect that he's got an immense amount of hatred for MS. I have no problem with Allen's feelings except for the fact that he encumbers the reader into separating the real topic from the hatred he exudes. This anger puzzled me and I googled Allen only to realize that he used to write for MSJ way back in 97... Wonder what happened...



4. After reading the first chapter of this book, I felt that Mr. Holub had a very unique way of explaining things which kept me going on. Sure enough, at the end I can say that this was the most interesting and informative book on design patterns that I have ever read !!! He often seems opinionated about how things are implemented in the OO world but he justifies them with relevant real world examples. The design patterns are explained with an example implementation along with a reference of the pattern in the Java API. This makes a lot of impact since most of the readers are familiar with the API and helps in correlating and remembering the patterns easier.
   
   Some of the golden rules suggested in the book that I will always keep in mind from now on:
   
   1) Dont ask for information from an object, rather give the object the information it needs and ask it do the work for you.
   2) Getters and Setters are evil because they compromise encapsulation.
   3) 'extends' is evil as it can cause fragile base classes.
   
   My only complaint about the book is the example of 'Game of Life' (Chapter 3) that was chosen. If you are one of those that havent heard of the game earlier, you would find it a little difficult to follow the code. It would have been better if the author had chosen any other real world application similar to the SQL Interpreter application that was explained in Chapter 4.
   
   The Appendix section is a great ending with concise descriptions about each one of the patterns. I am sure I will refer to this book for a long time and it definitely deserves a space on every serious Java developer's book shelf.
   
   Happy reading....



5. Holub on Patterns focuses on applying design patterns, as they exist in the real world. That is, many overlapping patterns, tangled up, and deliberately so. Holub teaches patterns by example, rather than the encyclopedia-style format we're used to. There's a strong "real world" focus, and it's both a unique and compelling format. It's also a great deal of fun. Holub's a strong writer, and very opinionated. He also advocates a purist's form of OO design, which I happen to agree with: don't use getters/setters, don't use extends, etc. If you aren't used to real OO programming, that'll also take some adjustment, but it's time VERY well spent.
   
   You'll need to be a java developer, or at least comfortable with the language, and have some familiarity with design patterns.

5 comments about The Object of Java: Introduction to Programming Using Software Engineering Principles (2nd Edition) (Visual Quickstart Guides).

1. The BlueJ IDE is less than impressive, and my copy (1st edition?) has plenty of errors (diagrams and/or codesamples have typos or are "wrong" with respect to the main text) ... however ... this book teaches OBJECTS using Java, not just how to program in Java. The excercises use problems that are optimally suited to object oriented solutions. The book was never boring or hard to understand. I love this book!



2. Let me say first: I love the BlueJ environment. It is by far and away the best environment I have ever seen for learning or teaching Java. I was facinated after reading the tutorial that comes with it (from www.bluej.org), and I got this book.

   This book is okay, and has some good points to it, but the 'BlueJ' tag on the front cover is a bit misleading. I got the impression that it was added as an afterthought, and does not make really good use of the BlueJ environment.

   BlueJ opens many fascinating possibilities (calling methods directly on an object!) and not much of this is used in the book. A bit disappointing. Otherwise the book is okay.




3. The Object of Java by David D. Riley
   
   This book is less than impressive. It exhumes the need for elucidated text in the field of computer science.
   
   I am compelled to correlate this book with the awkward ramblings of Vizzini to Westley in the movie, "The Princess Bride".
   
   Reading this book was more than a slight burden. Only one who is versed in reading the writings of such authors as Joseph Cambell or Henry David Thoreau can comprehend the confusion of word and sputter heavily peppering this book.
   
   Allow me to illuminate:
   
   1) This author finds it fit to include typos and syntax errors in the example code as to completely change the meaning of the code. Only one already experienced in programming will catch such errors. Others will wallow in confusion as to why the program is not working properly, after all, they copied it from the book word for word, it should be working, right?
   
   2) In several instances, the author uses programming syntax and variable naming methods in his text that has nothing to do with the code explaination at hand. He actively titles the beginning of each sub-section as if it were a class or variable. IE: DivisionOfRadians()
   NO THAT'S NOT A CLASS! :D
   This is a common practice of David D. Rileys throughout the book, and not only for chapter sub-sections. He uses such writing methods all too liberally.
   
   3) This genius author also uses an arbitrary library called aLibrary. Good for him, he designed his own library! Since this whole book is based on the aLibrary, any real world application have just been made void. I mean seriously, try convincing your co-workers that this aLibrary is the next big thing. What happened to the commonly used AWT and Swing libraries? Hmmm, oh, it's shoved in the back index. Right where you would expect commonly used every day libraries.
   
   4) His code snippets and actual text are seperated by font style. Only problem is, you can't tell at all. His method of referring to code, methods, arguments, classes etc in his text is extremely easy to miss without paying impossibly close attention. His text is filled with inconsistencies and problems. I DO NOT recommend this book. If at all possible, avoid it entirely. For those of you who are using this book as a college text, well, all I can say is, I'm very sorry.
   
   On the bright side, his explaination of objects and classes is ... decent.



4. i had to get this book for a course i was taking at the college i go to. i cringe every time i read it because the title is a bit misleading. I thought i was going to be learning JAVA insted i'm learning how to take someone elses class files to apply them to completely meaningless projects that really dont teach anyone anything about how to program, let alone about the inner workings of the programs your working with. the teaching style is more of a top down approach rather than explaining whats going on at the lower level and you learn to program with classes to make programs at an upper level. This may work for some, it definately doesnt fly with me.
   I have read many books on C, and C++, and have paged through some promising java books (like Sun's own books on the subject).. if it werent for the requirement for this book in the class i would have passed it up INDEFINATELY!!! Peice of Krap!!!
   
   do{
   if(The object of JAVA==pickup){
   The object of JAVA = Leave it the hell alone!!!;
   else if(The object of JAVA == buy)
   {
   do{
   Beat head with stick && knock sence into head;
   burn book || return to store;
   }while(book==posession)
   }while(@bookshelf)



5. This book was a required text for my java class. In conversing with my classmates, we all agree that this book wasn't of any help. I would recommend any other book, this one is just too abstract for a beginner. It's difficult to apply the concepts, and the flow is jagged. With the addition of a teacher, and reading this book from front to back, my java class sucked hard because i didn't have that solid foundation I needed.

5 comments about Pro SQL Server 2005 Reporting Services (Pro).

1. I began this book with limited Reporting Services experience, not really knowing what to expect. What I found in every chapter was that the authors really took the time to explain the nuances of this technology that can only be understood from working with it in the real-world and not on a sample database with simple reports. I also learned much more about basic and advanced queries that really helped me out with parameters and stored procedures. I would definitely recommend this book for everyone new to reporting services and those who would like to get answers to detailed reporting scenarios.



2. This book has been well written. Concise, but to-the-point. Coverage on Share point portal and Microsoft CRM is the most comprehensive comparing all the other SRS books in the market. I would recommend you buy this book as well as Wrox to be complete.



3. Well not a good book at all. If you don't have anything else in the office to read or do...and just want to know what Reporting services is all about, you can go throught the book in few hours.



4. This books serves as a great learning tool and reference for people learning RS or for those of us that use it on a daily basis.



5. 
   Loved the writing style. I really appreciated that instead of boring us with an introductory chapter to RDL (Report Definition Language), they sneak it in here and there, keeping the info flowing at a good pace. Plus they wrote the book based on a real-world project they worked on, which makes it easier to grasp the concepts. I give this an A+ and will look for Apress books first from now on ;)