2 comments about XML Data Management: Native XML and XML-Enabled Database Systems.

1. At our company, we write Java applications. Soon, we got to the point that we needed a more formal way to read/write data than merely an ad hoc approach. We use XML. The obvious approach is to use a well tested relational database, like those supplied by IBM, Oracle or Microsoft. A problem was getting detailed, objective explanations of what would be involved with each choice. Each vendor is perfectly willing to be our "friend" and supply us with reams of documentation. But still...

   The chapters in this book that describe how to hook up XML to those 3 vendors' databases were excellent and clear.

   But what we ended up doing was going with something suggested in ANOTHER chapter - building an embedded XML database. You will not see this advocated by a vendor; there is no sale for them here. Other than this book, we found it tough to get lucid explanations of the pros and cons of this route. It will take more work, but we hope it will give better performance - no interprocess communication, for one thing. Plus of course no licence fees, and easier installation and management, since we will have access/own all the source code. This was not our original intention, by any means. But the book's comparative analysis was so persuasive that we ended up taking this road. (Hopefully, it will not be a dead end.)

   That one chapter on embedded XML databases was, to us, the most precious thing in the entire book!




2. I think it is a very good book. It describes several actors in the XML data storage world. It also points out several strategies to deal with XML in relational databases.
   It is very easy to read and the language is very clear.
   Some experience in XML and how to store it is recommended in order to get the most of it.
   I really enjoyed the chapter on eXist as it really goes into details about the index and storage architecture. It is stays quite high level though.
   It helps you understand pros and cons of the different products and architectures (client/server as opposed to embedded).
   Everyone dealing with XML storage should read it.

5 comments about XML Hacks: 100 Industrial-Strength Tips and Tools (Hacks).

1. If you've ever tried to go to a web page automatically and then parse the information by examining the string you got back, you can appreciate XML. While not perfect XML is probably the most practical option for packaging data that can be read by both humans and computers.
   
   As with the other O'Reilly Hacks books, this one contains 100 hints, tips and suggestions on on how to get more out of XML.
   
   I find that whenever I read one of their Hacks books I pick up something useful that just happens to fit the problem I'm working on at the moment. This one was no exception. Great idea! Great Books.



2. Nothing irritates me as much as the industries gratuitous use of the word "hack". I won't say more on this topic other than to advise you that any time you see the word "hack" in this book, substitute it for "tip", "task", or "how to". Once that is understood, this title takes on a whole new feel and its usefulness is made clearer.
   
   Anyone not already familiar with XML, its creation and use, should probably not pick up this book. However, if you are using XML documents a lot, the chances are that this book will yield a resolution method for most of the XML file transformation, modification or parsing need you may have. This method, however, typically requires the use of a third party utility, application, or script (a great many of the tips are titled "Do [something] using [something else]"). A quick flip through the table of contents reveals at least 35 different utilities required to the complete the associated tasks - which is OK if you don't mind incorporating "black box" solutions into your environment. There are also many "see this book" notations within this title as well, so if you find a solution to a need, but require more than what the tip tells you, you may need to make additional purchases.
   
   Overall, a good read for anyone that already knows and makes heavy use of XML; you're sure to walk away with something new.



3. I'm familiar with XML and have found this book to be helpful. Not a book to learn XML, it is a place to pick up new information that can help to complete a toolbox already in the making. There were some hints to bridge gaps between what I want to do and what I know how to do. I plan to have it nearby to make my work easier and faster.



4. This is my favorite O'Reilly book. The scope covers everything you can imagine for working with XML. I really like the depth of information in every hack ('hack' in the sense of ways to get something done). Whenever a tool is mentioned, there is often additional info about related tools that do similar functionality and why you would choose one or the other. Each hack is like a well-crafted short story.
   
   At first I glanced through the book. It's amazing how people have solved so many common tasks to make working with XML automated and flexible. It's fun to look at the titles of each hack and see the illustrations. I found myself saying "That's a technique that'll come in handy someday."
   
   Then I found myself marking up the tools and applications mentioned that did nifty things that will be good quivers in my XML toolkit.
   
   Finally this book provided some invaluable techniques when I needed to do a few one-time XML tasks. I needed to extract information from a humongous XML file. I was able to extract the text of all elements into a nice tidy HTML page.
   
   Another time I created a tree diagram with custom bullet list symbols for the two types of items in the tree using CSS to format the XML (I'd heard it was possible, but didn't know how to do it).
   
   And if you're looking for a quick explanation and examples for some XML technology, like XQuery, XSLT, SVG, XPointer, XLINK, RSS, some recommendations on commercial and free XML tools, XForms, XHTML, working with Microsoft Office documents as XML or for importing into Word or Excel and many more, then I recommend getting this useful, information-packed and handy reference book.
   
   You'll grab it off the shelf whenever you want to do something efficiently in XML without reinventing the wheel.



