5 comments about XQuery: The XML Query Language.

1. This is a well written introductory and reference work on XQuery. It's primarily an introductory work, the first 260 pages are introduction and the final 240 are a reference that is organized as an appendix.

   The writing is solid, and it by no means panders to the reader, so you should be prepared to read over sections multiple times to completely understand the topic. I can't penalize the book for this because the topic is fairly complex.

   On the downside there could be more in the way of real world examples in the text as they explain so of the more complex topics. It easier for the reader to retain the information if they knew why they would be using the language feature in the real world. In addition the book needs a section on existing tools and support for XQuery.

   Strong chapters are chapters five and six which cut to the heart for the FLWOR expression syntax.

   Overall this is a fine introductory work that could use some expansion and some more focused explanations.




2. This is a well written introductory and reference work on XQuery. It's primarily an introductory work, the first 260 pages are introduction and the final 240 are a reference that is organized as an appendix.

   The writing is solid, and it by no means panders to the reader, so you should be prepared to read over sections multiple times to completely understand the topic. I can't penalize the book for this because the topic is fairly complex.

   On the downside there could be more in the way of real world examples in the text as they explain so of the more complex topics. It easier for the reader to retain the information if they knew why they would be using the language feature in the real world. In addition the book needs a section on existing tools and support for XQuery.

   Strong chapters are chapters five and six which cut to the heart for the FLWOR expression syntax.

   Overall this is a fine introductory work that could use some expansion and some more focused explanations.




3. Too many development books are slanted towards either concepts or practical, in-the-trenches development. This book manages to balance both by giving not only the what's and why's, but the how to's, and does so in a readable and highly credible manner.

   The discussion about why Xquery instead of Xpath, XSLT or even direct access through another programming language shows both the strengths and some weaknesses of Xquery. This discussion extended into documents, databases, the state of the Xquery specification, and culminated in a essential types, and types you will not need. This is both conceptual and practical.

   For the developer who wants to get up-to-speed with (or refine skills in) Xquery, this book goes deep into every facet, using concepts, concrete examples, and code. More importantly, the author's extensive experience is shown in Chapter 11, which covers problem areas and common points of confusion. This short chapter will prove invaluable to new developers. I also liked the chapter on query optimization, and the rich reference material in the appendices, which is almost half of this book.

   If you want to learn Xquery, hone existing skills, or step back and see the big picture this book is the best one in my opinion. Expect in-depth technical information, and expect it to be provided by someone who understands developers and provides the code to make it real.




4. This very good book gets only 1 star because of the poor quality of binding. A few months of (admittedly heavy) use is all it took for individual pages and whole sections to start falling out.
   Otherwise, I generally agree with the previous review. It's a thorough introduction to the XQuery language with extensive reference and numerous examples. If it wasn't for the horrible production values I'd give it 5 stars.



5. This is simply a great introduction to XQuery. In general this is a book rich on examples. I used this to test every other query, and gain a more thorough understand of the particular topic. The best way to learn a new language is to practice - right ?
   
   Besides the examples bit, I think this is a well written book that explains the more academic content in straight forward manner. About half of the book is references, which has a lot of examples. My personal favorite section is the "Idioms" part of Chapter 10 that gives some clever solutions that I wouldn't have come up with myself.

3 comments about The Web Wizard's Guide to XHTML (Addison-Wesley Web Wizard Series).

1. If you are a beginner, this is the XHTML book for you. An easy read for those starting to learn web design.



