5 comments about The Definitive Guide to Java Swing, Third Edition (Definitive Guide).

1. This book is an alright reference, but a poor tutorial. The problem is that there is no examples of a complete GUI, especially real life examples. Sadly, this a a flaw in many other Java books, Head First Java is particularily bad in this regard.
   
   What these types of books need is a full blown example, one that has a menu bar, tool bar, and multiple items on one or more panels, complete with layout and listeners.
   
   A book like this must be a nightmare for a total beginners, having to piece together info from all over the book.



2. 'The Definitive Guide to Java Swing' by John Zukowski is a bloated book that just isn't worth the price. I found the content to be alright most of the time in this 900 page doorstop, but the lack of many GOOD examples and poor layout really hurts this book. One of the things that drives me nuts about apress books is the lack of color within their texts, while so many competing publishers produce books that jump out and make you WANT to read what lies within. Dark grey mixes with black and white in the sparse dialogs that are contained within, and for a book that talks about the GUI technology of Swing, you would figure that this would not be the case.
   
   There's nothing overtly that makes this book outright poor, I just feel that there are probably other choices on the shelf for Java Swing that would be better used as a reference manual or teaching tool.
   
   Apress, you need to learn the word BREVITY. Not only will you save $$$ on less pages to print, edit and ship, but this will make for a tighter book that will sell better.
   
   ***



3. I found this book to be of little value. I did not gain any additional knowledge beyond what can be found in the javadoc and tutorials. It is also extremely dry and didn't really demonstrate an advanced understanding of swing. I bought this book when I first started with Swing and quickly had to replace it with one of the far better books that are available.



4. If you are not already familiar with the precise technical meaning (in Swing/AWT) of terms such as window, frame, dialog, component, and container, or not already familiar with AWT, you will find the introductory chapters tough going. The term "Definitive" in the title is certainly misleading.
   
   Also be prepared for syntax errors in the code samples and poorly organized (and confusing) section headers, not to mention prose that seems to make little sense.



5. This is a useful and well-written book. His examples are clear and helpful.
   
   Unlike other books that throw the API at you, this has excellent examples.
   
   You do have to wade through some of the usual "This extends that, which extends that, which implements that," but the examples make it worth it.
   
   I was surprised by the mediocre reviews that I saw here. My guess is that these reviews come from people who need Sun's tutorial to get started.

5 comments about Java Web Services Architecture (The Morgan Kaufmann Series in Data Management Systems).

1. Java Web Services Architecture addresses the most difficult aspects of web services including security, registries, components, reliable messaging, and long-lived loosely coupled asynchronous transactions. These are the concepts of web services that the experts agree will ultimately be the most important, but for which the standards, protocols, and tools are not yet fully baked. The authors explain these missing-piece challenges, describes the ultimate solutions, and helps the reader develop a web-services architecture for their organization.



2. This book disappointed me with belated material and using older java implementations. The content and examples needs lot of updates and confusing the readers. The book suggested website www.webservicesarchitecture.com is not working at all. I find no response from the publisher and author as well.



3. I am involved in a project to determine the best practices for integrating web services into our applications. We purchased a handful of recommended books on the topic including this one. I have to say that I am disappointed in this book.
   
   First off there is little coverage of web services from an architecture point of view. There are some decent chapters that introduce the concepts of web services and SOA and then the authors jump directly into reference mode on the dozen or so technologies that they think you must master to develop web services.
   
   Maybe it is just a failure of the J2EE process, but this book does little to address the confusion and complexity involved with developing web services in Java. In fact this book just adds to the problem. Developers should not need to know all the details of SOAP, WSDL, UDDI, and all the JAX APIs in order to develop web services. For the most part, all this plumbing technology should be hidden from developers yet it is the focus of this book.



4. Hi, I( masters in computer science with 7 yrs of experience on j2ee ) really enjoyed reading the book, though I am new to web services. As the book discussed with finance related terminologies and examples it helped me very much as I develop banking applns in j2ee. An excellent convincing explanation was given for allmost all the topics even considering the new guys to web services. Architects and programmers can read this book for a convincing explanation of the technology. all the best...