5. As a Perl programmer, my first instinct when given some XML to process is to grab the appropriate Perl module (probably XML::XPath or XML::LibXML) and use that to do whatever I need to. Although that usually gets the job done, reading this book opened my eyes to a number of other XML processing tools that will sometimes be more useful than a Perl program. Actually Perl doesn't get mentioned at all in the index, whereas Java gets half a column of entries.
   
   A lot of the book isn't aimed at the kind of person who is comfortable firing up an editor writing a program. Many of the hacks introduce ready-made applications that handle a number of different XML tasks. For example there are applications that, given an XML document, will take a first pass at creating an XML Schema or DTD for the document. This is something that would be an interesting project to write for yourself, but if you just need the schema it's nice to know that someone else has already written the application for you.
   
   One of the most interesting chapters for me was the one about editing XML. My usual tool for that is xml-mode in Xemacs but the book introduced me to a number of other possibilities. The one that particularly caught my eye was nXML for Emacs. Unfortunately it's not currently compatible with Xemacs, so I need to try out some of the other editors that are discussed.
   
   Like all of O'Reilly's Hacks books, this book is aimed at a very wide audience. Some of the tools are Open Source and some of them are commercial. Some of them run on only one platform and some of them will run anywhere. That has the potential to be a little frustrating when you find a tool that looks really useful, only to find out that it only runs on Windows. Fortunately the authors are aware of this problem and make a real effort to present tools that run on as wide a range of platforms as possible. If one hack presents a tool that only runs on Windows then you can be sure that the next hack has a similar tool that runs somewhere else.
   
   The audience is diverse along other dimensions too. There are hacks aimed at people who will just want to save a Word document in DocBook format (hint: use OpenOffice) and at the other end of the spectrum there are hacks aimed at people who want to create SOAP services. There are hacks aimed at all levels of producing and using XML.
   
   It's an inevitable consequence of this type of book that not everyone is going to find all of it useful. But the authors are obviously experts in their field and they explain themselves very clearly. I thought I knew a lot about processing XML but I discovered a lot of new and interesting things from this book. If you want a good overview of the various ways that XML can be useful to you, then this book would be a very good start.

5 comments about Xsl Fo.

1. the author says he expects only some knowledge of xslt, but I think that some knowledge of printing and characteristics about texts, images, ... are also very useful if you want to understand this book. If you have this knowledge, this is a very good book for getting into the basics of xsl formatting objects.



2. My main gripe with this book is the manner in which the author chose to present the material.

   Rather than focusing on "literal" XSL-FO, the author gives fragments of XSLT stylesheets that produce the XSL-FO. This means that the path to understanding the XSL-FO in the examples goes through XSLT.

   While I understand the author's point in choosing this presentation (that no one will "really" be coding XSL-FO by hand, but will instead be writing XSLT stylesheets to generate XSL-FO from other XML input), I don't agree that it's the best way to explain the material.

   I would have preferred to see actual, "complete" fragments of XSL-FO (both with and without larger context). I can draw my own conclusions about structuring the XSLT that I need. What I'm really keen to see is how the XSL-FO itself works, otherwise I've got no clue -what- to generate.




3. Armed with only the most rudimentary understanding of XSLT, I found this book a little overwhelming. It's not a "cookbook", though the examples are good. There are a few places where it seems to dwell on minutia, but mostly it moves along at a jog to brisk run pace. I got a better understanding of the topic and and am prepared to do more research, but this could not be my only reference.



4. An interesting book covering a powerful but niche technology. Not a book for the faint of heart, get it only if you want to investigate this very specific topic or plan to do things like XML > PDF transformation. The author digs immediately into the technical details, condensing a relevant amount of info in less than 200 pages; the results are good, focused and well structured, but it's not an entertaining read. This is definitely not a beginner book. A decent understanding of XML, XSL and XPath is required; some knowledge of printing would be helpful too