2. I have bought this book as it was a prerequisite for a college course.
   I started to read the first chapter and proceeded to do the assignments,
   when lo an behold what I had read was grossly inaccurate. In black and white.
   The errors start on page 9. Gross errors such as Cheryl M. Hughes stating that, a "paragraph
   is an empty element,unlike other elements, have one tag. WRONG
   An paragraph must always have a start tag
   
   , and an end tag
   I won't go on because the following errors are just as gross. I found out about
   the errors through the instructor. So I ask how does a 196 page glossy, visual, colour
   book come up to 41.38 plus tax. Why does the college promote it? Sam's Xhtml you can get
   for 40 to 60 dollars and is about 500 pages long. Who's in cohoots with whom.
   I am not throwing this money away and I'll be asking for a refund from the publisher.
   How can the college who is aware of gross errors still promote this book?
   Who's in cohoots with whom? Who is this Cheryl M. Hughes? Has anybody proof read the book
   who knew anything at all about XHTML or can I also write a book publish it and charge that
   kind of money for a sloppily, inaccurate, ERRONEOUS information.
   DO NOT BUY THIS BOOK IF YOU DID BRING IT BACK. ASK FOR A REFUND. WRITE TO THE PUBLISHER.
   As for the person who gave it five stars, did you even bother learning anything...?
   Have you a clue what you are writing about?
   Who's paying you to give a book full of major errata five stars.
   By the way I gave it 1 star because there was no 0.
   DO NOT BUY THIS BOOK



3. I am currently using this book as a text in a course I teach. Xhtml is a minor component of the course material and as such, this is a good text. There are good examples and references to important web sites. It covers all of the basics.
   
   Being small (yet pricey), this book doesn't spend a lot of time on web design and it is not a particularly good reference manual. As another reviewer wrote, there are a few errors in it.
   
   But, if you want to get your feet wet, take the book, read it carefully, duplicate all of the examples get them to work. If you do this, you'll have a good solid start in the subject matter.

