5 comments about Ajax in Action.

1. Spent a lot of time discussing non-Ajax related information - Patterns, best practices, Javascript OO. All of this is valuable (especially the latter, which few actually use prior to Ajax). The Ajax examples that were included had a lot of plumbing required (and provided) which is nice for re-usability, but misses the mark if you want to grow your understanding by starting easy and progressing to more complex examples.



2. It's amazing how much the JavaScript world has changed.
   
   This book has a relaxing style, and it was enjoyable to read. However, it no longer represents what I think of as "modern" JavaScript. For instance, it doesn't cover closures until appendix B, and even then it tells the reader to avoid them. These days, having studied Dojo, jQuery, and Douglas Crockford's videos, it's clear that closures are at the heart of how modern JavaScript is written.
   
   The copyright for this book is 2006, yet the index doesn't even mention Firebug, YUI, dojo, or jQuery which are now staples of the JavaScript community. Although, dojo is at least mentioned in the list of Ajax frameworks and libraries.
   
   This book is an interesting piece of the history of JavaScript, but for those wanting to learn modern JavaScript, I recommend watching Douglas Crockford's videos instead.



3. i am very interested in AJAX learn and this book is essential for any person that work in the web, how web developer, web desginer and others. you can learn the structure and the metodology about AJAX and JavaScript too. It is great and interesting



4. I've bought the portuguese version of this book (AJAX em Ação), and I agree that it was incorrectly named.
   I have a good experience with AJAX, and I was looking for an "AJAX bible", with hacks and something like this... but, like other people here, I am disappointed.
   The book is excellent as a guide for project patterns that can be applied not just to AJAX, but to any web project. But the title, "AJAX in Action", suggest another type of content.



5. Looking for the latest DHTML tricks and Javascript libraries? You came to the wrong place: this was published in 2005.
   
   But I really liked this book. All you need is competence with HTML, CSS and Javascript, and Ajax in Action will help you understand what makes Ajax different from the traditional client-server architecture of web apps. It also introduces some design patterns and other basic considerations, e.g. cross browser issues. The second half of the book has several examples that illustrate what Ajax can buy you.
   
   If you're already doing Ajax, there's not likely to be much here of any practical value, and a lot of the basic issues have been finessed away with the more common Javascript libraries. But if you're looking for a higher-level overview of the principles of Ajax and the issues involved in delivering the Ajax experience across browsers, this is still very relevant.
   
   Reading Ajax in Action is not going to make you an expert. But this (or something like Head Rush Ajax) is a very good introduction.

5 comments about Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers).

1. If you are thinking about using Groovy (and you should be)then this book provides a nice and gentle introduction to the language. I don't think it is a 5 star book though.



