5 comments about Agile Database Techniques: Effective Strategies for the Agile Software Developer (Wiley Application Development).

1. Like many, we struggle to de-couple logic from data, and we pay the price every time we need to do substantial schema changes. Scott's approach is sound, however, like many who write on these topics, it lacks a certain degree of pragmatism that will let you take a big, complex system from ugly, embedded database queries to one with a clean, extensible persistence layer. Not that there's anything particularly wrong with the approaches outlined, it's just that it starts to feel like a "religion" and that makes any of these ideas hard to retrofit back into a complex system.



2. The book was well written and very easy to use. I found many insightfull thoughts as to the purpose of Agile development. If you are looking for a great book to guide you into AGILE development, this will do it.
   Drawbacks or missed points, yes this book has two flaws that I have to list. 1. the repeated use of the word Legacy and the very negative congnitation of the word. Older database will have many flaws, and we need to identify them. They will also have many objects and data patterns that are valid and efficient and should not be abandoned because its not todays effort.
   2. Agile and refactoring of tables does not address, production, zero down time, large volume databases. How do you refactor a table with 2 terabites of data and can not allow downtime. (medical)



3. This is very well written, enjoyable book, with few (if any) competitors. Given its agile sensitivities, it's perfect for a programmer looking for an overview of the whole data modelling she-bang, from use cases to impedance mismatch. Despite clocking in at 400 pages of fairly dense type, interspersed with various tables and UML diagrams, it's a breeze to read. It assumes a bit of knowledge of database technologies, but you don't need anything more than a nodding familiarity with SQL and basic concepts like normalisation.
   
   This book deals with a lot of issues related to using databases as part of agile modelling. The main message is that agile application developers need to think about persistence issues, and database admins need to understand agile development. The differences between data-driven and object-driven models are clearly laid out, and there's an excellent section on refactoring databases.
   
   The important thing about this book is not so much offering you specific solutions to problems, but alerting you to potential problems you might not even know exist, and explaining that you do have options in solving them. As well as introducing agile methods like TDD and refactoring, it also covers database issues like transactions, security, concurrency and object-relational mapping.
   
   Additionally, there is an emphasis on the organisational and political issues you might face in transitioning to agile methodologies, and it's very pragmatic in pointing out that some things that might be considered the preserve of an application developer, could be done in the database itself. The issues are presented at the same level of detail as those presented in the likes of The Pragmatic Programmer (but a different subject, of course). For more specifics, you will need to turn to the likes of Martin Fowler's Patterns of Enterprise Application Architecture, or to see specific technologies being used, Chris Richardson's POJOs in Action. I would definitely recommend this book before reading those.
   
   As someone with little knowledge of databases, I found this an excellent and unique resource to join up the dots when it comes to persistence and agile.



4. To be fair, the book title suggests that it is for the software developer, and not a database administrator. I thought that it had a good overview of agile related items. Although it was probably not as useful for software developers who might have more exposure to the agile methods. From a DBA point of view, I thought it was a nice overview because agile is not typically used in DBA teams.
   
   As far as specifics relating to databases, I thought it could have had more real-life scenarios and suggestions on how to deal with them. Some of the ideas presented were just too unrealistic for my liking.
   
   That being said, there are a few good ideas in this book. It was a quick read too. So if you are a DBA who has no idea of agile, it might be something to start with.



5. If you are an application developer that has ever worked with a system that is difficult and convoluted because of fear of touching the Database then you owe it to yourself to read this book. This book will provide you with the insight and techniques to make changes to your Database with confidence.
   
   I also recommend Refactoring Databases: Evolutionary Database Design (The Addison-Wesley Signature Series) for those who seek details on how to implement the topics discussed in "Agile Database Techniques"

5 comments about Java Servlet Programming (Java Series).

1. I wouldn't say this is an excellent book, but it's not bad. The book covers good fundamentals in its first 8 chapters for those beginning Servlets. The book also covers some useful information on JDBC and Java Server Pages. There's also some additional coverage on Applet-Servlet communication, Internationalization and Tea & WebMacro application frameworks. However some topics like JavaBeans, SSL, Filters, deployment descriptors and XML were too brief and should have been given some depth. Another dissappointment is that all examples are based on API 2.2 but not 2.3!!. The Appendix just touches on new features of API 2.3 with also a separate listing of API 2.3.
   It's been 8 mths since I purchased this book. I'd suggest that starters either wait for the next edition or get something that is based on Servlet API 2.3.