5 comments about DocBook: The Definitive Guide (O'Reilly XML).

1. The DocBook standard is a way of marking up a document so it can be printed in multiple ways. The benefit is that the document you create contains only the content -- if you want to generate web pages, or a printable file, the same source text file will do both for you. This can save you a lot of time in maintaining parallel print and web versions.

   I used this book to create an employee handbook for my company in both print and web formats, and found it very handy, though it does have a couple of problems. Good things first: it contains a complete reference to every element in the DocBook standard, so you can look up Note or SimpleList or Article or RevHistory and find everything you need to know. This is the bulk of the book, in fact, and is what it is mostly useful for.

   However, even these entries have one big flaw: they don't give you much of an indication of where they can be used. For example, if you want to add a Note to your text, can you do it from the section level, or do you have to be inside a para tag? The book won't give you this information if you look up Note--you have to look up all the different things it might be inside to find it. In practice this isn't too bad since you tend to settle down into a default set of tags you know well; it's more of a problem when you run into an exception.

   The first five chapters give you an overview of SGML and XML, and then take you straight into the basics of creating DocBook documents. This section is good explanatory material and will definitely help orient you if you're not sure what DocBook can do for you. There's also a section on how to interpret OpenJade errors, which are among the least comprehensible error messages I've ever seen. This section is well-intentioned but not much use--the error messages are just too poorly written to be useful. They do give you the line number though, so that's usually where you have to start.

   Installation and setup is another matter. There's an appendix which is helpful but there are a lot of pieces to get right and you should be prepared to take some time over this. Get help from someone who's done it before, if possible.

   I would have liked to see a diagram of how all the pieces fit together--SGML, the parser, transformation, the DSSSL files, and the output formats. I had to draw my own to understand it.

   Overall, recommended, for the explanatory material and the reference section; but it could be improved.




2. This book presents full detail on the use of the DocBook "DTD," documenting the various sorts of elements that can be used to structure a sophisticated technical document.

   DocBook supports all the sorts of titles, subtitles, paragraphs, tables, itemized environments, and such that are likely to be needed to produce something like a book, and this book documents in goodly detail the hundreds of such "document elements," and how they are put together.

   There is an introductory section which swiftly runs through an overview of SGML/XML, and describes how DocBook may be customized. The book contains more documentation about the DSSSL rendering language than seems to be available anywhere else, although if there is to be disappointment in the book, it is in that "more than anywhere else" still isn't quite enough.

   The body of the book then goes into detail on each and every document element. This is necessarily dry material, fortunately combined with often-humorous examples of how to use the elements.

   What may NOT be obvious from the book is what tools should be used to edit DocBook documents, and what the production process should be like. Briefly, the more sophisticated the text editor, the better (in a word, Emacs!), and production usually to involve some sort of "batch" process that transforms DocBook into HTML, RTF, or TeX output.

   The most visible users of DocBook are the many "Open Source" and "Free Software" projects that often surround Linux. Perhaps most well-known is the Linux Documentation Project, though DocBook is used for MANY other things. I prepare my own web pages using DocBook, for instance.

   The existing tools for DocBook have the strength (over, say, using raw HTML) that they can automatically generate internal crossreferences, tables of contents, and the likes. A weakness is that other sorts of references (indexes, bibliographies) likely need programmed intervention. [Be prepared to write code...]

   If you're planning to write technical documentation using DocBook, this is an excellent reference that you will likely greatly appreciate having. Personally, I prefer having a "dead trees" edition to page through to mousing through the online versions.




3. I recommend this book to anyone starting on the road to DocBook. Not only is it useful for the new user, like I was, it has a comprehensive reference section for all the elements of the DocBook SGML.



4. The problem with this book is never up to date with the latest and gratest DocBook stuff. You can download a copy of the reference guide for free, so why would you need a hard copy?

   I think the main reason for buying this book is to say thank you to Norman Walsh, we has been the DocBook lead for ages, and we all know he does a great job. From that perspective, this book is definitely a must.




5. If you are (like I am) in a situation where you need to serve two masters with a DTD you're trying to build (the online and the print world), after your first or second rough passes at putting it together yourself (there's a great many tools out there to help you in this, of which I personally recommend XMLSpy from Altova), then is when O'Reilly's DocBook will come in handy. The matter of the fact is that, no matter how much brain you put into the creation of a multi-purpose DTD: these guys thought it over several times a while before you, but granted that you might not have a use for a vast majority of the elements presented in DocBook, it will help get your feet out of the mud when in trouble and you don't know how to deal with a very particular situation.

   The only "negative" part about it is that, with its print date of 1999, it is clearly outdated, but who cares, when even an outdated version of the standard will be considerably better than what you can come up with on your own!

5 comments about XSLT and XPATH: A Guide to XML Transformations (The Definitive Xml Series from Charles F. Goldfarb).

1. I would agree this is more of a reference for the seasoned XPath/XSLT programmer. I'm a intermediate java programmer with some decent background in xml. I haven't really been able to get that much from this book in the way of examples. It's very light on examples.



2. I suppose this book might be helpful as a reference, but to someone who is actually trying to figure out what to do with xslt and xpath, this book is a very poor primer. I found that, in addition to offering little explanation as to how xpath and xslt are needed in a larger context (is this supposed to supplant sql??, for example), the examples are so error-prone that I learned more by correcting the errors than I did reading the book. Here is a list of errors you will encounter (from the CD) for the first 3 chapters:

   1.1 (string not quoted)
   1.2 (only 1 top-level element allowed).
   2.1 (invalid character)
   2.4 (cannot locate resource)
   2.5 (template.xml undeclared namespace)
   2.7 (cannot locate resource)
   3.2 (output.xml invalid at the top level)
   3.3 ditto
   3.4 worked -- hey, a working example!
   3.5 (output.xml invalid at the top level)
   3.6 misplaced period
   3.7 invalid at top level
   3.8 only 1 top level element allowed
   3.9 invalid at the top level...

   The rest of the chapter examples are similar to this one.
   Without good examples, a programming book is almost worthless.




