1 comments about Professional XML (Programmer to Programmer).

1. This book has got a decent content about XML. But, most pages have been added to technologies that aren't being used much and just adds bulk to the book. A little rhetoric and not always concise to the point; but can live with it. Over all a good reference book. 3 Stars.

5 comments about Applied XML Programming for Microsoft .NET.

1. Gr8 book if you need assistance with xml programming and also helps in using all methods of reading, writing and using xml. Dino! High five.



2. Dino Esposito has total, absolute command of the subject matter that he expertly teaches in this book. This is a template for how all technical training books should be written. I wanted in-depth coverage of the XML object library in .NET and that is exactly what this book delivers. This is THE book on XML in .NET. Don't waste your money on anything else.

   It is also terrific supplemental material for the Developing XML Web Services and Server Components certification exam. I recommend Mike Gunderloy's book as an all-encompassing source (look up my review for that book); however, I recommend reading the first four chapters of this book before you start Gunderloy's book if you don't have much experience reading and writing XML in .NET. Chapters 12 and 13 on remoting and web services, respectively, are also great sources of exam prep material. In fact, Chapter 12 on .NET Remoting is the best chapter on the subject you will find anywhere.

   Terry, MCAD and MCSD for Microsoft .NET




3. Dino tells all in this superb and in depth look at XML on Microsoft's .NET platform. The book is well organized, starting at the fundamental classes and then branching out to the high abstraction level .NET classes and other Microsoft products such as SQL Server 2000 and Internet Explorer.
   
   As an example of why this book is so wonderful, there have been several situations where I needed to do something in XSLT that just didn't seem practical (maybe not even doable). The section on how to use standard .NET languages such as C# from XSLT is itself worth the price of admission.
   
   Keep in mind that readers are expected to have a good grasp of XML; the book is a .NET book.



4. I am a proficient MSXML coder but i can't get what I want (knowledge about .Net XML programming objects) from this book because the author habitually relies on advanced concepts from related technologies to explain things. So unless you are a pretty competent .Net programmer and already proficient in ADO.Net/ADO you will struggle to understand this book and struggle to understand the significance of what you are being told and why. I gave up and resorted to looking for articles on MSDN. Undoubtedly there is good stuff here but Mr Esposito writes as an extremely knowledgeable person for the already extremely knowledgeable person only.



5. Dino does a great job on this book. It is a great reference on how Microsoft handles and processes XML.
   
   This book only has one drawback that it is outdated as it refers to Visual Studio 2003 and many things in Visual Studio 2005 have been changed or are outdated.
   
   Hope they pubblish soon a book that is more up to date.

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

1. This book is an excellent resource for combining these two technologies, XML and Java. The author starts with the assumption that the reader is conversant in XML and at least intermediate skill level with Java. The first chapter of the book serves as a XML refresher. The author uses this chapter to reach a common understanding of terms with the reader. The first part of the book covers using many of issues of managing XML from Java and introduces two XML based services, XML-RPC and SOAP.

   The remainder of the book is devoted to the various APIs for parsing XML hence the subtitle "A Guide to SAX, DOM, JDOM, JAXP, and TrAX". Throughout the book the author creates clear code examples and very readable text. This serves to develop understanding and insight in reader. This particular technical topography is under continuous change. Adapting to these changes will be much easier after having read this book.

   A lot of tips and "gotchas" are shared in the book, but it is arranged so that the developer grab what he needs or he can sit and camp awhile. The book text is available at the author's website, but I prefer to read the paper copy. If you are going to use XML and Java together, this book would be a good investment.




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




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



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




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

4 comments about XML All-in-One Desk Reference for Dummies.

1. Before reading the book, I was knowing nothing about XML, but after reading a few chapters, I got familiar with the technology.
   The book is good for XML first timers, also if you know a little bit about it, but it's not enough if you need to be professional.