2. I found this book to be semi helpful. It would have been nice if it was more tutorial like. The examples also were not the most straightforward. The book does cover alot though.



3. This book's examples in later chapters may be a bit much for the beginner, but it does a good job of covering thing very well. Good coverage of various protocols, etc.



4. I completely agree with the 5-star positive reviews listed here. I saw a couple of new ones that were not so positive, so I wanted to voice my opinion.
   
   This book is very well written - well structured, with in depth explanations, humor, good code examples. It can be used both as a tutorial and as a reference.
   
   Even though it may be showing its age now in a couple of places (e.g. Tapestry is not mentioned, uses JDK 1.0 and 1.1 for the examples), it is still very good. It paints a complete picture, so one ends up with understanding of the principles and architecture - which is what matters - for the updated APIs there is always JavaDOC.
   
   I don't know how suitable it is for beginners, but for an experienced programmer it is a thoroughly enjoyable read - once I started it I couldn't stop until I finished (I didn't actually type the examples - that isn't necessary for understanding the material) .



5. If you do not understand servlets and program in Java this book is for you. I found it very easy to read and comprehend right off the bat. The examples are excellent and you will get off writing servlets very quickly. It is somewhat shallow in complex examples but then again how complex are servlets. Some best practices and commercial examples could have helped a lot.

5 comments about SCJA Sun Certified Java Associate Exam Questions Guide by Cameron McKenzie Passing Exam CX-310-019 (Scja Series).

1. I used this book and the SCJA guide SCJA Sun Certified Java Associate Study Guide for Test CX-310-019, 2nd Edition - Incredible Update to the former ExamScam Book from the same publisher. To pass, the study guide will get you there, but if you want a really high score on the exam, I suggest you pick up this book as well. It's got over 350 exam questions - like writing the SCJA exam 7 times before you actually take the test. You can't get much more prepared than that.



2. The practise tests are thorough and the author explains the answers in detail. Its good to have if you already know java programming and you want to prepare for the SCJA test.



3. The book seems larger on the web, don't let the photos trick you into thinking you are getting a huge book for the price. Although, the book seems to cover all the material and at close to 400 pages is probably a good deal. After all, there isn't much out there on this subject available on public sites...(check with the school bookstores, but i dont think many people have spent much time writing textbooks on this subject)maybe thats why the publisher charges so much for a book thats only 8.5 x 5.5 inches!



4. If you want a high score on the exam, start going through this book about a week before your exam date. When you write, make sure you can answer all the questions correctly and you know why certain answers are right, and why certain answers are wrong. The book provides all of thet information so it help you learn all of the really important things that might trip you up on the exam.



5. This book is packed with over 350 questions and thorough answers.
   
   Each exam objective gets hit with about 10-15 different questions, tackling the objective from every angle that is possible.
   
   It's hard to believe that anyone could go through this book, do all the questions, and not come out of the SCJA exam with an incredibly high score.

5 comments about Java Servlet & JSP Cookbook.