5. The book is a competent explainiation of XSL-FO, which is an XML-based language for describing the appearance of text, usually for the purposes of printing it. If you thoroughly read everything, you will understand how areas, blocks, spacing, and the various other technicalities interrelate to one another.
   
   However, the author does not seem to be very good at explaining these crucial concepts for an audience that has no or little familiarity with the subject matter. One can pick them up, but the author does not make it easy. In order to delineate the book into chapters, the author will make a mention of some crucial fact, but not go into detail on it until much later in the book. The material is complex enough, and the author's method of demarcation does not help the matter.
   
   Also, as mentioned by others, this book does often use XSLT transform examples to "explain" XSL-FO concepts. While any significant use of XSL-FO will certainly use XSLT transforms to convert from some other XML format into the XSL-FO, it is not appropriate to offer examples of XSL-FO that are written as an XSLT transform. Having a chapter or two in techniques for writing XSLT transforms for XSL-FO would have been more appropriate than providing examples of XSL-FO concepts using XSLTs.
   
   That being said, this book does cover some fairly difficult material. XSL-FO is very complex, particularly when it comes to positioning things. The information is all there, and it is all good. It is simply a matter of explaining that information in a way that one can read the book in a linear fashion and understand. To gain the full measures of XSL-FO, you will need to re-read the book, or at least the sections on position of elements.

5 comments about .NET and XML.

1. This book has probably all you need to know about reading, writing, formatting and sending XML over the wire with C#. Standout chapters for me were chapters seven, on XSLT, and nine, on web services. That being said all of the non-reference chapters were evenly written, easy reads and neither rat hole nor pander to the reader. The code samples are numerous but they are hilighted with bold to emphasizes the portions that a critical to the narrative.

   C# is the only imperative language covered in the book even though most .NET authors cover both C# and VB.NET. In the introduction the author calls C# the central language of .NET and says it's the best language for the job. I don't have big issues about that but other potential .NET readers may, especially considering the popularity of VB.NET. Personally I prefer when the author chooses one language and then leaves the other to the site or the CD. I think VB.NET example code fragments on the O'Reilly site probably would have been a safer bet.

   It's this one language approach in the dual language .NET environment that kicks the rating from five down to four.




2. Over the years, I've found it increasingly difficult to buy technology related books simply because of the speed in which they become obsolete. So now I look at each book as not only an instructional tome, but whether or not it will be useful 6 months down the road as a reference. This book (like many of O'Reilly's titles) has easily earned a place in my library.
   
   Mr. Bornstein's method of writing seems to fit very well with the way I learn, and his coverage of the subject matter makes this book a great resource when I'm trying to remember the exact syntax of a specific method call.



3. Note that I decided to write this review because I could not believe that so many people wrote so nice reviews about this book. My assumption is that someone or some people are really trying to sell this book, because this book is definitely not that good whatsoever.
   
   Actually, this book is definitely not what I expected from a .NET/XML book. I was expecting a practical book with some theory, a good description about .NET's XML implementation and good examples. This is not what this book included. I'm very flexible with books. It's impossible that every book will be perfect. Actually, most aren't, so you have to get used to it, but again this book is for the most part terrible, unless you only want to get a general idea of how to use XML with .NET, otherwise get a different book. Again, I don't know where the reviews for this book came from, because this book is really not that good.
   
   To name a couple of things that I find wrong with the book, lets start with the examples included. Two words: they suck! Each chapter is pretty much like this: here is the general theory, some of it unnecessary like the constant reference to W3C stuff; then, here are a few lame, simple examples without much substance; now, lets go to the next chapter.
   
   The first time I looked inside the book I was looking for information about how .NET did Xml Validation, and it is just terrible. I actually found more information out of general .NET books I already had, than from this one. And when you are working on a project where you need this information, and you have a book that's suppose to help you with this stuff, it is very disappointing to find out that the book is pretty much irrelevant.
   
   You would assume validation is a very important XML topic, among many others, but there's really not a lot of info on it. Actually, if you look on the book's index, you'll see that about half the related info is in the reference section, which you could get out of MSDN anyway. BTW, almost half of the book is simply reference for the different .NET XML namespaces. Again, the same data you could get out of MSDN.
   
   In any case, I know there's not much else to choose from, but pretty much anything else might be as good or possibly way better...