5. I didn't like this book, but that doesn't mean it's a bad book. I had to write my first web service using Axis and the word "Axis" isn't even in the index. This book might be a good overall book for Java web services, but it's so full of information, I didn't know for sure which chapters applied to what I needed to do for my first web service, and I'm a 19 year veterin of code development. I have resold this book and plan to find another one on Java Web Services.

5 comments about Java 2 Certification Virtual Trainer.

1. There are a number of subtle errors present in the material. The material states that the call to string1.toUpperCase() alters the value of string1. Please recall that Strings are immutable. I have found that there is some very good material here that I was unaware of. The sybex web-site offers no errata.



2. Worthwhile complement to "Complete Java 2 Certification." Offers practice and timed exams. Keeps statistics. Allows review of answered questions. Provides explanation for each question. Good investment.



3. This is an excellent tool not only for learning ALL of the Java Certification material but also for charting the progress of your study.

   It allows you instantly to review your progress. And with it's comprehensive review questions it's very useful for helping to pinpoint troublespots or missing areas in your study.

   This is the only tool I've come across that easily helps you determine if what you THINK you know is the same as what you ACTUALLY know.

   After completing all of the many review questions and practice tests contained in this product, the Exam itself was almost an anti-climax!

   It deals especially well with some topics like Threads and IO which are really not covered all that well with other guides.

   Initially I was somewhat concerned with the rather steep cost of this guide but as it turned out it was well worth the price!




4. The software basically covers the SAME EXACT INFO as the book and 99.99% of the times its word for word the same. Why spend extra money ? Just get the book. Also, on my computer there were about 15 - 20 test questions where some html tags were not interpreted properly and were therefore indecipherable in some cases (I do know HTML). The book is great. Just get the book. The authors could have did a lot more with this concept, but sadly they didn't. I did pass the SCJP test and their book helped a lot.



5. I bought this software primarily to get another angle on the certification test, but this software is unusable!

   I installed it on two different machines (one Windows 2000, the other Windows 98), and in each case it failed to run properly. In one case (W98), the user could do nothing, since the left navigation applet crashes and so allows for no navigation. In the other (W2000) the user could take a test, and it would display a your score, but it would fail when the user attempted to display any question that had been previously graded.

   The software is built upon Java applets that run in a browser, but it fails with null pointer exceptions (as seen in the Java console), all over the place. If I were Simon Roberts, Philip Heller, or Michael Ernest, I'd feel like hiding where no one would find me. I mean, here they are, with their names on this software that's supposed to teach Java, and the Java code that's driving the application crashes with null pointers?!? Sad, very sad. I'm just glad I didn't pay retail.

5 comments about Programming and Deploying Java(TM) Mobile Agents with Aglets(TM).

1. The content covered in this book is both extremely useful and well written. The basics of mobile agents and why you would want to use them, the security issues involved and the fundamental issues facing someone wishing to implement their own system using Aglets are all examined. The code examples are all easy to follow, gradually grow more complex and demonstrate the power of the Aglets package. The latter part of the book covers more advanced topics such as design patterns found in mobile agent based applications and an in depth look at the Aglet Framework, the underlying structure behind the programmers Aglet API.

   If you are currently, or are thinking, about doing anything with aglets then this book is a MUST read. Even battle hardened agleteers can learn the best way to build and optimise their aglets.

   If you simple want to find out more about mobile agents and see them working within a successful framework then this book is also for you.





2. The book is an excellent read. When I started the book, I knew every little about Agents. By the time, I was done I knew much more. The writing is extremely clear, interesting and understandable. Unlike many of the Agent fanatics, Lange and Oshima carefully explain the problems with Agent technology as it stands today.

   All of this translates into a book that is useful to read even if you do not care about the Aglet technology. It is a good book for anyone who wants to understand the state of the art of Agents and see how one particular Agent implementation works.




3. This is a great book about an exciting technology. The concepts are presented in a clear and concise manner. Unlike many computer-related books, it is not at all repetitive and doesn't dwell on minor issues. The programming examples are reasonable.