1. Target Audience
   Web developers who are looking for real-life examples of the use of servlets and JSP.

   Contents
   This is a companion-type book that goes beyond strictly reference material to the use of different servlet and JSP features, along with working examples of code to illustrate the concepts.

   The book is divided multiple chapters that each cover a different technique or function:

   Writing Servlets and JSPs; Deploying Servlets and JSPs; Naming Your Servlets; Using Apache Ant; Altering the Format of JSPs; Dynamically Including Content In Servlets and JSPs; Handling Web Form Data in Servlets and JSPs; Uploading Files; Handling Exceptions in Web Applications; Reading And Setting Cookies; Session Tracking; Integrating JavaScript with Servlets And JSPs; Sending Non-HTML Content; Logging Messages from Servlets and JSPs; Authenticating Clients; Binding, Accessing, and Removing Attributes in Web Applications; Embedding Multimedia in JSPs; Working With The Client Request; Filtering Request and Responses; Managing Email In Servlets and JSPs; Accessing Databases; Using Custom Tag Libraries; Using The JSTL; Internationalization; Using JNDI and Enterprise JavaBeans; Harvesting Web Information; Using the Google and Amazon Web APIs

   Review
   I really like the O'Reilly Cookbook series. I read a lot as part of my ongoing study, and often it's easy to understand conceptually what is going on. But making the jump to practical solutions can be difficult at times. The Cookbook series gets plenty of use on my bookshelf as I do my day to day coding. And when it comes to servlet and JSP coding as I continue to learn more about Websphere Application Server, this book will surely become dog-eared like the rest of them. Bruce Perry has done a great job.

   As with most Cookbook titles, each chapter in the Servlet And JSP Cookbook is made up of a number of Problem/Solution/Discussion groupings. This format proposes a coding problem, states the solution to solve it, and then devotes the necessary space to discuss the solution both with text and code. By using this format, you can think through a working solution and determine how to apply that technique to your own problem. Perry covers a wide range of problems that will help both the beginner and the experienced coder. For beginners, the solutions for setting cookies with servlets and JSPs may be just what you need to get started. Experienced people will find the internationalization and JNDI/Enterprise JavaBeans solutions useful. I appreciate the fact that coders of all experience levels can get something out of this book.

   The only caveat I have on this book is that it is very focused on the Tomcat and WebLogic web application servers. If that's your platform of choice, you're going to get everything this book has to offer. For me, I'm partial to the WebSphere platform. While I will benefit from a lot of this book, there are chapters that will have no appeal to me, such as using the Ant package. I will also need to pay attention to the coding examples to make sure that the techniques are coded correctly for my platform of choice. Even with that warning, I would still highly recommend this book to all coders working in this area.

   Conclusion
   This is definitely a title that will be useful to you as you learn more about servlet and JSP programming. It will give you the ideas you need to solve real business problems you'll encounter as a developer.




