5 comments about Introduction to Java Programming-Comprehensive Version (6th Edition) (GOAL Series).

1. This is an excellent text. It goes into great detail for an "introduction". The excercises at the end of the chapters are very well designed using everything you've learned up to that point and re-writing old excercises more efficiently using the new topics learned. His website also has alot of additional information. Head First Java is a good overview, while this text digs down to the details. Very good author and very good text. Highly recommended. One note though, this is a very long text with alot of information so if you plan of reading the entire book and doing all the excercises you will need to invest a large amount of time to do so. But if you do invest the time you will have a very good grasp of the Java language. I usually always say that there's never a "one-book catchall", but this comes pretty close. I feel that by reading this book, doing all the excercises, and making sure that you fully understand the topics, you can adequately program Java in a work environment.



2. I highly recommend the Deitel Java: How to Program book instead.
   
   Liang over and over again introduces terms that he has never defined. He does not tell you why code is the way it is. He is terse, and there is just no true explanation.
   
   The layout of the text is also in black and green, and that's it. His code is hard to follow compared to the Deitel book.
   
   I'm truly shocked at how people seem to like this book. It's unintelligible in my view. I dread reading it and actually read the Deitel book instead.



3. I bought this book motivated by the good reviews that i saw on amazon. I was very pleased not only with the wealth of information(Fundamentals, OOP, MVC, JDBC, JSP/Servlets, JavaBeans, Swing/Advanced Swing, Collections etc ), but also from the presantation which is consice and very easy to follow. This was the text that did it for me. I struggled with other texts and the presentation was always missing something to say the least. Thanks to this book i was able to move to the world of J2EE and my biggest problem was dealing with application servers than with the java language itself.
   My current position demands some C# .Net development and once again i am struggling with horrible incomplete Books that neglect to provide the hole code assuming previous knowledge.
   I thought that may be Liang has written something about C# (Unfortunatelly not), but i was sad to see that there is
   some critism which i consider unfair -not so much for the author but -for those who are trying to learn java.
   I dont Know how to strech this more but listen: There is no better intro
   book in programming. May be an experienced teacher has objections about the right positioning of the chapters but believe it or not after reading the first 7 chapters you are able to skip to any chapter you want(At the beginning of the book there is a flow chart that helps you guide your study according to your needs). Also dont forget that it is a programming book which tries to teach tough theoritical ideas in a practical way and dont fool yourself that there is a
   way for doing this without your ability to understand.
   Finally i saw that someone suggests a well-Known book instead of Liangs. I already own that book and its really confusing . A ton of information mixing together without making a specific point. If you dont beleive me just check the review for the book.



4. This book has an extremely dry writing style and often does not explain things well to a beginner. Additionally, the book is very "fat" and heavy especially when carrying it around or to class.



5. Got this book for an object oriented programming class. I have had very little programming experience, but the book has helped greatly in both learning Java and learning some of the fundamentals of coding.

5 comments about JavaScript & DHTML Cookbook.

1. I still have the first edition of this book but other than perhaps missing the chapters on ajax it's not outdated at all. This book has saved my life several times already. Almost every time I am looking to solve a tricky problem in javascript, I find that this book contains a well explained chapter with the exact solution that I was looking for. The authors often make a point of going through multiple iterations of a solution, to demonstrate what needs to be modified to support certain browsers, and at the same time ensure that the reader actually understands the code too.
   
   This is a great book for experienced javascript developers who want to save time by using tried and tested code to solve common problems, but at the same time understand that code too.



2. I wouldn't buy this book if you are going for aesthetics for you website. I wouldn't buy it if you are a heavy programmer either. Its a good "middle" book for just general roll overs, browser detections, and other javascript functions for form validation. Its a little small.



3. I really like this book. The format of each technique demonstrated is
   
   Problem- Solution- Discussion
   
   The nice thing is that you can get a quick explanation from the solution, and a more in depth response in the discussion. The author presents complete code which is easily built upon and customized.
   
   I knew a bit of Javascript when I started, but I think this would be an excellent book even for a complete beginner.



