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

1. Other reviews have mentioned that there are many problems with the examples in this book. I can only reaffirm what they've said.
   
   The other thing that I really didn't like was the disorganized fashion with which the examples were presented. The authors seemed to jump around describing one small section of the problem in great detail, then 3-4 pages later would give you the critical piece of information you needed to understand their example 3 pages before. I am a fan of examples that are logically presented:
   First you do x,
   Then you do y,
   you configure x to point to y
   now deploy it, type this in the url field, and there you go, it works.
   
   I found these examples to be more like:
   First you do x,
   then let me tell you everything there is to know about x.
   y is very important as well.
   if you wanted to set up y you could do it like this.
   of another popular way of configuring y is like this.
   and then there's this thing called z.
   z is also very important, and here's some more information about z.
   But of course, before we can set up z, we need to configure x to point to y.
   I'm sure you can figure out how to configure x and y.
   that's it, we're done.
   
   So when you're done reading you feel like you have increased your general knowledge of the subject, but you really don't know exactly what you're supposed to do to actually make something that works.
   
   I also would have liked more information about using commons-validator with Spring MVC instead of so much detail on VaLang. This would have been especially helpful for people moving from Struts to Spring MVC.
   
   Those are the negative aspects of the book. On a positive note, it is fairly well written. There is a lot of good information that will increase your general understanding of the MVC and WebFlow frameworks. I do use this book as a reference from time to time, and it has provided me some value in that respect.
   
   Overall though, I do not recommend purchasing this book. I think you can get a better idea of the WebFlow framework just by using the documentation on Spring's website, downloading the framework and walking through the examples. As far as MVC I think this book is better in the MVC chapters than it is in the WebFlow chapters, but with the release of Spring 2.0 even those chapters are now out of date.



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



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



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



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

5 comments about Java Software Solutions: Foundations of Program Design (6th Edition).

1. There is an updated printing of this book that uses ISBN 0-321-32202-7. The updated printing (which corrects small but important changes from the final version of Java 5) also is called the 4th edition. The publisher added words "Java 5.0 Version" to the title listed in online stores, and added a leaf with the words "Covers Java 5.0" to the bottom right of the cover. Be sure to verify that you get this ISBN, and do not to buy an old printing that you can't return.
   
   This URL to purchase the most up-to-date printing from Amazon is: http://www.amazon.com/exec/obidos/tg/detail/-/0321322037/qid=1126549578/sr=8-2/ref=sr_8_xs_ap_i2_xgl14/102-3991796-1688157?v=glance&s=books&n=507846



2. Lewis & Loftus give the reader an excellent introduction to object oriented programming in Java. The very clear explanations as well as simple examples do an excellent job demonstrating many concepts to the reader. I recommend this book to anyone wishing to learn Java for the first time.



3. Another great hit by Codemate. Best programming book for new programmers/students. Really goes step by step and gives adaquete information for newbies.



4. For the price I wouldn't buy this book unless it was a textbook for a class or if you can find one used. That said, it is a great book for someone with a few Java basics under their belt. You could use it as your first Java book if you are a quick computer learner and can remain focused as the chapters are rather long and meaty. Each ends with a GUI section which could almost be a chapter on its own. The code runs well and is available for download. There are very few mistakes and/or jumping assumptions in Java learning although the complexity makes having an instructor to ask questions helpful. Basically it is a textbook for just after intro object programming college class and it does that very well.



5. In case you're doubting how much of a beginner's book this is, consider that the first chapter of this book is all about telling you what a computer is. If you have any experience writing any sort of script or program you will not want this book. If, like for me, it's required for a course, keep an eye on the bookstore's textbook buyback schedule.
   
   Even once you have learned what's taught in this book, you will probably find it frustrating if you try to use it as a reference for Java syntax. Information about the language is dribbled out in bits and pieces with no clear way to find what you're looking for. Well, yes, there's a table of contents and an index, but you'll do better selling this book back and picking up Java In A Nutshell, 5th Edition once you have some familiarity with Java.