4. i was looking for example on using the System.xml.serialize name space. This is the example copied from the book
   public enum AddressType {
   Home,
   Office,
   Billing,
   Shipping,
   Mailing,
   Day,
   Evening,
   FAX
   }
   If you'll look again at Example 9-7, you'll see that each state is actually listed by its full name, not the abbreviation as listed in the State enumeration. Here I've added an XmlEnumAttribute for each state name. Note that I've skipped some in the interest of space:
   
   public enum State {
   [XmlEnum(Name="Alaska")]
   AK,
   [XmlEnum(Name="Alabama")]
   AL,
   [XmlEnum(Name="Arkansas")]
   AR,
   [XmlEnum(Name="Arizona")]
   AZ,
   // ...
   [XmlEnum(Name="Washington")]
   WA,
   [XmlEnum(Name="Wisconsin")]
   WI,
   [XmlEnum(Name="West Virginia")]
   WV,
   [XmlEnum(Name="Wyoming")]
   WY
   }
   The Address class has one attribute, type, and four elements. Here I've added XmlAttributeAttribute and XmlElementAttribute, as appropriate. The AttributeName and ElementName fields of each attribute are used to set the names of the XML attributes and elements, respectively:
   
   public class Address {
   [XmlAttribute(AttributeName="type")]
   public AddressType AddressType;
   [XmlElement(ElementName="street")]
   public string[ ] Street;
   [XmlElement(ElementName="city")]
   public string City;
   [XmlElement(ElementName="state")]
   public State State;
   [XmlElement(ElementName="zip")]
   public string Zip;
   }
   Similar to Address, the TelephoneNumber class has one attribute and three elements. Again, I've decorated each member with the appropriate attribute. Note also that here, as in Address, I've set the names of the attributes and elements to match the ones in the XML; that is, they all start with lowercase letters:
   
   public class TelephoneNumber {
   [XmlAttribute(AttributeName="type")]
   public AddressType AddressType;
   [XmlElement(ElementName="areacode")]
   public string AreaCode;
   [XmlElement(ElementName="exchange")]
   public string Exchange;
   [XmlElement(ElementName="number")]
   public string Number;
   }
   Now we come to the meat of the personnel record, the Employee. This class has three attributes: firstname, middleinitial, and lastname, which I've treated with the appropriate attribute. However, the Employee class also has two additional elements, addresses and telephones. These two elements actually contain nested arrays of elements, so I've used the XmlArray and XmlArrayItem attributes to help the serializer figure out what to do with the XML elements it reads:
   
   public class Employee {
   [XmlAttribute(AttributeName="firstname")]
   public string FirstName;
   [XmlAttribute(AttributeName="middleinitial")]
   public string MiddleInitial;
   [XmlAttribute(AttributeName="lastname")]
   public string LastName;
   
   [XmlArray(ElementName="addresses")]
   [XmlArrayItem(ElementName="address")]
   public Address [ ] Addresses;
   [XmlArray(ElementName="telephones")]
   [XmlArrayItem(ElementName="telephone")]
   public TelephoneNumber [ ] TelephoneNumbers;
   
   [XmlAttribute(AttributeName="hiredate")]
   public DateTime HireDate;
   }
   Here's the document element, personnel, which is decorated with XmlRootAttribute. Although the Employees member is an array of Employee objects, it is not a nested array, like addresses and telephones. By adding the XmlElement attribute directly to the member, the XmlSerializer knows that this member is to be serialized as an array of employee elements, without a separate top-level element:
   
   [XmlRoot(ElementName="personnel")]
   public class Personnel {
   [XmlElement(ElementName="employee")]
   public Employee [ ] Employees;
   }
   Finally, I've made some changes to the Serializer class, which I introduced in Example 9-5. Serializer's Main( ) method still uses the CreatePersonnel( ) to create some personnel records, but it then instantiates an XmlSerializer to deserialize the objects it created back out to a file:
   
   public class Serializer {
   public static void Main(string [ ] args) {
   Personnel personnel = CreatePersonnel( );
   XmlSerializer serializer = new XmlSerializer(typeof(Personnel));
   using (FileStream stream = File.OpenWrite("Personnel.xml")) {
   serializer.Serialize(stream,personnel);
   }
   }
   }
   
   notice its in java??? for crying out loud if your going to say .net and xml use .net examples not JAVA



5. A careful reader would have noticed the "using" keyword in the code sample, and realized that this is C#, not Java. I found this book a good supplement to the MSDN; its well-conceived examples got me off to a good start in this area.

5 comments about The Semantic Web: A Guide to the Future of XML, Web Services, and Knowledge Management.

1. This book is well written and comprehensive. It clearly explains highly complex subject matter. I refer to it constantly.



2. Different people will not agree on exactly how to define all concepts.
   As a result there will be ontological mismatchs across parts of the
   web designed by different people. In conventional logic if even one
   inconsistency exists it will be possible to draw all conclusions and
   their contradictions! It is not explained how they will prevent this
   from happening.



