5 comments about Eclipse: Building Commercial-Quality Plug-ins (2nd Edition) (Eclipse Series).

1. Eclipse: Building Commercial-Quality Plug-ins (2nd Edition) (The Eclipse Series)
   
   + Provides a good overall picture of plug-ins structure, a lot of details.
   - Contains a lot of methods description that you can find it otherwise in Javadoc, running an eclipse plug-in could have included some more options (in fact for developing I preferred the version from Eclipse help)



2. I got the book on time and the condition of the book was new as promised. Couldn't ask for more.
   
   Cheers!



3. This is a good guide for developing Eclipse plugins. Since most online documentation for Eclipse is garbage, this will get you up and running in much less time. It doesn't answer all questions but is a handy reference.



4. If you're planning to write an eclipse plugin, this is THE book to read. The authors have done a fantastic job. Kudos.
   Now a few suggestions.
   The examples in the book can now be imported in the form of an eclipse plugin. This is great but the examples take a huge leap. For example, chapter 6 introduces you to the concept of views and shows you how to build a simple view with a table and a hard coded set of values. The example in chapter 7 is a huge leap in complexity. It would have been nice to have an example that shows you how to wire events to mouse clicks in the basic "One, Two, Three" view. Instead, the example in chapter 7 tries to do too much. As such, I can only give a limited time to reading the book and going through the examples. The jump in the complexity of the examples from chapter 6 to chapter 7 is like going from "hello world" to socket programming.
   
   Again, my review is based on the perspective of someone who is writing eclipse plugins as productivity tools for my project, not as commercial products that I plan to sell. I may not be the right audience for your fantastic book but I suspect there are a lot of people like me who want to write plugins as productivity tools. Since your book is THE best book on eclipse plugins, I'm sure they'll be referring to it too.
   
   Another thing: Part of the examples from chapter 7 don't seem to work. Specifically, the "add to favorites" button on the toolbar doesn't work because the selection object is of the type TextSelection and not IStructuredSelection. Maybe I'm doing something wrong.



5. I am writing Eclipse plug-ins for almost two years now and owned this book almost from the beginning. Looking back I must say that the book helped me get started and let me believe "it's possible". As probably many others I was a little intimidated at first by the vast possibilities of the framework.
   Now that I am much more experienced I must say that whenever I look into the book it leaves me a little bit disappointed. It only adds little value to the "Platform Plug-in Developer Guide" which is part of the online documentation and already covers a lot.
   The book goes into details and code very quickly without explaining the concepts very well. I still use the book every now and then for finding some nuggets not covered elsewhere and sometimes I get lucky but not too often.
   Shall you buy this book? If you are a beginner and if you like to learn by programming a sample plug-in then yes. The more proficient you get the more the book will lose its value and you will use other sources of information.

5 comments about Java Cookbook, Second Edition.