2. The author's have done an outstanding job in writing the book. I found that even the mundane details were covered in the right place and with a little humor. The coverage starts out very simple, so many people won't use the beginning chapters extensively. However, as the book progresses, the coverage becomes more technical and I think that most people will find the authors have covered most of the XML details that any developer will need. The authors also discuss some of the details that other books leave out, such as the default namespaces. Little bits of information like this make the difference between a book that merely teaches and one that really helps. This book has something for everyone. Novices will get the most out of the book, but even advanced readers will receive some benefit. The thing I like the best is that the book is arranged as a quick reference--something that makes it especially useful when you're trying to complete a project and need to know some detail you've forgotten.



3. Though the book covers material quickly and lucidly, the editing is very sloppy and key details are omitted. For example, in discussing using the ID datatype for attributes in DTDs, it omits a key detail: a number isn't an XML name, and to get around this, prepend an _. The example given even shows a useage that won't work! The O'Reilly book of a classmate included this. Elsewhere the text discusses examples that aren't in the book and seem left over from a previous edition, and reading the text is distracting for the grammatical errors.

   In general it appears that the book was thrown together in a big hurry, which is a shame, as it's a very likeable book and would be great if the information was correct.




4. I found this book to be an excellent introduction to XML and the XTeam, as the book calls it, but in reading it I realized that the book is only just an introduction to a much broader world. I think that it is perfect for beginners, and does a good job of steering you in all the directions you can go with future studies.
   
   Some things to consider...although the author does not assume you have any previous knowledge in Web development, I don't think it would be possible to comfortably pick up on XML without knowing HTML and XHTML and the CSS knowledge that you should have when learning XSLT. As far as covering XSLT, you should definitely buy another book for that because XSLT mastery is beyond the scope of the book.
   
   It is well-written and flows good. The way the book is written is so that you don't have to flip when using it as a reference. So, if you read it cover-to-cover, information repeats itself. If you do have experience with Web languages you might feel like you are getting too much information, but it is worth reading through to find those lesser known bits and pieces of info. The author is thorough with the material he decides to cover, enough so that you can intuitively plan your own code rather than simply emulate examples. Overall, I would say the book has definitely given me a great appreciation for XML, and I want to take it to new levels.

5 comments about Effective XML: 50 Specific Ways to Improve Your XML (Effective Software Development Series).

1. Effective XML is a collection of about 50 tips for working with XML. Although XML seems is simple and easy to use, it's also easy to get wrong. I've often scratched your head and wondered why things like XML Schema, for example, just doesn't feel right. But it wasn't until I read Effective XML that I understood what was really awkward with it.
   
   Because the book is so diverse (an amazing feat considering the small page count), it is hard to single out any specific part as being a reason to read the book. The book doesn't just talk about schemas, the infoset, etc..., it digs down and really explains what is good and bad about the technologies and what the best ways to apply them are. All I can say is that I use XML day in and day out and have learned everything I know by trial an error. I've made many mistakes along the way. I've tried my best to learn from them, but Effective XML was the book that made everything click for me. The best part is that the book went well beyond just helping me see my errors. I've already applied some of the ideas to new work I've done recently and have been able to head off some of the problems I would have encountered.
   
   
   Effective XML is by far the best XML book I've ever read, and quite possibly the best tech book I've read all year. I might even have to add it to my favorite tech books list. If you work with XML to any significant degree, I can't recommend this book highly enough.



2. The flexibility of XML can often mean that there's a gap between using XML and using XML effectively. Elliotte Rusty Harold's book Effective XML - 50 Specific Ways to Improve Your XML (Addison Wesley) is an excellent way to move towards the latter condition.
   
   Chapter List: Syntax; Structure; Semantics; Implementation; Recommended Reading; Index
   
   There are obviously a large number of books that will teach you the semantics of writing and using XML. But just because you can create an XML file doesn't mean that you've done it well or effectively. Harold's book provides a bridge to being able to create XML files that will be usable in nearly all situations. The book starts out in the introduction with explanations of terms that are often confused (element vs. tag, text vs. character data vs. markup, etc.). Then there are four parts of the book that include a total of 50 tips that will improve the quality of your XML usage. Some tips are pretty basic, like "Include an XML Declaration". Others are more complex like "Verify Documents with XML Digital Signatures". But every one is practical and useful for making sure that your XML is widely useable by all potential applications.
   
   Excellent bridge book to read after you've learned the basics of XML. This is a book that, when taken to heart and used, will cause your coworkers to thank you.