4. Like most web developers, I typically will reach for one of the many JS libraries when it comes time to add client-side enhancements to my web applications. This is usually the obvious choice for the sake of saving time on projects, and keeping costs down... but quite often, many libraries are simply overkill for a simple little js/dhtml enhancement.
   
   As such, that is what lead me to this book. I was hoping the cookbook format would give me some fresh ideas on doing some simple js/dhtml work and it most definitively delivered.
   
   Perhaps the most valuable parts of this book for me were the aspects of working on the DOM. Additionally, I always enjoy reading different techniques for dealing with client-side form validation.
   
   To me the coverage on loading dynamic data/ajax was good, but I still think that when entering into that realm of JS, it is usually time to deploy one of the libraries I mentioned earlier.
   
   All in all this has become a valuable resource that I often refer to during my daily work.



5. The book doesn't go in-depth in it's explainations. It is written more for the seasoned script writer and not the beginner. I found it very confusing and not enough detail to be of any use to me. I preferred "Javascript, Demystified".

3 comments about Eclipse Web Tools Platform: Developing Java(TM) Web Applications.

1. Though I have had some experience in Java, Eclipse, and WTP, a recent project required me to get more into depth. This book got me through the whole development process. It explained to me clean coding techniques when writing web apps in Java, how to get my web server up and running for use with WTP, to get my apps to talk to the server, debugging using different tools, and unit testing in a web environment.
   
   This book was an invaluable addition to my collection, and is also a great reference now that I have mastered these concepts.



2. Eclipse Web Tools Platform: Developing Java(TM) Web Applications
   
   This is an excellent book; I specially liked the iterative approach (for example, for presentation tier, iteration 1: HTML, iteration 2: add CSS, iteration 3: add Javascripts, iteration 4: XML and XSLT, iteration 5: DTD)authors have taken. I have used examples from this book, with Eclipse and NetBeans, of course for Eclipse user this book has added value, since it goes through configuration of Eclipse and recommended practices. Please ignore the gripe about errors in the code; there are two minor errors which are detailed in the errata on book's companion site, it doesn't take more than a minute to fix those two issues.
   
   Authors discuss All three tiers in great detail. How about this, by page 85 you would be deploying a simple web service (and you would be amazed how simple it is).



3. To give a brief background about myself. I have been one of the primary contributor and committer of the Web Tools Platform (WTP) eclipse tools project since its inception through WTP 1.5 release. I contributed the Validation Framework component for this project. I read a large portion of this book and can say that this most comprehensive book that explains the complete WTP in a step by step fashion that can be help you easily understand the whole WTP project, its sub projects, its components and features through several real world examples. I strongly recommend this book to all users and contributors of WTP.
   
   Vijay Bhadriraju, IBM

1 comments about Operating System Concepts with Java.

1. Currently I am a CS student in my senior year. I am taking my final for the class tomorrow and the book has done an excellent job of taking some complex topics and translating them into legible english. That being said, I will just explain some of the flaws.
   
   The first problem is the pictures or figures in book which are trying to give a visualization of the topics being explained. There a surprising amount of figures in the book that are completely horrid. I mean that they just either further add confusion or are just completely useless. Very shocking because the author/authors are very talented with words, yet seem to very bad when it comes to creating visualizations. There are a few with flat out errors as well.
   
   The second problem is that the questions in the back of each chapter are a catastrophe. The questions are typically just very vague or just aren't very good questions. For instance, there is a question that is similar this
   
   "Does virtual memory need to be supported by the operating system of a handheld system?"
   
   The answer in the teachers guide is apparently "yes". But clearly, this answer is truly "no". Handheld device operating systems don't NEED to support virtual memory. There are plenty of handheld devices that don't, and certainly you don't ever NEED to support alot of things. The question really means to ask "Is it beneficial for a handheld device to support virtual memory?" The obvious answer that is "of course". I got this question wrong on my homework, but myself and a few others talked with the teacher and he quickly agreed that we were right. There are just far too many questions like this that are poorly written.
   
   Regardless of these two problems, the book is really well done.

5 comments about Learning Java.

1. I have been working in this industry for past five years, I have been addicted to buying books on programming, The trouble with most of the books is that they don't focus on people who are programmers, They just re-hash for-loop while-loop its really irritating to read such topics in say 1 hour that you can squeeze out of your time. And most of the time you end up dropping the book.
   This book is definitely different
   
   Doesn't focus on teaching programming like a text for university course?
   The style of narrative is super and free-flowing. It is easy to read say 100 pages per day
   The examples are quite stylish and don't have the dummies approach.
   The authors have depth knowledge abt what they are talking
   
   In all a good book if your bit experienced in java/C++ or even C
   (Newcomers should start with books like head-first java or C++ by lafore before taking up this material)
   
   There is one definite short coming this books some times doesn't covers very complicated topics; and definitively you can't hope to use it as an reference.
   
   Hope the authors write a book on advance java topics that can be read after finishing this book



