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 Programming Web Services with SOAP.

1. This book is a nice introduction to SOAP. It doesn't get caught in the Software wars and has examples of most existing systems. Another advantage: it is a thin book and not a 1000 pages bible. So you can easily read it in a weekend and then decide where you want to dig deeper (if necessary).



2. This book was a disappointment. I got thrown into an XML/SOAP project and had to get up to speed in short order. After struggling on my own for a while I bought this book hoping it would have lots of meat on actually using SOAP::Lite, but it had pretty thin coverage.

   I did like the big-picture overview of the various technologies, but it was not very helpful in writing an actual SOAP client to talk to a third party's SOAP server. Considering that the author of SOAP::Lite also wrote this book, it seems to me that there could have been a whole chapter on SOAP::Lite from the client view.

   This will stay on my shelf as a reference, but for getting up to speed rapidly on actually writing a SOAP client, it was a bust.




3. If your pretty new at SOAP, and if you need an overview, then this is the book you want.
   If you don't care about interoperability, and you just want a book on SOAP within a particular environment (say Java), then this is not the book you want.
   If you need a reference guide, then you don't need this book.



4. If you are new to SOAP and you want to get the overall picture, and you don't care for details, this is the book you need.
   If you need a reference guide, this is not the book you want.
   If you're looking for a book about SOAP on a particular platform (say Java), this is not the book you need.



5. I was so keen to learn from this book, but no matter how hard I tried it had too much nonsense to be readable or usable.

3 comments about Python & XML.

1. I'm not very far along in the book, but I don't like what I'm seeing.
   The preface purports that the book's audience need not "know anything
   about XML." There is very little in the way of explaining XML, however.
   The chapter on "Fundamentals" is O'Reilly at its most terse. If you already
   understand XML very well, you might think this chapter an excellent
   itemizing of the specification. Sadly, most people, I imagine, would be able
   to retain little from this.

   Regarding the code examples, the explanations hardly illuminate the API.
   The code stands as is; and the commentary does only a somewhat decent job
   of explaining the larger context. You could always check the documentation
   given in the back of the book, but that's hardly as helpful as a good overview
   and commentary.

   Moreover, and in some ways worse, I have found many typos -- and I am only
   as far as the first two examples. These mistakes include missing import
   statements, errant capitalization, bad indentation, double underscores ('__')
   written as one long underscore. This is unacceptable. I can only hope it is just
   this one chapter.

   I bought this book because of the topics, and because I figured Python would
   be the easiest way to learn XML API's. I am only hoping that the book will
   get better, and that I will be able to derive benefit from it. As it stands,
   I'm skeptical that I will get my money's worth.




2. I really liked this book because I was able to quickly start using XML with Python. I tried to use the package docs, but they were often hard to read, and didn't fill me in on the background stuff I needed to know. The examples in this book were easy to understand, and easy to see how to make practical applications from them. I didn't encounter any typos like the other reader did.