3. This is not a book explaining XML. This is not a book that goes into any depth on XML APIs. It is not a book explaining any one XML format like XSLT, RSS, or XSD.
   
   Instead it is a book on how to work with XML. How to design an XML application to take full advantage of the facilties of XML: schemas, processing instructions, XSL transforms, namespaces. It is all structured to slowly introduce you into the complexities, and deserves to sit up on the bookshelf with Effective C++, Java and Enterprise Java.
   
   If you already know the basics of XML, it is actually quite a good way to learn about some of the more esoteric concepts -from the pragmatic perspective. Too many XML books rant about how wonderful some feature like XML schema's extension stuff is, why XML is the most universal format ever, SOAP and WS-* the best protocol for distributed systems ever, and XQuery everything you need for an XML database.
   
   This book bursts the bubble of hype with rational analysis of what makes sense, and what doesn't. Item 28: Use only what you need, is my favourite: A review of the main XML specs and analysis of what really matters, which comes down to #35, navigate with XPath.
   
   If you are designing an XML schema/system/application, you need this book. If you have to put up with architects telling you about WS-MetadataExchange, WS-Transfer and RDF, you need a copy to roll up and hit them over the head. And, if like me, you are involved in standards bodies that produce XML related things, you need to buy a copy for all the other participants, so that what you produce will actually work.
   
   Remember that XML is a language designed for use by people and machines. The machines have the upper hand. But with this book, and some thinking, you can design XML applications that people can use.



4. Elliotte Rusty Harold states in the introduction of Effective XML that the book is neither an introductory book nor an XML tutorial. Rather, it is a distillation of the author's experience using and teaching XML and how to use it effectively. The book does a great job of explaining how to use XML and its related technologies.
   
   The book is divided into four major sections: Syntax, Structure, Semantics, and Implementation. Each of the fifty Items packs a lot of information into a few pages. The Items span topics such as why you should Include an XML Declaration (Item 1), Make Structure Explicit through Markup (Item 11), Program to Standard APIs (Item 31), and Write in Unicode (Item 38). Even the Introduction is valuable because it sets the definitions for XML-related terms used in the rest of the book that the author has found to be used interchangeably or inconsistently.
   
   Item 24, Choose the Right Schema Language for the Job, provides a typical example of the great information contained in Effective XML. This Item discusses the strengths and weaknesses of four schema languages: W3C XML Schema Language, DTDs, RELAX NG, and Schematron. The use of programming languages to handle situations that the schema languages can't handle is also discussed. The Item ends with a set of questions to think about when selecting the schema language to use.
   
   I found the book very readable and like that the information is presented in digestible chunks. Effective XML isn't meant to hype XML but to identify what the actual capabilities of XML and its related technologies are and how best to use them. The book does an outstanding job at this task.
   
   Full disclosure: I received a complimentary copy of the book for review.



5. I bought this book quite a while ago and I absolutely the format. It's a great resource to just pick up and get great ideas, verify that you are on/off the right track and generally learn how to get to the next level with XML. Highly recommended

5 comments about XML Weekend Crash Course (with CD-ROM).

1. XML is changing at a lightning fast pace, and this 2000 book is already out of date.



2. I knew nothing about XML and needed to come up to speed quickly. This book served that purpose well. It starts with basic theoretical explanations and goes into some technical detail. It did not teach me "everything" I needed to know, but it did a good job of getting me started. I would recommend it for a novice with little to advanced technical background who needs to learn XML.



3. A great introduction to XML.
   The example programs and tutorials cover a breadth of topics. The sections are related and continue to build on useful tools and suggested practices.
   I would recommend the book to anyone new to XML that wants to rip through some examples and would like to know about dtd and xlst.