1. I make no apologies about being an "R&D" developer... "Rob & Duplicate". I learn best by seeing something that works, and then adapting it to my own needs. Therefore, a book like Java Cookbook by Ian Darwin (O'Reilly) is the exact type of book I look for and use on a regular basis.
   
   The chapter breakdown: Getting Started; Interacting With The Environment; Strings and Things; Pattern Matching with Regular Expressions; Numbers; Dates and Times; Structuring Data with Java; Data Structuring with Generics, foreach, and Enumerations; Object-Oriented Techniques; Input and Output; Directory and Filesystem Operations; Programming External Devices: Serial and Parallel Ports; Graphics and Sound; Graphical User Interfaces; Internationalization and Localization; Network Clients; Server-Side Java: Sockets; Network Clients II: Applets and Web Clients; Java and Electronic Mail; Database Access; XML; Distributed Java: RMI; Packages and Packaging; Threaded Java; Introspection, or "A Class Named Class"; Using Java with Other Languages
   
   For those unfamiliar with the "Cookbook" style, the chapters have a series of real-life problems, such as playing a sound file, playing a video clip, and printing in Java. The problem is followed by a short one or two line solution and an expanded discussion of the issue complete with code. This approach makes it really easy to find something that is similar to the issue you're facing and to see how someone else would solve it.
   
   For me, the quality of this book is really high. It's a second edition covering the Java 1.5 package, so it's fully up on the current technology. In fact, the Generics chapter deals exclusively with new features in 1.5. Some of the solutions are code classes developed by the author and made available for download. But unlike some books I've reviewed where the author supplies code, this isn't an attempt to push their company or product. It's just a clean way to use a solution that someone else has worked through.
   
   This isn't a book you'd use to learn Java from scratch, but it's a book you'll use on a regular basis as you continue to expand your Java knowledge. Highly recommended.



2. This is an excellent book-it manages to make itself appropriate for both introductory and experienced Java developers. If you've ever looked at any of the books in O'Reilly's "Cookbook" series, you'll know that the book is organized into "recipes", which illustrate how to accomplish various development tasks in Java.
   
   Many of the beginning recipes are pretty basic, but will be used by developers new to Java to get started. Recipes include setting up the IDE to work correctly, working with a debugger, and even an introduction to JUnit. The next few sections of recipes are similar to what you would expect from any "Learn to Program in Language" book. There is a discussion on strings and string use, numbers, and date time values.
   
   As the book progresses, the recipes become increasingly technical. I was quite impressed to see a discussion of Generics in chapter 8, which were added to 1.5. Additional technical recipes include I/O, graphics and sound, and using sockets in Java. The author is able to successfully discuss a lot of different topics in a very clear and concise way. Additionally, I was both pleased and surprised to see the author include brief discussions on software patterns and agile methodologies, both of which are very much coming into vogue.
   
   Naturally, this book isn't easy to read from cover to cover, but it was never designed that way. Much like an actual cookbook, it is designed to best be used as a reference manual. Experienced non-Java programmers will benefit from this book, which can be used as a good tutorial to learn the Java language quickly. Java programmers will also benefit greatly from this book, and will likely want to have it next to their computer as a reference manual. I would highly recommend this book to anyone either wanting to learn Java or anyone looking for a good Java reference book.



3. Anyone who has been involved in programming very long soon comes to realize the value of the various programming cookbooks. The cookbooks are not for the person who wants to learn how to program in a particular language, but are very useful for programmers with a basic knowledge of the language. The idea is simple, take the most common problems people deal with and put the solutions into a book. Simply state the problem and then show the code to resolve it. So, if you need to know how to do something you can look it up, enter the code, and test it.
   
   Some of the chapter subjects include Interacting with the Environment, Strings and Things, Pattern Matching, Numbers, Dates and Times, Object-Oriented Techniques, Directory and Filesystem Operations, Graphics and Sound, Network Clients, Server-Side Java, Database Access, XML, and Threaded Java. Typical of any of the programming cookbooks, it is a quick and easy source for answers. Each item has a short explanation of the problem and then goes straight to the code to demonstrate how it works. A great time saver and required resource for Java programmers, Java Cookbook, 2nd Edition is highly recommended.



4. I am a Java newbie and purchased this book in addition to the Head First Java text to get me started. I am a big fan of the Cookbook series, and have generally been very satisied with them. However, the Java Cookbook has been a disappointment.
   
   I must echo the sentiments of "schrapnel" in his review of this text. The recipies given seem designed to teach general concepts rather than solve common programming problems. The result is a general Java textbook that is encumbered with the Cookbook format of Problem, Solution, Discussion. There are numerous instances of the Problem being trivial, or downright silly. For example, "You really want to know about end-of-line characters" and "You need to learn the syntax of JDK 1.4 regular expressions" are presented as Problems for recipies. Clearly, the author is reaching a bit too far in his attempt to present the material in cookbook format.



5. I bought the first version of the Java Cookbook many years ago and it was a huge find back then. There were few online resources at the time loaded with really great, consistent sample code, like http://www.javaalmanac.com. The Java Cookbook filled a need then and it fills a need now.
   
   The book covers subjects of interest for programmers with any level of Java expertise. It is written in the classic 'cookbook' format. Each chapter concentrates on a specific area, like 'Strings and Things', 'Pattern Matching with Regular Expressions', 'Object-Oriented Techniques', 'Network Clients', 'Database Access', 'Threaded Java', etc.
   
   Within each chapter, several problems are tackled. One or more pages are devoted to each problem, with a general format of: 'Problem', 'Solution', and 'Discussion'. Many of the problems build on previous solutions. Nearly every solution contains a Java example and the code tends to be simple enough to grok at a glance.
   
   The book has been updated to cover most of the new Java 1.4 and 1.5 goodies, but doesn't have as much coverage as I would have liked. However, the most fundamental topics are covered well. The 800+ page book includes 312 recipes that cover a wide range of topics.
   
   If you are like me and spend a lot of time learning by example, you will find this book an excellent resource.

5 comments about Head First Design Patterns Poster (Head First).

1. It is a great poster, very clear and very big... still looking for space to put it on the wall :) it deserves to make space for it...