2. Being an O'Reilly fan it is hard for me to find fault with their no-nonsense approach to technical books, but there is one MAJOR issue I have with this book.
   
   As a developer for a major corporation I cannot use custom libraries for my work, especially when the license (http://www.servlets.com/cos/license.html) does not allow for commercial use. Where it would be helpful to see details on creating say, a multipart request class, Bruce Perry instead uses the com.oreilly.servlet.MultipartRequest class to hide much of the functionality (this is just one example).
   
   This makes little or no sense. Developers in the real world need real examples. Hiding the implementation of such under the non-commercial license pretty much ruins much of the potential application of an otherwise well written book. If you buy this book realise that only some of it will actually be useful in the real world.



3. This book is exactly what it claims to be: a general reference to hundreds of "everyday" situations Java Web developers face. Just as any cookbook, it doesn't go into the "deepest" details about every little thing, and it does give examples of ways to not reinvent the wheel. Some reviewers see this as worthy of only 1 star... This is only a 1 star book for readers who like to reinvent the wheel and waste time on unnecessary details... if you're like me and have deadlines to meet, you'll find what you need here quickly and efficiently.



4. I'm not a big reviewer. I find writing a challenge, even if it's a positive experience, as it is now. I started learning Java a few months ago and bought a number of books on the topics I needed to really create a java website.
   I stumbled on this book as one of the ten or so I purchased.
   
   I haven't touched the other's since. This book has it all, written so clearly that you know the author is very familiar with her subject and understands it thouroughly. It was written in 2003 and discusses Tomcat server as release 4.0 but that does not matter one bit. I was truly able to use this book to put together a website. Servlet, jsp, even java script is covered. I found many questions I had assembled reading the other books being answered in this one.
   Murach's books should be proud of this and I notice that they don't publish a 100 books on a subject; just have a few. I'll bet they're just as good.



5. A good book. Not for someone looking for a "tutorial" or "introduction" on the subjects covered. However, a good reference book to find examples of specific programming problems for someone who already has a good understanding of servlets and JSP. Covers a good number of different aspects of servlet/JSP programming. I also found it a good book to convey some general knowledge in areas like using attributes, DB access, etc. I enjoyed selectively reading different chapters.

5 comments about JavaServer Faces.

1. 1/4 of the book goes explains how to use JSP, JSTL
   2/4 of the book API reprint
   1/4 of the book actual JSF stuff - not real world related - unless you know exactly what you are looking for you'll never find it...
   i'm surprised this book went into print - probably somebody upstairs decided to have at least something rather than nothing.
   waste of time and money.



2. I have this book and Core Javaserver Faces; this is the book that lies open on the desk, is dog eared, and has coffee spills on it. It's not perfect, but it's the best there is in this space.



3. I've been working on webapps for the past 3 years in PHP, Python, and most recently Ruby. I've been trying to learn J2EE and have found it very difficult to find a foothold, a solid piece of ground to get oriented as to how people write Java webapps. I tend to like tutorial-style books when learning a new subject, ones that pick a project and implement it step by step, explaining the importance and contextual relevance of each hunk of code along the way. Of the four or five J2EE books that I've read on O'Reilly's Safari, this book is by far the best one for my style of learning. Java webapps are unique in that there is such a wide variety of options for each layer of your application. The Model, View, and Controller layers are all completely independent, and the interfaces between them are all configurable. Not only are they configurable, but you can choose to implement the connections between layers in code, or by using xml configuration files. This is *very* different to any other framework that I've used, and the complexity and power it presents is immensely overwhelming.
   
   Bergsten does an excellent job (in contrast to the Official J2EE Tutorial, imho) at presenting each concept with just enough background, context, and detail as is necessary for one to understand what is happenening at a given moment.
   
   I really like the fact that all of the code is listed in its entirety in the text, with descriptions interspersed. I really dislike the style of tutorial that tells you to "download and install the source code" and then proceeds to discuss it. I find that by having the example provided to me, I tend to skip over the boring, but important, details and at the end of the read, I haven't retained much. I learn by "following along" and typing in the listings myself. It helps me to remember the concepts, and forces me to concentrate on what's happening.
   
   I can't speak for how effective this book would be for someone who already knew J2EE in some capacity, but for me, a J2EE newbie who likes a hands-on, applied approach, this book was the perfect fit.



4. This book is an "OK" starting point for someone learning JSF.
   
   Here are some things to be aware of:
   1) Does a poor job explaining the lifecycle of a JSF component; he writes the sequence of events out in paragraph style and does not provide diagrams (UML or otherwise) to help with the illustration
   
   2) Constantly switches metaphors as he is explaining JSF; sometimes he will be talking about the implementation view of a JSF component and then other times he will be talking about the application view of a component. It would be better if there were one or two chapters that focused on the "how the heck does this work behind the scenes" and the rest of the book focused on applying JSF.
   
   3) There are syntax errors throughout the examples; this includes the code examples (.jsp examples) and the configuration examples (web.xml and faces-config.xml). To his credit, he constantly references the appendix section for a more complete example. As a reader, I personally don't like flipping back and forth all the time.
   
   4) His coverage of the application (using JSF actions) is very basic (academic). He doesn't go through the academically classified edge-cases, which is disapppointing because those are typically classified as real-world.
   
   5) He forward references way too much; for example he will talk about / use something in say chapter 4, and then states something to the effect "oh, we'll come back to that later, don't worry about it now". From a learning perspective this is terrible. It causes your train of thought to be derailed and you end up asking yourself the question "what does that do?".
   
   On the positive side, the flow does seem to make some sense from a learning perspective. He builds on the foundational concepts and frames the learning in the context of creating a "real-world" application.
   
   I understand this book is a bit out of date (suprises me O'R hasn't encouraged an update). My suggestion is to buy this book used.