4. Good book for someone new to html, xslt, xml and the like. You get a good background of the evolution of the webspace languages as you are learning, and lots of little self-tests and pretty good examples. I had trouble with the CD-Rom, the Turbo XML included either no longer supported the beta copy or I missed something in the installation, in any case I never bothered with it any more. I was mostly just using it to gain an overall understanding of XML before I started studying XSLT. For that it was sufficient. I didn't really do many of the examples, but they seemed well developed and had a logical flow.
   The part I had a little problem with, but only a little, was when it came to writing code that would access outside data, especially tables and databases, and a bit with how the sorting worked. Probably had I done some hands on work it would've clarified it, but I was a bit lazy for that. In any case, overall it takes a simple language and doesn't make it needlessly complicated, and the style is light and breezy without being flippant. You probably could knock it out in a weekend.



5. I have bought a lot of Programming Books, at least one other of this "Brand" and have NEVER before written a negative review. I am so disgusted with this book that I decided to at least get the word out.
   
   Realizing this book was published in 2001, I know they could not foresee everything about this programming language, but you do not set up more than half your book based on one piece of software. Of course there are other ways to go further with XML without the Instant Saxon software they tout and insist you must use. It is included on the disk, but doesn't work and is not supported(the web site they send you to is vague and the downloads you may use there are confusing and not helpful). Now I will be looking elsewhere for that information when I bought this book for that reason, and all of the fragments of code they have had me updating, waste. The SUPPORT Web Site is non-existent, and the disk harder to access than a 1999 magazine demo disk.
   
   It starts out pretty good, but then they begin doing more complicated code that apparently needs to use Instant Saxon, for reasons which I now do not know. Of course, I might have known if only they had stayed with the 'program'. .
   
   If this book were really about XML, none of these things would be so tackily and weakly done.

1 comments about New Perspectives on XML, Second Edition, Comprehensive (New Pespectives).

