1 comments about Enterprise AJAX: Strategies for Building High Performance Web Applications.

1. College-level computer holdings strong on Ajax or web programming guides need ENTERPRISE AJAX: STRATEGIES FOR BUILDING HIGH PERFORMANCE WEB APPLICATIONS. It covers advanced Ajax topics, so it's not for the beginner - that will please any already versed in Ajax who want to skip the basics. From implementing Model-View-Controller in the browser to overcoming security risks and optimizing Ajax functions, this is the item of choice for any collection moving beyond introductory texts.
   
   Diane C. Donovan
   California Bookwatch

5 comments about Inside Java(TM) 2 Platform Security: Architecture, API Design, and Implementation (2nd Edition) (Java Series).

1. If you are a Java developer, please read this book. It is complete in terms of the security hooks and accurate. It is a great book, deserving of five stars.



2. The second edition is the most up-to-date Java security book for j2se v 1.4.x. A must-required reading for Java security platform written by Sun's Java security team. It describes the nuts and bolts in a readable language. Highly recommended.



3. If you are new to Java, then you shouldn't buy this book.
   If you are new to security, then you shouldn't buy this book.
   If you prefer loads of examples instead of dense and precise explanations, then you shouldn't buy this book.
   If you are looking for a pictorial guide on Java security, then you would probably have to go somewhere else as well.

   However...

   If you know your Java basics,
   If you like completeness,
   If you like preciseness,
   If you want to know why the APIs look the way they do,
   If you take nothing for granted,
   If you want an update on latest changes,
   If you like things to be drawn in a historical perspective,
   If you want a book that you can pick up and read a chapter without having to go through it in a linear way,
   If you are serious about security,
   In that case you should now pick up your coat, and run to the nearest bookstore to buy this book.

   The only thing I found odd in this book is the introduction into security, covering a discussion in general, and an overview of different types of security and access control models. The weird thing is that it introduces a lot of concepts, without actually refering to any of them in the chapters later on.




4. This book is certainly gives good introduction to the fundamentals of Java security. For those new to Java security, there is also brief intro to security of the Java language and platform. The coverage on Java Security APIs are bit narrow and needs lot of update on JCE, JAAS, JSSE etc.
   Frankly speaking this book is a bit obsolete and now it's for the authors to come out with a new edition including Java 5 and Java 6 !



5. In fact this book is a complete coverage of the java security.
   It is true, that the subject is quite complex and needs concentration
   to be understood perfectly. However I believe this books lacks suitable examples.
   In my personal point of view, providing sufficient clear examples in a book,
   will help the reader to understand better the subject.
   I didn't find this important quality in this book.
   If somebody wants to buy a book about Java security, this
   means that he/she didn't understand completely the whole subject, just
   by reading the API on Sun web site and therefore he/she is looking for
   a better source of information that illustrates the subject in a more
   convenient and clear way. Unfortunately this book, although complete
   in the coverage of the topics, is too far a way to be considered as a clear
   and easy understanding book, particularly, for those who are not already
   seniors in Java security.

5 comments about Sams Teach Yourself JavaScript in 21 Days (Sams Teach Yourself).

1. I found this book very useful, and I was able to learn JavaScript from it, although I didn't follow the book's tutorials sequentially.

   The most important thing to note is that this book is not really suitable for an experienced programmer who wants to add JavaScript to the list of programming languages that he/she knows. If you already know several other programming languages then you'll find the pace of this book much too slow. There are too many simple examples and too much discussion of basic programming principles.

   For a beginning programmer these many examples and down-to-earth discussions are great. The authors assume that the reader has no knowledge of programming at all, which is fine if the reader is new to programming.

   A couple of the especially useful things I found in this book were an example showing a clever way of using the onClick event for an "a" tag, and information about where to find the Microsoft script debugger.

   On the other hand, I did find a few minor errors. And on page 20 a CD-ROM is mentioned, but in fact no CD-ROM accompanies the book. Instead, as explained on page 5, the sample files from the book are available on the Internet.

   So if you're new to programming then this is a good book for you, but if you're an experienced programmer then you should find something else.

   Rennie Petersen