5. The book is rich in content and you can definitely learn a lot about JSF. Unfortunately, a good author also needs to be a good teacher and story teller. Reading Bergsten is like listening to Ben Stein or Stephen Hawking talk, you will undoubtedly wish you were doing anything else except this. Things such as changing a diaper or jury duty will become more appealing after reading this book. I stopped once during reading and decided to clean my room instead. That's exactly how exciting it was to read Bergsten.
   
   To give a contrary example, Kevin Yank from sitepoint or Joe Burns from HTMLGoodies are infinitely more fluid and entertaining to read. If you want a book for its content, this is a good book. If you have a crappy attention span like myself, this is a difficult book to read. To give a bit of background on myself (not that anybody cares) I've been a Java programmer for about 6 years so the book isn't above me, its just too dry in my opinion. That's my two cents. Good Luck and Happy Shopping!

5 comments about Struts: The Complete Reference, 2nd Edition (Complete Reference Series).

1. This book presents the technical information in a straight forward and organized manner that is useful to a first time Struts user such as myself. The first portion does a fine job to describe what Struts is used for and how the pieces fit together and the second portion is superb raw reference material. Great combination.



2. Overall a well written and lucid introduction to struts programming. Struts:TCR needs a better index to be a truly great reference book, but I would still recommend it to anyone starting out with struts.



3. Overall very good book for starters but don't expect here too much. Case study is well designed to cover most development scenarios presented in the book. However, it doesn't bother to explain how to use Struts with databases. This is a big disadvantage of the title. Besides of that if all the repeated descriptions will be removed the book might easily lose 1/3 of its weight. Nevertheless, this is not a bad book and I'll keep it as a quick reference for some while.



4. James Holmes's explanation of the fundamentals of Struts is very clear, thorough and specific. I am very grateful for the foundation he has given me.