2. This book covers almost everything (that fits inside one volume) in Java. Very concise and precise, but needs some prior experience in any high level progamming language. Very good examples. This book help me a lot to dive fast in the Java's deep waters.



3. The book is a great addition to my library. While it didn't get all my questions answered, it was very helpful.



4. One expects a certain amount of intellectual gravity and reliability with the O'Reilly "animal series" books on technical subjects. I bought the book based solely on the fact that I needed an intro book on Java, and have never been disappointed with an O'Reilly book. Well, now I have been disappointed.
   
   The book starts very well. The first two chapters take you through an engaging tutorial -- taking one idea in Java at a time, and slowly building up. However, after those first two chapters, the tutorial goes away and the book gets very dry. The organization of the content is not well thought-out for a beginner's book. Just for a couple of fairly trivial examples, the authors spend a few pages on the "assert" keyword before they explain arrays (a very fundamental concept). As a comparison, "Head First Java" (highly recommended, by the way) doesn't mention "assert" until an appendix, and only as one of the "Top Ten Things That Didn't Make it into The Book" list. Also, there is a wasted page on optimization and performance in chapter 6, which is about Subclassing and Inheritance. It would have been better for them to focus on getting code running, and doing what it's supposed to do, and leave optimization for an Appendix.
   
   Good points of the book include a lot of detailed explanation on some of the Java API, including Swing and JavaBeans, as well as explanations on how to use the two most popular IDEs: NetBeans and Eclipse. RMI and the natural relationship between Java and the web are covered well. And the 3rd edition of the book has been expanded to cover topics new in Java 5.
   
   The accompanying CD contains Eclipse, Tomcat, NetBeans, Ant, and other utilities -- all of which (except for scripting language written by one of the authors) are readily available from the web. So the CD doesn't really contain anything that you couldn't get by trolling the web for a half-hour and doing a few hundred MB of downloads. (Plus, getting the tools from the web ensures that you get the most up-to-date versions...)
   
   So, this book is another reference work, another way to explain Java, but it's nowhere near the best.



5. I've been programming in Java for the last year and half, and Learning Java is the book I've been turning to most after picking up the rudiments from other sources. This 900+ page book is great for a reference on almost any Java topic. It is well written, and the authors generally do a very good job cutting through to the important aspects of each topic.
   
   Learning Java is NOT, as other reviewers here have pointed out, a good choice for a first book on Java (unless, perhaps, one is already an experienced object-oriented programmer). This is not to say it's overly technical - just that there are better books for the purpose of learning Java as something new. For beginners I'd recommend Head First Java as the best single book.
   
   As a deskside reference for Java topics, I find Learning Java more useful than Java in a Nutshell (Flanagan), Thinking In Java (Eckel), or Just Java (van der Linden). These other books each have their own strengths, but Learning Java has been a most worthwhile addition to my group of core Java books. I suspect that Learning Java would have a much wider following if only it had a different title.

5 comments about The Definitive Guide to SWT and JFACE.

1. If your main question is how to place widgets on your screens, then this book is excellent. But if, however, you would like those widgets to actually trigger events, then this book is a damned disappointment. They have a general chapter on events but for widget after widget, their examples show you how to place the widget on the page but not how to get its events. You can write code to trigger events but try to do something useful with those events and you will be greatly disappointed.
   Also, if you were hoping for some guidance or examples on how to use the 'asyncExec()' or 'syncExec()' methods, you will be disappointed. There is nothing. So, if you need anything beyond the basics, don't waste your money.



2. This is overall an excellent introduction to SWT and JFace. After working with the technology for over 2 years I can say that it would have been a great help to have this book back then. The book's layout was well thought out. My only wish is that they put out a follow up book covering some of the more advanced topics like Events, Embedding Swing components, Packaging and Distributing SWT/JFace applications (including using JWS), using Native code. Plus, even though is Java covering some of the things that can be done with ActiveX controls would be a plus.



3. Much of the beginning chapters in SWT are simply API listings - WORTHLESS! I've got those online...don't need them in a book, especially since they are not as complete as the JavaDocs. Otherwise, not bad. I'm looking for better...