4. The IBM Aglets Software Development Kit is, to me, the most promising leap to intelligent and mobile application development yet. I applaud the research and development by IBM, Danny B. Lange, and Mitsuru Oshima.

   But this book creates more questions than answers, and with IBM's lack of current up-to-date documentation, I cannot see the java developer community embracing this NOW as the next logical java leap; which I think it is.

   My initial excitement waned after I purchased this book. Many of the examples did not work. Written to the JDK 1.1.5, no comparison/contrast with ASDK 1.0.3 and 1.1.b2 is mentioned. Furthermore, the Tahiti server (Aglet Environment) is not even explored. To me this is a fatal oversight because an aglet cannot exist without an environment. That environment at least initially is Tahiti which comes with the ASDK the book mentions.

   In short, this work is excellent in concept and poor in real-world implementation. The authors should work on a second edition. Is it worth buying? Easy. For understanding the Java Aglet concept, yes. Implementation, no.




5. This book falls short in terms of its coding examples, none which worked. The book presents the coding examples in a very confusing manner. There are some errors in the book (particularly in the usage of URL on page 48, for example). The "dispatch" context is no where to be found in any of the aglet jar files I downloaded from their website. The programming examples are not explained very well and there is no discussion of what code goes with what in order to execute the mobile code correctly. As I examine the code and attempt to use it, I get the impression that the authors didn't check to see if the code worked properly. This book is a total waste of money, and my advice to the authors is to take there time and re-write the book to make sure that the code works properly, discuss specifically what "jar" files are needed for the classes used in the book, and to explain in a more thorough way with their code examples how to construct mobile agents. Also, the authors need to provide a website to download the code examples as opposed to forcing the readers to write the code from scratch. This method of obtaining code has become a standard for all the books I've bought, and saves time and effort, and allows the reader to think about how the code is working. In general, I was very frustrated with the examples in the book, none which were consistent with the aglet jar files I downloaded from the Tokyo IBM website. I hope another addition is in the works.

5 comments about Java 2 Programmer Exam Cram 2 (Exam Cram CX-310-035) (Exam Cram 2).

1. My study for the exam consisted of:

   1) sit sample test 1 from the book (scored 58%)
   2) read a chapter of the book, skimming the easy bits but writing test code to demonstrate any interesting/surprising language features.
   3) do the questions that appear at the end of the chapter.
   4) repeat 2 & 3 for all chapters
   5) sit sample test 2 from the book (scored 90%)
   
   This allowed me to pass the exam with a 88% score.

   While this book was my primary study tool, I also made frequent use of the online library Javadocs and the book 'Java in a Nutshell' to provide supplementary detail.

   Overall I thought the book was pretty good, my biggest complaint would be that the answers for the chapter questions are right under each question making it *much* too easy to accidentally see the answer. I also felt the threading coverage was a little weak.

   I'm an experienced developer, it could be that someone with less experience needs more detail.




2. I would not rely exclusively on this book to get you through the Java exam unless you have some significant practical experience with Java to cover the stuff you won't find here.

   There are some things missing in this book...simple stuff even like anonymous array creation. And everything else, as the title says, is crammed: about 10 pages per topic. Annoyingly however there is some stuff in this book that isn't in the exam objectives: eg. static intialization blocks...

   I found the tests in the book were somewhat misleading of my current knowledge: they are fairly easy, so they flatter to deceive to a certain extent. ALso of annoyance are the topic tests at the end of each chapter: these are quite good in themselves, but each one has the answer straight after it. SO it's hard to avoid seeing it and the remedy: using a peice of paper to cover it and another the page next to it so you can't see and memorize the answer to the questions over there is a little demeaning. Seriously...it shows poor oversight and miserliness...what's a couple of more pages and put the answers in one section at the end of each chapter? A small gripe but nonetheless an important one.

   The CD contains an exam where some of the questions cover material that isn't in the exam objectives: I hit one question on Iterator Methods! This is absurd!

   I recommend Kathy Sierra's Book (she helped create the test!) instead of this and also reading the Java Language Specification to find out all the rules, nuances and quirky behavior that makes Java the language we all love- and love to hate because of this Exam (but what's life without a challenge?)

   Also: to these people who like to post their test scores as vindication of a book: why do this? Firslty anybody cna make up a number or lie about having done the test. Secondly, god knows how much of your life you've spent on Java. So unless you give a fair assessment of your knowledge --book and then book++ it really doesn't mean much....just a thought.