5. I highly recommend this book, and will buy this authors Struts 2 book when it comes out.
   
   After having completed some introductory Java programming work, I decided to dive into struts as I wanted to implement the MVC pattern in Java. This book helped me to achieve that without further referencing other material.
   
   Everything I needed was in this book. The first couple of chapters outline the Struts framework using a basic (but not Hello World) example followed by an elaboration of the Model, View and Controller. The rest of the book simply builds on this example to demonstrate features. I only read the first few chapters and used the rest as a reference (I don't need Tiles for example).
   
   The book is sparse in some ways, but it is all there. I had some tricky problems I wanted to solve and all the required information was in this book - although I did need to meditate on some of the examples to figure things out. Having said that some previous experience with JSP is useful.
   
   Recommended, looking forward to October 24.

5 comments about The JFC Swing Tutorial: A Guide to Constructing GUIs (2nd Edition) (Java Series).

1. This tutorial is well laid out and thorough. It looks suitable for learning Swing (I'm already fairly proficient) except for beginners to GUIs. It's also well organized as a reference work. It's much easier to understand than "Java Swing" from O'Reilly.
   
   Of course the "down side" is that all the material is available online for free. So as an individual you can judge -- if the free online version is suitable for you then go for it. If you want something for your bookshelf or something you can write on and add bookmarks, well then shell out the money for the book. A CD in the back contains all the examples, so you won't need to go online for anything.
   
   Ironically, unlike some earlier reviews (of the first edition) I feel the book is now better organized than the website.



2. This book has a great potential to be instructive, however, i give it a one star because it fails miserably in the delivery. The book has one full example in chapter 2 then after that all the examples are from the CD and the information about a particular issue such as comboboxes for example is strewn with code snippets that only address the most basic information; but when one looks at the full example from the CD, it contains much more in depth code that goes beyond the scope of the particular lesson. This left me with a confused situation. On one hand i have a very basic example that only shows the bare minimum of how to use a component and on the other i have code that introduces methods that are not very pertinent to the example and require more explanation. If it is pertinent then it should be explained fully which is not.
   The book has great potential. For me, i would rather see the full examples at the end of each chapter or at the end of each lesson where the code snippets reside. This would be more helpful to me as i could study the full code without having to go to the CD or its copy in my drive and navigate through the way nested tree to get to each example. Thus one star.



3. The JFC Swing Tutorial Second Edition is among the very best how-to-do it programming books I've read---and I've read scores! For this reason, I felt compelled to write a review of the book, admiring its organization, applauding its authors and encouraging progammers who need to to write Java GUIs to hurry up and by it. But then I read Thomas Duff's review; I became redundant. My recommendation is to read Mr. Duff's excellent review---knowing that I agree with every word of it.



4. I've looked at many HORRIBLE Swing books, This one is great and recommended for anyone that is interested in doing anything practical with Swing or Java GUI's other than making a colored triangle in an applet window. I cant stress enough.. BUY THIS BOOK! i'm surprised this didn't have at least a 4 and 1/2 stars.
   
   A compliment that I use to work with this book is the Core Java Fundamentals vol.1.



5. 3.5 stars
   
   Having used the book a number of times I find it an excellent first reference for doing most relatively simple to intermediate things with swing. It has excellent organization and index so finding what you need is quite easier and fast. There are many code samples- snippets, not full listings- showing how are use the major and most heavily used features of most components. It is also written in an approachable and helpful manner. It disavows exhaustive coverage of every single feature ( Try Swing by Robinson and Vorobiev- ISBN 193011088X for that)
   
   This book is not a tutorial on java. There is no overview of the language. There is a disc with code listing. The style is generally of a bunch of small, self contained lessons on how to use a component- hence the usefulness as a first reference (at the cost of cohesiveness and an overriding arch). Where it falls down is when you progress beyond beginner-intermediate level with swing and want major coverage of obscure features. This probably isn't a problem for most of us not needing to attain guru level swing-skill. I think a solid example on how to use the MVC pattern (Model View Controller where Swing addresses the View) would have been a nice (and appreciated!) addition. From personal experience there is a tendency to put too much Model in the View rather than separate them out so changes/updating through versions is simpler. Learning this lesson is a must for anybody working with GUI's.
   
   At times too there is the annoyance of not including things you would consider necessary, for example an explicit example of a combo box model and so forth. This devalues the work to some extent. A brief reminder of annoymous inner classes (as event handlers of choice) should also be included as too perhaps some mention of threads and thread safety. Thus the book requires a certain level and certain approach. Just remember it isn't a step-by-step, "let's build an application" tutorial through Swing.
   
   So overall: a good book to start with and keep handy as more of a easy reference than a tutorial (I like paper references rather than online ones so I maybe baised in this respect). It's light on some areas, particuarly higher level and greater depth stuff. It starts at a reasonable level if you have some experience with Java (a typical book like Core Java by Horstmann covers easily up to and enough Swing to get you to the point where this book is a reference rather than a how-to). As a how-to for a novice I think it may be beyond many of them. Swing: A Beginner's Guide by Herbert Schildt may be better in this regard. If you don't mind the short, sharp discrete (disjointed) approach to concepts than you might not mind this. Otherwise it may be frustrating.

5 comments about Java 1.5 Tiger: A Developer's Notebook (Java 5,Version 1.5).

1. This book delivers on what it promises - quick and dirty introductions to the new features of Tiger. It does a great job of getting one familiar with all of the new features, though, as noted by other reviewers, it is not intended to be an in depth reference. The chapters on generics and concurrency could certainly be deeper, but the book provides a good grounding in the basics, opens the door to more complete study, and provides enough sample code to get one writing code.



2. First off, i sincerely appreciate O'Reilly on their innovative idea of a notebook series. This series is targetted towards busy developers who dont find the time to crunch through big fat books and learn about every grain of sand; rather they would spend less time and learn what is absolutely required. This is certainly a welcome concept.
   
   That said, this book is about the new additions that sun incroporated into java 5 (Tiger). Yes, there are so many additions that it requires a book in itself. The author covers all the significant additions like Generics, Enums, Autoboxing, Varargs, Annotations, Enhanced For-Loop, Static Imports, printf and Threading. Isnt that a mouthful? Yet, he covers them in under 200 pages. That in itself is an achievement. Also, the conversational tone and the humour with which the author writes makes the text very interesting.
   
   Now, for the bad news. This book is edited pretty poorly. There are a lot of typos both in the text and code. I understand that, this book is conceptualized saying that it is a scribbling of an alpha geek who takes down notes as he researches new technologies. But, that doesnt mean that we get to read the same scribbling without even getting edited, though we pay for it.
   
   More than the typos, the author establishes certain technical claims, which are both wrong and misleadging. For example, the author claims that it is IMPOSSIBLE to use the enhanced-for-loop for generating a comma-seperated string from a list of strings, where the resulting comma-seperated string doesnt end with a comma, so as to display formateed output. The author justifies this by saying that a developer doesnt have access to the counter variable in the enhanced-for-loop. Though i agree that we dont have access to the count variable, the use-case is ofcourse possible. This piece of code can be used to achieve what the author claims IMPOSSIBLE.
   
   import java.util.List;
   import java.util.ArrayList;
   
   public class CommaString {
   public static void main(String[] args) {
   List numList = new ArrayList();
   numList.add("1"); numList.add("2"); numList.add("3");
   
   String numStr="";
   for(String num: numList)
   numStr = numStr.equals("") ? (numStr+num) : (numStr+", "+ num);
   
   System.out.println(numStr);
   }
   }
   
   This may not be the most efficient implementation, but, it atleast proves that what author claims as impossible is rather possible. There were some statements like this in the threading chapter as well, where the author compares synchronized keyword and lock. So, beware not to always go with author's opinions, but ofcourse, the technical content can be trusted.
   
   In the end, i would say that this book achieved its goal by neatly summarizing all the significant improvements/additions in tiger and we sure can learn every feature from this book. There are some issues, but it will not affect the overall value of the book as long as you dont overlook them.



3. This is a great book. If you know Java 4 and you want to upgrade your knowledge, this book is short-and-sweet -- only 170 pages. It tells you quickly what is new in Java 5 so that you can make the transition from Java 4 prograamming to Java 5 programming.



4. There's nothing in this book that you couldn't find on Sun's website, but it's a good quick reference book.



5. This book delivers most of what it promises to, which is a good introduction to the latest and greatest features of Java 1.5 Tiger. Considering the extent of changes Sun introduced in the new version, I think the authors did a decent job explaining them. If you are new to 1.5 version though, you would probably need to read another book that explains the concepts in greater detail.
   
   My only complaint is with the "Threading" chapter which was full of of API methods instead of letting the users know the concepts behind the changes. Looked like the authors were in a hurry to get the book finished and the "Threading" chapter got affected.
   
   Overall, it is a good read.

5 comments about Pro Spring.

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



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



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



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



5. Takes forever to get nowhere: Authors use about 800 pages in order to explain Spring (trivially a framework, i.e. a conceptually trivial subject, not comparable in complexity with e.g. compiler theory).
   
   Wordy, uncreative and just as boring as watching paint drying.
   Lacks illustrations of concepts.

5 comments about Java: A Beginner's Guide, 4th Ed..

1. Some computer books are nothing but dry text, and others are so full of intense graphics that your eyes burn. This book strikes an ideal balance between those extremes. The teaching style is engaging, and there's also plenty of reference material, making this a great book to start with and keep handy as you advance.



2. This book may be good if you can sit down and work your way through it from beginning to end, but I prefer the Sun Java tutorial online. I got through the first 5 chapters in this book and was still shaky with the concepts. Somehow it missed conveying the big picture to me. When I then went to the Sun tutorial it was a big "Aha!, so that's what they were talking about." Also, the Index is sparse.



3. I read this book to get a good start with Java. It's an excellent book to pick up if you have little/no java background or if it's been a while. I used this to build my foundation then went through a certification book and passed the scjp 5.



4. This is an amazing book. I retired from engineering research 16 years ago and have not done any programming since. Things have changed a lot! (all for the better). This book has an excellent teaching style, thorough and clear. It was my second book on Java, the first being Barry Burd's "Beginning Programming with Java for Dummies". That book is a good foundational start but it has not quite kept up with the rapid pace in the development of Java. Schildt's book is up to date (JDK 6 and Java SE 6) and makes a great reference work on the subject. I recommend it highly.



5. This is a good hands-on guide for beginners to learn fundamentals of the latest version of Java SE 6. It is well presented and organized into modules which include data types and operators, program control statements, classes, objects and methods, packages and interfaces, using I/O, multithreaded programming, generics, applets and swing. I find the mastery checks at the end of each module quite useful for reviewing and testing of knowledge.