1. To be fair, I am not a fan of the Thompson Course Technology books in general. But this is the first one that actually drove me to write a negative review to spare some innocent XML programmer-to-be the confusion this book will likely cause.
   
   Our local community college unfortunately requires this text (a fair percentage of the classes seem to use Course Technology books because of the pre-fab quizzes, Powerpoints, and online supplements available to the instructors who can't be bothered to make their own).
   
   The good: The Chapters are called "Tutorials" and in general, if you can read and copy the tutorials line for line, you will be able to get them to validate. However, you probably won't understand why in many cases.
   
   The ugly: Like most of the Course Technology textbooks I've seen, there are significant typos and the explanations are very poor and awkward. There is little or no rigor in defining terms, the author often uses a tangential example as an adequate explanation for the entire concept.
   
   Many explanations are as clear as mud. Case in point p. 199 (which is only partially understandable to me because I've taken a few computer classes (including C++ object oriented programming) and the concept of scope is familiar to me, even if the word is never mentioned here):
   
   "In XML Schema, any element or attribute that is declared globally has to be entered as a qualified name in the instance document. The reason is that global elements and attributes are added to the target namespace, while local objects are not. Local objects are interpreted based on the namespace affiliation of the object in which they're nested. Because global objects are attached to the namespace, they have to be qualified in the instance document with a namespace prefix. The target namespace applies the document validation through the qualified elements in the instance document using them as the starting points for the validation process. You can't go down the hierarchy and validate only the local elements and attributes."
   
   And that was a relatively clear passage. Even if you understand the concept, you are unlikely to get the syntax exactly correct. This book has singlehandedly caused me to consider a campaign to our department dean to stop using Course Technology books, and search for a decent textbook substitute. This book is of little use in class, and will be even less useful as a handy reference.

5 comments about XML 1.1 Bible.

1. When I first saw this book I thought that someone must be kidding. There's no question that XML is clearly the language to use when you want to transfer data using the standard web communications protocols. But a book that's more than a thousand pages, get serious.
   
   They I opened it, low and behold, links, style sheets, specialized forms of XML for specialized purposes that have been agreed upon by multiple competing companies. It turns out that there's a lot more to XML than I thought.
   
   Then in conjunction with XML other languages have been developed, some have proved not so useful and have faded away, others have evolved and changed to be more useful.
   
   All in all, this is a very useful book, well written and has given me some ideas about how to solve some problems. That's all you can ask out of a book.



2. Review for XML 1.1 Bible (3rd Edition):
   
   Elliotte Rusty Harold is that rare technical author who can write about anything and make it interesting. In this case, he has written 1,000 pages on XML providing us with an excellent guide book to this technology. Whether you are a beginner or advanced user of XML, there will be something in this book for you.
   
   The book is divided into five parts. The first part discusses the basics of XML giving us an introduction to what XML is, what it is used for, and explaining the basics of creating a well-formed XML document. Part two discusses DTDs and explains how namespaces are used. Part three looks at various style languages including CSS and XSL. The section on CSS will be useful to anyone wishing to use CSS to format their HTML documents. Part four gives us a tour of some supplemental XML technologies including XLinks, XPointers, XInclude, and Schemas. The chapter that most interested me was on Schemas and the explanations were clear and complete, leaving no mystery about how to use this technology. The final part looks at a few XML applications including XHTML, RDDL, and SVG. The book does not cover writing programs to process XML documents using SAX or DOM, for example. The author has another book on that topic if that is of interest to you.
   
   Each part of the book does an exceptional job of explaining the topic. The author gives us plenty of examples to make the text crystal clear. The author writes as a colleague helping out fellow programmers and not as an instructor droning away at a blackboard. You really get the idea that the author enjoys XML and enjoys explaining it. If you are interested in working with XML this book is truly an indispensable guide.



3. I have purchased many books from Amazon, but this one is printed on the lowest-quality paper I've ever experienced. Though it's relatively new, the yellowed pages look like a 1960's pulp novel. There is literally a 2mm yellow border surrounding each page. Come on "Hungry Minds" publishers, you can do better than this.



4. I haven' read the book, only browsed its TOC. It doesn't cover the Document Object Model (DOM) and the Simple API for XML (SAX). It also discusses CSS in too much detail. These days, web development professionals will probably have a knowledge of both HTML and CSS before starting with XML.
   
   Consider "Beginning XML" or "Professional XML" instead, both published by Wrow.



5. I bought Harold'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. This book bogs down quickly in very long explanations & examples which could have been a fraction of the size. I think it has good coverage, but Harold uses too many words every time he approaches a subject. To paraphrase someone else, Harold could write 10,000 words on the color red.
   
   The problem with Wiley's Bible series (I have several of them) is that the goal seems to be to make them as big and heavy as a boat anchor. This results in verbose books, which may be ok for use as a reference but way to hard to read cover to cover for initial learning. The time needed to read these books cover to cover exceeds the value of the book itself. If you buy books by the pound (or kilo), this is a good buy. But if you value your time more than you value impressive size, there are better alternatives.
   
   On a positive note: I have not found a bunch of typo or editing errors and Harold seems to know the subject. I'm just frustrated by the slow pace, although I will continue trying to read it at least a little longer.
   
   Warning: [Some opinions given here appear to be by paid reviewers. ie: Feb 3, 2005, and others. How many others are also raw attempts to sell books without honor? Can you trust anyone who writes hundreds or thousands of 5 star opinions?? Heck no! Hint: Check out the person writing the review before actually reading it. Look for how many opinions he/she writes and how many stars. Distrust all high opinions in the first few months after 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. Thanks for the lack of honesty Elliotte &/or Wiley &/or big A. (my opinion, 2 cma).]

5 comments about Web Services Essentials (O'Reilly XML).

1. This book is really lacking on much useful information. It's mostly a high-level overview. For anyone seriously interested in web services I'd recommend getting a different book!



2. This book is really an excellent one for programmers who want to start with web services. It gives a compact overview of XML-RPC, SOAP, UDDI and WSDL. Especially Java programmers will find some good code listings. But don't expect more than an introduction to web services.



3. This book is based on obsolete specifications and older SOAP implementation which is not even available for download. The Apache SOAP is already a piece of junk and Apache recommends to use Apache Axis (which is not in the scope of this book). All other implementation examples such as XMethods and UDDI4J are also obsolete as well. The APIs are already deprecated and the code discussed does'nt make any sense.



4. First of all, to clear up someone else's comment:
   while the API samples, URLs, etc. in the book are all outdated but even beginners should be able to figure out the updates.
   
   The only word of caution: it does NOT cover REST.
   
   This book provides a wonderful set of core topics and values that are essential to understanding what is currently out there (at the time I'm writing this in close-to-mid 2007, anyway). Providing samples, history and general information on each topic covers allows this book to be a wonderful, thorough introduction to the world of WS.
   
   Samples focused in Java and Perl help keep things simple, while there is more of a focus on the Java world. The APIs changed, but since the author references primarily open-source, it is easy to figure everything out.
   
   I recommend this book at this time, but can definitely see it being completely out-dated by the same time next year.
   
   As with many emerging technologies, however, I think this is a must have in order to better understand and follow the evolution of its realm. Since it provides pointers/references to pieces of the puzzle(s) even before its publishing, you can gain even more insight and possibly make some educated decisions as to where the future will take it.
   
   Recommended for all, if for nothing else, as a general reference and "emerging history" lesson.



5. This is a well written overview for those that may have missed how Web Services rushed onto the scene earlier in the decade. Being 5 years old now, it is definitely out of date. I consider about 120 of 300 pages useful as an introduction to the subject to a developer who has been working in other technologies. It provides a good overview. The examples provided work well to illustrate the point presented. Keep in mind that the examples are outdated so skip liberally.
   After reading/skimming this as an introduction, find a more current book for more hands on examples to work through in the technology you intend to use.

4 comments about Pro .NET 2.0 XML (Expert's Voice in .Net).

1. Book is extremly poorly written and covers just a little more than MSDN documentation.
   
   The entire book is copy-pasted template paragraphs of the following format:
   - 2-3 lines of code
   - a paragraph of 5-10 lines explaining what it does, almost always following the same template:
   "The code creates a class named Employee with five public properties: EmployeeID, FirstNmae, LastName, HomePhone and Notes... " page 284
   "The code creates an instance of the proxy class... The code then binds..." 287
   "The code creates a form-level var... The code then creates..." 288
   "The code creates an instance ... It then sets..." 289...
   and so on the entire book.
   
   Imagine someone commenting every line of code he's written. EVERY line. And using the same copy-pasted phrase for that.
   
   For example:
   page 283 contains a simple class Employee with 5 simple properties (name, id etc.) Nothing more. That simpliest straight-forward code is spread over 2(!) pages (seriously, I can send you a scan of the page if you like, huge empty space in between the code lines), with a paragraph before the code and after, explaining what is inside this class.



2. This book has a number of flaws, but it's still a useful book for learning about using XML in the .NET world.
   
   There are a number of weakness in the book in that it's rather shallow and leaves out details or concerns on a number of topics. Examples include skimming over a DataSet's ability to infer a schema when reading data in. Are there any drawbacks? When would you use this? When might you want to avoid it?
   
   So with the negatives out of the way, let me focus on the positives, because they're definitely there. There's a lot of content on a broad range of topics. There's a very solid introduction to XML which is soundly and concisely written. The discussion of SAX and DOM is nicely done, and there are a large number of fundamentals which are well-written.
   
   You'll be able to learn the basics on things like XML's use of DTDs, how schemas roll into things, the basics of validation, and a number of other topics. The chapter on XML in ADO.NET has some good coverage on XML support in DataSets, and there are solid chapters on Web Services, SQL Server support, and a chapter which combines remoting, XML in ASP.NET, and configuration files. Joshi also wraps in a chapter on XML's role in WCF.
   
   I think the book's a solid introduction to XML in the .NET world.



3. This book is very well written with practical examples in C#. If you are an experienced developer you won't need much more. Enough said.



4. I was looking for a book to get me started in XML. I wasn't interested in Web Services or anything like that, I just wanted to learn how to read through and do some clever things with XML.
   
   This book really helped me a lot. This should be the starting place for all .NET programmers wanted to begin XML. I appreciate the book it has helped me tremendously.