3. This was not my primary study guide as I highly recommend the Sierra title, but it is a solid effort. The questions and practice exams are well worth it and it is concise. Some in depth explanations are lacking, and if you are trying to understand polymorphism and casting, you should augment what you read here. I think it is always good to have a couple of books when going for certification because each book may stress or explain something different. Many times, that gives you a three dimensional look at material that begins to really make sense. If you have a study guide already, pick this one up as well. It is compact and loaded with information and practice questions that are of excellent quality. I passed using this and the Sierra book primarily and can only recommend it.



4. Too many typos in the practice exams (such as the upper-case 'I' in question 15 of Exam 1) make this a risky choice for the exam. You certainly don't need confusion when trying to study for this exam. The content is good though and it seems to targetthe necessary concepts.



5. This can be a good supplement to "Sun Certified Programmer & Developer for Java 2" by Sierra and Bates.

5 comments about Java Collections: An Introduction to Abstract Data Types, Data Structures and Algorithms.

1. This book is one of the best books out there for Java Algorithms and Data-Structures. It helped me a lot through CS180 (Purdue University). Very easy to understand definitions and code give you the essence of the topic.

   HIGHLY RECOMMENDED!!!!!




2. When you're a beginner, and obviously one usually is when reading this type of material, you can't afford to waste time and energy reading 3 or 4 books to compensate for their flaws. You want one solid one that can quickly get you up to speed without tripping you up. I found the writing style to be awkward and perhaps it is the more formal British writing style. The material seems to be comprehensive but unfortunately the explanations are too brief. I found that I understood some stuff only because I have read other OOP and algorithm texts, and for a newbie without that background this book would be rather confusing. I might give it 3 stars but someone gave it 5 so I want to even it out immediately.



3. I've been reading through a copy of this book, and comparing it to another notable book on the same subject, mainly "Data Structures and Algorithm Analysis in Java" (DSAAJ) by Mark Allen Weiss. Something very noticeable is that Java Collections is a much simpler book to tackle, though I feel that this detracts slightly from its use as a textbook. As a PhD student in Computer Science, I prefer the mathematical detail I found in DSAAJ than the lesser amount of math that Watt and Brown provide in Java Collections. Yet, at the same time, the case studies in Java Collections are a tremendous help in understanding what a given ADT is useful for, which DSAAJ doesn't go into at all. And the detail on what a specific ADT is supposed to do is much better detailed in Java Collections than in DSAAJ. As a TA, I taught a course in Data Structures and Algorithms for Computer Engineering students. The textbook we used for that was Weiss' DSAA book directed towards C++ instead of Java, but for those who know both versions of the book, the two are very similar. If instead of C++ the course was oriented towards Java, I would have chosen this book as a textbook for that course; these students weren't needing the math focus, and they (and I) would have preferred the practical programming knowledge in here.

   For the programmer out of college, or the college student that wants an alternate view on ADTs than what DSAAJ provides, this is an excellent book.

   Member of the Columbia Java User Group (www.colajug.org)




4. If you step into the Java universe bubble, then "Java Collections" means the standard core API with the same name. This book does not cover the standard classes and interfaces that form the Java Collections API, and this is a real shame. I don't like books that feature highly misleading titles, because it hints at a lack of accuracy of the book's content.