2. I thought this book was pretty good, when I first started. Because I was able to do a little something with Javascript and I've never even really tried a scripting or programming language before (I know HTML, buts thats just markup). But I put this book on the back burner after I learned what I wanted from Javascript (and really hit the wall after not being able to really use it much more after that). So I started learning Actionscript, where I saw more opportunites for its use. I got "Actionscript: The Definitive Guide" by Colin Moock, and I was actually enlightened. Everything was so much clearer. Actionscript and Javascript are very similar, and when I do write scripts with Javascript and need help, this book "Sams Teach Yourself Javascript in 21 Days" never helps me, I have to use Colin Moock's ACTIONSCRIPT BOOK and I find what I need.
   The back appendix of this book, "Javascript in 21 Days", where it is supposed to list methods/functions/etc. is useless. Why even have it there? Moock's actionscript book has an appendix that you can actually use for reference (descriptions, examples, usefull)
   I wish I knew all this before I bought this particular Javascript book. I suggest O'Reilly's "Javascript: The Definitive Guide", if it is half as good as Moock's "Actionscript: The Definitive Guide", you'll be all set.



3. I'm very pleased with this book. It covers a large amount of JavaScript. However, like any other Sams Teach Yourself in 21 days series, this book will take you longer than 21 days to finish. The only complaint I have with this book is the lack of a JavaScript reference in the back. While it has one, it's not that large. Over all, if you want to learn JavaScript, buy this book. You can easily tell by how well written the book is that the author of this book is great JavaScript programmer.



4. There are enough serious errors in this book to overshadow any positive attributes it may have. Things like on page 88 (first edition, May 2002) where the author confuses the modulus of a number with its absolute value: "The modulus of a number is the same as the number if the number is greater than zero. If the number is less than zero, then its modulus is the negation of the number - that is, the modulus of -5 is 5. The modulus is sometimes referred to as the absolute value of the number." You will discover a function called "getModulus" that returns the absolute value of a number on page 87.
   
   You also will find on page 74 the author claiming that the bitwise NOT operator used thusly: ~9 would result in -10!
   
   These sorts of errors are not acceptable in a professional reference or tutorial of any sort.



5. Some programmers look down on the Sams Teach Yourself series as beneath their level. I imagine that some professional chefs also look down on a ham sandwhich. However, sometimes a ham sandwhich with cheese on rye really hits the spot. The Sam Teach Yourself series of books provide a practical and efficient way to get introduced to a new topic.
   
   The "Sams Teach Yourself JavaScript in 21 Days" is no exception. With the emergence of AJAX as a cutting edge way to provide rich web based applications, the demand for a working knowledge of JavaScript will increase.
   
   "Sams Teach Yourself JavaScript in 21 Days" goes step by step through the core aspects of JavaScript. This book teaches fundamentals such as variables, arrays, statements, functions, built-in methods, and basic objects. The book also teaches introductory DHTML and SVG manipulation--though some of it may seem out of date as the book was published three years ago.
   
   In general, the authors do a good job of explaining programming concepts and how JavaScript implements them. I found in a couple of cases where the code examples had errors. While I was able to work around the errors in the book, it's always frustrating when the example doesn't work.
   
   If you are a programmer who needs to implement JavaScript in your current project, "Sams Teach Yourself JavaScript in 21 Days" will probably help you get up to speed quickly. Or if you are new to programming and need a step by step guide to a relatively easy language to use, you will find "Sams Teach Yourself JavaScript in 21 Days" an easy to use and approachable book.
   
   If you are looking for a more advanced discussion of JavaScript, this book may disappoint you. You may want to consider O'Reilly's "JavaScript: The Definitive Guide".

1 comments about The Complete Idiot's Guide to JavaServer Pages.

1. Don't be fooled by the title of this book. This is a very good book to quickly learn the basics of JSP with, if you are already familiar with Java. The style is clear, concise and friendly, without the forced (inane?) humor of many of the Idiot's and Dummies books. The codes work. I have read about five JSP books before this one, and I still had many tips and explanations to pick up from this book. It's presentation of Security is a very clear introduction to the topic. This topic is absent in virtually all other so-called beginner books on JSP. I give the book 4 stars instead of 5 because it has nothing on database access. Hopefully, the author will include this topic in the next edition of the book. It was an enjoyable read.

5 comments about Java 2 for Dummies.

1. The book is a great primer for Java 2. Have been using it as a home schooling resource. The concepts are explained clearly, in a manner that teens from age 12 can easily grasp. The humor that peppers the text keeps them looking forward to daily sessions. Chapters and sections are sized so that you can take in a little or a lot at each reading. Coding examples helping to provide templates for your own programs.
   
   We added in some home-grown practice assignments and got teens who were writing programs in a manner of weeks and enjoying it.
   
   In addition, having an email address to send questions to and get quick turnaround responses is a great benefit for learning. Mr. Burd most obviously knows his stuff.