2. Excellent book. Every book I've ready so far in the Head First series are Great.



3. I bought this poster in the idea that the book was really interesting.
   The problem is that is badly designed. I'm not sure what others expect from it but for me I bought it to remind me all the constructions from the book.
   A very fast guide in case you want to design.
   I saw it as a post help for those that read the book. You can't put all the details on the poster but what you can do is put the guide lines.
   Most of the UML drawings for different patterns are missing. There is just a simple definition in the box.
   The text is very small and unless you are really in front of the poster is quite hard to read it.
   If I were to design this poster I would put with in big letters the principles stated in the book and the UML drawings for each pattern and maybe a few sketched examples. Something that would be focused on helping the programmer remember the principles.
   When looking at the poster you should not waste time to try to read from it. That is not the point. In my view if you want to check more details you grab the book and read it.
   this is my view... I hope it helps.



4. If you have Head First Design Patterns (Head First) this poster is great overview that you can stick on wall and stare at it from your computer table.



5. To reiterate the subject for those who care about such things, this useful poster is shipped folded instead of rolled.

5 comments about Java Power Tools.

1. To begin, I should note that I was a technical reviewer on this book. Ever since I reviewed it last year, I've been telling everyone who would listen that "Java Power Tools" was going to be one of the best books to be released in a while. If you are on a Java development project, you must have this book! I'm still amazed by the breadth and depth of the information in it. As it states in the back of the book, it's like having 30 reference books all in one. And, it's not like John simply gives a high-level overview of the tools. He goes into great detail such that you can take the examples and use on your own projects. The beauty is that he has weeded out all of the bad tools and given a concise set of tools to immediately help improve your team's productivity. What's more, they're all open source and you can download them immediately and try them out. He covers all of the major tool types in the development process including version control, build, CI, issue management, testing, code metrics, etc. "Java Power Tools" helps you automate your own development processes. If you'd rather be spending time creating software rather than trying to bend your process or tools to meet your needs, this is the book for you.



2. The book is enjoyable, extremely well organized and covers a wide range of open source tools needed for any successful software development life cycle. I would recommend Java Power Tools to anyone writing Java. My only complaint is the size of the book; but I think in order to cover 30 tools , and the breadth of material covered for each of these tools do make up for its weightiness.
   
   This book is written with a Java developer audience in mind. I should however say that Java is not actually the main focus of the book, and I believe this book would be of great interest to anyone concerned in writing better software.Readers should have a basic knowledge of Java and XML. You don't need to have any prior experience with any of the tools covered.
   
   Java Power Tools can be used as an introduction to various technologies and also as a complete and easy-to-use reference work. After having read and reviewed numerous book over the past 5 years, I think it safe to say I have not read another text that so well combines the best attributes of both.



3. We are moving to hibernate on my project, so I bought several books to help introduce me to the subject. I got Hibernate Quickly and Beginning Hibernate along with Java Persistence With Hibernate. I enjoyed Hibernate Quickly because it really does give you the 20% that constitutes 89% of your tasks. However, I still had questions and found this one.
   
   The author of this book has excellent examples and tutorials of what he is introducing you to. He builds the project as if it were really going to production. He explains not only the Hibernate, but the build files and what is being accomplished quite thoroughly. As you work through the logically ordered chapters, you are introduced to and apply new Hibernate concepts and put them to use in the example project you are building throughout.
   
   Chapters 10 through 14 are an added bonus and multiply the value of this book. The authors cover connecting to MySQL and how to integrate Hibernate plugin into Eclipse and use it. They also include chapters on Maven, Spring, and Stripes.
   
   The chapter on Maven is as informative and useful as I have found. Seeing how the definitive guide isn't available until about August, this is a great standby and introduction to Maven and the functionality it has. In this chapter, he also explains in some detail the projet management model (pom.xml).
   
   The chapter on Spring is excellent in that it gives high level details about dependency injection but more importantly, gives a clear overview and exercise in the Spring Framework ORM module and how it can abstract out much of the grind of Hibernate. I learned a lot about Spring and how to use it to interface to Hibernate.
   
   The last chapter on Stripes was mainly of interest since our project may use Stripes and there isn't a lot I could find on the subject. It too helped me understand Stripes and how to integrate it into and set it up in a project. It also gives clear examples of Stripes and how it plays with Hibernate.
   
   All in all, this book has been and will continue to be a valued addition to my library primarily because of my current development context. However, the material on Hibernate will be much referenced no matter what context I am in.