5. I've been teaching data structures and algorithms for over 25 years,
   and the fundamentals--which every computer science student should
   know--haven't changed very much. However, it doesn't follow that
   everyone needs to write their own linked lists or hash tables from
   scratch, when Java already supplies so much of that. I have looked for
   a textbook that balances explanation of the basics with exploration of
   the Java Collections Interface, and this is by far the best book to date.
   (The similarly-named book by Zukowski has too many errors of fact
   in it for my taste.)

   Another reviewer said that this book does not cover the Java Collections
   API. This is incorrect. The authors develop the ideas behind each data
   structure as a suitably abstract data type, and then go on with "...and
   here's how the Java Collections API does it." I think the previous
   reviewer simply didn't read far enough to get to those parts.

   For a tutorial on just the Java Collections API, Sun's online "Trail" is
   the best single source, and has the advantage that it is not intermixed
   with implementation details. If that were enough, no data structures
   textbook would be necessary. However, in real problems, any
   predefined generic data structure is likely to be inadequate and will
   need to be extended; this is why a good programmer needs to know
   the Collections API (so as to avoid reinventing the wheel), but in
   addition a good computer scientist needs to know how these data

   structures are implemented, so that he/she can go beyond them when
   necessary.

   The book is somewhat weak on algorithms and would not serve as a
   reference on this topic; however, there is plenty of meat here for a first
   course on data structures and algorithms.

3 comments about Practical J2EE Application Architecture.

1. Very interesting approach that provided for faster learning on diverse disciplines. Lots of books combined in one. I could quickly apply the concepts and techniques on existing project.



2. This book is largely divided into two parts. First part of the book focuses on the process of requirements gathering, analysis, and design considerations:

   [Chapter 1] The author begins by taking a high-level (business) perspective on the subject. This includes modeling the problem domain and system context by using UML use cases. The focus here is capturing a complete set of functional requirements, without digging too deeply into technical details. A sample large-scale software solution (GreaterCause application) is introduced, then defined and modeled by using static/dynamic use cases, activity diagrams, and sequence diagrams.

   [Chapter 2] This chapter is an excellent overview of how information architecture for a project is derived by using industry standard practices. It explains how site content can be organized using site flow/storyboard diagrams and wire frames.
   The author fully develops the GreaterCause architecture using detailed use cases - showing actors, pre/post conditions, user interface, flow of events, and activity diagrams for the main use cases.

   [Chapter 3] Here the author has chosen to lightly cover all the important aspects of J2EE application architecture, based on prominent technologies and specifications. MVC paradigm is discussed since it lends well for a tiered approach taken by J2EE architecture. Struts framework is also introduced. There is an extensive section on planning application security including various digital signatures, single sign-on, JAAS, etc. Also, there is a section on caching - in order to provide a scalable and high performance solution.

   The second part of the book deals with building enterprise-class business applications on J2EE platforms:

   [Chapter 4 & 5] For web and front-end developers, these chapters kick off the nuts and bolts phase of the book by examining the Struts framework. The author chose this out-of-the-box solution for implementing the presentation tier, thus simplifying the application design. It provides a complete roadmap of application architecture from the presentation standpoint. A concrete design pattern is formulated where MVC architecture is fully utilized. Although a bit hard to understand for beginning J2EE developers, studying the recommended readings/tutorials and following the downloadable source code will get you up to speed quickly. Even as a seasoned developer, you will find the sections on internalization/localization and error & exception handling very useful. I especially enjoyed the section on realization of use cases. The key use cases for the sample application were elaborated by describing the design pattern(s) used for that particular use case.

   [Chapters 6 & 7] For the backend server/database developers out there, these chapters are your cup of tea. The author deals with creating the data model using ER diagrams and implementing domain model using EJB2.0 specifications (container managed persistence only). However, I think it's important for the readers to keep a high-level perspective while studying these chapters and the sample application. This book is by no means an exhaustive reference manual of specifications, but rather a real-world solutions book, where industry proven processes are explained. It gives you valuable and specific tips on avoiding pitfalls while architecting and implementing an enterprise solution, where other specification/reference manuals fail to emphasize or even explain. EJB transaction & configuration semantics are mentioned for the sake of completeness, but I found sections on business tier design patterns using session façade and data transfer objects invaluable.

   [Chapters 8] This chapter explains how one can use web services to simplify the task of business systems integration. By using WSDL, SOAP, and UDDI, the author shows how one can expose some of the key business services provided by GreaterCause application.

   [Chapter 9] This chapter describes how you can get the GreaterCause application up and running by showing how to install/configure BEA WebLogic application server and Oracle database. I found the information provided to be minimal, but I think it does a good job of providing an overall reference map to deployment.

   In summary, I highly recommend this book to any J2EE developer, architect, or web designer who needs a comprehensive understanding of the J2EE solutions architecture. Although the reader needs to have certain background knowledge (i.e. UML and XML), and has to reference few other specifications to have complete understanding, this book does an excellent job of presenting a complete architectural solution that you can build on.