2. Venkat does a fantastic job of explaining what Groovy is, how it evolved, why you would want to use it, and how to integrate it with your Java projects.
   
   He has a fantastic sense of humor, which really shows through in this book. If you ever get the opportunity to see him speak, take it. He's an incredibly intelligent, articulate programmer, and probably the most language-agnostic programmer I've ever met.
   
   One caveat: if you are a Java zealot, this book may send you into little fits. In the first section of the book, he converts standard Java code (groovyc can compile most Java code, so it's actually Groovy code that looks like Java) into Groovy. There are a lot of comments that may make Java zealots throw little fits.
   
   If you're stuck using Java, get this book.



3. Overall, a very good book on Groovy. Great simple examples to work from. I was very impressed with the chapter on Closures which can be a difficult subject for those coming from primarily a Java background. Wanna learn Groovy? Get this book. [...]



4. With 'Programming Groovy: Dynamic Productivity for the Java Developer', Pragmatic has quickly become THE choice for Groovy and Rails resource books on the market. This book is another fine release in the Groovy set of books (Pragmatic has released a few previously) and I can easily recommend this if you program with Java + Groovy.
   
   **** RECOMMENDED



5. I can't add much more to Neal Ford's great comments but I just want to say that I also am truly enjoying Venkat's book. I have seen him and Neal in several NoFluffJustStuff conferences and this book honors that tradition. He does a great job at introducing language features without any unnecessary stuff.
   
   I started reading his beta copy in PDF from the Pragmatic Bookshelf and being relatively new to Groovy I now feel quite a bit more prepared to tackle problems that are difficult and a bit clunky with Java. I suddenly feel like I have a chance of doing some of that 'cool stuff' that the Python and Ruby dudes are always bragging about.
   
   Thanks Venkat!

1 comments about Dojo: Using the Dojo JavaScript Library to Build Ajax Applications (Developer's Library).

1. I was a little disappointed in this book, but before I go on to the reasons let me explain what I am looking for. I am not new to programming, web development, or writing fairly complicated applications with Javascript. I am already fairly familiar with toolkit such as Ext and Dojo before the version jump. I was hoping this book would be a good reference and guide to working with the features of Dojo. I am not as interested in "dojoifying" web pages as I am in creating Javascript applications that heavily integrate with Dojo. This book may be decent for a web developer that wants an introduction to adding Dojo to web pages, but for a software engineer that wants to really get in depth in Dojo this book seems fairly week to me.
   
   The book has 316 pages and is broken down into 3 sections.
   
   Section I is called "Dojo a Tutorial." This walks the reader through a standard web form implemented without Dojo and then the process of switching to Dojo Widgets and simple client/server communication. (63 pages)
   
   Section II is "Dojo Widgets." This section is a decent reference to many widgets including the layout widgets which get their own chapter. It includes HTML Markup Examples and Javascript constructor examples. I really like these, but they usually seem to be very basic. It also has nice pictures of many of the widgets and layouts to help you understand what they are. I like this section, but unfortunately it is limited to the core features of each widget. The examples are pretty bare, and many of the non-essential features are left out. I do see this being one of the more useful parts of the book, but I really wish there was more depth to it. (121 pages)
   
   Section III is "Dojo in Detail."
   This contains a lot more of the meat of the book, but everything remains pretty lightweight. Some examples and references are given to the Dojo API and various helper function included in Dojo. There is some talk of JSON, event handling, XMLHttpRequests, and testing. This is all good stuff, but it really lacks depth. Everything just seems to brush against the surface. It still is essential and will help someone get started, but I don't think it will take you very far beyond that. (112 pages)
   
   
   I have only had this book a few days now. I am really glad that books on Dojo are starting to come out. I haven't yet received any of the other new Dojo books, so I can't compare them. This book is alright for getting started and for a light reference to common features. My big complaint is the lack of depth.
   
   I wish there were more examples and more details of the features and internals of Dojo. A chapters on making your own widgets instead of a 3/4 page mostly irrelevant section would have been nice. More details on customizing and overriding Dojo's CSS to make your application look the way you want it to would have been great. I think Dojo's grid feature deserves a chapter since it is something that so many applications can take advantage of. There are many things of this sort that the book either left out or just lightly touched.
   
   Overall I'm giving this 2 stars. It's alright, but it's not what I need. I don't think this book contains nearly enough depth to help people far along into building Ajax Applications. It is a good intro and a reference to basic features. It can be helpful to a web developer looking to add some Dojo functionality to a site. For the serious user though this book really doesn't have enough content to take you very far into using Dojo.

5 comments about Groovy Recipes: Greasing the Wheels of Java (Pragmatic Programmers).

1. So you're in a hurry to pick up Groovy, and you're not a big fan of books that while informative, fill you with more language theory than useful knowledge. This buck, while around 240 pages in length, manages to take you from Hello World! to Web Service programming and Grails rapid development in a short period. If you know Java, you'll feel right at home with Groovy, and will feel good about your skills after you're done reading this book.



2. 'Groovy Recipes: Greasing the Wheels of Java' is a typical Pragmatic release in that it is written well, free of bells and whistles, and jam full of relevant and useful information. There is 250+ pages of information here on how to use and implement Groovy, the wonderful Java addition that makes programming easier and more exciting for any and all developers!
   
   Content is spread over 12 chapters:
   
   01. Intro
   02. Getting Started
   03. New to Groovy
   04. Java + Groovy
   05. Command Line Groovy
   06. File Tricks
   07. XML Parsing
   08. Writing XML
   09. Web Services
   10. Metaprogramming
   11. Grails
   12. Grails + Web Services
   
   As can be seen by the TOC, this is a book for programmers of today living in a networked world. The focus is on writing efficient, good code that is fast and useful. This book is extremely beneficial to any and all Groovy developers that want to learn better and faster this wonderful technology.
   
   ***** RECOMMENDED



3. I got this book after hearing the author speak at JavaOne. His talk covers the content of the first chapter along with a few other items, but I didn't mind. It was quite helpful to read through the points and examples he made and try them out at my own pace.
   
   The book is driven by a series of insights rather than complete, formal coverage. I found this approach very useful to getting started and experimenting. The writing is clear, light-hearted, and relaxed, especially in the beginning.
   
   Towards the end of the book, the explanations wane a bit. The sample code is more often given without an introduction, beyond the section header. I was less sure what was going on in some of these cases, as I had gotten accustomed to picking things up very quickly in the beginning. The explanations that followed these code bits were good enough, but I missed that sense of the author's energy from beginning to end of each section.
   
   I don't understand at all why it's called Groovy Recipes. There aren't any. The examples illustrate very well the power of this tool, but I didn't see anything that amounts to, say, the Groovy way to mine a web page, create an IM interface, read mail, etc. If you are looking for code you can apply immediately to some series of problems, this isn't the one.



4. It is a nice little book to have by your computer, if you are working with Groovy. I give this book 3 star review because this could have done without first 5 chapters. I think Groovy is a great language, and in my humble opinion it is more useful to a Java programmer, then Ruby, however the quality of Ruby books is far superior to books available in Groovy.



5. Groovy Recipes is an excellent introductory book into Groovy programming. The first few chapters give clear instructions for learning how to use Groovy. The remaining chapters give clear instructions for using some of Groovy's cool features: using Groovy with Java, Grails programming, metaprogramming, working with XML, File manipulation, and web services).
   Much akin to the fun and energetic manner that Davis speaks in his presentations he writes Groovy Recipes.
   If you haven't heard him speak(and even if you have), do a quick Google Video search for Scott Davis Groovy and you'll find a presentation or two of his. I recommend them.
   One technique that I found especially useful is how Davis compared performing a simple task in the Java world, and then showed how it could be done in the Groovy world. Of course, it's easier in the groovy world for all the examples. It's nice to see areas where we can take advantage of Groovy's strengths.
   Groovy Recipes has enough content to sit on an experienced Groovy developer's book shelf, but the more novice Groovy people will find more value in Groovy Recipes.

5 comments about Java For Dummies (Java for Dummies).

1. What can i say, if you ever want to learn JAVA then this is your book. For some time i have found it hard to understand the basics in java, most of the books i have read gave me headaches they are just to complex but this book by Proff Barry Baud is an absolute knockout. The intresting thing about the book is the manner in which he wrote the book its very easy to undestand complex topics are broken down into bits and pecies that you can undestand.



2. I am a mature University student studying Web Development and Programming.I needed a gentle introduction to Java, and this book has provided just that.It takes the reader by the hand and introduces all of the basic concepts in an informative and uncomplicated manner (not an easy task).
   The author is also very accesible.I had a problem with some code and he responded to my email within hours.(He pointed me to a posting on his Weblog which did just the trick).
   I approached Java with some trepidation but thanks to Mr Burd I am now feeling very confident about tackling the more complicated issues.
   I am also more than holding my own at University.I can`t thank the author enough.
   An introduction to Java that I would highly recommend to anyone.



3. This was a gift for a friend. She really finds it a good resource



4. I needed a book that would explain the important concepts of java, but also introduce them to me from scratch. This book did exactly that. The writing is great, and easily understood, even if java itself seems to give me headaches! There are examples of pretty much everything that is explained, and whenever I had a moment where I looked at a code and said "what is that?" it would be explained a few pages later. All around good book.
   
   The only reason I don't give it five stars is because there were no exercises for the beginner. This is a major oversight since reading about something and understanding it is so different from actually doing it. I had to go to another book for exercises and found they didn't always line up with what I was learning. The explanations themselves, however, were great.



5. I recommend Barry Burd's book. It is a good starting book with humor and illustrations. The material is clearly explained and not overwhelming. Perhaps more important is the author himself who will answer email questions. The programs can be typed into notebook and compiled and run using the Windows run feature or with an IDE provided on download. Ralph Fullwood

5 comments about Hibernate Made Easy: Simplified Data Persistence with Hibernate and JPA (Java Persistence API) Annotations.

1. I've had this book for 2 days and I'm already at chapter 4. All I have to say is this is THE book to get if you want to learn Hibernate from scratch. Believe me, you will not hibernate when reading this book. Writing style is very clear and easy to understand. This book reminds me of the Murach series books, but much better. I also love the fact that the examples don't force you to use other miscellaneous helper tools (Ant, JUnit, etc) to get the examples working. The author apologizes for not using those tools at first, but I think this is a good thing. Had he made us use those tools, it would have complicated the learning process, not to mention having to learn how to use those tools. Don't get me wrong, eventually you should learn those tools for large projects.
   
   The only thing I wish the book would cover more is how to use Hibernate with servlets or JSPs or other web front end technologies since now a days people want to learn how to make Hibernate work with their web applications. But I understand wholeheartedly why the author didn't do a more deeper coverage. Perhaps he should for his next book (hint...hint).
   
   I also found some minor mistakes or omissions, not in the code, but in some of the explanations. For example, reference to where the library zip files are located (page 50) is incorrect and to get Log4j to work, the author should have explicitly stated where the log4j.properties file needs to be saved(page 97). He explicitly states where the other files need to be saved, but for some reason, he made an exception for the log4j properties file. I had to use trial and error to figure that out (needs to be in the c:\_mycode directory). Sorry the only reason I'm mentioning these mistakes here is because the book's website at the time of this review doesn't appear to have a link to see/send errata and download sample code.
   
   I look forward reading the book to the very last page. So far so good! Without hesitation, I highly recommend this book.



2. The perfect book for learning Hibernate. Reads like a Head First Book, but with attitude.
   
   This book is a must have.



3. Awesome book/guide/primer - but make no mistake in thinking that this book is a just a primer. It covers a lot of topics and is written in a very easy, reader-friendly and intuitive fashion. Most (pretty much all) of the code is error-free and is very easy to understand (This is useful very much especially for Newbies). BEST/PERFECT book to learn Hibernate. If you are a newbie, look no further - this is THE book to learn Hibernate. A++. Shining Five stars for this book. I hope the author of this book (Cameron McKenzie) publishes more technical books like this is in future. (If there is something like a "Made Easy" series with books like this from this author, I guess it would be at least equivalent or greater than "Head First" series). What more - find a bug in the code and win $100! (I am desperately trying to find a bug in the code to buy good earbuds for my ipod - looks like it is not going to happen..)



4. This book really got me started on Hibernate. Before I bought this book, I bought Java Persistence with Hibernate book. Soon, I realized that Java Persistence with Hibernate book was not a good introductory and tutorial book. So I decided to try the Hibernate Made Easy by Cameron. After reading Hibernate Made Easy, I have a good understanding of Hibernate and I am ready to move on to more advanced topics. I gave five stars to this book for the following reasons.
   1. The book was written in simple, clear and concise manner. It is easy to understand and absorb.
   2. The code examples in the book works.
   3. The book uses a simple development and deployment environment so that I did not have to download a tons of software to get the examples working.
   4. The examples use mySQL database instead of HSQLDB like in other Hibernate books. So it is more practical.
   5. This book is not just about learning Hibernate. It is also about how to apply this technology properly. The author included tutorials on how to design the persistent layer using Data Access Object and Factory design patterns.
   6. This book has web application examples using JSP and Hibernate running on Tomcat. These examples are very simple yet very poweful. They get to the point.
   7. Finally, about the author. Cameron loves to hear from the reader. He accepts the reader's comments and he shares his ideas freely with the reader.



5. This book is a great introduction to Hibernate and all the code really works. The examples are pretty good and the author builds upto a simple set of classes which illustrate all the mapping concepts. I had avoided working with Annotations and Hibernate before but I found them easy to work with and understand.
   The chapters on Mappings and How Hibernate Works are very good. Keep a copy of Java Persistence with Hibernate to supplement some of the concepts. This book is meant to be an introduction so does not cover advanced topics like transactions, caching and optimization.

5 comments about Test Driven: TDD and Acceptance TDD for Java Developers.

1. When I purchased the book "Test Driven" by Lasse Koskela I hoped to see suggestions, patterns, and tools for continuous testing during the development cycle. It is not a secret for an experienced developer that postponing the testing phase until the design and implementation are complete is very dangerous. Every real world developer is well aware that implementation quite often reveals design shortcomings, while testing does the same for implementation, and less frequently for design deficiencies. Refactoring provides the flexibility to make incremental improvements during the implementation and testing phases.
   
   What I found instead is a manifest of software development madness. The book proudly presents in pictorial form (as if words weren't sufficient enough) on page 15 a reverse development cycle: test - implement - design. And naturally, since there is no design forethought, testing is followed by endless refactoring to improve the design and implementation in order to achieve better and better results. Which, in my opinion, doesn't equate to good or great; it still equates in best case to mediocre. Why?
   
   The power of software design (OO especially) is the ability to establish inherent relationships and commonalities between seemingly unrelated domain entities and model systems in our mind (and modeling tools that exist in abundance) before they materialize in a final product. We design frameworks in order to use them over and over again. Well designed and reusable components should have minimal yet complete interfaces to be successfully utilized in more than a single application. This doesn't come from the test and try approach; it is the result of a significant design effort. There are many other things that I could write about software design work and positive aspects of this activity, but this is a book review, so let's switch back to the topic.
   
   I am very perplexed with a proposal to substitute use cases or user stories with test cases (page 46). In short these are different activities usually performed by different people with different sets of qualifications.
   
   The suggestion to "choose composition over inheritance" (page 119) is very strange. Inheritance reflects a different relationship which could and should be exploited in design and implementation. I found ridiculous the argument to use this advice to simplify testability (not even improve). Page 121 suggests avoiding Singleton patterns claiming that "object instantiation is dirt cheap with modern virtual machines" as if static and Singleton are used to make code more efficient.
   
   And I could go on and on.
   
   I don't disagree with the desire to be agile; it keeps you grounded in reality. It is hard, or close to impossible to achieve first-class results without iterations. That is why the waterfall approach fails so miserably. Testing - unit, functional, system, performance etc. - is critically important during all stages of development. Test plans should be created in parallel with the design and implementation efforts. As regression tests are software product "sanity checkers", unit tests keep developers confident as they make progress.
   
   Why would one think that the right approach is turning the development process on its head? I think that it is extremely harmful for young software developers, who would bypass the necessary steps (and pains) of a systematic routine of building good software.
   To tell the truth, as entertaining as it was to discover more and more intricate details of TDD, I stopped somewhere on page 100 and browsed through the rest without going into details.
   
   On a positive note, "Test Driven" has a reasonable amount of good references to existing tools and technologies. The book stresses the importance of testing, including acceptance, and gives interesting insights into various techniques. Code examples are well written. The refactoring suggestions are very sensible as well. Apparently, the author has first hand experience with the methodologies and tools he describes.
   
   My major disagreement is with the fundamental principles in this book, not in practical terms and advice. 1 star rating reflects my very negative attitude towards approach. A lot of recommendations are very useful.
   
   I came up with this metaphor for the book: Lasse Koskela is building a house for a young couple. They are vivid bikers. So, Lasse builds a bedroom and a bike room. Tests passed. A few years later the couple has a child and the bike room has to be remodeled to be a baby's room (not the best room for a child) or he adds a room by eliminating one of the garage spaces. Tests still pass - everybody is alive. Then a second child arrives, and Lasse has to add yet another room, in the process having to relay new electrical and plumbing lines. Tests still pass. The result is an ugly, poorly designed house that the original family leaves and nobody else wants to move into.
   



2. This book is one of the best books I have ever read. It's easy to understand and well-written. It dives deep into TDD without complicating things, and shows with good examples why you should do TDD.
   
   Highly recommended.



3. "Test Driven" is geared toward Java developers interested in writing better JUnit tests. Despite the title, it is useful whether you want to write test first or test last.
   
   The first part of the book covers the softer aspects of testing such as how to decide what tests to write first and spikes. The rest of the book covers writing tests for common Java components including servlets, data access code and Swing. Examples were for things that we frequently want to test. They included "hard" things such as testing times and threaded code.
   
   I particularly liked the sections on design and testing patterns. There was good coverage of different JUnit extension libraries with examples including dbunit, jmock, easymock, jemmy and abbot. There was also a full chapter on FIT.
   
   I got a sense of "in the trenches" realism from the book. Tradeoffs of techniques were clearing mentioned. The chapter on adopting TDD shows the experience of someone who has done it many times. The section on how to fight resistance really spoke to me.
   
   This is the first book I have read using JUnit 4, which was useful for reading well written tests. While there is an appendix "tutorial" on JUnit 3.8 and 4.0 (two page annotated classes), you really should feel comfortable with one version of JUnit before reading this book. While a few sections pertained to specific technologies, such as Spring, the concepts apply to everyone. I highly recommend this book.



4. Great book. I've read Kent Beck's book, but his book is a bit dated these days. I found Test Driven to be a nice, timely refresh of the TDD and refactoring topic. I've done some mentoring and teaching on TDD and refactoring lately and I've been evangelizing this book to my students/participants. Well worth the money.



5. This book is an great resource for Java developers wanting to get started on TDD. It covers the majority of tools and techniques available, along with useful tips and best practices.
   The first part is already worth the book's price. The author presents TDD and its benefits, shows how it works with a lot of coding, and ends it with an excellent chapter on concepts and unit tests design patterns. By the end of it you'll feel eager to, at least, give the practice a shot.
   The book proceeds showing how to test technologies commonly known as "hard" to unit test, like web components, database access code, threads, and swing. Although the author doesn't go into too much detail in any of them, he presents good solutions to make their testing easier.
   The last part is a very good introduction to Acceptance TDD and how to write tests with Fit. It is not as thorough as the TDD introduction, but will give you a very good understanding of what ATDD is, how it should be done and how it can (and should) be complemented with unit testing.
   Essential reading for Java developers looking for ways to improve the quality of their code.

5 comments about Pro Spring.

1. I'm finding it hard to get into "Pro Spring". In all fairness, I've only read three chapters. However, after those three chapters, it is still unclear just what "Spring" is and what value it adds -- except in vague generalities. I'm no neophyte software developer, having been involved in a wide variety of state-of-the-art software development professionally for 40 years. I've heard enough good things about Spring that I want to learn more, but so far, this doesn't seem to be the way to go.



2. This book gives a good introduction to the Spring Framework, Aspect-Oriented Programming, and Inversion of Control on a whole. However, for a framework that many people will be using for web development, this book has only one chapter on Spring MVC; much of the implementation details are left up to the reader to discover on his/her own.
   
   If you are looking for an overview of the Spring Framework and some of its basic implementations, this book is a good start. If you are looking for a "cookbook" with detailed examples, you would be better off searching the forums and newsgroups online.



3. At my old position, I constantly referenced this book, but fortunately the company owned the book. When I left that job, I purchased my own copy. It's well written and provides enough examples to get you started. This book is a MUST HAVE for my library.



4. 1. Excellent Organization
   2. Easy to Read - explanations are concise and easy to follow, even for Spring beginner like me.
   3. Excellent Samples - the evolution of sample code is very clean, concise and easy to read. Even if the listing is 1 or 2 page long, you just need to take a glimpse to understand what's going on. Good presentation!
   4. Detailed Coverage - can function as a reference book.
   
   The authors should write more books!



5. Lots of good information on the Spring framework, at least for 2005. While I can find a lot of it online already, especially in the excellent documentation provided with the framework itself, I can live with that. What does irritate me is that the book needs more why than how; and more intersection with the real world, more tales from the trenches where things don't always work, and where we cannot simply trim requirements to fit a technology demonstration.
   
   I've been programming long enough to know the difference between a cowboy programmer who gets the job done, but has the good sense to leave before anyone has to deal with the mess he's created; and the professional whose work brings both joy and awe to maintain. I think a book with "Pro" in the title should inspire and encourage that professionalism, not just teach enough of the concepts, syntax and idioms to get by.
   
   Don't get me wrong. If you want to learn Spring, I heartily recommend this book. Just don't be surprised to not find that secret sauce that makes one a professional.

5 comments about Java(TM) Puzzlers: Traps, Pitfalls, and Corner Cases.

1. Disclaimer: the fact that I have known and worked with Josh on and off for around 10 years now has little bearing on my review of this book.
   
   Anyone who believes they are a Java master should read this book, it is well written, captivating, informative and full of useful information!
   
   In short it's a must have (along with Effective Java) for your Java bookshelf



2. The book is very friendly and readable.
   Some of the examples are real unique and in most cases you are not going to meet them but it's fun to read, use your mind and check you knowledge.



3. You really have to be a language weenie to care about many of these. If you're looking to become a better programmer, or simply to be entertained, this probably isn't the right book.



4. This book was so much fun to read but more importantly it surprised me a couple of times ... which is what i expected when i got it ...
   
   Cutting it short, if you are looking for some puzzlers ( some real ones ) get this book, at least you'll have some fun ...
   
   Regards
   Vyas, Anirudh



5. Completing the puzzles in this book will increase your knowledge of the Java language spec. This book was written by 2 of the world's foremost Java experts.

1 comments about Beginning Groovy and Grails: From Novice to Professional (Beginning: from Novice to Professional).

1. I come from a strong Django background and when I recently inherited the role of Lead Developer I had the power to make decisions for a small start-up. There were two requirements for the product the customer needed: database independence and it must be based on a java framework. Additionally, the team would be fairly small and we would have less than 4 month to deploy. Needless to say I felt Grails would make my life livable.
   
   This book does a wonderful job introducing you to the Grails framework. To be honest, its hard to pick up Grails based on the documentation out on the net unless you already have experience with a similar framework. I had several members on my team that failed miserably with Grails who came from a Spring/Struts background. However, those who had Rails and Django experience could hit the ground running.
   
   If this book came out earlier, I'm sure the 'other' developers could've had less headaches. The book holds you hand and introduces you to the simplicity this technology offers. Give Grails a shot and get this book! Yes, the framework and language isn't quite mature yet and does have a number of 'gotchas.' But with its glowing community I can see it easily improve and become a very popular choice in the job market.