4. I was really surprized how much info is in this book, most of them is very useful for me and my team, with this book we can reach more automation in ours work ;-)



5. If you want to be efficients and productive as a Java programmer I highly recommend this book to you. It is not about the Java language, but how to use various tools to use deploy your time productively. It introduces you to tools such as maven, SVN, JUnit, etc. which are very useful. And it is a well written text, well organized.

5 comments about GIS for Web Developers: Adding 'Where' to Your Web Applications.

1. The book is a *solid primer* for understanding GIS data and its usage.
   
   It will walk you through vectors, projections, and rasters. You'll be introduced to spatial databases and OCG (with a focus on Open Source tools).
   
   This will get you going... places :)



2. Prior to reading this book, my experience with mapping technologies was limited to writing Google Maps applications and using its geocoder. I didn't even really understand what a geocoder was.
   
   Scott Davis provides a friendly, easy-going assist to learning the bizarre complexities and conventions associated with real mapping technologies. I was frankly dismayed at the state of the art, with its odd compromises and incomplete, conflicting tools. But Scott leads the reader through the maze quite effectively.
   
   If you're ready to move beyond simple markers and lines, this book shows the way to _real_ mapping applications.



3. We have a hard time as software engineers mastering our own concepts. Once we are asked to work in a non-trivial domain like geospatially-enabled environments, it is easy to get lost (pun intended). This book acts as a map to the world of maps. It shows you where you are; in this case, building web-based applications that need to visualize spatially-oriented data. It shows you where you can go without taking too many trips down unnecessary rabbit holes. In short, Scott walks masterly on the very fine line of theory and practice making it both useful and instructive.
   
   In addition to the informational content, the book is one of the more beautiful computer books I've seen recently. The decision to go with color plates for the images is key. In order to fully appreciate the power of visual contexts like this, you have to see the richness of the data.
   
   I worked on one of the first "whole Earth" environments 14 years ago and would have gone bananas for a book like this. The field has changed pretty dramatically since then with the emergence of both the Web and rich and complicated standards like those we are seeing from the OGC. This book lays enough foundation of the theory and catches you up to the new and sexy tools available to us now.
   
   We are not genetically-programmed to stare at words and tables. We are visual creatures and gain real insights when we can see relationships literally laid out in front of us.
   
   Do your customers and users a favor and add some "where" to your applications. Do yourself a favor and pick up this guide to help you along the way.



4. GIS (Geographic Information Systems) is one of the most important development technologies to be applied in the past few years. By using GIS concepts you can learn to apply geographic code to any and all applications easier and better than ever before. With 'GIS for Web Developers: Adding 'Where' to Your Web Applications' you can learn the ins and outs of how and why you will want to add a GIS presence to your application. With plenty of maps, code samples, and a look at the different GIS viewers and editors out there in the world today, this is a good book for any developer that wants to learn more about GISs and their relationship to GPSs.
   
   Good introduction to the technology.
   
   **** RECOMMENDED



5. I was not familiar with GIS system and I got this book to figure out how things work. The book turned out to be a great help for me. Since everything was very new to me I ended up spending a lot of time to learn about the PostGres database, it PostGIS extention and Geoserver. So do not take it as a complete walk through tutorial but it certainly great help when you get stock somewhere. Bear in mind that I am quiet computer savvy and familiar with linux, java and such. Overall, I recommend this book if you are a web developer that wants to deal with spatial data and his needs are beyond things that can be done simply on google Map, yahoo map and such.