3. True value of this book is its approach to developing software. Lots of technical information flows nicely with methodology and processes. For deep dive on different technologies used in this book, you will be better served looking at other sources, but come back to this book to understand execution and the glue-factor.

1 comments about Experiments in Java: An Introductory Lab Manual.

1. This is a good book for practicing basic java programming concepts but the problem with book is that you need a lot of already written java classes from authors site. Sometimes problem of classpath arises. Secondly, some advance computer science concepts like seraching, recursion are introduced very earlier which makes it difficult to use this book for first java course. I am myself a teacher. I think labortary manual should be self sufficient not dependent on the code or material not available in manual itself. It reduces the interest of student in the subject and experiments. However, it is an execellent effort by the author. There is no such book available. It can be improved more if it is made not dependent on some code not written in the manual.

1 comments about Java Drawing with Apache Batik: A Tutorial (A Tutorial series).

1. Batik simplifies dealing with SVG content in Java based applications or applets. For example, using Batik's SVG generator module, a Java application or applet can easily export its graphics into the SVG format. Using Batik's SVG viewing component, an application or applet can also integrate SVG viewing and interaction capabilities without much trouble. Another possibility is to use Batik's modules to convert SVG to various formats, such as raster images (JPEG, PNG or TIFF) or other vector formats (WMF or PDF). This is a very good book for the Java programmer who wants to learn how to use Batik in their programs. Thus, prior knowledge of Java is assumed. The following is a run down of the chapters and their contents:
   
   Chapter 1 Getting Started with Batik - discusses what Batik consists of and what the benefits of its modules are. In particular, this chapter explains how to use Squiggle to create, view, and manipulate an SVG document and how to use Rasterizer to export an SVG document to different formats.
   Batik Overview
   Batik in Real World Projects
   Your First SVG Document
   Using SVG Rasterizer
   Using Pretty-Printer
   What Else Comes with Batik?
   Summary
   
   Chapter 2 Creating SVG - shows you how to use one of the core modules in Batik, SVG Generator, in a simple Swing application that generates SVG documents with a single click.
   Drawing in Java
   Using SVG Creator
   Other Features of SVG Generator
   Summary
   
   Chapter 3 Viewing SVG - discusses how to display SVG documents using JSVGCanvas, a specialized Swing component that comes with the Batik distribution.
   Displaying Generated SVG Documents
   JSVGCanvas Interactivity
   Saving the Generated Document
   Displaying an SVG File
   Summary
   
   Chapter 4 Working with Transcoders - explains how to use the Transcoder API to convert SVG images to raster formats such as JPEG, PNG, and TIFF.
   The Transcoder API
   Using Transcoders in Applications
   Setting the Area of Interest
   Using the SVGTranscoder for Pretty Printing
   The Enhanced Version of the SVG File Viewer
   Summary
   
   Chapter 5 Document Object Model- explains that, behind the scenes, Batik uses the tree-like structure of the Document Object Model (DOM) to represent an SVG document. Using Batik, developers have full access to the DOM and can easily change the properties or structure of the document from Java code.
   SVG Document as a DOM Tree
   Creating Documents with the DOM API
   Building an SVG Document
   Working with Gradients
   Using the DOM API
   Other Thoughts
   Summary
   
   Chapter 6 Working with Text and Fonts - demonstrates the many ways of being creative with text. Shows that any font can be used in SVG documents and also shows how to convert a True Type FOnt to an SVG Font.
   Using the text Element
   SVG Fonts
   Using the Font Converter
   Using SVG Fonts in a Document
   Text Workbench: SVG Writer
   Text Elements, Text Nodes, and Text Content
   Characters Positioning
   Using tspan elements
   Text Layout
   Text on A Path
   Text Selection
   Summary
   
   Chapter 7 Batik on the Server Side - puts Batik to the test in a couple of actual projects. Here you can find some interesting solutions for a Java-driven web site.
   The SVG Graph Web Application
   SVG Filter Effects
   SVG Filters Web Application
   Summary
   
   Chapter 8 Batik Interactive - discusses the use of scripting in Batik. This chapter shows how to make your SVG images move and interact with the user. However, to accomplish this you do not need to resort to writing javaScript, as animation and interactivity can be defined directly in your Java applications.
   SVG and Scripts
   Interactivity
   Animation
   Scripting Alternatives
   Using Java for Scripting
   Adding Animation
   Summary
   
   Appendix A Introduction to XML
   
   Appendix B Introduction to JavaScript