3. Painstakingly, in a literal sense, read from cover to cover without learning much about semantic description and search (more pedestrian XML technologies, eg, XPath were covered well). Some of it, eg, on Topic Maps, is impenetrable. Very light on interesting and compelling usage and how-to of the more ambitious, semantic technologies that are the reason most would buy a book of this title.
   
   And so, unfortunately, I agree with the negative assessments already given here: little practical information for implementers and on the contrary, the considerable time spent in attempts to decipher will not be justified, in my experience, with their pay off in knowledge that is useful or memorable.
   
   To be fair, part of the problem, from what I gather by its absense in the book, is that the W3C semantic web technologies are not even attempting to solve any part of the ultimate problem of semantic analysis: natural language understanding. Instead the highest goal in this presentation is the /manual/ cataloging of /whole/ documents (and emails, customer questions, etc).



4. This book can be a good general introduction to semantic web technologies, to get an idea about how they can be useful inside your organization. The starting and ending chapters are rather good in this respect.
   But unfortunately the middle chapters, which try to explain the technical side in more detail, are somehow confused and hard to understand, maybe incomplete. The part about RDF is not bad and can give you some useful info, but things get worse when you get to topic maps and ontologies. Maybe this wasn't the main purpose of the book, but it's a waste of pages and reading time anyway.
   
   So, when you finish reading it, you can be excited about the topic and have nice ideas for implementing those technologies in your work/life, but you still are left clueless regarding HOW you should actually do it.
   
   It should also be noted that the book is becoming a little dated now: new technologies like OWL are more mature now, than what it describes. Not the authors' fault, of course.



5. The book throws around all of the right buzzwords: ontologies, XML, KIF, taxonomies, metadata, etc. However, it never even properly defines these terms or organizes the information. If you already understand what the semantic web is, the book makes perfect sense but you don't learn anything new. If you don't already understand what the semantic web is, you won't be able to make sense of the author's high level descriptions and diagrams and you won't learn anything either. You can go to Wikipedia and probably get better explanations of most of the terminology. For example the Wikipedia definition of ontology from a computer science perspective is : "In computer science, an ontology is a data model that represents a domain and is used to reason about the objects in that domain and the relations between them." Why can't the author just SAY that??? Instead he wanders all over the map with a kind of philosophical musing about ontologies, and then proceeds to dissect a human resources ontology without ever properly defining why this model is useful in terms of the semantic web and what makes this model an ontology in the first place. The whole book is like this.
   The only reason I give it three stars is that there is useful albeit poorly organized information in here, and if you do know what the semantic web is and you have to present the information to management you can use the individual pieces of the book to probably stitch together a pretty good introductory presentation ... providing you already know what you are doing.
   However, I really recommend the book "The Semantic Web Primer" instead. It is more technical and better organized with much clearer explanations.

5 comments about No Nonsense XML Web Development With PHP.

1. Do you want to teach yourself XML the easy way? Well, you're in luck! Author Thomas Myer, has done an outstanding job of writing a book that introduces readers to a large part of the XML world, and to walk them, step by step, through the creation of an XML-powered Website.
   
   Myer begins by introducing XML. Next, the author introduces you to the XML family, namely XHTML, XML Namespaces, and Extensible Stylesheet Language Transformations (XSLT). Then, he covers DTDs for consistency. The author continues by talking about XSLT and how to use it to transform XML for display in a browser. In addition, the author next covers XSLT in detail. He also shows you how to manipulate XML with client-side tools. Next, the author tackles the server side, specifically addressing the question of PHP 5 as he explores the differences between SAX, DOM, and SimpleXML function libraries for working with XML. Then, he delves into the specifics of the different varieties of RSS that are available, and discusses news aggregators, the parsing of feeds with PHP, and more. The author continues by looking at XML and Web Services. Finally, he considers XML and databases.
   
   With the preceding in mind, the author has done an excellent job of presenting the fascinating topic of XML. So, with any luck, XML will serve you well for some time to come!



2. This is a book about XML, all the power and flexability that the language gives you. It just happends to use PHP for the database access. Which means that no matter what language you use, this is a must have reference guide.
   
   Thomas Myer has managed to put into writing one of the very best XML primers out there. It starts so gently, dealing with the familiar (HTML), and steps you through some basic examples. By the end of chapter 2 you are doing transforms. Before you close out Chapter 6 you will have worked with XPath Queries. These are no small concepts, but I never felt overwhelmed or lost. Mainly due to the precise and comprehensive writing, but the familiar examples (for web developers they are very familiar) helped keep me on some familiar ground.
   
   If you are using XML over the web (in any language), I urge you to pick this one up. It wil be time very well spent.



