Shop now Shop now Shop now  Up to 70% Off Fashion  Shop all Amazon Fashion Cloud Drive Photos Shop now Learn More Shop now Shop now Shop Fire Shop Kindle Shop now Shop now Shop now
Profile for Mr. Jeremy Flowers > Reviews

Personal Profile

Content by Mr. Jeremy Flowers
Top Reviewer Ranking: 2,049,083
Helpful Votes: 207

Learn more about Your Profile.

Reviews Written by
Mr. Jeremy Flowers "Working on Grails portal" (Milton Keynes, UK)
(REAL NAME)   

Show:  
Page: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
pixel
Apache Maven 2 Effective Implementation
Apache Maven 2 Effective Implementation
by Brett Porter
Edition: Paperback
Price: £24.99

6 of 7 people found the following review helpful
1.0 out of 5 stars Another abomination on Maven., 29 Aug. 2010
Many of books that interest me seem to have adopted Maven 2, much to my chagrin. (APress: Spring Recipes 2nd ed. & Beginning Java and Flex, Manning Spring: in Practice & Flex on Java).
So I thought I ought to have a bash at improving my knowledge in this area.
To put you in the picture; Initially, a couple of years ago when I was looking at Matt Raible's AppFuse that utilises Maven 2 as well, I read the freebie Sonatype PDF on Maven 2. The Sonatype book was dull and arduous to read and hoped this book would be more engaging and help me master the technology. In fact this book in many ways is worse!

Avoid this book like the plague if you are a novice at Maven 2. My advice read the chapter 2 (close to 100 pages) of the O'Reilly Java Power Tools by John Ferguson Smart & co first. John's book is slightly outdated, using the mvn archetype:create when these days there is the mvn:archetype:generate option. There are quite a few typos in the O'Reilly book too. Although some questions weren't immediately answered, I found it a lot easier to understand. Some of the diagrams in the Java Power Tools book are a bit confusing, but at least they helped.

Overall I find reading about Maven to be one of the most exasperating experiences. There is this inheritance process that is supposed to simplify stuff. But I feel this actually is an obscuring force impeding the process of learning the product.
For example. Not one of the books I've read even mentions where the super pom is. They make reference to it. But don't tell you where it is to see the conventions that get inherited! Is it in the JAR in the Maven install folder perhaps? Stored remotely somewhere? Who knows!
I keep wishing Manning would come out with a Maven in Action say to blow the competition out of the water. (Ant in Action rocked).
In disgust and frustration, I initially gave up on this book after reading chapter 1.
Then I read the Java Power Tools chapter and had another stab at it.
Hint to PACKT with this book! Where's a diagram in chapter 1 describing goals?! I'm still pretty much in the dark about the ins and outs of the Maven build lifecycle. This wasn't described clearly enough for my liking.
The books single biggest failing in my eyes is the way snippets of XML are given without leaving the user with a concept of the context to which they apply. The authors would have done far better to provide complete listings and use cueballs into the code, the way the folks at Manning write their books.
I've hardly ever felt such a disconnect as I did with the authors of this book. To elaborate. It's like the authors randomly flung together some thoughts without thinking about storyboarding stuff and conceptualising the flow or how things relate. The kinds of things a beginner would need to know. You need to lay some foundations upon which to build. None of this happens here. Consequently it's hard to retain the knowledge the authors are endeavouring to impart to the reader.
To put it another way, the vague incomprehensible overview the authors give is like a 5000 piece jigsaw puzzle with only 500 of the pieces present. It's hard to get a complete picture from the fragments provided.
To illustrate a few points on the vague superficial nature of this book; It makes reference to Checkstyle, PMD, Clirr etc, but other that giving an overview of their purpose, it doesn't show you how to customise or configure these technologies, and just provides URLs to help you on your way. In the best practices chapter it eludes resorting to writing your own plug-ins to avoid repetition across builds. It also mentions these are normally written in Java. Yet nowhere in the book does it showcase how to do this with an example!
John Smart's Java Power Tools at least does this with a Plexus example. (Its only defense again is that in the archectype chapter a URL is again provided. Where's the substance in these pages?)

The book is also sloppily edited with typos and grammatical errors reverberating throughout the book. The sentence construction was lousy too. I wasn't sure if English is the native tongue of the authors (later I ascertained one is Filipino).
It is poorly indexed and the cross-referencing by chapter numbers is too vague. The book should have had sub-section numbers, to make the cross-referencing more granular. There were times I couldn't find the associated references. These problems were compounded by a messed up references to Best Practice chapter as 1, when in fact that was 7. Chapter 1 was 'Maven in a Nutshell'. (A real misnomer in my opinion!).