2 comments about Pro Java 6 3D Game Development: Java 3D, JOGL, JInput and JOAL APIs (Expert's Voice in Java).

1. There is some overlap between this book and the author's other book on Java game programming, "Killer Game Programming in Java", but overall there is enough new material to make it a worthwhile purchase. The author starts out trying to explain Java3D. His explanations are OK, but the best explanation I have ever found as an overview of the API is "Java 3D API Tutorial" on the Sun Microsystems website. It's old, but the basics haven't changed. For the specifics of working with Java 3D in the modern era, come back to this book. The author has done a good job of putting together some programming examples that show how to program in current versions of Java 3D including a 3D version of Conway's game of life. He then modifies the program to show off some of the features of Java 6 such as its ability to communicate with scripting languages. Further chapters show how to build creatures with operational limbs that demonstrate Java 3D's TransformGroups, how to handle physics and Java3D using a specific physics API, multitexturing for more natural looking outdoor scenes, and finally how to deal with level of detail problems using mixed mode rendering. In each case, the author just doesn't talk about how to do something, he produces working code that gets the job done and provides a blueprint for the reader to go further.
   
   The section on non-standard input devices deals with interfacing devices such as webcams, game controllers, game pads, and the P5 Virtual Reality Glove to your 3D worlds and games. He mentions parts of Java that are seldom well-explained such as JInput to describe how to control these devices. In the section on webcams, the author talks about JMF and an alternative method of interfacing to cameras. This is good, since for all intents and purposes JMF is really a dead API with very little useful capability. One of the more interesting chapters in this section really has nothing to do with input devices, that being the chapter on JOAL, which is a wrapper around OpenAL, the OpenAudio Library. This is very practical since there are bugs in Java 3D's sound interface that have been there from the beginning and show no sign of being resolved. This chapter provides a practical way for Java programmers to get actual reliable 3D sound into their games and applications.
   
   The final section of the book is on JOGL, which is a Java wrapper for the OpenGL graphics library. The author explains and illustrates the use of JOGL by first implementing a very simple application to clearly illustrate all of the steps needed. Next, a 3D world is written using JOGL that includes a floor with a checkerboard pattern, an orbiting earth, a skybox of stars, a billboard that shows a tree, overlays, and keyboard navigation.
   
   This book, along with the Sun tutorial, is a good education in how to use the Java 3D API in general, and also how to build virtual worlds in Java as well as how to write 3D Java games, which was the book's original purpose. Highly recommended.



2. If you are new to 3D programming in Java then this book is not a very good place to start. That's not to say this isn't a good book its just that you will need to be somewhat comfortable with Java3D before reading this book. Like the previous reviewer said the sun tutorials will help to understanding the examples used in this book, just don't think that this book will hold your hand.

5 comments about Expert One-on-One J2EE Development without EJB.

1. This is a fine book. I appreciate the practical insight and opinions expressed by the author. Sometimes it seems that he justifies his points by using the same rational he attacks in other technologies like EJB. Not that I am a fan of EJB, having used it in projects and found it wanting.



2. It does not fit for Software Engineer or Developer at all. EJB has bad performance though, it is a well-known fact, no need to say lots on the point. This book is like an advertisement for Spring Framework, but no directly and clear outline of Spring. From beginning to end, the book wrote lots verbose concepts about java, no real touch of authentic content. Although Rod is famous and experience on Java, this book might be an artitechure knowledge book, not good for level below intermedia java developers and SEs.



3. This book introduces the Spring framework strategy as an alternative to J2EE which is GREAT. I noticed this book is far behind while comparing to the latest updates to Spring framework. Now, I am looking for updated code example and how-tos.



4. 
   bought this book long back,
   kind of boarting book, nothing is writen very clearly,
   AOP part is horrible, its so boaring whenever i try reading it
   after reading one or two page i just fall to sleep,



5. By now a classic, this book eloquently expressed how the Corba component design committees came up with an EJB specification that was not an ideal cornerstone for all J(2)EE applications. Although very fit for selected purposes the early EJB specs had to evolve to EJB 3 to really leverage the power of Java. Fundamentals of component based flexibility often lost on OO design are explained well, regardless of whether one decides to use Spring the alleviate the risks around it.

5 comments about JBoss(R) Seam: Simplicity and Power Beyond Java(TM) EE (Prentice Hall JBoss).

1. I needed to develop a project and fast. I purchased this book because I needed to get Seam up and running quickly. I found it very clearly written: with helpful examples and source code. It also provides a introduction to AJAX and has a few chapter on how to integrate AJAX with JSF and Seam. Very interesting! I recommend this book 100 percent!



2. This is a very good book for learning about SEAM, a web framework that I would consider one of the best for its simplicity and power. However, what this book is best at is teaching you the basics of SEAM (though is some areas, such as stateful navigation rules, it doesn't go deep enough).
   
   Where this book lacks most is as a reference book. The reason for this is that many concepts are introduced well before the chapters that talk about them. When looking back at these concepts, I find myself having to find the first place the concept is introduced because the chapter about that assumes that you have read the earlier introduction.
   
   Overall this is a good book for learning the basics of SEAM. However, it is not a good in-depth reference. Nevertheless, SEAM is an excellent technology and there are not yet many good books on it. This book will bring you up to speed on SEAM pretty quickly so I still recommend it.



3. Its a great book.. It difficult to learn Seam without this book.
   It may be slightly dated, with Seam 2.0 coming out recently.
   But per the author, there are not significant changes in the code
   ie mainly config changes.
   (eg they recommend JPA with tomcat instead of embedded server option
   with tomcat)
   
   Seam(and specifically seam-gen) still has some significant bugs/issues
   to iron out(but workaround exists).



4. It's not a cookbook with ready made recipes. It gives a shallow but complete overview of the Seam framework features. That is important because if you don't know it exists you will never try to use it. Examples: XHTML validation tags for Hibernate, conversation state, and much more.
   
   It's a must read to get a good start with Seam and to learn what WebApp development should have been from the beginning.



5. Compared to other computer books this book is to shallow and does not cover the depths of Seam. I would like a more continous example throughout the book instead of a collection of small, rather trivial examples.

5 comments about Webbots, Spiders, and Screen Scrapers: A Guide to Developing Internet Agents with PHP/CURL.

1. This book covers every aspect I could ever hope a book on web bots would cover. It goes into great detail and provides lots of background information about things such as why you should use web bots, security issues, how to authenticate a bot with password protected sites, writing search engine crawlers, parsing HTML, how to handle cookies, HTTP headers, dealing with forms and a lot more.
   
   I was very pleased with how this book covered concepts. The book uses PHP and the cURL library as a teaching tool instead of trying to give a lesson in how to use PHP as a crawler language. The way the code is explained makes it very easy to translate into whatever language you are most comfortable coding in. The book uses fundamental functional programming concepts which make it easy to pick up the general idea without actually knowing PHP.
   
   My boss bought this book to help my group us with a project we were working on, and even my co-workers who had no background with PHP were able to use this book to write a web bot in C# (using the cURL library) very easily. The concepts from this book easily transfered over to object-oriented concepts.



2. great book. very well organized and code in book is available for download and code is well documented



3. "Webbots, Spiders, adn Screen Scrapers" is a solid book for building basic scripts to do web scraping. Michael Schrenk goes covers the "should you do this" aspect very well, and devotes much of the book to these kinds of topics. On that reason alone I give him major kudos, "just because you CAN do a thing, doesn't mean you SHOULD."
   
   Technically the book and examples are very basic and beginner level. All code is procedural and has absolutely no references to object oriented programming at all. This is great for a simple project, but building anything larger than a targetted webbot or two is beyond the scope of this book.
   
   I was very dismayed at Mr. Schrenk's opinion of regular expressions:
   "The use of regular expressions is a parsing language in itself, and most modern programming languages support aspects of regular expressions. In the right hands, regular expressions are also useful for parsing and substituting text; however, they are famous for thier sharp learning curve and cryptic syntax. I avoid regular expressions whenever possible."
   
   This disregard for regular expressions effectively wipes out a powerful toolset for budding developers. Regular expressions are no harder to learn than PHP. The reasons for his disdain for them is also flawed:
   
   "The regular expression engine used by PHP is not as efficient as engines used in other languages, and is certainly less efficient than PHP's built-in functions for parsing HTML."
   
   PHP uses the same regular expression engine used (very effectively) in PERL with the use of the preg_* functions. There has been many studies that show preg_* style expressions outperform basic text matching in PHP. In this assesment the author is terribly wrong.
   
   The book does a great job of explaining how to make single use scripts for scraping, but never how to create a larger infrastructure. There is no focus on creating multi process engines with pcntl_fork(), or proc_open(), these are critical for scaling web scraping applications. A single script scraping a few hundred websites on a single thread would take ages over a multi-threaded engine.
   
   If you are looking to break into web scraping and not sure where to start, this is likely the best (and possibly only) book on the market. If you are intermediate or advanced you will quickly question the author's logic and see that scaling will become the number one issue you have to over come.



4. This book is simply awesome. You will need to come armed with at least a basic knowledge of php, but everything is pretty straight forward. The projects are well explained and applicable to a wide range of projects that you might be getting yourself into.



5. This is an excellent book used as an introduction to the cURL library. The author has created a set of his own functions that are well written and, with the help of the book, easy to understand.
   
   It does pre-suppose some PHP and data transfer protocol knowledge but if you are already armed with that, this is an excellent intro to data exchange across servers. Each chapter introduces a new concept and a simple usage of that concept. I seldom read tech related books cover to cover but this book was an exception. I have been programming for over 20 years so being excited by new stuff is somewhat rare. I enjoy new stuff but this book whets the imagination!

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 Java How to Program (6th Edition) (How to Program (Deitel)).

1. The book provides many visual examples that help audience to absorb the concepts easier, still we need to reference Sun Java website' API though. Concepts of Object-Oriented Programming, GUI, Data Structures, Sorting & Searching, and among other basics are covered in relatively brief but clear. I think those are enough for beginners who take Java as their first course, as its purpose. The later chapters sparsely introduce more advanced features in Java such as Networking, Web Applications, Database with JDBC, JAX-WS Web Services, etc... without giving complete explanations, as if they are reluctantly added to the book to make it looked thicker and heavier. If you are a beginner, you might not need to cover these features, but if you are going to advance, you might likely encounter dead-ends or summarily discussions.



2. I wish I had started Java programming with this book. It's written for those who prefer a thorough and methodical learning approach (less "whimiscal" than "Head First Java" and less "philosophical" than "Thinking In Java". The book covers general programming and basic Java language concepts. It is long but not lengthy. The book teaches practical programming skills in a no-nonsense fashion. You can learn Java from the ground up with this book and the free Java tutorials and JDK/API from the Sun website. I already work with Java for some time, so I did not learn anything new from this book, but I still appreciate the didactic approach. The only thing I found annoying is that each and every code example (which are excellent by the way) is explained tediously in natural language. This adds bulk to the book and is IMO unnecessary, because the code is self-explanatory. Hence, four stars instead of five.



3. JAVA HOW TO PROGRAM 6TH EDITION
   If you are serious about learning Java, then you must have this book.
   This book is a comprehensive study of Java.
   You have to read each line carefully and do the exercises. You will have to go back to many sectioins that you studied already in this book and read it again. At some points, I decided to go to other books that might make it easier for me to learn Java, but I always go back to this book.
   The book has a large variety of examples and exercises. When you finish
   this book, don't get rid of it. You will need it when you are writing
   Java Code.



4. Pros:
   =====
   Good material. Great organization. Good examples. In Color. Love the writing style.
   
   Cons:
   =====
   Print is to small. This should possibly be spilt into Vol 1 & 2 or the format enlarged to make the material more readable. Yes, I know it would cost more but the additional paper would be worth the cost.



5. nice book. EASY TO UNDERSTAND / FOR LEARNING THE BASICS.
   
   FOR BEST RESULTS, USE WITH AN ONLINE REFERENCE WEBSITE.
   
   YOU`LL BE FINE

5 comments about Ant: The Definitive Guide, 2nd Edition.

1. This book can take you from zero Ant knowledge to being productive in a matter of days. After starting with some simple examples, it builds up the following concepts very well: properties and types, compilation, deployment, testing with JUnit, working with CVS, and Eclipse integration. I skipped chapters 8, 9, 10, and 12 because I did not anticipate a need for them right now. However, if I need to know about web deployments, working with XML docs, optional tasks, and extending Ant I know that this book covers these things too. To get the most out of the book, you need to download ant to your computer along with the example code from the book's web site. It is very easy to modify the code and see how different options for the various tasks work.



2. This book provides a good enough introduction to Ant, but it only takes you to the point of knowing how to use Ant and not the point of knowing how to use ant on a project of any size. As an introduction it works well. You learn how to get up and running with Ant very early on in the book, and you learn all of the key tasks rather quickly as well. Everything is explained clearly, and it seems reasonably organized. What it lacks is really any explanation of various best practices for using ant, whether on a small program or a large one. For a book of this size, I was surprised at the absence of this info and ultimately I felt that it was only a bit more useful than the free online docs for ant.



3. Apache Ant is the primary build tool for Java projects and this book is excellent introduction to it. Although the title is misleading - this is not really a definitive guide (its not really reference book for starters), it is well written and easily understood. If you work through this book from start to finish then I'm confident that you'll come out the other end as an Ant expert.



4. Web research on Ant revealed a lot of explanations, but they were very hard to understand. And I didn't want to waste time scratching my head. This book explained what Ant is and how it works in an approachable way without insulting my intelligence. The author obviously has a lot of experience in Ant and many of the other technologies it interacts with. While other comments have pointed out that it's not a reference, I can easily get those other details on the internet. This book got me up and running with Ant quickly and painlessly. It contained useful examples that actually worked when I tried to follow them.



5. This book is a regurgitation of O'Reilly web material. This book had a real opportunity to discuss Ant internals or at least something that can't be found on tech sites or the software documentation. Project wikis will undoubtedly replace the need for tech books of this sort.

5 comments about Pragmatic Project Automation: How to Build, Deploy, and Monitor Java Apps.

1. This book is the third volume in the Pragmatic Starter kit, but is self-contained enough that it can be read on its own. The first chapter starts with a story about how built-in automation makes everyone's life better-especially the developer's. Thus this book is really about letting the computer do boring, repetitive things so that developers can concentrate on what is new and interesting. The rest of the first chapter answers some frequently asked questions including why and when developers should automate. This FAQ is useful in its own right, but also helps readers figure out whether the rest of the book is for them. The next two chapters show how to automate a Java build with Ant and then schedule that build. Clark points out that running tests is part of the build process. Chapters 4 and 5 describe how to generate and distribute releases of software. One of my favorite ideas from these chapters is writing a checklist script that clients can run on-site to check for "is it plugged in" errors. The last chapter is about monitoring all this automation. This chapter alone is worth the price of the book. Developers always want this information, but nobody enjoys being spammed by their own computers, and it's a pain to set up filters so that the right messages reach exactly the right people. Clark's solution is to use RSS notifications so that your build system creates a blog as it goes along. It's a great idea, and I've already started implementing it locally.
   This book is short, but it's chock full of ideas and advice that can be put to use immediately. I found Clark's writing style clear, easy to read, and often entertaining. As a bonus, the book's concepts are language independent even though Clark uses Java and Java-based tools.



2. This is a great book for developers and teams who want to know how that can automate their processes better. It doesn't go too deeply on some topics, but there are enough pointers to more information. If you need to learn more about how to streamline your work, this is an excellent book.



3. If you are a Java developer and want to know the basics of how to construct a decent build and release process then I recommend reading Mike's book. It doesn't go into any topic in real detail; however like most Pragmatic Bookshelf books, it is concise, well written and easily absorbed. The tools that the book discusses includes CVS, Ant and CruiseControl. One of my favourite and most enjoyed books.



4. I grabbed this book from the shelf in our Atlassian office few months ago. I just finished reading it this morning. This book is very well written and easy to read.
   
   I read it most on the train commuting to work. My trip only takes 20 minutes, so you could think "what can you possibly read and learn in 20 minutes?" Well not a lot, but enough to get you started. The way the book is written makes it easy to continue reading after an interruption.
   
   Book is structured in a way that leads you though the processes in software development: building (testing), releasing, installation, deployment and monitoring. Each process is described and the ways of automation are discussed in detail.
   
   I consider myself a senior software engineer but this book had several points that made me say: "That would be nice to have in our build!" This book will save you lots of time and lots of manual work, thanks to automation. I can guarantee you'll get inspired by this book.
   
   I'm happy I found this book on our office shelf. Now, I'll put it back so others at Atlassian can read it as well...



5. Pragmatic Project Automation: How to Build, Deploy, and Monitor Java Apps
   
   This is one of the best books that I have read (and own). It is very to the point, excellent explanation(s) and top that with source code. Highly recomended.