3. This is my revised and rewritten review of this book.
   
   The first review dated Feb 19 was just two stars, titled `Disjointed and Superficial', and read...
   
   I bought Myer's book to help me move from XHTML to XML and to handle data with PHP which does not fit well in a relational database / SQL. I am not interested in writing a CMS, and therefore tried to skim or skip those parts. Unfortunately, some key points are buried in the CMS discussion. Subjects (ie: Namespace) seem to be mentioned or touched on in several places without doing a thorough job at any one point or multiple points. The subjects which are discussed, are not discussed in depth. And why is Ralph Waldo Emmerson given ink on page 59, and then included in the index??? I found myself working a little too hard to just get the important points.
   
   I know Myer tried very hard to write a good book, and it is not a 'really bad' book. On a positive note: The editing error rate seems to be low as compared to a lot of first edition, first printing computer books. There is some good material in it, but this book does not work well for me. I have at least temporarily given up on this book a little short of the half way point. Since finding a really good XML book seems harder than it should be, I may come back to this one, and if so, I'll update this opinion.
   
   Warning: [3 opinions given here appear to be by paid reviewers. ie: 9/14/05, 10/7/05, and 11/8/05. I now suspect some of the others are personal friends of the author. Hint: Check out the person writing the review before actually reading it. Look for how many opinions he/she writes and how many stars. I distrust all high opinions in the first few months of publication, all high opinions by people who have only written a couple of opinions, and all high opinions from people who only write high opinions. Bottom Line: Distrust all high opinions except those from people who have established some evidence of independence by posting negative as well as positive opinions about other books. Thanks for the lack of honesty Tommy &/or Sitepoint &/or big A. I would have given 3 stars if there were not so many false ones posted here. (my opinion, 2 cma).]
   
   Now, having finished Myer's book (except for most of the CMS stuff), I have changed it to 3 stars and concluded ....
   
   There are about an equal number of pros and cons. It is somewhat light and easy to read, and the editing error rate is good. It is kind of a quick survey of subjects which Myer thinks are important. I did like chapters 7 & 9 (Manipulating XML with PHP, & XML and Web Services).
   
   On the con side: The Appendix listing of PHP functions / methods is not complete and no examples are given. Where he discusses ways to extract XML from a database, two different sources (tables) are used, so the results are not comparable. I wish he had spent more ink on handling XML with PHP and less on client side technologies which are not well supported yet. I found the example listings a little short and lacking some additional code which would have helped follow what was supposed to happen. More output/results listings would also have helped.
   
   The book is not particularly complete, and could not be used as a reference, but it may be ok (not great) as an overview or introduction. A better intro book may be `Beginning XML, 3rd Edition' by David Hunter etc., although that is a much bigger book.
   
   Lastly, do not trust any high star rating review unless the source has proven his/her impartiality by posting positive as well as not so positive reviews of other books. Too many opinions of this book do not pass that simple test. The basic problem is determining who to believe and which postings to suspect are covertly trying to sell books because they have a vested interest or undisclosed motive.



4. This book is helpful and easy to understand and follow, however, the more I read about XML the less useful it seems to be. If I knew then what I know now I probably wouldn't bother learning about XML because I work with web design and nothing else. I am familiar with PHP and MYSQL so I can't really find a purpose for XML at this time. The book is great but the technology is not as useful as I thought it would be.
   
   I may change my mind in the future but for now XML is on the back burner and PHP/MYSQL is my current focus.
   
   My point in this review is to let others know that if you already know PHP and MYSQL and only work on the web then you may find learning XML redundant or maybe even useless. I'm sure it would look great on a resume though.



5. This book has a few shortcomings. The author goes about building a toy CMS that stores various content types. One of the content types is an article. A big disappointment is that he uses a CDATA section to encapsulate the content of an article - it simply contains XHTML tags. I was quite disappointed when I saw this because it cheapened the book and gave it less technical depth. A more suitable example would have been to use simplified Docbook or even come up with a simple article DTD consisting of custom element tags. Then show by example XML/PHP/XSLT on that DTD. That would have been way more useful.
   
   For PHP developers, this book doesn't use much of it until well into the middle chapters. There are quick tutorials on DTDs, RSS, and SimpleXML that are good. The chapter on client side Javascript should have been removed (wasn't this book about PHP?). The templating framework is backwards - the author uses php includes to build out the page. He should have used XSLT to create a proper XHTML transformation instead.
   
   The writing is generally quite good and the reading light. You can go sit outside on the porch without a computer and follow it quite nicely. The organization and topic coverage is good also. I would have liked to see more technical depth and thought put into it, rather than what appeared to be a quick surface introduction. For example, show more how you can pass variables between PHP and XSLT as well as how to cache the pages. The admin panel should also take into consideration that to see 1000 articles on one full page is silly - use a pager.
   
   Because the author used too many shortcuts to write this book, I gave it an average rating. If you are looking for a basic book on XML/PHP development, this is a good start. For those more experienced, I'm afraid this won't suit your experience level and would be left looking for more.