5 comments about JavaScript for the World Wide Web, Fifth Edition (Visual QuickStart Guide).

1. Believe it or not, this book is an acutal textbook for a course I am taking in college. I was hoping for a book better than this for a college course.



2. The authors are not very good at explaining things, even relatively simple things such as the prompt() method or the dot syntax. It could be much clearer and they could do it with fewer words. The authors take a rambling tone that doesn't quite give you the information you need. You can't depend on the authors to give you meaningful explanations. You have to experiment and try different things.
   It's possible to learn JavaScript with this book, but it will take much more time than is necessary. In five editions, why couldn't they have improved this book? What are they doing? Other Visual Quickstart Guides are the same way. I hope the Visual Quickstart Guides go out of business and some other company takes over the market share. They've been cavalier toward their customers and don't deserve to be in business much longer.
   Other books like JavaScript: The Definitive Guide by Flanagan, and JavaScript: The Complete Reference by Powell and Schneider are better at explaining the language even though they are considered to be more advanced books.
   The same authors have published JavaScript & AJAX for the Web, which has almost the exact same content only it has a couple of AJAX chapters thrown in. Check out the review by another customer (at this point it is the only review). His critique is very similar to this one.
   On the positive side, the authors manage to get most of the information across and the content is relevant for the majority of users.
   If you choose to buy this book, use it as more of a guide and do not depend on it. Purchase other books to supplement it.



3. This is useful as a reference book or to learn JavaScript. I do not use it often, but when I need it I am very glad to have it on my shelf. Good examples.



4. This book was well packaged for delivery. I like it for the clarity with which the authors present the various lessons.
   
   I hope to derive a lot from it and to add to my skills.
   
   I am still going through it and so far it has been very exciting. Thank you for the good business. A value for the money.



5. It's downloads don't work, and the book requires that they be used.
   the examples will not run as written in the book.
   They do not conform to the w3schools standards.
   it cannot be used outside Microsoft products.
   Like Firefox.

5 comments about Eclipse IDE Pocket Guide.

1. I found the book to contain several tips and tricks that were new to me and I have been using Eclipse for over two years now. I would highly recommend this book to new Eclipse IDE users to help you get a leg up on learning the Eclipse IDE. I found this book well worth the price and will be looking for more pocket guide books by O'Reilly to add to my bookshelf.



2. I expected a little more from this book than creating a simple java file and compiling it. This book is for someone who is new to IDEs. This is *NOT* for someone trying for a quick reference to migrate from another IDE to Eclipse - which was my purpose.



3. The most common comment from the people I showed this book to was "I wish I had it when I started using Eclipse".
   
   While this is a very small book, the contents have been selected to give you a best start with the main features of the Eclipse IDE. The topics are short but concise and include scattered tips for the points of interest.
   
   If you're just starting with this IDE, the Eclipse IDE Pocket Guide will give you a great head start and will continue helping you as a lovely reference to refer back to as the features become familiar. Having all of these critical features pointed out earlier will save you a lot of bother in the future, since you'll be annoyed if you only find out about them much later by accident or experimentation!
   
   Experienced users are less likely to get much from it though. The authors made a decision between content and size, and I feel they chose to stick with a smaller, simpler book than I would have expected. There is a final section on places to go for more information, but it just refers to various community sites.
   
   I wish I had this book when I started using Eclipse.



4. I've come to expect a lot from O'Reilly guides, and this one didn't let me down. It really helped me past some areas of confusion I had with Eclipse, although I think I may want a larger book eventually that gets into more detail on some of the add-ins.



5. I thought this would be a handy little "tips and tricks" reference. It basically just tells you all the obvious stuff you already figured out on your own. Save your money and just use the doc from the internet.

4 comments about Core Servlets and Javaserver Pages: Advanced Technologies, Vol. 2 (2nd Edition) (Core Series).

1. 2nd edition has all the details for environment setup so it makes it easy and clear how to start your first web application. I always refer to this book when I need some reference or to review basic web application development.