Not all of the book is as bad as chapter 1.
Chapter 5 on the Reporting, just left me cold with the technology. It's got so much complexity. The pitfalls and work around needed to get site generation for a multi-module project working makes me feel Maven 2 is way too bug ridden a for my liking. The messed up URL mappings etc.
Chapter 6 (useful plugins) was just as superficial as the first (Maven in a nutshell)
Chapter 11 on Archetypes was the best chapter in the book for me. It was far more coherent than the rest of the book.

I'm also more of a Hudson CI server/Git source control guy myself, so reading about Continuum or vague references to SVN orientated plug-ins didn't really float my boat either. Consequently I never read any of the Continuum chapters.

I continue to be baffled why Maven 2 has gotten to such a following and amazed at how much mindshare it has. My advice, stick to Ant + Ivy or take a look at one of the up and coming projects, Gradle instead.


ActionScript 3.0 Bible
ActionScript 3.0 Bible
by Roger Braunstein
Edition: Paperback
Price: £33.99

6 of 7 people found the following review helpful
4.0 out of 5 stars Frustratingly good, 7 Aug. 2010
This review is from: ActionScript 3.0 Bible (Paperback)
This is a monster textbook. I read this not long after the Colln Moock Essential AS3 book.
Comparing the two:
The Colin Moock book does a better job of explaining the security models and the event model, but I think overall this one has the edge in terms of more up to date content.
However I did slightly prefer the writing style of Colin Moock, although neither authors writing styles were perfect. (You'll also find a review of mine for that on this site too).

The book comprises 41 chapters, split into 9 sections.
I didn't read a couple of the sections on Sound and Video, or Graphics Programming and Animation, as my aim is to master Flex and SpiceFactory and deal more with the commercial e-commerce side of things, rather than that of a multimedia or games programmer.
I think the book has you covered on from both angles. From a cursory glance, I can see Roger has gone into the mathematics of matrices and transformations (Bitmap and Vector graphics, PixelBender, 3D graphics etc).
I'm somewhat familiar with this stuff already from doing geo-spatial coordinate conversions anyway..
So my disclaimer is the rest of this review is based on about 630 of the 920 pages the book contains..

The frustrating stuff:
- I think the book gets off to an absolutely awful first chapter. So full of fluff and waffle, I thought, why did I purchase this book. But as I started to read subsequent chapters I warmed to the book. So if you pick the book up in a bookstore you can definitely get the wrong first impression.
- I guess some other turn offs for me were a double helping in binary arithmetic. Nothing new here.
- Also there were times when I'd read a page, or paragraph and think. Did that add anything? Did it move the plot along? And the answer was a resounding no!
- I'm all for an author being evocative to convey information memorably, but the chapter on debugging was the second worst in the whole book, because it spent way too much time painstakingly and tediously conveying a simple concept.
- Particularly in the first third of the book, I often found sentence construction was awkward. This was often because of a missing word, or poor punctuation/prose. So I'd end up re-reading sections a few times to decipher stuff.
- There were a couple of diagrams that were howlers too (Fig 3-1 and Fig 20-3 : Those pictures weren't worth a single word, let alone 1000).
- 90% of authors attempts at humour were so lame, that they detracted from the overall quality of the book.
- My sentiments, give those Wiley editors a proverbial kick up the backside...
- Then we come on to the fonts that Wiley used. They suck big time for a computer book. The descents on characters were lousy. So a Q looked like an O, a semi-colon like a colon, a comma like a full-stop (period for you guys across the pond). These characters were barely discernible.

The good stuff:
So after all this negativity, why the high ranking...
Because if you are prepared to sift through the detritus, there are some real pearls of wisdom in here.
I was particularly taken with:
-chapter 41 on Globalization (the level the author pitched this chapter and how everything built from what had gone before was perfect. If author had carried this style through book, it would have undoubtably been receiving a resounding 5 stars)
- detailed coverage of TLF (Text Layout Framework) - although table 18-1 could do with mentioning tags are part of Spark, so s: is required as tag prefix (unless using default namespace).
- coverage of SharedObjects.
- There's also an excellent Flash package/class diagram after the table of contents, that cross references to chapter numbers which makes for a handy reference.
- If you like to learn from examples that work, this book comes highly recommended.
- The book also contains tons of links to useful libraries and articles and there are a lot of excellent notes helping you avoid pitfalls.

I think some of my negativity results from the fact the book attempts to be all things to all people, so whilst I felt I wasted a lot of time reading certain things, like binary arithmetic that I knew inside out, I tended to read it, because from time to time some really sage advice jumped out of the page and I didn't want to miss anything. For example I consider myself to be pretty O-O savvy, but there were a few tips that were still worth reading.

So I guess if you are a beginner you won't feel the same frustrations an experienced developer would feel.

Incidentally, the few minor places server-side code was used, PHP was resorted to rather than Java, but I think that made sense and provided simpler solutions.
Comment Comment (1) | Permalink | Most recent comment: Jan 20, 2011 3:38 PM GMT


Essential ActionScript 3.0
Essential ActionScript 3.0
by Colin Moock
Edition: Paperback
Price: £31.60

4.0 out of 5 stars Good but could be better. Time for a second edition/extra content/more distilled?, 19 July 2010
As other readers have commented, the author does tend to repeat himself in this book. And at times some of the things he covers are so intuitive, you think it's hardly worth covering.
I think this was taken to the extreme in chapter 17, where the author takes nearly 50 pages to cover Namespaces. Right near the end of the chapter you finally get a get useful example (Permisssion Based access) , but if you've worked extensively with Java and XML there's a lot of money for old rope here. By contrast I think in Chapter 19 on Flash Player security, an overview was given and then scenarios were described and solutions given. This was a good chapter. Any repetition done in this way was useful and acted to positively reinforce material.

Part 1 covers the core of ActionScript. I think it does quite a good job of introducing a beginner to the concepts of OO Design. There's a bit of chicken or egg stuff going on with forward references the OO newbie might get thrown by, but on the whole the book does a good job of cross referencing stuff. I would have really appreciated a distilled chapter highlighting the syntactic nuances from a Java developers perspective instead of having to wade through 19 chapters (454 pages) for Part I. (Food for though in a second edition?)

Part 2 (chapters 20-28 - pages 457-818) is more about front-end stuff, displaying content, working with events etc. This is where the most useful stuff was.
The Stage Detector class was a core foundation used in several other places throughout the book, which alone make the book worth the purchase.
Once again unfortunately there was a turn off chapter for me. The Bitmap graphics chapter 26. By about half way through I started skim reading, finding it extremely dull and tedious.

Part 3 Covers 3 chapters on Flash Authoring/ActionScript, an MXML taster and Distributing a class.

Then theres' the Appendix which contains the Virtual Zoo example
- which is used to give people a grounding in OO that gets a final overhaul from part I,
- using the information gleaned mostly from part 2, a front-end attached to it.

The book covers the era of Flex 2/Flash Player 9/Flash CS3 (authoring tool) : So things have moved on a bit since then (Published in 2007).

As the book indicates there is no coverage of Regular Expressions. Not such a biggie for me... But there are also other things like Vectors and Dictionaries, and printing too that aren't covered. If you are looking for more up to date content then ActionScript Bible by Roger Braunstein may be the ticket. (All these are covered in his book. Can't vouch for it's content yet. Next on my list to read - Table of Contents looks good - Published April 2010 - Flash Player 10).
It doesn't cover RSL's (runtime shared libraries either) : see Enterprise Flex Development (also has good section on printing)
Finally it doesn't cover Tween Engines or anything like that too if you are more into gaming/animation. See Keith Peters : AdvancED ActionScript 3.0 Animation or ActionScript for Multiplayer Games and Virtual Worlds (One-Off) -A bit off my radar.

Overall thought it's a pretty lucid text book, with code that is well commented and easy to follow. Apart for the two chapters (17 & 26) I'm happy with the purchase.


Enterprise Development with Flex: Best Practices for RIA Developers (Adobe Developer Library)
Enterprise Development with Flex: Best Practices for RIA Developers (Adobe Developer Library)
by Yakov Fain
Edition: Paperback
Price: £39.50

4 of 4 people found the following review helpful
4.0 out of 5 stars The vision the title conjured up for me and the content don't match., 14 July 2010
To me this book has more emphasis on component development, with Java server side and enhancing the open source side of BlazeDS to bring it in line with LCDS using Farata Systems Clear Toolkit. This is more of a code generation solution based on XDoclet SQL statements and an enhanced set of components. It's more a book about trying to increase developer productivity using their library.

I found that some chapters didn't really follow on from each other, so the book to some extent can be read non-linearly. Chapter 4 in particular could be more of the kind of thing a project manager would read or someone looking to setup a project, whilst the remaining chapters would appeal to the more technical audience like architects/project leads.

PROS:
- There are some really great enhancements the guys did to make Flex components more useful.
-Great discussion on design patterns
- Extensive references to useful links for other projects in the Flex ecosystem througout the book.
- There's some fantastic low-level discussion on things like protocols, threading/NIO, Messaging etc. The guys really know their stuff. In particular I was fascinated by Assembler design pattern /ChangeObject to track the delta changes in data and using these to fire off events. It was somewhat reminiscent of Datasets in the .NET arena. This was eventually used in chapter 9 on AIR (v 1.5 - not 2, but features in 2 got an overview: More AIR context than the Flex 4 cookbook) to allow data resynchronisation when an offline system was hooked up again to the central server.
- Discussion on printing via PDFs using XPD/AlivePDF. This was one of the benefits Clear Toolkit provided.
- The authors actually give an honest appraisal of Flex 'warts and all', and transfer some sage advice I'd not heard about from the 'official sources' : Such as, closures in ActionScript giving rise to memory leaks, ways to improve RSL loading and improving Flex. Ways to submit improvements to the Flex framework itself.
CONS:
I think my biggest gripes with the book were:
- The fact that Clear Toolkit used XDoclet style comments to generate code with straight SQL code. I would envision the code would be susceptible to SQL Injection attacks and because the SQL code had to pertain to a specific database vendor, you were locked in to that syntax. I would have much preferred it, had the book paid more atttention to a Hibernate/JPA based backdrop, perhaps GraniteDS. Or better still been based upon GORM and translated the validation rules in the Groovy DSL into components. I wasn't sure how one to many joins were resolved to the underlying tables so repeating columns got resolved to the individual tables either with Clear Toolkit.
- For me I would have much preferred it if the book had dropped the discussion on Cairngorm and PureMVC (since other books cover this in far more detail : For example Pro Flex on Spring by Chris Giametta) and had particularly concentrated on SpiceFactory (and possibly Swiz),
- I would have liked to have seen more discussion on Spring ActionScript Framework. In my eyes, had these topics along with GraniteDS been covered, then the book would have been covering the kinds of topic conjured up by the title.
- It's got some really sophisticated content. But, in a way this is a double-edged sword, in the way it's presented. The book seems to flit from high level stuff to really complicated code, without really ever hitting the middle ground. I think in part this is due to the fact that reams of code is presented without the kind of cueballs into code breakdown and analysis you get, with the likes of Manning books. Sometime the authors did this be presenting everything then repeating this with snippets of code, but it just didn't quite work well enough for me. I would have much preferred it had the authors taken the path of setting the scene with a high level overview and then describing things in smaller pieces.
- I concur with the summation in the final chapter MVC is not necessarily the best solution for Component Driven Development. To me MVP is a far better solution. No mention of this style of design in the book. (Check out upcoming Flex on Java from Manning if you're interested in that approach- plus a couple of issues of Groovymag April/May 2009)
- The dryness of the content of certain chapters - Chapter 10 in particular on Life Cycle Enterprise Suite : a workflow/BPM suite from Adobe.
- I found it odd also that the book discounted PureMVC because it was a pure ActionScript based framework and didn't make use of MXML, but then later in the chapter on performance in a way contradicted this, by suggesting converting MXML to ActionScript in order to squeeze /reduce the size of the swf files and achieve faster loading of code in the Flash Player.
- The quality of the proofreading. I spotted close to twenty silly mistakes and typos in the text on a cursory read through. This doesn't detract from overall book too much. There's a certain irony here, as I offered to assist the authors, but they declined my offer inferring they had this covered!
- Some of the images were way too small and so were difficult to read.
- The indentation and formatting of nested if statements was really bad throughout the book making the code harder to comprehend. I also didn't like the way method signatures were split over multiple lines and the closing parentheses was on third line with arguments in the middle.
SUMMARY:
I'd say the book is a worthy addition to a Flex Developers library, with lots of good and advanced ideas in the Clear Toolkit library that are worth taking on board. If you want to have some of the features of LCDS but want to stay with BlazeDS, and avoid the costs of the license fees, then Clear Toolkit is going to be a good inspiration. Drop XDoclet though guys. It's so last century!

PS: I've since read another of Yakov and co's book, Rich Internet Applications with Adobe Flex & Java, published by Sys-Con ISBN-10: 097776222X (Google on theriabook) - an import from US. Although it's an earlier work, it's a slighter better book in my eyes and the chapters seem to build on each other better in that book, so it's not so disjointed. It's also the best book I've seen on describing Flex from a seasoned Java developer perspective. You can also find it on the US Amazon website. It also contains a DVD. You'll also find a review from me on Amazon US for that book.


Pro CSS and HTML Design Patterns
Pro CSS and HTML Design Patterns
by Michael Bowers
Edition: Paperback
Price: £24.99

5.0 out of 5 stars After reading this, my days of tinkering with CSS and constantly Googling are at an end., 8 July 2010
In my own personal journey of become a developer, I've always felt CSS has been my achilles heel from going after Web Developer roles. I'd always been more comfortable server-side and using Java or Groovy.
I've know the basics, things like CSS selectors, am a whiz with DOM manipulation and using Ajax libraries, but every time I tried to achieve something outside the comfort of YUI or Dojo, rolling my own CSS had been a frustrating and arduous process of trial and error and time spent Googling trawling through results that invariably didn't work.
I'd find I'd be copying and pasting examples without really understanding why things sometimes worked with certain HTML elements and then didn't with others.
Yes I was aware of the basics of inline vs block components, but Michael opened my eyes to the fact that there are more granular classifications of elements and consequently why certain attributes weren't capable of being styled across the board because these classifications.
The book is comprised of 20 chapters.
Chapter 1 distills a lot of information down into a superb and handy reference.
Chapters 2-20 are a series of patterns that build on each other and are cross-referenced.
For me I think Chapter 17 was the high point of the book when the author discussed various layouts (including Fluid) and the final example in this chapter ties everything together.
The layout of the book essentially follows a screenshot, following by the HTML & CSS code on the left page. On the facing page, the problem & solution is described.
It is a bit tough going around pages 100-200, but my advice is to concentrate on the Pattern, visual screenshot and the HTML/CSS and the Example section when present when the author discusses the solution in more depth for the meatier problems.

Knowing how to combine the CSS elements that form the pattern (or building blocks) you'll be set to tackle rolling your own code.

In addition to this, there is also sage advice on search engine optimisation, performance related issues, semantic markup and accessibility issues scattered throughout the book.

There are various routes people take when coding web pages for multiple browsers, hacks, coding to standards, graceful degradation, progressive enhancements. Thankfully you'll find no hacks in here. As the author indicates, hacks are prone to stop working once a browser fixes the issues.
If doesn't just follow the standards are the only way to go route, and what the heck if some poor sucker is still using IE6, then tough luck. Instead the book shows patterns that work in all the browsers including (yuck IE6).

At the time the book was written it concentrated on IE6/IE7/Safari2/Firefox 2. Things have moved on a bit since then. But for the better, Wiki has a good comparison of the capabilities and adherence of browsers to standards.

If there are issues with browsers, the author describes why he takes certain approaches to cover all the bases.. He discusses the merits and limitations of solutions and above all else the patterns which show how to combine a staggering number of permutations of CSS rules to achieve a given goal. (350+ patterns according to back cover).

I guess my only gripes with the book were:
* the rounded corners example. I couldn't understand why there was a need for three graphics and I got lost in the figure 14-7 on P312. I couldn't understand why the square with the rounded corners couldn't be placed in each corner.
* the use of cssQuery over the likes of jQuery for some of the dynamic design patterns. This book was published in 2007, and I've seen references to jQuery from that timeframe.. jQuery is faster than cssQuery enabling CSS selector DOM manipulation too. Is cssQuery even being maintained any more?
* P208 & 292 Text Replacement/Replaced Text were one and the same pattern. I sort of get the reason for this, because one was in a chapter on images, the other was on text. But even so... Why repeat, just cross reference.

Overall this does not detract from what is a quality must have book for any web developer. The best I've seen on CSS (and I've got around 8 to 10 books on the subject). Once you know the basics, clear the shelves and replace it with this one. You won't be sorry you made the purchase.

If you want to have a sneak peak at the code and examples in action too, try Googling on cssdesignpatterns
Comment Comment (1) | Permalink | Most recent comment: Jul 10, 2010 7:08 PM BST


Flex 4 Cookbook: Real-world recipes for developing Rich Internet Applications (Cookbooks (O'Reilly))
Flex 4 Cookbook: Real-world recipes for developing Rich Internet Applications (Cookbooks (O'Reilly))
by Joshua Noble
Edition: Paperback
Price: £33.50

3 of 3 people found the following review helpful
5.0 out of 5 stars Thorough and great book to get to grips with Flex 4., 1 July 2010
-If you like to learn by example and know more about the latest version of Flex, then this is the book on Flex for you.
-This book moved my understanding of Flex 4 (Spark (v4) & Halo (v3) actually) on immensely.
-It's a hefty thorough and extensive tome, covering 295 diverse examples which are meaty enough to lay the foundations for other ideas (of which 293 were clear and easy to follow).
-Chapters 16 & 17 on Browser Communication and Modules/Shared Runtime Libraries were my favourites as they covered things I'd not seen in enough detail before.
- The recipes are extensively cross-referenced too, so if you look at one example you can find an elaboration elsewhere, so the book makes for a handy reference I'm sure I'll be referring to often in the future.
- It's probably worth supplementing this book with the Colin Moock book too (Essential ActionScript 3.0). I'm quite a polyglot when it comes to computer language but there was the odd bit of syntax I was unfamiliar with not present in other languages that I uncovered reading the book, but it didn't hold me back from getting the general gist of things.

Prior to this I'd read Flex 3 in Action by Tareq Ahmed and Pro Flex on Spring by Chris Giametta:
- This book doesn't have an architectural bias, whereas Pro Flex on Spring did and covered PureMVC & Cairngorm and obviously Java integration.
- Flex 3 in Action was too basic for my taste and I like to dive right in more at the deep end and learn by example and this book did just that in spades.

Kudos to the folks who did the proofreading too. it was probably one of the best books I've read in that respect and I only spotted a few things on an initial read through 700+ pages:
-One of these was indentation of code on P587,
- a trivial one, a weight was defined in XML as k instead of kg...
- I also think there was an example where the code said something like function fun ... in there somewhere too, whereby a partial word inadvertently got repeated.

The only sections of the book that were unclear to me were:
- recipe 14.11 P396 : The sentence beginning "Translating this into English.." on regular expressions. The unfortunate thing was a regular expression group was part of the sentence enclosed in brackets and it looked like the sentence was referring to what was in the brackets on a first read and that didn't make sense. It took a couple of read throughs to understand that... :-)
- recipe 18.18 (P523 in particular) and the creation of an AIR application with update capabilities. There was mention of an update.xml file which I don't recall seeing an example of and the index made no mention of it. I couldn't see how this could work if you were more than one release behind on your desktop and you had to refer to an update file on a server via some url (mentioned in prior recipe). Did the update file have several nodes, one per version, or should the update.xml file be named in such a way as to relate to a given version. Who knows.

Overall a great job guys.
Now I'm familiar with the works of these authors, I'll keep my eyes peeled for one of the co-author's (Marco Casario's ) Friends of Ed book: Flex 4 Solutions: Essential Techniques for Flex Developers ISBN: 1430223952. I think it'll make an excellent companion to this book.


Mega-Sonic Cat Repeller
Mega-Sonic Cat Repeller
Price: £21.43

1.0 out of 5 stars Absolutely useless, 26 Jun. 2010
The cat did a number two one foot in front of the unit. A complete waste of money. A hose and patience is a better solution!


Groovy and Grails Recipes: A Problem-solution Approach
Groovy and Grails Recipes: A Problem-solution Approach
by Bashar Abdul-Jawad
Edition: Paperback
Price: £35.49

2 of 2 people found the following review helpful
3.0 out of 5 stars A book of two halfs. Grails coverage better than Groovy, but poorly proofread, 15 Jan. 2010
It's worth picking up this book if you want to be a Grails expert and discover some interesting corner cases not covered in other books.
The main failing of this book is the sheer number of gaffs in terms of errors I spotted. Apress could have done with having a few proof readers look over the text before it went to print.
This book is split into two parts:

1) An introduction to Groovy : Chapters 1-9 : 2 star rating.

Ch 1: Getting Started with Groovy : Installation, Groovy Shell, Console, Eclipse, IntelliJ (fails to mention chgmod for bin folder for UNIX flavours P9)
Ch 2: From Java to Groovy
Ch 3: Groovy data types and Control Structures
Ch 4: Object Orientated Groovy : Incorrectly mentions Groovy doesn't support multiple inheritance on P76: Luke Daley wrote the Injecto library used in GLDAPO to facilitate this. This appears to have gone walkabout on Luke's site. Otherwise I'd include a link. It's on the internet archive though (Wayback Machine). Since Groovy 1.6 there has been the @mixin annotation. Mixin got a mention in GroovyMag Apr 2009 (What's new in Groovy 1.6) and Dec 2009 (Groovy MetaObject Programming) issues.
Ch 5: Closures
Ch 6: Builders
Ch 7: Working with databases : - Best Groovy chapter. USP* for buying book
Ch 8: Testing with Groovy : - This chapter is a howler. The main reason for loss of a star.
Section 8-2 P158. Bubblesort routine. If you do a for loop in Groovy with a range of the format for (n in m..<n), if m contains 1 and n contains 0, then the loop will execute once. So the test case would not work for an empty list or a list with one entry. This is not the same as a conventional Java for loop. for (int i=1; i<0;i++) which will never execute.
Ch 9: Miscellaneous Recipes :

There are far better Groovy guides out there. I often felt the author failed to use the best syntax or omitted things that you can do in Groovy. That combined with the number of typos and errors combined accounts or the low rating for the Groovy half of the book.
Scott Davis Groovy Recipes is far superior as a Getting started guide to Groovy.
Groovy in Action if you prefer a reference to a recipe book. GinA is more complete. (The second edition will be out later this year).
I think the Scott's Recipe book is one you'd refer to more often.

2) An introduction to Grails : Chapters 10-16 : 4 star rating.

Ch 10: Installing Grails : Eclipse / IntelliJ integration (both now a bit dated what with Spring Tool Suite and IntelliJ 8 & 9 now being out)
Ch 11: Web layer. Nice architectural diagram. The Grails section of the book is presented in a rather peculiar sequence. The author decided to showcase the view first (GSP's and Controllers).
In order to get a prototype of a Forum app up and running the author saves all the data off to the session first.
This is like swimming against the tide with Grails, since Grails facilitates automation of this stuff with scaffolding that you can later adapt by converting the scaffolding from dynamic (generated on the fly in memory) to static (generates a source you can modify).
Ch12: Covers the data layer and all things GORM. This is a good chapter, with the exception of Section 12-7. A mistake on P276. The like statements needed percent signs to make them work as a contains. Minor issue. Should have emphasised the need for Serialized on Composite keys in text - it's in example...
Ch13: Scaffolding. A really nice chapter. Would have thought it better to put ch 11 after 13.
This is one of the books USP's. Covers how to change templates and add property editors to render a rating property in a Domain class. Like the Amazon five star review using a Rich UI plugin tag. It's a bit rough round the edges, but an excellent intro.
Ch14: Security The usual stuff on XSS & protecting against SQL injection & restricting Request Methods on actions (so you can't delete a domain instance with a hacked URL), Codecs and Filters. Rounds out with best part (a USP*) on Acegi (Spring) Security (a brief overview is provided to get you started) and a discussion on OpenId.
Ch15: On Testing Grails apps. Really nice chapter. Unit testing Controllers - mocking operations. Integration Testing. Testing Taglibs (could have done with identifying folder these go into), Domain Classes and Functional Testing with Canoo Web Test. Mentions the Firefox plug-in to record these.
Ch16: Miscellaneous Recipes. Highlights for me were Using Grails with Maven 2 and Apache CXF, the successor to XFire is showcased for doing SOAP web services. It's handy to use Maven here for dependency resolution. A huge number of jars are required for this.
Services, REST, logging and tweaking web.xml and spring bean configuration (via XML & GroovyBuilders) round out the chapter. Log4j pattern matching could have done with a table of what the codes meant. Lucky I have a copy of APress's Pro Apache Log4J!

Overall this part of the book isn't one I'd recommend over Jon Dickinson's newer Grails 1.1 book by PACKT for Depth of coverage - although this is easier to follow.
It goes into slightly more detail than Dave Klein's Quick Start book.
The author doesn't always show just the best way of doing things. So this is sometimes handy if you want a quick and dirty fix and broadening your Groovy & Grails skills which it undoubtably will do.

As I said at the start, it's worth picking up this book if you want to be a Grails expert and discover some interesting corner cases not covered in other books.
* USP = Unique Selling Point


Groovy Recipes: Greasing the Wheels of Java (Pragmatic Programmers)
Groovy Recipes: Greasing the Wheels of Java (Pragmatic Programmers)
by Scott Davis
Edition: Paperback

1 of 1 people found the following review helpful
5.0 out of 5 stars A veritable gold mine of useful Groovy nuggets. This book rocks., 11 Jan. 2010
Having already seen many of his videocasts after listening to the Grailspodcast, I consider Scott to be a like a Vincent Van Gogh of the tech world. A Master.
I've read Groovy in Action, a more in depth reference (Groovy in Action 2 will be out later this year too) and Programming Groovy, both fantastic Groovy books.
But I actually like this one the best. It's definitely the book I'd turn to first when I need an example to jog my memory. Worthy of the pragmatic badge as always.
It's an awesome read. Great if you want to learn Groovy in a hurry and like learning from examples. The book distills things into more clear, concise memorable chunks.
It's well cross-referenced and the format make it easy to read in a non-linear fashion if you want to.

The book consists of twelve chapters:
--1 Introduction
--2 Getting Started: Installing & Running Groovy, Groovy Shell/Console, IDE support. There is good advice on Mac/Unix/Windows installs.
--- The book only covers binary rather than source versions. It advises the use symlinks for Unix & derivatives, which is best way to go.
--3 New to Groovy: covers syntax - bringing the Java developer up to speed
--4 Java and Groovy Integration - includes good discussion on joint compilation
--5 Groovy from the command line - This is a superb chapter - material not covered in a lot of the books.
--6 File Tricks - Listing Files/Directories, Writing to files, Moving, Renaming files, AntBuilder etc
--7 Parsing XML : XMLParser, XML Slurper comparison
--8 Writing XML : MarkupBuilder & StreamingMarkupBuilder
--9 WebServices : Another fantastic chapter : Takes you through HTTP, SOAP, REST, XML-RPC, Atom/RSS, Parsing search engine results as XML
-10 Metaprogramming : Really good chapter. Good for getting your head around Categories, Expandos & ExpandoMetaClass (Venkat's book goes into more detail here - but this is a good second)
-11 Working with Grails : A whirlwind tour of Grails. - A similar approach was taken in Groovy in Action at the end..
--- Scott informed me he is actually working on a second edition of a Grails PDF book with Jason Rudolph for InfoQ too that is in the finals stages of production. So expect this to be another great resource.
-12 Grails & Web Services : Returning XML, JSON, Excel. Setting up RSS (for podcasts) & Atom Feeds - Pretty good. But worst chapter of book for me. Didn't like the way some of the code was laid out.
--- I prefer to see the whole thing at once, not snippets with bits missing, then incrementally expanded later.

There are a few errors:
-P42 A size that should have returned 4 not 5 as a result.
-P79 Space missing between words.
P107 Space missing between words.
P215 Mentions customising scaffolding to facilitate adding a timestamp to a record in Grails - which Grails automatically does by adding a couple of appropriately named properties. Google on "Grails GORM Events".
P224 Graeme Rocher confirmed Grails now supports M-M relationships in the scaffolding. Mike Kimsal, the guy behind Groovymag blogged about a solution a while back too.
P236 There is a paragraph repeated twice.

Scott also writes for IBM Developerworks (Practically Groovy & Mastering Grails series).


Grails Persistence with GORM and GSQL
Grails Persistence with GORM and GSQL
by Robert Fischer
Edition: Paperback
Price: £23.99

1 of 1 people found the following review helpful
3.0 out of 5 stars A mixed bag, 10 Jan. 2010
This book has some some five star content in places.
I've picked up a few new Groovy tricks to add to my coding repertoire and I'd recommend this book for that alone.
The book demonstrated things with extensive use of Assert statements which was good.

But there are a few things that irked me and hence the loss of a couple of stars (points 5-7 lose a star and points 8 & 9 causes loss of a second).
1) Comments showing artifact names weren't in some other font or bold or in italics to show a clear deliniation between artifacts in an individual listing.
2) P25 Luke Daley's Injecto library. The link seems to have stopped working at the time I write this.
I looked on the Wayback machine and found it was also used in GLDAPO. Then I exchanged Tweets with Luke & he tells me the @mixin annotation have replaced this.
Guiilliame LaForge covers @mixin this in the Groovymag April 2009 issue (What's new in Groovy 1.6) and Craig Wickesser gave an example in Dec 2009 issue (Groovy MetaObject Programming).
3) P27 1-30 should be 1-32
4) P130.
- Firstly, it seems there are a couple of lines missing here to declare the Testing class and a comment to signify where the artifact is along with its name.
- Secondly the author quotes parameter mapping for Dates as not working in Grails Controllers. So statements like:
def foo = new Foo(params)
Or
def foo = new Foo()
foo.properties = params
wouldn't work for Dates.

I investigated this a bit more and I think this was as a result of the test the author was performing not a Grails problem per se!
ie Date.toString() doesn't give a date in a format that the underlying Spring binding understands!

- I found a quote from Graeme Rocher on Nabble stating:
-- Default date format is "yyyy-MM-dd HH:mm:ss.S" but you can change this by defining a custom PropertyEditorRegistrar in resources.groovy that registers a new CustomDateEditor using whatever pattern you want.

- If you look at the API docs for java.util.Date.toString() you will find the format returned is
dow mon dd hh:mm:ss zzz yyyy (eg Sun Jan 10 11:06:01 GMT 2010)
So the binding obviously wouldn't work from the test given!

Date and Calendar are in fact a pet hate of mine in Java anyway. I wish the Groovy guys could tidy up the Java library. Thanks for commons.lang DateUtils parseDate tip Robert. I've been meaning to look into Yoda time too...

5) There must be a discrepancy with what is in print in places compared to something that would run.
For example:
6) Listing 1-14 on P12. The assertEquals above the shouldFail and the foo.ReadOnly should be swapped around.
7)P16 GORM does not update the lastUpdated property of a Domain class on Create
Try Googling on "Grails GORM Events".
Also lastUpdate needs a nullable constraint in ClassFoo as a result at top of page, and the FooTests should be assertNull foo.lastUpdated instead.

8) Parts of book were hard to fathom:
P24 Listing 1-28. The line that looks like a map calling a closure starting doAddedMethod:{-> This is some sort of MOP stuff I'm unaware of. Could have done with a better overview.
P29 - last four lines above listing 1-33
P41 At this point there is no support for using external or custom comparators on domain classes in GORM. (Wasn't sure what author was getting at here)
P61-65 The whole section on Custom Constraints and Listing 2-2 in particular.
After staring at this for a few minutes I suddenly realised Listing 2-2 was in fact three artifacts! This was not helped by the fact there were no blank lines either side of the messages.properties.
But it still didn't make it eay to understand the example and I particularly found the testListValueMessage perplexing.
I think once again this primariy came down to a map/closure like combo (P62-63) like the P24 example.
I just didn't get what listings 2-2 & 2-3 were supposed to be showing me!!
Bashar's Abdul-Jawad's Groovy & Grails Recipes - has a better example of this. I prefer examples based on a realistic validation, not some convoluted and contrived example. That, combined with the fact that book didn't set the scene well to describe the context in which you'd use this is what makes this difficult to follow.
P110 Sentence ending in 'appropriate' didn't seem to make sense. A wording issue. Perhaps appropriation? Who knows.

As a passing comment, the overloading of the term 'projection' seemed a bit odd too, to me.
It means different things in the context of Criteria Builder (P112) and HQL (P122).
The latter was the context I was familiar with as it relates to the way you would describe projections with SQL - ie column selection.

9) The book also left me with the impression that it was finished to a deadline, as some of the latter chapters were a little light in content.
They gave you pointers to go research, rather than give an example. Materialized views on P141 for example.

As a final footnote it would have been helpful if the book notified the reader against which version of Grails the tests were performed. As I'm wondering if embedded classes (value objects) and associations are now properly initialized too from the request parameters in Controllers. If the author had raised some JIRA issues and left references to those, it would have made it easy to check up on this.


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