3. This feels like a book that had it's table of contents laid out, and then the content filled in as quickly as possible. Editing must have lasted about 3 days. With a more thorough editing process, and a bit more thought to the examples (the boulevard examples taumatized me so much, I nearly stopped driving), it may have been a very good book.

   In some sections, the same paragraph is repeated verbatim 2 or even 3 times. Often in the chapter overview, and then on the next page in the first chapter section.

   Possibly the book appeals to other learning styles better, but I've found it a tough slog. In fairness though, XSLT is a strange and difficult beast- I may be transferring some of my frustration on to the messenger!

   However, in general, I find the examples are too repetive, causing them to blur together. And you find myself flipping back as many as 6 pages at times to find the xml code the description is talking about.

   And there is a lack of technical illustrations to help with more difficult topics.

   I would have appreciate larger examples from different domains to specific goals. The problem with a lot of the examples is the purposelessness of the examples.

   XML in a Nutshell, and Michael Kay's XLST reference have provided me much more joy.

   My last word of advice- follow the examples live. XSLT and XPath need practice, and lots of it.




4. I've had this book on my shelf since publication. I had to dig it out last week to do some fairly complex XSLT programming. The book was a huge help and helped me get everything done quite quickly.
   
   I use this book as a reference book, not a how-to. This book is great for things like "what is the function that does 'x' and what are its arguments?" It probably helps that I know XML pretty deeply, so I don't typically look at the examples. Of course, that might be because the docs on the functions in the book are so good that I find I don't need to look at the examples.
   
   XSLT hasn't changed much since this book was published. If you deal with XSLT, and, by extension, XPATH, get this book for reference.



5. I love this book, they are no longer printing this book, but if you can grab it, grab it! It's truly amazing. Love this book and it comes with a CD.

5 comments about Office 2003 XML.

1. Hurrah! Microsoft has said for several years that it strongly supports XML. Well MS Office 2003 is one of the first major products that conforms to this. As you probably know, earlier versions read and wrote to Microsoft's own doc format. A binary format. Third party developers then had to write code to read and write files in this format. Doable, but certainly an aggravation to some, given the complexity of the format.

   Which is why MS Office 2003 was eagerly awaited. Now, XML is a fully supported data format. It also lets you see in an easy and direct way the complexity of deciphering the doc format, if you had never tried to do that firsthand.

   Here, the book walks you through the various XML outputs and their associated schemas. There is the usual XML verbosity. (No surprises here.) But you can now read, in plaintext, how the suite structures its code in an OO fashion. So much nicer!

   Not that the book is trivial. Many examples show how a lot of XML's capabilities are used. Like namespaces, XSLT, XSL and XPath. A reassuring point is that your needs might not have to extend to all these usages. The book also has many very simple XML examples that could be germane.




2. I've read the Addison Wesley book on Microsoft's new Office XML standards and this book is much much better. The book covers four applications; Word, Excel, Access and Infopath. It covers both the storage XML format for Word and Excel, as well as the use of XML within Word and Excel itself from the end-user side. The coverage of the storage format is excellent, and that, being a developer, is something I can appreciate.
   
   For end-users of Word and Excel who are just looking to consume XML in your document or spreadsheet, or to mine XML using Infopath, this is a well written book that is worth your money and you can ignore the technical segments. For engineers looking to work with the new Microsoft XML storage formats you will find a lot to like here, and you may just find some cool things to do with XML to do on the forward facing end-user side of the house.



3. This book answers a very specific need - you are working with the new Office xml formats. If you are directly reading or writing WordML, SpeeadsheetML, or the other xml formats - stop what you are doing, buy this book, and read it. It will put you miles ahead.
   
   Clear, concise, and about as complete as it can be with Microsoft's incomplete documentation to work from. I had it open on my desk next to me the whole time I was working with these file formats.
   
   It has some stuff for InfoPath and Office WebServices. I didn't read those part but the rest is so well written I would bet that part is indespensible too.