2. I've read a couple of other reviews and would like to clarify something here: In order to completely understand this book, you need to first read Barry Burd's prequel, "Beginning Java Programming for Dummies."
   You can read my review and others on that book. It was a breeze. But this review is for Java 2 for Dummies. Although I have learned much from it, it does leave me wondering why he hardly ever references his earlier book. The first review I read gave this book a one-star review. I think it deserves a little more from a perspective of a person that read the earlier book.
   If you're considering buying this book and do not own or have ever read Beginning Java Programming for Dummies, then this book is not for you. You must absolutely read that first, because every author and teacher has a different way of teaching.
   In this case, it is more difficult because he is entirely bringing up a new subject. He intorduces Java to an absolute beginner like me very well. But the thing is, he does it in his own way. If you learned basic Java from another source, chances are they taught it in another way. You will feel confused because you aren't continuing the flow of his teaching.
   Overall, here's what I think of the book.
   
   1)Good-The author continues his prequel, Beginning Programming with Java for Dummies, in an elegant, easy-to-learn way.
   
   2)Bad-He doesn't present it in a way that any beginner Java programmer can pick up on, only for ones who have read the prequel or other similar teachings.
   
   3)Good-He introduces necessary pieces of Java perfect for the intermediate and gives you the skills you need to create simple to more complex programs from web applets to a sophistocated game.
   
   Overall, I would like to give this a 3-star rating, but the content of the book presented in such a way urges me to give it four stars.



3. This is great book for beginners, and you have to get other one to get to intermediate level. Read it before you get some theoretical book like Eckel's. Good for people who already have idea about what is class, object etc.



4. This book was the first one I ever read about programming. It launched a whole new world of logical and complex thinking that I could never have understood without the magnificent touch that the author gives us. He applies very simple examples to explain very complex matters about programming instances adding humor and intelligence... what else would you want?
   It's simply excellent. 110% recommended.



5. I'm a college student working on a programming degree and I will say that this book is EXCELLENT!!! Featuring an easy to follow no non-sense format, I would recommend this book to anyone who wants to learn Java without the complicated text book aspect!!!

5 comments about The Definitive Guide to Building Java Robots (The Definitive Guide to).