5 comments about Securing Web Services with WS-Security: Demystifying WS-Security, WS-Policy, SAML, XML Signature, and XML Encryption.

1. This book would help you if you need an introduction to Web services security standards. If you need to know the strategies for how to implement then this book may not help much. Some of the specifications discussed in the book is not complete and there is lot of confusion in the standards committee moving forward. I bought this book before I bought the Core Security Patterns which details both the standards and patterns-based implementation strategies for Web services security. This book also needs a revision in terms of updating to SAML 2.0, WS-Security 1.1, WS-I Basic Security profile.



2. i am an architect working on large-scale web services on j2ee and .net ddevlopment and deplyment. I bought this book for getting myself introduced to ws-security and saml. if you would like to know the security specifications for web services at a high-level you may find this book useful. If you are looking at the practical aspects of how to implement them in a j2ee or .net web services you wil find limited help. The coverage on ws-* specs are little bit old as new revisions are already out.



3. This book is a good introduction to the application of security to Web Services and SOA. The authors focus on "message level" security versus "transport level" security, and its application to Web Services. The book explains standards: WS-Security, WS-Policy, WS-SecurePolicy and other current standards at the time of publishing (2004).
   
   However these standards are constantly evolving and this book needs to be updated on a regular basis.
   
   Gary E. Smith
   SOA Network Architect
   SOA Networks



4. This book delivers good introduction to WS-* specs beyond that I don't find much help. From a developer perspective, the book does'nt help with good examples, it is missing with coding guidance and also lacks detail about the PKI in Web services. Possibly this book is too early to market before the specs are endorsed by OASIS. It's time for a revision..otherwise I could've added two more stars.