5 comments about Mike Meyers' Java 2 Certification Passport (Exam 310-025).

1. The contents of the book are OK if you already know Java and want to quickly brush up. There is too much assumed to just pick this book up as your first Java certification book. My major complaint is that there are numerous errors in the question and answers and on the CD's practice exam which is the main reason for buying. It is very frustrating to look at a list of answers and feel that none of them are correct or to look for a third when only two are - you find yourself doubting your knowledge and then, doubting the rest of the book's contents.



2. What's Good:
   1. Gives you good overview of what to expected on the exam.
   2. Questions at the end of each chapter and their answers (not all answers are clear but overall it's acceptable).
   3. Quick summary at the end of each chapter.

   What's Bad:
   1. Tons of errors. Just look at the book's webpage. The lack of professionalism on the publisher's part is quite evident. Let me put it this way, if I had know it had this much errors prior to purchasing this book, I wouldn't have purchased it.

   2. Very weak in area's where explanation IS necessary. It really annoys the hell out of you after a while. This is definitely not a book for beginners, but even if you are an expert some statements in the book will make you say "huh, what the heck are they talking about?"
   3. The accompanying CD is worthless! Just go to "JavaRanch.com/maha" for mock exams.

   What's Ugly:
   1. The book's index is just horrible! You can hardly find what you are looking for even though something pertaining to it is discussed in the book.
   2. No glossary. What's an exam book without a glossary? The book make's it nearly impossible to do last minute check on things you don't fully comprehend. If the back of the book index was good the lack of a glossary would have been acceptable but it isn't.

   I would recommend that you go to your local library and check it out rather than purchase it. You definitely shouldn't rely on this book alone to prepare you for the exam.




3. I have been working with Java for 4 years now and decided to finally get certified.

   I decided to go against my instinct and not read amazon's reviews before purchasing the book. It was a terrible decision.

   There are so many errors in the testing sections of this book, that I will most likely have to pay more money and get another book just to straighten my mind out. Examples of this include things where the author suggests you choose 3 out 5 possible answers for a multiple choice question, and then only lists 2 correct answers in the solutions. Now granted this inhumane struggle is a great way to learn the langauge, but isn't that what I paid the author to do in the first place?

   Do not waste your time on this or other passport books.




4. This book is only worth purchasing as a doorstop

   There are numerous errors in the test areas. The result is that you can not determine whether or not you are indeed prepared. It will waste your time to use these materials; to speak much less of your money!




5. This is a very good Java book for not only the certification exam but also the one which helps you to get clear concept. I have experience in programming Java and now decide to go certified. I do feel this book help me quite a lot in the exam preparation. It serves as a very good review for the Java knowledges I have. The price of the book is also very nice. I can say that you get far more than you paid. One thing I would like to mention is this book probably a little bit tough for the newbies. If you are new to Java and do not have much OOP experience, I will not recommand you this one. Although most of comments here are negative, I still want to give this book a high rating.