1. It is really difficult to rate this book. If you are a hobbyist who is somewhat Java-savvy and you are looking for a book that gives you rather non-complex code that performs complex tasks primarily by harnessing the power of native as well as open source Java API's, I would give this book four stars. If you are looking for some technical or computational details on some of the interesting topics that the author covers I would give it two stars since there is very little of that in this book. Therefore, considering all possible audiences, I give it 3 stars, or an average rating. This book is not a tutorial on the Java API's that it mentions, but it is the only book I know of that even talks about how to do anything with speech synthesis or voice recognition in Java using the free implementation of the Java Speech API, which is FreeTTS. I actually tried out some of the author's Java speech programs, and they do work as advertised. The author performs his interesting tasks by harnessing the Java Beans activation framework, the Java Communications API for serial port communication, FreeTTS and Sphinx API's for speech applications, the Java Advanced Imaging API and Java Media Framework for computer vision and camera control, and the servlet and JSP API for more complex control of a robot. He has even written his own package that pulls together all of these API's to perform integrated tasks, such as object recognition that integrates image processing, camera control, and speech recognition. Thus, I recommend this for a hobbyist who already knows Java and wants to use that language to control robots at a very high system-level. I do not recommend this book for people looking for theory or algorithms related to the topic of robot control. I notice that Amazon does not show the table of contents so I do that here:
   1. A Primer
   2. Serial Communication
   3. Motion
   4. Sensors
   5. Speech
   6. Vision
   7. Navigation
   8. Other Topics
   9. Sample Programs
   A. Definitive Guide API (Author's Software)
   B. Microcontroller Reference
   C. Robot Parts Reference



2. I was taken back when I first got the book as all the sample code seemed to be in Parallax's PBASIC. I thought this was a Java robotics book! But as I got into it, the robot is programmed in Java and talks to BASIC Stamp microcontrollers via serial interface. The microcontrollers handle critical peripherals. He does say that you could use another microcontroller instead of the BASIC Stamp, and suggests the Parallax Javelin Stamp which is programmed in Java as well. In fact, on his web site, he has the Javelin code to replace the PBASIC code in the book if you should decide to go that route and keep everything pure Java (which I recommend as I really like the Javelin Stamp). The book does go into a number of topics such as vision, speech, etc. and does a good job of covering each subject. To me, this is a keeper. It is a good reference.



3. If you want to make a robot based on a PC, and you like java as a programming language, this is the book for you. It covers building a robot from a PC, a Basic Stamp II, and a Serial Servo Controller. The author does an amazing job building up classes from the hardware level to the navigation level.
   
   Michael Ferguson



4. If you want to control a microprocessor with your PC using Java programs then this is the book to show you how.
   
   You will need to know Java in order to understand the programs. You'll have to set up the Java communications Api, which is just a matter of downloading it from the Sun website and then placing the files in the correct directories on you PC.
   
   He illustrates the use of the Basic Stamp II [...]. This is a great microprocessor to get started with because it's very easy to use and they have great support for beginners. You don't need to know how to program the Basic Stamp as a prerequisite, you can learn this while doing it using a very simple dialect of Basic programming. You can also use the same microprocessor programs he wrote for the Stamp for use with PicBasic, (with some editing) since they're very similar.
   
   You don't need experience programming microprocessors, you learn as you do.
   You do need to know Java in order to understand the PC programs written in Java. Even without previous Java experience you can still compile and run the programs from this book and make the "Robots".



5. This book provides a window to many technologies like motion, speech, and vision. It tackles a wide spectrum of topics and is a good place for a beginner to see whats out there.

1 comments about Foundations of AOP for J2EE Development (Foundation).

1. Foundations of AOP is an introductory book about the new programming paradigm "Aspect Oriented Programming" that takes care of crosscutting functionalities and code scattering to help you create better structured and clearer programs.
   
   The book starts defining the new concepts related to AOP (joinpoints, poincuts, aspects, etc) using some examples in pseudo code and then describes 4 of the most popular tools that exist today: AspectJ, JAC (Java Aspect Components), JBoss AOP and Spring AOP. These descriptions are very complete, showing complete syntax, configuration and compilation instructions for each case. Basically, it implements the same example with the different tools so you can compare them.
   
   There is a chapter dedicated only to compare the 4 tools mentioned above. This comparison includes the weaver implementation, syntax for pointcut definition, aspects, jointpoint types, jointpoint instrospection, introduction mechanism, advice code type and some advanced features like aspect instantiation, ordering and reuse.
   
   The book also covers some design patterns using AOP. It shows implementation of well known patterns like singleton, observer, command, etc, using some of the tools described before and then evaluates these implementations to see if they are optimal for real world solutions.
   
   Another topic covered is quality of service and AOP. Here the authors show us how to use AOP to verify that an application's definition and execution correspond to its identified requirements. They achieve this by implementing what is called design by contract using AOP. They also show two testing techniques (coverage analysis and nonregression test), and the use of AOP to integrate JMX with a java application.
   
   The last three chapters are dedicated to show the full potential of AOP in a sample J2EE application. It shows how to use AOP in the business, presentation and client tiers.
   
   Finally, I could say the book is very good introducing the concepts of AOP and describing several tools that implement them. If you have none o little knowledge of AOP, this could give you a good start. Even if you already know some of the tools described here, this book can be used as a reference. The only thing to consider is that the book doesn't cover the latest releases of some of the tools.

5 comments about A Little Java, A Few Patterns.

1. If you're looking for a curiosity, buy this book-like object. If you're at all interested in a practical volume on patterns and Java, you'd learn more by by watching the patterns your money made as you throw it into the breeze.

   The book's format is horribly non-conventional, and that may appeal to the egghead in some people, but for the vast majority of people, you'll be very unhappy you purchased this useless book. In fact, to prevent anyone else from getting burned, I won't be looking to sell mine as a used book, just to keep it off the market; if you're an egghead looking for a coffee table book, buy it from someone else.




2. Decades ago, a predecessor of this book introduced me to Lisp. At first, the
   cutsey Q&A style put me off, but that book, "The Little Lisper", succeeded very
   well in its goal of creating a Lisp-speaking recursive mindset for me. Likewise
   this book creates a Java-speaking, object-oriented mindset. However, not the mindset
   you may think you want when you start reading. This book is a true sequel to "The
   Little Lisper" and not an out-of-the-box Java patterns book. My first reaction
   was "this is really neat but not necessarily too useful". Wrong. It wasn't long
   before I was designing an open source Java package that stacks Swing objects in
   a way strongly reminiscent of the stacked pizza toppings in this book. Who
   knows? You, too, may end up stacking boxes rather than thinking within them.



3. I first read and enjoyed "The Little Lisper" in College (1990ish). It was entertained and educated at the same time. This was the first book I saw that "broke the mold" of computer programming texts.
   
   I bought "A little Java, A Few Patterns" because it was recommended to me. I was very pleasantly suprised to see the same approach used in the Little Lisper. I enjoyed this new book just as much and learned even more.
   
   This is a book for thinking programmers. It won't teach you Java syntax. It will help you learn how to think about what you are doing.



4. I read this book about 7 years ago; it is still in my bookshelf. I actually learned a lot of OO ideas from this little book which I think had been deceptively titled; it should have been named "A little book of OO patterns in java" -I thought it was an introductory book in java at that time and I end up learning about interface, abstract, patterns, etc. before I even compiled my first
   "Hello World" in java.



5. This books was written in the late mid 90s when there was a lot of misunderstanding about OO. I enjoy reading Robert Martin's writings from that time and you'll see he is still a best selling OO author today. The form of OO in "A Little Java..." is exactly the form of OO that Mr Martin proved wrong then and today.
   
   More precisely, these authors use inheritance (the "is-a" relationship) as a form of aggregation (the "has-a" relationship). They did this, as another reviewer said, so their Java would look like Lisp. For instance, in this book, Tree inherits from Leaf. Shouldn't a tree have more than one leaf? Anyone conversant in OO recognizes that the relationship between a Pizza and its ingredients is Composition, not inheritance. While Lisp is a wonderful language, Lispy Java doesn't work.
   
   This book is worthless. The authors should apologize for writing it. It is difficult to follow as many reviewers say because it is so wrong.
   
   And yes, my former boss writes code just like this. It is difficult to write unit tests for code like this (he never did) so the quality is poor and maintainability also proved difficult.

5 comments about Decompiling Java.

1. Decompilers are something of a black box to most programmers. Not unlike compilers. Actually Nolan shows us that the 2 are very similar in their lexical methods.
   
   In the specific case of Java, this book may well cause unease in the reader, if you program in Java and are worried about protecting your source code. After all, it probably has proprietary methods that are not covered by any patents you might have. While you can copyright the source, Nolan points out that this may not stop someone from decompiling and reimplementing your "secret" methods.
   
   The book shows that the big problem with Java bytecode is that decompilers for it have a far easier time than decompilers for actual assembly code, whatever the specific hardware for the latter. The basic reason is that the bytecode retains extra information that a decompiler can use, whereas assembly does not have this. Like the fact that the bytecode separates data from instructions. A vital simplification to a decompiler.
   
   Nolan shows countermeasures. At the source code level, there are several good obfuscation techniques, described well enough for you to try. And these may be better than buying a commercial decompiler.
   
   Also, Nolan suggests fully compiling your Java into specific assembly binaries. One for each combination of microprocessor and operating system that you need to support. More work. But it makes a decompilation far harder. Besides, these days, you may only have to support a few combinations. The hardware may be a Pentium or a Sparc or an IBM cpu. If a Pentium, then you might only support a recent linux or Microsoft OS on top of it. If a Sparc, then you need only support a recent Solaris. While for an IBM cpu, the only choice is AIX or Apple's OS.



2. "Decompiling Java" is an interesting piece of work. In just 250 or so pages, you'll go through legalities related to decompiling Java code, learn the basics of Java's class file format, get a brief run-down of tools available for decompiling and obfuscating Java code, all the way through different methods employed by obfuscation tools. Finally, Nolan goes through the design of a basic Java decompiler implementation using JLex and CUP open source compiler compiler tools.
   
   The brevity of the book is both its best and worst characteristic. It's great because I certainly wouldn't have wanted a bible on copyright and patent laws in different parts of the world, but it's unfortunate because the topic you're interested in is bound to be slightly too superficial or detached from the rest of the book. For example, I would've liked to read a lot more about the actual class file format and the internals of a JVM in the book itself instead of having to read from a specification on the web. On the other hand, the author managed to light some bulbs in my head along the way and I actually enjoyed reading his text - especially the chapter about creating a decompiler using JLex and CUP (which I've also found a bit too intimidating to actually look into).
   
   In summary, "Decompiling Java" is a good overview of decompilation in Java and it has a couple of real gems inside, but if you're looking for a manual for dissecting class files or the JVM, it might not the book you're looking for.