5. Agree completely with all of the other reviewers in respect to practical working examples and detailed information. This is nothing more than a high-level overview of documentation and specifications you can easily find yourself on the internet. Look elsewhere (and yeah, I'm still looking myself) for solid information about how to design and deploy WS-* applications.

No comments about XML: Your visual blueprint for building expert websites with XML, CSS, XHTML, and XSLT (Visual Blueprint).

5 comments about Processing XML with Java(TM): A Guide to SAX, DOM, JDOM, JAXP, and TrAX.

1. I bought this book when it first came out. I really enjoyed reading it. The book is well written. It has a lot useful code.
   The author code that can be used in the real world of JAVA and XML. I liked the books section on JDOM. This book shows the differences between DOM and JDOM. Also, this book has a lot of information on SAX, DOM, JDOM, and it shows the differences when using each. I would recommend this book to anyone who wants to learn JAVA and XML. Make sure you are an experienced developer before purchasing this book.

   Michael




2. This is definitely a valuable resource for anybody dealing with XML and Java, written by one of the best tech writers in town. The author covers in details a huge amount of topics and API, so many that you couldn't ask for more.
   Be advised that some basic understanding of XML and intermediate Java skills are required to get the best out of this book



3. I really like reading this book. It is easy to read and understand. The author does a good job of describing the XML technologies related to JAVA. This book has a lot of code to analyze. This book is a must have for the experienced developer who wants to do JAVA with XML. I have a message for the experienced developer: THE CODE WILL CHALLENGE YOU; IT CHALLENGED ME!!!

   Michael




4. If only every technical book was written this well! Anyone who is working with Java and XML should have a copy of this book. Highly example driven with clear explanations, the author makes using XML in your Java programs a breeze. Even better, the author has a style that makes the book fun to read as you feel like you are learning all sorts of secrets from an XML insider.

   The book starts with a quick introduction to XML and then gets into how to create XML documents in your programs. The first four chapters cover everything you need to know about creating XML whether it is for XML-RPC, SOAP, or simply to store in a file. The next section covers parsing XML documents. SAX and DOM are compared and then the next eight chapters discuss these two methods of parsing documents, explaining how to use them, comparing them, and helping you determine how to decide which technique to use for which situation. The section on DOM explains not just how to parse documents using DOM but also how to create new documents. The final chapters of the book cover JDOM, XPATH, and XSLT.

   Did I mention that this book is full of examples? The author doesn't rely on simply explaining how something works or how to use a technology (even though his explanations are excellent), he has examples to demonstrate everything he discusses. Each example builds upon the previous example and makes learning the techniques easy and enjoyable.




5. great book on xml, specially on different kind of parsers, their purpose, advantages and weakness.

5 comments about SVG Essentials (O'Reilly XML).

1. This subject perfectly fits O'Reilly's "In a Nutshell" tradition, for SVG itself is just that: Web design, including text, graphics, animation, and programming, all in a nutshell -- concise, pithy, simple, and deep.

   SVG, a refactoring of several generations of Web technology and a public standard approved by the World Wide Web Consortium, can be authored without any special tools and without any special background, other than the immediately productive background provided by this book.

   Eisenberg swiftly, but with diverting variety, illuminates the process of drawing, assembling shapes, creating textures, transforming coordinates, structuring documents, enriching text, creating reusable components, fine tuning color, animating shapes and colors and structures, creating lighting effects, and programming user interactions. All of this is built upon the simple SVG architecture: arrange your elements in a hierarchy and set their attributes.

   There is an art to conveying important points without belaboring them and Eisenberg moves from example to example with perfect pitch.

   The book also contains an eight page section with full color images.

   Some people have complained about the lack of reference books on SVG. The SVG reference is in fact widely available, all 500+ pages of it, on the W3C site. What is really needed, and would have been useful in this or any SVG book, is a five page guide to using that reference -- how do I, in ten seconds or so, determine whether this element can be a child of that element, or if this element supports this attribute?
   
   While I was developing SVG Composer the only book available was Watt's "Designing SVG Web Graphics" (another fine book with a rather different pitch).. When Eisenberg's work came out I happily relearned SVG, doing every example and picking up any number of new tricks.

   I do have some reservations: I didn't care for the cat drawing (hated it!) and the final two chapters on generating and serving SVG seemed aimed at the wrong audience (adepts at Java, servlets, and Perl) though the material itself is perfectly fine.

   At first I had the same feeling about the appendices, which include brief samples of subjects from programming to fonts to matrix algebra, that surely Eisenberg was misjudging his audience. However he may have things just right -- SVG may well become the greatest crossover hit ever in computer languages, a lingua franca for logic and art.




2. Not a bad book if you want to learn just the basics; however, I think you can easily find everything in this book on the Web if you take the time to dig around. If you're looking for a book to get you started, this one will do nicely. But if you're looking for more advanced/esoteric SVG material, I'd keep looking.



3. While it's difficult to separate my excitement over SVG from the contents of this book, it's quite possible that the two are so directly related as to be inseperable. Within a few hours of buying this book, I was producing and printing extremely high quality images that I had found all but impossible to produce w/other technologies (JPEG codecs, etc.). If you are familiar with the basic mark-up language concepts, then you should have no trouble gleaning the essential elements of SVG.

   After an excellent introductory chapter that provides a general overview, subsequent chapters cover aspects of SVG in detail, such as how to create basic shapes or generate text. One thing I particularly liked was that the author mostly uses a single example (SVG code to create a picture of a cat) to illustrate new concepts, creating a sense of cohesiveness that tied the chapters together. This book is *not* just a scattershot collection of essays that characterizes so many other technical books -- the text is clear, concise, and to the point. Finally, there is a very uselful appendix that summarizes the most frequently used attributes.

   Perhaps the only drawback is that if you are coming to SVG from a non-technical background, you might find this book a little too gear-headed for your liking. For technical readers that want a thorough introduction (i.e., not a PhD thesis) to this exciting and useful technology, however, this book is a must.




4. The book provides a solid introduction to SVG through an increasingly complex set of examples of SVG use. It is well written and edited, it also provides a thorough description of the entirety of the standard. What it lacks is more depth in the area of recipes for commonly used image effects. It also needs more advice about how complex SVGs are organized and built for efficiency. I understand that SVG is still on the adoption curve, so perhaps we could see these improvements in a second version of the book when the standard has picked up a little more.

   For the time being the book earns it's four stars by providing a nice learning curve and having high quality examples that demonstrates the concepts effectively.




5. Das Buch (in englischer Sprache) erklärt sehr genau die Details. Auch als Nachschlagewerk sehr gut geeignet.