4. Having being treated to a text called Windows Forms Programming for C# by Chris Sells in late 2004, and considering that's pretty much the closest book in spirit in terms of covering a high-level Windowing API and is relatively well-known, I'll go right ahead and use that as a metric:
   
   I am surprised to find no coverage of SWT and Java 1.5's threading abilities. I wanted to see a coverage of how to handle long-running worker threads that must call delegates that run on the UI-thread (like a web services caller threaad telling the gui-thread to update the progress update bar to show 75% completed). I wanted to see coverage on how to send events information back and forth between GUI thread and the worker threads. It's one of my favorite chapter in Sells' book because without it it is very difficult to write a responsive app. This is criticial in this day and age with the decent amount of web services and distributed computing being used in Intranets and Internets. If Harris and Warner are willing to write an extra chapter on this very topic, I would be greatly in their debt. We are all waiting for this chapter! I guess some of you will say, wait for Doug Lea's next book, but I trust Harris/Warner to get to the point faster and better--and stay on topic (I am not sure if Doug Lea would bother with SWT). I am hoping there's an answer to this, because I need to use this asap.
   
   There are some other surprises I find distasteful: data access and binding of data recordsets to grids are no where to be found.
   
   These are the main reasons why this book gets a four star. Because people like me are spoiled.
   
   Anyway, back to the book review:
   
   Real-world cross-platform development is a tough subject. If you ask most people, they'll relunctantly say the best way to go about it is to write platform neutral c++ model/controller code and write the view code in Qt or Gtk/MFC or WinForms/Carbon or Cocoa. Nasty.
   
   It goes without saying most small development shops simply can't budget serious competence in one, let alone three major GUI frameworks. This is not counting all the trouble you have to go through to evaluate count-less so-so [for one reason or another] libraries (wxWidget, MainWin, Swing, OpenStep API, Flash, Mozilla) just to arrive at the point where you can clearly say aha, I really want MFC/Carbon/Qt after all.
   [And let's not even get into strictly system programming libraries, for which there are several dozens on the sourceforge galaxy alone.]. So for light work, where you aren't trying to please 500 million users right away (Internet Explorer, Outlook Express) or even 200,000--you really want something like Java 1.5+SWT:
   
   > One productive language.
   
   > One well-supported effort to map a common gui api to all major windowing systems while preserving native looks.
   
   > A quick build that produces three executables. One for RedHat Linux. One for Mac OS X. One for Windows NT 5+.
   
   Which is why I am really happy Sun and IBM is trying so hard to make this option happen. I build small softwares for a relatively small audience. With IBM's contribution of SWT, all we need now is a good text that cover it thoroughly--from the perspective of developers--not the library writers. The Definitive Guide to SWT and JFace gives you just that.
   
   At times, I can see how some of the other reviewers might say, "It's just table listings rehashing documentations", and if you compare this book to Chris Sells' book you may wonder the same thing--but I think it's still an excellent try and the authors add something to the docs. I'll point out a few examples:
   
   * In the "Selecting Files for Open and Save" they went out of their way to write the correct version of how to handle over-writing an existing file. Hey, just imagine if the authors said nothing... ;-)
   
   * Throughout the book they document what the behavior will be if you did something undocumented: they'll mention when you shouldn't subclass SWT; they post questions to the eclipse group to clarify some of the bad decisions that had to be made and they tell us what we should do about it.
   
   * They explore some patterns they expect real world programmers will likely try (like Decorations, which is like a half-implementation of MDI), and warn you ahead of time what you can expect to find or even whether you should use it.
   
   The best part about them adding a bit of details is that you'll likely dig through the MSDN with Sell's book (which is not a bad thing), but you'll probably have everything at your finger-tips with Harris/Warner--so is it a bit wordy? Is it too referency? Maybe--see for yourself. :-)
   
   This is a great book, and I wouldn't hesitate recommending it. It's a key to a world of cheaper better cross-platform development--walk--no run to your bookstore and get it!



5. if you are looking for something to walk you through widget by widget..holding your hand this is your book . Excellent reference and very clear structure.
   Good to have by your desk when you need to look up something and dont like reading javadocs from the source ...

5 comments about Lucene in Action (In Action series).

1. This is a good technical book, it has plenty of examples and code bits. I was hoping for more examples of implementation - how to apply it to customer systems. It also had little information regarding hardware and how to scale. I think it's a good book, but I might have had other expectations.