4. Clear, concise, and packed with practical knowledge. I work with XML, XSLT, and C# for a living, and this book had me using XSLT to whip up WordprocessingML documents in no time. I especially appreciated learning how to turn off the default "Word" display of ML documents in Internet Explorer. I'm also using Evan's great XSLT that mimics Word's "data-only" output format-- as part of a process to validate foreign tag sets in WordML documents. Thank you!



5. This book provides a good overview of Microsoft's Office XML formats. In addition to covering these formats, it also provides some useful material related to Microsoft Office smart documents, an extension mechanism for Microsoft Office applications.
   
   Note: Microsoft Office XML is completely distinct from the Open Office.org XML format (OASIS OpenDocument) which is not covered in this book.

5 comments about Pro XML Development with Java Technology.

1. This book discusses technologies that a Java/JEE developer would use on a regular basis. It keeps it real by providing sample code and discussing the concepts at a technical level unlike other books that bombard you with buzzwords and jargon.
   
   I keep the included sample projects mounted in Eclipse all the time. I found myself copying and pasting from these samples into my own programs. I do this not only for APIs that I am learning but also with APIs that I am pretty familiar with. I do this to save time as I won't have to lookup javadoc or other internet resources.
   
   I have worked as a J2EE Architect and am now working as a Web Services Architect. As part of my job I frequently develop documentation on concepts discussed in this book for providing guidance to my developers. Now all I do is, I give them this book and refer them to a relevant chapters.
   
   In short this is the only book I need for all my XML development needs. A must have in any Java/JEE developer's bookshelf.



2. This book covers all important details of XML technology for use in Java.
   Although all this information exists in various fragments elsewhere, this
   book does an excellent job of bringing a lot of technology together in a
   simple to use, step-by-step description.
   
   This is great book to have if you use java on a regular basis but have
   been hesitating to use the XML alphabet soup. This book is a must-have.



3. This book is titled 'THE EXPERT VOICE IN JAVA TECHNOLOGY'. But this book is full of something like how to use eclipse(window pictures in many pages), which most of experienced programmers already know. It repeats this again and again. Another book 'Java & XML ' is much better than this one.