3. This book really dvelves into the using XML with Python. The
   chapter are well laid out and easy to read. There are some typos
   but nothing that you can't fix. There are some problems using the current XSLT processer that ships with PyXml0.7 but you can
   still apply the concepts (I used MSXML's XSLT). The best chapter (last one (:-|) ties all the concepts explained into a Web Service like app. that really shows the real strength of XML

4 comments about Oracle Database 10g XML & SQL: Design, Build, & Manage XML Applications in Java, C, C++, & PL/SQL (Osborne ORACLE Press Series).

1. I wish more books were written like this. When you read it you understand that a team of high professional people have worked on it. The book is organized to be useful for developers, DBAs, managers. You'll find here everything you need: XML & SQL, XSQL , XSLT, XML in PL/SQL, Java, C, C++. I highly recommend this book.



2. This book covers everything on how to develop XML applications based on the Oracle XML infrastructure. It also provides the readers with a lot of samples on how to utilize the technology. No matter you are an advanced professional or a fresh graduate, if you are interested in XML-related Oracle application development, personally I think this is a must-have book.



3. This book does not do a good job of getting the small experiments running. And w/o that, it is difficult to get any handle over the big picture. If you haven't done XML and Oracle integration before, this book definitely is not what you are looking for.



4. I guess I am rushing to judgement - but in the first 10 pages I read, there were about 8 typos - so I am giving this a 2 stars for now. Will update my review/rating as I go along.

5 comments about XPath 2.0 Programmer's Reference (Programmer to Programmer).

1. After stumbling around trying to a handle on XSLT, I finally realized that a big chunk was not being explained within the XSLT books. Most of the XSLT books bring XPath statements out of hat like a magician's rabbit -- there is no way one can figure out what to do in any given situation. Thanks to this book, what was mystery meat is now clear as a bell. In the first nine pages, a dozen questions were answered. I don't see how you can do serious XPath and XSLT without this book in hand.



2. The problems people describe aren't the author's fault - I think. If someone did the ghostwriting, even with him dealing with the submitted manuscript, then shame on Mr. Kay, although his reputation would preclude this being a possibility. I think the odds would be like the lottery - so this would be an anti-lottery.
   
   As to the quality of the WROX books, something many people forget is WROX went belly up, despite the quality of their material. The assets & IP were picked up by Wiley in 2003 (http://www.wrox.com/WileyCDA/Section/id-105072.html). Most news doesn't mention the financial straits, just the purchase.
   
   When Windows 3.1 came out in 1992, many asked "What's the best book(s) to buy?" The general concensus was "Petzold (MS Press) and any of the following list...". As web development has become the hot topic of the previous seven or eight years, specifically with the maturing of Microsoft's IIS/ASP, evolving into .NET. O'Reilly has long been recognized in the *NIX market and has successfully branched into many other disciplines successfully. Enough so that it's considered to be on the list of "This [O'Reilly] book and any of the following...", which may or may not be an O'Reilly book, but it's not a surprised if it is. The familiar dense (weightwise), red book with author headshots (WROX) have a similiar standing with many developers, frequently expressed to be of good standing in recommendations to others.
   
   Unless the critical personnel were transferred along with the purchase, then the relationship between Wiley (the new owner) and WROX authors at the hands-on level and the ability for the Wiley people to acclimate and maintain the habits, philosophies, and perspective of the WROX "style", then there will be misfires, such as we've seen in the two new Kay books.
   
   Good authors are flexible but when it comes to computer books, the various types of editors have the ability to considerably alter the destiny of the content. This can be in terms of pre-submitted direction or changes made inhouse. On top of that, unless things have changed radically in the previous years, books are written on accelerated scheduled, edited, returned to the author for verification and only [hopefully] minor changes in response to queries from the various editors. Once that manuscript is at the publisher, it's tough for external forces to change what will likely happen to the book. Aside from software feature changes (e.g. in beta), the direction has been established and things move forward.
   
   One would hope as X* continues to mature there will be another opportunity for the second edition of this book to overcome a first edition which should have been a complement to Kay's XSLT Programmer's Reference, a must-have item on the shelf of anyone who claims to work with XSLT. Important enough, as I've said elsewhere, it's an interview question: what XSLT books do you have on your shelf? If Kay is missing...then either the candidate is *so* good they don't need it (extremely rare) or their unfamiliar enough with what's going on in the real world (and real world resources) they are likely not to be at a level they should be and may need to be nudged into additional professional growth with the book.
   
   Rating? ** As Clint Eastwood says in The Gauntlet, "I'll give her a two. But that's only because I've never seen a one." In this case, we've seen a 4 1/2 or 5 star XSLT book unable to transfer its performance to an equally important sibling. The potential is there, the content is [mostly] there, the author is there, so it's better than nothing, or a lesser work from someone less qualified than Mr. Kay. Because we've seen an extremely high quality product, we have to look at this with an critical & hesitant eye.
   
   For those who feel they've been punk'd, particularly if they've had the book strongly recommended to them, more's the pity. They're at a fork in the road, requiring a coin toss: keep the book for what's there or return it to the publisher with a few specific statements regarding your displeasure and what you expect. Otherwise, you're probably going to be presented with a choice of another WROX book (or a book from another publishing house within the Wily lineup). If you want your money back, you're going to have to be firm about that. Money going back out is money out of their pocket(s). Keeping a customer happy, as opposed to pacifying soon to be ex-customer, regardless of what else is said or done is far less expensive and they feel it's a generous sign of good will.



3. If you are an expert in XPath then this book might be worth having. But if you only have a general knowledge of XPath this book is basically useless. The author clearly has a solid knowledge of his topic. But the ability to communicate it in a practical way is sorely lacking.



4. I'm reading Michel Kay many years ago. The XPath separate book from XSLT book is a very useful tool.



5. I have never had a question about XPath that wasn't answered by this book. I appreciate having an authoritative reference written by someone who was deeply involved in the development of the standard.
   
   However, this book (and its companion XSLT reference) is perhaps the worst-formatted reference book I have ever seen. Much of the book consists of an alphabetical reference of XPath functions. Unfortunately, the page headers and footers only contain page numbers and chapter titles. They do not contain the name of the function that is described on that page. So you can't just riff through the pages watching for your function to appear in the footer.
   
   There is a heading for each function name, but the font used for the sub-headings are as large as (if not larger than) the major headings. There are no page breaks between functions. So you can't even visually scan the pages looking for your functions.
   
   Finally, the table of contents consists largely of function names on the left, with page numbers on the right, separated by about five inches. But there are no dot leaders between them. So, even when you resort to using the table of contents to find the section you need, you have to use a ruler to find the page number.

5 comments about Essential XML Quick Reference: A Programmer's Reference to XML, XPath, XSLT, XML Schema, SOAP, and More (The DevelopMentor Series).

1. Keeping in mind that this is a "quick" reference, this book is organised well and very easy to use. When learning XML I had it by my side many times and almost always found what I was looking for. My only comment for improvement would be a more comprehensive index and maybe some a more suitable cover design (I am constantly pointing people to the text on the cover in order to convice them this is a book about XML).



2. Who can remember all the little details surrounding XML? This book is a great summery of the most important XML technologies. It isn't a tutorial, it isn't for beginners, it's for "What's the name of that XPath function that removes excess spaces?" (normalize-space). Highly recommended for finding answers fast.



3. This is a reference book. It's not intended to read, but rather provide quick reference to just about any XML related topic. Unfortunately, the examples are very short and don't provide a great deal of insite. My next task is to look for a reference book that does provide useful examples -- I hope one exists.



4. Not only explains very clearly all the complex stuff of xml schema when u're a beginner, but also well organized so that it's easy to come back to it when u have a precise questionning.
   For me it's THE reference book about xsd, like stroustrup for c++ and kerningam for c.



5. Got an used copy of this for my XML study.
   
   This book was arranged with great concentration of various key concepts in the XML realm. Very concise and quite useful for experienced program developers.
   
   However, the downside of this book is that some of its examples are not consistent with the Interface Definition, for instance, SAX 2.0, example in this book used .addAttribute Method, which could not be found in SAX 2.0 class definition at all, therefore confusion was there. The same problems were there in the DTD chapter, e.g. vague Entity explaination..
   
   For you can get an free copy of this book on the web now, I gave it 3 stars.

5 comments about Building Web Services with Java: Making Sense of XML, SOAP, WSDL, and UDDI (2nd Edition) (Developer's Library).

1. I am still wondering why the authors don't provide all the code, since the book describes an application and that should have been tested and the code is there. Just a few wsdl files don't help very much.



2. The writers either do not understand the topics, or they want to confuse the readers intentionally. You will find their writing style extremly annoying. They use the Skatestown(??) example to mislead the readers whenever they need to explain something. I dont know how such a bad written book can make it out to the book stores. If you buy this book, it will be the biggest waste of money.



3. This book has helped me immensely in implementing some really intense production quality data interchange across systems using web services.
   
   This book will quickly help you understand the entire XML stack of technologies that you will need for Web Services.
   
   The authors have uniquely enabled the readers to develop an understanding of the underlying technologies that make up the web services. Certainly expect to put in some effort in understanding the content.



4. The problem with Learning Web Services is just one - there is too much happening..the technology has grappled everyone's attention and a lot of Organizations are on it..
   A beginner to web services just doesn't know where to look..strong foundations give 'empire estates', this book does just that
   The primer on XML was one of the best i ever read anywhere and i am a big fan of Dr.Google, the clarity of the authors on WSDL Element model is very informative. All in all - if you need a book to trace Web Service concepts and build your foundations - i would strongly refer this book.
   
   If you are looking for a quick reference/book to get started in implementation you should look elsewhere..Sam's 'Teach Yourself Web Services in 24 Hours' is a good choice..but then i believe that this book is definitely worth a reference because it goes a distance conceptually.
   Kudos to the authors



5. Without a doubt one of the worst computer books I have ever bought. The intent of buying a book about programming is to actually learn programming. I have fought the XML section until I have a screaming headache with very little accomplished. So far I have found it impossible to get the so-called examples to run. The source code is not available from the publisher in spite of what others may tell you. Yes, there is a file to be downloaded. However, it has almost none of the source code in it. For example, it only contains the source code for one .jsp file for the entire 2nd chapter. The writing style is practically incomprehensible, jumping around all over the place without ever finishing anything. There are nine authors listed on the cover. Perhaps that is why this book is such a clusterf#@k. How did this thing get to a 2nd printing? STAY AWAY FROM THIS BOOK. I cannot stress that enough.

5 comments about Professional ASP.NET 2.0 XML (Programmer to Programmer).

1. I would recommend this book to anyone working on ASP.NET 2.0. XML is the integral part of .NET framework and used widely on all projects.
   Book explains XML classes, Data Validation, XML transformation, XML and ADO.NET, Web Services and use of XML in Web.Config and Configuration files.



2. This book was very useful. It covered a wide variety of topics and explained most topics very well. I would have liked the book to get into some more subjects a little more in depth, but when you are covering so many topics that is a little difficult to do. This book did cover a lot of the new XML classes in the 2.0 framework. I would have liked some more info on the sql server 2005 xml stuff, particulary xquery. The book talked about OPENXML and even made the statement that you should use .nodes for these types of queries now. But it made no mention of how to do so. Overall, this was a very useful text.



3. This is an excellent book covering the XML features of ASP.NET. It is very professional but, not for any beginner. It has the first 2 chapters which pretty much cover the basics but, throughout the rest of the book you need to know what you are doing. It is very detailed but is not really "step-by-step" like 1-2-3...It will walk you through how to do something through reading; so if your not one of those people who don't like to read, I wouldnt fully recommend this book to you. It shows a many screenshots in there so it makes it fairly simple to follow along. The book has almost 500 pages that are completely dedicated to the XML features of ASP.NET. If you are willing to take out the reading glasses and read a little bit. Overall, its an outstanding book!



4. Thiru Thangarathinam is one of the few authors out there who truly know how to teach and convey the knowledge they are presenting. The manner in which he approaches and expounds a topic should be formulated and used in all books. Most books these days simply show how to do the simplest of tasks and never provide real world scenarios. But guess what, in the real world your tasks are never that simple.
   
   Thiru does a great job in not only showing "how to" but also provides best practice tips so that you know "when to", "when not to", "when you do be sure to". These are the things I need to know in the real world. Without a doubt this was one of the best technical books I have read in a while. I will definitely buy any future books that he authors. Glad to see he's a fellow Phoenician also!



5. This is an excelent book. The section about MsSQL server and XML is excelent. I highly recommended

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.

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.