2. Beware that this book is quite outdated by now: some of the APIs described in the book (e.g. "Field.Keyword") don't work anymore in recent versions of Lucene, lots of new stuff isn't covered, some information (such as that IndexWriter can't delete documents) is no longer true.
   
   It's still useful as a "Getting Started" tutorial, because there's no such thing in Lucene's official documentation, but the price is a bit high for that.



3. Lucene In Action is well-written and easy to understand. It provides in-depth coverage in key areas such as indexing (tokenizing) and retrieval. Definitely a must-read for anyone learning or working with Lucene.



4. This book is a MUST read if you're working with Lucene. While there is information on the internet about Lucene, I don't know how we can have succeeded on a project without this book. The authors know Lucene inside and out and every single page contains information that cannot be skimmed over.



5. Albeit outdated, 'Lucene in Action' remains a must read for anyone who's looking for a fast and scalable solution for a full-text indexing and search solution. Instead of stumbling through the API documentation all by yourself, the authors provide a high-level overview of the core components of the Lucene API, how to extend them, and best practices associated with each component.
   
   For our application, we've adopted Solr, which abstracts the majority of Lucene API's, but the contents of this book have proven to be invaluable when it came to initial setup and quickly bringing our development team up to speed on the internals and best practices of Lucene.

2 comments about Sun Certified Web Component Developer Study Companion: SCWCD Java EE 5 (exams 310-083 and 310-084).

1. If you are really looking for the SCWCD certification, this is the ONLY book you need. If you spend enough time on this one and understand the concepts the author has laid out, you are all set to get certified! Also, this is not just for the certification. I am sure, I will be using this book as a reference down the line!



2. This is a complete, no nonsense guide to the material on the Sun Certified Web Component Developer (SCWCD) exam. It is well written, and easy to read.
   
   Last week I passed the 310-084 exam with a score of 92%. This book was one of my chief resources in preparing. I bought this book on impulse (I already had the other three big books on preparation for the SCWCD). I was pleasantly surprised. The book covers all the material on the exam in a straightforward way. For example, I found the description of deploying web applications (deployment descriptor elements) very helpful.
   
   Readers with no background in Servlets and JSP may find the material here too detailed for an introduction. These readers may be want to look at Head First Servlets and JSP: Passing the Sun Certified Web Component Developer Exam (Brain-Friendly Guides). Once they have the big picture from the "Head First" book, this would be a great second book, filling the details needed to pass the test.
   
   Like most exam preparation books, there are questions at the end of each chapter (over 300 total). These questions make sure that help the reader make sure that they understand the material (these questions are somewhat easier than ones on the exam). Here, each answer has a complete explanation. I found it very useful to read ALL of the answers, not just the ones I missed. This helped me find things that I misunderstood, or once in a while pointed out when I got right answer for the wrong reason.
   
   The book contains additional material (beyond the exam objectives) on methods and topics that are useful in real world web development. Also, the final section of the book contains a description of differences between J2EE 1.5 and Java EE 5. This added material is clearly labeled, so that candidates can skip it during final preparation.
   
   Preparing for one of Sun's certification exams will never be really easy or fun (they're too hard for that), but if you have committed yourself to passing, this book is a great resource.
   
   Highly recommended.

5 comments about Java How to Program (4th Edition).

1. Most people who purchase Deitel books do so because it is the required course material for their CS (pick a number) class. Deitel book are needlessly saturated with filler material that do not justify their extremely high cost. You could easily save your money and learn Java by going through the Sun tutorials which are FREE, not to mention the countless online Java tutorials out there (just do a Google search "Java Tutorials"). Stay away from this book! If you have to buy it, then please save some money by purchasing a used book.



2. I learned Java solely from this book. I had learned several languages prior to turning to Java. With the help of this book, I was able to become quite proficient very quickly. It has also served as my only needed reference ever since. The intended audience seems to be the novice or even completely new programmer, so the more experienced folks may need to do a little skimming. In any case, I have and will continue to highly recommend this book.



3. You will be able to write Java prgrams, but you will not UNDERSTAND and KNOW object oriented programming language Java. Avoid Deitel's books. They simply do not know Java.



4. This book is simply amazing. I had an incredibly difficult time with the "other" book I used to attempt to learn Java for class. This book absolutely walks all over it. It teaches in a style that I easily grasp. The authors went to great lengths to specify the "why" of each new line of code, and give very detailed explanations of the methodology of programming, along with "good practices" for programming. I recommend this to ANYONE with a desire to learn their first programming language, as well as those who are looking to learn more.



5. You can see examples, the API, methods, etc, etc. Really nice book if you are begginer or advanced

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