4. This is a very decent book on XML with Java. Lots of examples and it is pretty well organized. Good coverage of SAX, StAX and JAXB. Be aware that if you are looking for in depth coverage of XSLT or XPATH this is not the book ( and doesn't purport to be). Although examples are for Eclipse IDE I was not fazed by this at all and readily translated them to my IDE.



5. 
   Information in the book is great.
   
   Author's sarcastic tone of voice often mocks/belittles the 'dumb reader'
   
   "We will not describe this schema definition in great detail. By now, you should be familiar with schema constructs; if you need to review this material, please refer to Chapter 1." pg. 375(ch 14)
   
   "At this point you may be wondering ..how it knows what this message is requesting. From an intuitive standpoint, the answer to this question is that the.... pg 361
   
   "If you examine the response message, again from an intuitive standpoint, you may notice the following points" pg 362

5 comments about MCAD/MCSD Training Guide (70-320): Developing XML Web Services and Server Components with Visual C#(TM) .NET and the .NET Framework (Training Guide).

1. This is the 3rd Amit Kalani book that I have purchased and used to prepare for Microsoft certification exams. Very easy to understand and follow. Good exercises.



2. This book is designed for the intermediate level developer who wants to learn how to develop web services using Microsoft's C# in the .NET framework, and for those who want to pass the 70-320 examination. This is not a 'cram for the test' type book but instead gives you the information you need to do the job, and incidentally pass the test. It is not a complete book on C# or .NET or even the Visual Studio IDE software. It is on how to use these to build real life systems.
   
   Tied in with this, of course is information on passing the test. There is information about the test itself, and practice examinations (one printed in the book, one on the CD included).
   
   If you are just interested in passing the test, there is a shorter book in the Exam Cram2 series. It's written by the same author but is significantly smaller as it is test only oriented.



3. I used just this book to pass the test with a score of 900. My only disppointment with the book is the exam that comes on the CD. The quality of the questions are not very good; although, I think it is only there to entice you to buy the full set of test that they market on the publisher's website. Other than, though, the book does a great job of covering all the relevant topics on the exam and I found the large amount of exercises extremely useful at driving home the material.



4. I'm sure Amit Kalani knows his stuff but there are several issues that I have with this book which make me wish I had bought another one.
   
   Firstly, and this is the most annoying fact, it is hopelessly out of date. I am using Visual Studio 2005 and it is painfully obvious to me that the book was written for an earlier version, which means that following the instructions given is sometimes impossible. This means I miss out on valuable experience that I could have gained through those step by step code examples where the procedures in the book clash with the current reality.
   
   Secondly, there are a number of small niggling typos present throughout which undermine my confidence in the authority of the book as a whole.
   
   Added to this is my suspicion (though I am not sure, given I'm not the expert) that some code examples given contain small mistakes or inconcistencies. Again, this is just a suspicion, as of this moment I have not actually tried to implement those examples where I have noticed such possible errors. Overall though, given the previously outlined gripe I have, my suspicion is very strong.
   
   So you can see, I am not very happy about this book. The fact it is out of date is the major contributing factor to this. I wish I'd checked the publication date before spending my money.



5. This series is for sure the most popular training guide for Microsoft's MCAD/MCSD certification exams. Even after the release of a new generation of certification exams there are still folks (like me) who are still taking the 2003 exam for their own reasons. Let's see the most important pros and cons for this book:
   
   Pros:
   * Text: the text is well written and easy to understand. Very simple and clear vocabulary. It is not a boring reading.
   * Guided Practices, Review Questionsand Exam Questions: there're plenty of exercises on every chapter, including 15 exam-like questions and some other review questions. I like books with exercises. It's a good way for the reader to measure what they've learned.
   * PrepLogic software: gives a good idea of the kind of software you'll have to deal with on the real exam.
   Cons:
   * Code examples: as in most programming books code example tend to leverage for the beginner, sometimes lacking in code design.
   
   All in all, this book is a sure shot if you're going to take the 70-315 exam as well as a good reading for ASP.NET newbies so don't hesitate to buy it.
   
   Exam tips:
   * be confident
   * know your strengths and weaknesses
   * don't rush the exam! there's plenty of time! in my exam there were 43 questions and 150 minutes for me to answer them!
   
   Good luck in your exam!

5 comments about XML Schema.

1. This book had potential to be a definitive guide to XML schema. This is not the kind of book you can pick up and read cover to cover (unless insomnia is a real condition for you, in which case this book may help). It is, by no means, a tutorial of XML schema - or even a reference. It's more of an exploratory academic walk of the W3C recommendation and all of its foibles and nuances. There is wealth of information in this book, if you can glean it out from inbetween the droning prose and historical diatribe.

   O'Reilly should be shamefully embarassed for ever letting this book go to print in the condition it is. It is replete with errata, typos, and slopped together examples. This book is destined to frustrate those new to XML schema. An uncharacteristicly poor level of quality for O'Reilly.




2. This book is very dry and terse. It has all of the required content but it doesn't provide much perspective of how it should be used. You could use it as a reference, but I recommend the XML Schema Companion before this one.



3. XML Schema is used almost everywhere (in connection with XML documents, Web Services, SOAP etc.). So I as other people needed to master XML Schema. There is not a great choice of XML Schema books. Specification is already quite getting old. The book is not easy to read. I read it sequentially chapter after chapter and I mastered a lot of basic rules. The main problem now I see is, XML Schema itself does not give you too much of design freedom. Sometimes you need to define a structure (data type) according value of other elements. So now I know mainly what is not possible to do in XML Schema.
   After all I have to recommend the book. You have to read it twice. So I have just bought another XML Schema book from Priscilla and I hope I will get to know XML Schema from other point of view.



4. This book tells you what you need to know. However, it is a bit of a hard slog because it doesn't tell you why you need to know it. It also throws in obscure acronyms and not only expects you to know what they stand for, but what those protocols/standards/programs imply. Yes, you can learn all you need to know about SQL schema, (and more than you need to know - without telling you why you need to know it, you don't know what to skip), but it is a little more painful than it has to be.



5. A real need for further editions on this book. As others have commented, it's very poorly constructed, poorly indexed and you'll be hard-pressed to quickly find accurate definitions. As other posters have suggested, O'Reilly should be worried that this one got published in this state.

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

1. [This is a review of the second edition.]
   It was with some trepidation that I opened this book. It has 9 authors. Sometimes this many can mean that the style varies widely between chapters, and that there may be little logical continuity. Glad am I to say that this book appears seamless. Thanks probably in part to good editorial management by the publisher.

   This is an advanced treatment of XML. It presupposes that you are already familiar with java and XML. The emphasis is on developing higher level applications that use XML as message medium.

   As a consequence of 8 of the authors being Japanese, they stress that for internationalisation, XML is a good choice for the medium. It was designed from the ground up to handle Unicode. This is needed to describe Chinese and Japanese, which, out of the major languages, are the hardest to deal with, because of the large number of symbols. You should design your applications to maximise outreach to as large a user base as possible. Native English speakers tend to live in a happy technological cocoon, because leading edge stuff mostly appears first in English speaking countries. It is easy when programming to inadvertantly build into your code restrictions to ascii or extended ascii. Then it becomes much harder larger to remove those. Whereas if you choose XML (andjava), you get internationalisation right out of the box.

   The discussion of DOM (Document Object Model) and SAX parsers is very nice. Especially in showing how to add SAX filters, and in quantitative estimates of runtime and memory usage of the two approaches. They make the point that XML processors are the result of intensive intellectual work, and that hence you should use these, instead of writing your own. More reliable, and you can concentrate on higher level issues.

   For more advanced XML uses, XML Schemas are described, largely supplanting DTDs, since they allow the easy handling of datatypes (like String and integer) and namespaces.

   They give succinct examples of how to connect XML messages to databases via Enterprise Java Beans. In doing so, Java Server Pages and servlets are explained. Very logical progression. Then the Web Services Description Language is introduced, along with showing how to use it with UDDI. Security via XML Digital Signatures and Certificate Authorities is then implemented.

   The logic flow is very clear. Plus the accompanying CD with the full example code is a great convenience for learning.




2. 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 ".*;"



3. 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.




4. 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



5. 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 comments about XML and Perl.

1. One of Perl's great strengths is in processing text files. That is, after all, why it became so popular for generating dynamic web pages - web pages are just text (albeit text that is supposed to follow particular rules). As XML is just another text format, it follows that Perl will be just as good at processing XML documents. It's therefore surprising that using Perl for XML processing hasn't recieved much attention until recently. That's not saying that there hasn't been work going on in that area - many of the Perl XML processing modules have long and honourable histories - it'd just that the world outside of the Perl community doesn't seem to have taken much notice of this work. This is all set to change with the publication of this book and O'Reilly's Perl and XML.

   XML and Perl is written by two well-known members of the Perl XML community. Both are frequent contributors to the "perl-xml" mailing list, so there's certainly no doubt that they know what they are talking about. Which is always a good thing in a technical book.

   The book is made up of five sections. The first section has a couple of chapters which introduce you to the concepts voered in the book. Chapter one introduces you separately to XML and Perl and then chapter two takes a first look at how you can use Perl to process XML. This chapter finishes with two example programs for parsing simple XML documents.

   Section two goes into a lot more detail about parsing XML documents with Perl. Chapter three looks at event-driven parsing using XML::Parser and XML::Parser::PerlSAX to demonstrate to build example programs before going to talk in some detail about XML::SAX which is currently the state of the art in event-driven XML parsing in Perl. It also looks at XML::Xerces which is a Perl inteface to the Apache Software Foundation's Xerces parser. Chapter four covers tree based XML parsing and presents examples using XML::Simple, XML::Twig, XML::DOM and XML::LibXML. In both of these chapters the pros and cons of each of the modules are discussed in detail so that you can easily decide which solution to use in any given situation.

   Section three covers generating XML documents. In chapter five we look at generating XML from text sources using simple print statements and also the modules XML::Writer and XML::Handler::YAWriter. Chapter six looks at taking data from a database and turning that into XML using modules like XML::Generator::DBI and XML::DBMS. Chapter seven looks at miscellaneous other input formats and contains examples using XML::SAXDriver::CSV and XML::SAXDriver::Excel.

   Section four covers more advanced topics. Chapter eight is about XML transformations and filtering. This chapter covers using XSLT to transform XML documents. It covers the modules XML::LibXSLT, XML::Sabletron and XML::XPath.

   Chapter nine goes into detail about Matt Sergeant's AxKit, the Apache XML Kit which allows you to create a website in XML and automatically deliver it to your visitors in the correct format.

   Chapter rounds off the book with a look at using Perl to create web services. It looks at the two most common modules for creating web services in Perl - XML::RPC and SOAP::Lite.

   Finally, section five contains the appendices which provide more background on the introductions to XML and Perl from chapter one.

   There was one small point that I found a little annoying when reading the book. Each example was accompanied with a sample of the XML documents to be processed together with both a DTD and an XML Schema definition for the document. This seemed to me to be overkill. Did we really need both DTDs and XML Schemas for every example. I would have found it less distracting if one (or even both) of these had been moved to an appendix.

   That small complaint aside, I found it a useful and interesting book. It will be very useful to Perl programmers (like myself) who will increasingly be expected to process (and provide) data in XML formats.




2. The authors of this book, definitely know the subject. I believe one of them is an author of quite a few XML modules, though both are widely known in the Perl XML community.

   This book definitely covers the state of Perl and XML. It goes over the most important modules, in great detail and providing concrete examples. I especially like the first two chapters, which in detail get you prepared for the rest of the book. The coverage of XML parsing theory was a great topic to cover. Two large chapters, each dedicated to SAX and DOM respectively, covered both parsing technologies in great detail.

   Many, many, more great chapters. Apart from some typos, which are inevitable in any book, this book stands way above the O'Reilly counterpart, which I also own.




3. I wrote a review VERY critical of what OýReilly passes off as reference books. Their various CD Books are pathetic. Shortly after getting burned on two of their books, I was in need of a solid technical book on perl and XML. Well instead of OýReillyýs Perl and XML I voted with my dollars for Reihlýs XML and Perl. This is how a technical reference should be written. If you want to get into the perl and xml saddle quick, you canýt have a better boost thatn XML and Perl.



4. Using practical, real-world examples, XML And Perl is the collaborative effort of Mark Riehl and Ilya Sterin to demonstrates how to perform a variety of XML tasks, ranging from such basic tasks as XML parsing, to more advanced tasks such as writing XML event handlers, RDBMS integration, and XML transformation. XML And Perl is a continuingly useful addition to personal and professional XML and Perl reference collections.



5. If you are interested in this book, you should already be aware of the importance of XML. Perhaps you already have used it elsewhere. More importantly, you should already have the basics of Perl. The book does not start from scratch on it. Though it assumes no prior knowledge of XML. It shows what can be done in Perl, to parse, change and write XML. Numerous modules already exist, especially for parsing. You really do not want to write an XML parser!
   
   Once you've understood enough to have your own custom XML files and be able to write Perl to read and display these, then it should get easier. Those initial steps can then easily be modified as your XML data and analysis changes.