3. This is a fantastic in-depth book on decompilers and code obfuscation tools for Java. It covers the structure of Java code files, the opcodes, and the all of the tools required to decompile classes, and to obfuscate existing code. It's an invaluable reference for anyone who has to deploy Java in a non-secure environment, or for those that want to learn how the language really works.
   
   There is a lot of code to pour though, and there are no illustrations. I think the text could have used some illustrations, but that's not a big sticking point for me.
   
   If you are a serious Java gearhead you should have a look at this book. And if you have a specific interest in either de-compiling some Java or obscuring your deployed Java bytecode then this is a must have.



4. This is indeed (as other reviews wrote) a nice book about decompiling Java if you want to know how to write a very simple decompiler, but you need to keep in mind that the author uses a HORROR design/implementation.
   
   The problem is this:
   
   * You can download the sourcecode from the publisher website (so you can check my critism below yourself), but this code even doesn't have a license somewhere in the download archive!! Mr. Noulan seems not to be a pro.
   
   * The author introduces a Class to XML converter, and tell the reader that the XML is the intermediate language. The problem is that in normal compiler design the intermediate language add something (else it's useless), for example the Intermediate language can be independ from the source language, but the Class to XML converter does not. It is just an another representation of the same data so it can be omited (but yeah it looks cool, saying that your compiler does something with XML) Maybe the author want to ride the XML 'hype'?
   
   * The author knows how to write a simple Java decompiler, but he don't know how to write nice Java code. For example he uses different stacks in the decompiler, but he only pushes and pops strings from/on it. He then parse the string to retrieve the data he need (if the string contains integer, he parse the integer). As a result his sourcecode is filled with .toString() calls to create the string and .indexOf, substring, etc. to parse it back later (and he assume this always goes OK). What a mess. Has Mr. Nolan ever read a real compiler design book? If he did, he would choose to use a AST Tree. I need to make a note: maybe this String mess was needed to keep the code size (for printing in the book) small.
   
   * The String mess is one thing, coding the whole compiler directly in the entire CUP parser file is something else!! What a great professional design. NOT!
   
   So this is a nice book if you want to know something about how a decompiler could look like, but please don't use his ideas ever in a real (de)compiler!



5. What I hoped to learn from the book was an understanding of modern Java decompilation techniques. With respect to this expectation, Nolan's book is a disappointment.
   
   His implementation, though simple, will decompile only the most simple of byte code. Nolan points out that it is difficult to recover all legal control structures offered by Java, but is not so clear about the fact that this will never be possible with his approach (i.e. using syntactical analysis).
   
   A stable decompiler which is able to produce clean code must do some control flow and structural analysis. The book gives no account here.
   
   Regarding the other topics of the book such as obfuscation, legal issues, tool selection and case studies, there are more concise and cheaper books. Simply refer to Amazon's "Customers who bought this book also bought ...".

5 comments about XML and Java(TM): Developing Web Applications (2nd Edition).

1. This is the best XML/Java book I've seen to date. Why? It's well written. For example, unlike most books written by more than one or two authors, this book does *not* repeat a lot of material that an author previously addressed. The code contained in the book and on CD is well formatted and doesn't contain a lot of needless fat surrounding the meat; it get's right to the concept they're trying to relate.
   I especially liked the chapters written by the lead author (Maruyama) and especially his XML Security chapters. Worth the money - just for the code.
   Additionally, the code is well written - example, the import statements list each class; they don't use ".*;"



2. I found this book very useful, covers a lot of unique topics
   in advanced XML processing, practical and to the point.
   Especially enjoyed coverage of advantages and disadvantages
   of different techniques.

   Would be nice to cover these topics a bit deeper,
   little more on architecture.
   How about making 3rd edition 1000 pages,
   maybe without CD-ROM, put code online
   (any XML/Java developer has Internet access now).
   And Websphere and DB2 getting outdated very quickly.




3. Even if 9 different authors wrote this book, the logical flow remains intact and the writing style is consistent, clear and concise, without any redundancy. The authors provide plenty of well written, relevant code examples, almost to a level of a cookbook. I was very pleased to see some pretty advanced topics covered in details and, while the focus is on Xerces, JAXP get a good coverage too. In my opinion one of the best Java/XML books on the market



4. Next Time before I purchase the book I would like to know if the CD in company with the book will be included in the mail or not.



5. The product was delivered before schedule, was in perfect shape, and it exatly fit my needs for a reference in my thesis :) thanks Amazon!