2. "Core Servlets and JavaServer Pages, Volume 2: Advanced Technologies" targets developers who already know Java and basic servlets/JSPs. Note this book's second edition does not cover the latest technologies. It uses J2EE 1.3/1.4 and Struts 1.3.
   
   The main topics are advanced deployment descriptor settings, security, custom tags, filters, event handling and JSTL. Then there are three chapters on Struts 1.3. These additional chapters were very good although I'm not sure what they have to do with "core servlets." The browser screenshots were good for showing output and the examples were excellent.
   
   As with "Core Java", the 700 page book contains some long classes. I could have done without the complete 5 page deployment descriptor at the end since it was gradually built up with new additions highlighted. The highlighting does help with spatial orientation.
   
   I did notice a couple typos in the book. None of these affected the meaning, but it gives you the impression it wasn't proofread as carefully as other books. And (at least my copy) had a printing error where one page was missing a few lines.
   
   For most part the book pointed out best practices. There were a few exceptions such as one chapter mentioning which jsp page should establish a database connection. Different chapters had different opinions on whether there should be scriptlets in a JSP as well.
   
   Overall the book was fine although I would prefer to invest in a different title - either fully on Struts or fully on servlets/JSPs.



3. I highly recommend this book. I have not had it for very long but I already find it very useful. It has helped my team introduce new technology and features into our applications. The Application Events Framework in chapter 6 helped me debug my application and discover that Struts creates a new session, if one doesn't exist, on every request In fact, JSP Tag files technology discussed in chapter 7 was the basis for a new reusable common component that we have created.
   
   I like the style of the book very much. One thing in particular that I like is when a new technology or feature is introduced the steps needed to use it are numbered and laid out clearly without going into too much detail. Then as the feature is developed and each step is examined in detail the steps as a whole are repeated. This helps keep things in perspective - you can see more clearly where each thing fits into the big picture.
   
   The authors also do a good job of trying to give small but useful and instructional examples of the different technologies - not always an easy task.
   
   Whenever I look into this book I find new and interesting ideas. Even the concepts that I am familiar with I still learn new things about them. I wish I had more time to read through the entire book.



4. This book is a continuation of the first book. The book covers deployment of web application in great detail. It takes you through the development of a JSP, custom tags and does not leave you hanging like other books. It takes you through the steps of compiling, building and installing your web app. It covers security filtering and much more.
   
   Another interesting technique this book uses, is it take the web developer through the different types of web development. It starts with development of custom tags and takes the reader through JSTL libraries and then discusses the Struts framework.
   
   Finally, I used this book to help me through deployment of my web application. It was an invaluable tool.

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 Programming and Problem Solving With Java.

1. this book have a simple introduction on software design by using java programming language. The content in this book is not too much for a biginner, but not really good enough for advanced study. I suggest readers to review this book in one bookstore and then decide if you wanna buy it. Maybe you would have known most of the content of the book while in the store.



2. The authors did good job in C and C++ books but not in this Java book, you can not learn Java out of this book, I recommend Introduction to Java Programming by Liang



3. You can not learn Java out of this book. The authors did good job in C and C++ books but not in this Java book, I read also the laboratory book that one also very weak I recommend Introduction to Java Programming by Y. Daniel Liang



4. The authors follow the outline they used to write their C++ book, and it just doesn't seem to work for Java. They usually provide one programming example in each chapter. Many times it is the same ole program enhanced. There really NEEDS to be more programming examples to reinforce and to show how to apply the programming techniques presented in the chapter. They use the same programming problem exercises they published in their C++ book. Java is more of a GUI language. It is not like the "black screen" algorithm, mathematical equation programming language that their C++ book teaches. Maybe these people are not Java programmers, but textbook writers, and this was the easiest way to produce a Java textbook. I guess you could say these authors have perfected the "turnkey" method for writing a programming language textbook. Many, and I mean many of the programs printed in the text have errors or typos. Swing is not covered. The authors do not provide a CD. This is a very expensive ... misstake. Don't buy this book if you want to learn Java. Buy the Sun Java books or go to the Sun website and go through the tutorials and documentation. The "Java Black Book" is a good reference if you have a specific question or need further explanation on using a technique or function. There are other Java websites that will teach you Java better than this book does.



5. The last 2 Intro to Programming through Java textbooks have been horrible, and this is one of them. The typos alone have caused many headaches during study and while trying to finish the work book exercises. This is a good "flip through" book at a bookstore, but not really worth buying to keep on your bookshelf.