Markup Languages Books

This book was quite helpful to starting up Web Development, although if you aren't looking for 10 opening chapters of web fundamentals, you may want to look elsewhere. HOWEVER, This book will cover all you'll need to know to get deep into HTML.

You won't find anything worth reading until you are 500 pages into the book and that is not a joke. The first 10 chapters is all useless garbage the authors threw together to get a big book. Those chapters cover planning and are written by people that don't even understand the word plan. To help the authors out, here is what Websters dictionary says the word plan means "n. a scheme of action or a drawing made to represent the top view." Hey, that's a single sentance. I just saved you 500 pages of reading.

The remaining 500 pages have dubious value. I mean if you've never heard of HTML and Web publishing, you may want to consider this book. HOWEVER you won't understand a word the authors have to say. I say you can do much better elsewhere.

Includes extensive background material, useful examples and a wealth of URL's covering all aspects of Web development. Good historical information gives the reader a firm foundation. While some more recent information is lacking (i.e., client side image maps), it is still a good starting point for the serious developer.

First, I must admit that I only skimmed the initial sections on web philosophy and design. Other reviewers seemed put off by the depth of those sections. Though I have only built small web sites so far, I very much welcome having a source of knowledge to ensure my larger developments do not look like a poorly organized beginner's site. The design sections are really more than you bargained for, and they don't take away from the excellent discussions and reference material on HTML and CGI. The HTML section in particular let's the reader know which version of HTML supports each tag, so browser compatibility can be ensured. Simple samples that focus on the tags being learned are provided. The book is very comprehensive; hopefully, beginners won't find it too overwhelming. This book is highly recommended.

Very useful book for anyone interested in web development! I applaud Ginsburg and December for putting together this masterpiece. Not only is there abundant information on anything you'd want to know about html and cgi, there's a fabulous section on links. Pick this up while you can... can't wait for a revised edition! BRAVO!

This is a fairly readable introduction to RDF - however, you will need an RDF Reference open while reading. My only complaint is not with the book but the nomenclature adopted by RDF. Some terms used in RDF are excellent, descriptive and contribute to understanding (e.g., subject-predicate-object). Other terms make simple concepts confusing (e.g. "Striped" syntax). RDF is not a new technology - it is an extremely interesting and useful technology that is handicapped by an needlessly ambiguous and unclear nomenclature.

Bottom line - use [...] while reading or buy a supplemental reference.

If you want to know how to apply RDF to information processing, this book is for you. Whether you are interested in large-scale information aggregation and analysis or in smaller-scale projects like weblog syndication, this book provides a solid foundation for working with RDF. If you are looking for a theoretical explanation of intelligent web bots, tutorials on how to create knowledge systems, or an in-depth look at topic maps and ontologies, you should probably look elsewhere. Also, a basic understanding of XML and web technologies is helpful for reading this book, so you may want to start with those first if you don't have any background in them.

The first section of this book (Chapter 1 through Chapter 6) focuses on the RDF specifications. Chapter 1 focuses on introducing RDF, but more than that, it also looks at some of the historical events leading up to the current RDF effort. In addition, this chapter also looks at issues of when you would, and would not, use RDF/XML as compared to "standard" XML.

Following the introductory chapter, the rest of the first section covers the RDF specification documents themselves. This includes coverage of the RDF Semantics and Concepts and Abstract Model specifications in Chapter 2; the basic XML syntax in Chapter 3; coverage of some of the more unusual RDF constructs--containers, collections, and reification in Chapter 4; and the RDF Schema in Chapter 5. As a way of pulling all of the coverage together, Chapter 6 then uses all you've learned about RDF to that point to create a relatively complex vocabulary, which is then used for demonstration purposes throughout the rest of the book.

The second section of the book focuses on programming language support, as well as the tools and utilities that allow a person to review, edit, parse, and generally work with RDF/XML. Chapter 7 focuses on various RDF editors, including those with graphical support for creating RDF models. In addition, the chapter also covers an RDF/XML browser, as well as a couple of the more popular RDF/XML parsers.

To be useful, any specification related to data requires tools to work with the data, and RDF is no exception. Chapter 8 provides an overview and examples of accessing and generating RDF/XML using Jena, a Java-based RDF API. Chapter 9 covers APIs that are based in PHP, Perl, and Python.

After the programming language grounding, the book refocuses on RDF's data roots with a chapter that examines some of the RDF query languages used to query RDF model data, in a database or as persisted to RDF/XML documents. Chapter 10 also has the code for the RDF Query-O-Matic, a utility that processes RDQL (RDF Query Language) queries. The last chapter in the second section finishes the review of programming and framework support for RDF by looking at some other programming language support, as well as some of the frameworks, such as Redland and Redfoot.

The last section of the book then focuses on the use of RDF and RDF/XML, beginning with an overview of the W3C's ontology language effort, OWL. If RDF is analogous to the relational data model, and RDF/XML is analogous to relational database systems, then OWL is equivalent to applications such as SAP and PeopleSoft, which implement a business domain model on top of the relational store.

The next chapter focuses on RSS, the implementation of RDF/XML most widely used, which supports syndication and aggregation of news sources. RSS is used to syndicate news sources as diverse as Salon and Wired, as well as online personal journals known as weblogs, a web technology gaining popularity.

A specification is only as good as the applications that use it, and RDF is used in a surprising number of sophisticated commercial and noncommercial applications. I say "surprising" primarily because RDF is not a well-known specification. However, it is one of the older specifications, and this is a good guide to it.

I started reading the book and very soon realized that even though I was learning a few things about RDF, I was getting stuck with mismatch between text and graphical representation, and other editing problems that can and should be fixed... may be in a new release or in a revised printing. I am happy to have a book to read but by no means I am happy with the quality of presentation.

This book is jam packed with RDF information. RDF itself is a fairly obscure and it is often difficult to find a single mass of information that is comprehensive enough to be useful. This book is definitely a good move towards consolidating the information available about RDF, though I fear that "Practical" is a misnomer, as this is much more comprehensive than practical.

This book is Practical RDF and not "Progamming with RDF (with examples)". Yes, you can find all of the information in this book by searching the Internet. The point is that your results will vary based on who you, how much time you have at your disposal, which day it is, and whether your phone is about to ring.

What Powers and the editors have done in Practical RDF is put the most relevant information (available at the time) in one place, with the typical advantages and disadvantages of a book, such as, you don't need an internet connection, it's operating system neutral, you can make notes in it, it's easy to put down and return to, etc..

I spent the last month researching RDF online. After all that work, I frankly didn't learn much from the book. However, I could have saved myself a lot of time had the book arrived at my door earlier.

We in the information business know how hard it is for our colleagues to embrace semi-new technology. Having a (or several) copy of this bookoin your bookshelf can save you loads of breath. Most people don't take well to "go do your own research." This book contains the research on RDF and is therefore indispensable for all except those who are fortunate enough to work independently.

As noted in other reviews, there are areas for improvement. The technology has advanced since 2003. The original text was probably rushed. This book is due for a second revision, perhaps with more focus on OWL and inference (e.g., take the cwm out for a spin).

For those seeking programming grit, the problem is very similar to programming with XML: which platform, language, and tools do you choose? With XML and RDF, many cross-platform tools exist (Jena, Sesame, Redland). As with most programming books, online documentation from open source tools are likely to be far more useful.

When you want to learn about a largish subject, buy a book. When you want to program, there's no substitute for writing code.

In sum, if there was a book that better educates the uninitiated to RDF, I would mention it here. But I haven't found one, and of course I'm hopeful that someone will write it. Until then, Practical RDF is the best of the pack.

There are two extremely catagories of books.
1. Explain unclear concepts with clear logic and clear language.
2. Explain clear concepts with unclear logic and unclear languege.
This book definitely belongs to the second catagory.
How hard XML scheme syntax could be? This book can screw all of them up.
It wastes of your time if you did not already know what SOAP is.

It's understandable that the author donot have much time in
writing this book. But I think both the publisher and the
author should be serious on writing a book.

Overall, it's not professional!

Sorry to say, but I felt this book was no more than a first draft . At the end of it, I had no clear idea on how to write a SOAP message without refering to many other books or the spec itself. Sure the book gave me a basic overview of SOAP, but not one that I could take away and use, and gave me an overall impression that SOAP is complicated and messy. This was a rushed effort, and a waste of time. If this is one of the best books available on SOAP, then it doesn't say much for the technical authors currently working on it.

I felt this book was poorly organized, and lacking in the type of information I wanted.

Chapter 1 is a history of the computer, starting with the abacus. (I'm not kidding.) Chapter 2 is an overview of XML, which might have been useful except that this book is clearly not aimed at people unfamiliar with XML. Chapter 3 is a rehash of the SOAP specification. While potentially interesting, this chapter (like the specification itself) is a blow-by-blow discussion of very minute details of the SOAP syntax. This chapter would have been better as an appendix. Better yet, just provide a hyperlink to the SOAP specification for those who are interested.

The remainder of the book is made up of two example applications and some "oh by the way" disccusions of issues more or less related to SOAP itself. Chapter 4 discusses a "simple" SOAP application in great detail. This was the chapter I found most nearly useful. Chapters 5 and 6 cover WSDL and UDDI, not SOAP. Chapter 7 talks about vendor-specific implementations of SOAP--a chapter that is already totally outdated. Chapter 8 through the end discusses a single large application built using soap. For me, Chapter 4 was the only one that came close to providing real value.

In summary, this is yet another "talk about anything to fill up the pages" book. If you remove 100+ pages of raw source code, 5 chapters that give general introductions to the history of the computer, XML, WSDL, and UDDI, you wind up with about 40 pages of poorly organized, scattered writings about SOAP itself. Not worth the [the money], in my opinion.

I've read about SOAP and Web Services from other books and have always come out with questions about how certain ideas work "under the hood". I feel that I really understand a concept if I know how it works at the wire level. The problem with many of the books out there is that they give you a very good coverage of the technology but not much insight into the fundamentals. Scott Seely's book on the other hand gives you a very balanced view of SOAP. It discusses XML schemas and the SOAP messaging protocol. Immediately, Scott jumps into implementing a SOAP server by hand which is essential to understanding how SOAP really works (and to learn to appreciate the need for SOAP frameworks that are currently available on various systems). The book is worth just for this chapter, if nothing else. The case study of an auction system puts a nice finishing touch, rounding off a comprehensive top to bottom treatment of SOAP.

I bought this text thinking it would compliment the E-business and E-commerce How to Program text (it was recommended that way). However, it is really just a reconstituted version of the other text, which also falls short of its advertised use. Don't waste your money!

This book was written in easily understood jargon that helped take the mystery out of XML programming for me. Additionally, the links to actual working code allowed me the opportunity to watch it work. The self review and tests at the end of each chapter really ensures that you get everything out of the chapter that you need to continue on. Loved it. You will, too.

I much enjoyed this book as the presentation of complex topics is made very clear. I feel that this book helped me to understand several topics that I never fully understood before (for instance XLink).

Generally the approach in this book is to give a clear and concise coverage of each important topics. This is the best approach to learn but reader should be aware that the coverage is not exhaustive enough for the book to serve as reference. In fact I would have prefered that the author added complete reference on several topics (XML DOM, XPath, XSLT, XSLFO) instead of the 'bonus programming chapter'.

The book is catered for programmers. As a result the table of content will satisfy programmers (unlike many beginning XML books it gives ample coverage of XML APIs) but examples are sometimes non-trivial and written in high-level programming languages. Although generally, it must be said that effort has been made to use various programming languages (i.e. Perl, Java, ASP, etc) so that everybody should find some useful examples.

I would have prefered additional coverage of XML services, SOAP, etc. Also, I found that several chapters (Programming java, programming Perl, etc.), while not useless, were clearly off topic and added to fill-in pages. Only other criticism is that the book is really quite expensive. However, it is one of the best book to LEARN xml (even though you may require additional reference to use it).

One last thing: do not buy the CD ROM training kit of the book. The CD ROM included is very disappointing.

Edit: I wrote this review a while back. Since then, I revisited the book and I must say that it does appear dated. In particular the coverage of schema (an important topic) fails to suitably cover the W3C Schema recommendation and focusses mostly on Microsoft's version of schema which are now hardly used. For this reason, I would recommend another book instead (for instance, Beginning XML from Wrox) until the publisher comes with an updated edition.

I read some of the other reviewer's comments on the book and I agree with some and disagree with others. In comparison to other popular XML books it's not perfect but it's solid. If you are like me, a beginning XML programmer then you need to learn XML hands on and the book gives just that. Giving you examples and problems to apply what you just read is the best way to learn and thats what this book does. I read the "XML by Example" by Marchal and although that was a solid book also, it doesnt give you the material or examples for YOU to practice. Marchal doesnt offer the code samples for download either. One reviewer said that in order to complete this book's self review exercises you have to use outside sources. This is true but think about it...what better way to learn than by being challenged?

I also read some of Erik T. Wray's (O'reilly series) XML book. That book is the better of all 3 books in my opinion but again it doesnt offer you that hands on material that I need. Love or hate the Deitel's books, the bottom line is that until these other authors challenge the enthusiast on whatever topic they are writing about people will always turn to these books. Yes the line by line styles are annoying but you know exactly what functions, (tags in this case) the author is referencing. Theory is great but the only way you will truly know any language you learn is by doing it! Last but not least I DO NOT WORK FOR THE COMPANY!!!!!!

I recently took an XML class at my university, and Deitel's "XML How to Program" was our textbook.

I have to say, it's one of my least-favorite XML books--nay, one of my least-favorite *computer* books overall.

Sure, it's thick and heavy, something many geeks like in a book (myself included). But within the covers are sometimes rambling discussions about a particular topic that leave you still wondering what you were supposed to learn, while other sections get cut short just when things are getting interesting.

My biggest beef: You won't be able to complete some of the exercises without the use of outside resources. Of course, multiple sources are great for any project, but you should certainly be able to answer a book's exercises with just that book! (Specifically, one exercise was within the XSLT chapter, and deals with a number-type element.)

When I was assigned to write an essay on a topic, XML Topic Maps, I first consulted the book. Only a couple of paragraphs as I recall. RDF, an up-and-coming XML technology, gets nary a page.

Mind you, there is a bit of good in the book, mainly with the introductory material. It's a bit Java-centric, but that's to be expected, and there is a decent Java primer in the back of the book. I also appreciate the code samples on both the CD-ROM and Deitel's Web site.

I wanted to like the book, but I found it useless for most of the projects I was working on. In a different class, we used Marchal's "XML by Example, 2/e", and I vastly prefer that book over this one. Especially with the price of the Deitel book, I can't recommend this one to anyone.

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

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.

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.

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

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.

Shipping a new CD is not an acceptable resolution. Why is there not an errata page on the Wiley web site along with downloads for the examples in the book? Why does the book not have its own URL? Why does it take at least three redirects and more than two minutes for the Wiley.com/compbooks web site to load?

The back of the book proclaims, "This is it - the only XMLSPY reference book authorized by Altova, Inc." which is not true, there is also the "XMLSPY 5 User & Reference Manual."

The content of the book is acceptable, if limited, but I am not happy with the quality of this book or the service given by the publisher. But if you are committed to use XMLSPY, which is a pretty good way to develop XML applications, this book and Wiley may be your only choice. The Tutorial in the software is very shallow.

I just finished this book cover to cover.
One should keep in mind while reviewing any literature on xmlspy, that there is a wealth of things one can do with this tool. And that it takes huge volumes to cover all those details.
Considering that this 326 page book has done a good job.
The book will definitely get you started.
Only the first 250 pages are useful. The chapters on WSDL, SOAP are too abstract to be of any use.
Also in the first 250 pages, the 2 chapters on XSTL are not done well. I was surprised to see a lot of dead code in the snippets printed.
I also came across a lot of printing errors.
Oh yeah the CD provided is for some dummies series XML book. The software was unusable.
So you are actually buying a book with around 150 pages. But I will still spend that money if I am given the opportunity to decide once again.

Hopefully there will be a revised 2nd edition.

Shipping a new CD is not an acceptable resolution. Why is there not an errata page on the Wiley web site along with downloads for the examples in the book? Why does the book not have its own URL? Why does it take at least three redirects and more than two minutes for the Wiley.com/compbooks web site to load?

The back of the book proclaims, "This is it - the only XMLSPY reference book authorized by Altova, Inc." which is not true, there is also the "XMLSPY 5 User & Reference Manual."

The content of the book is acceptable, if limited, but I am not happy with the quality of this book or the service given by the publisher. But if you are committed to use XMLSPY, which is a pretty good way to develop XML applications, this book and Wiley may be your only choice. The Tutorial in the software is very shallow.

This book shines light on the pillars of XML: XML, XSL, and XSD (schemas) with simple procedures to create and manipulate XML documents. The book is organized with each major technology in its own chapter, or basic and advanced features in 2 chapters (great for learning/mastering a particular aspect of XML, such as XSL stylesheets).

Respectfully, the flame comments about the wrong CD coming with the book seem irrelevant now -- the book now comes with all the exercises and an incredible 90-day trial version of XMLSPY (the normal download trial is for 30 days).

The information builds logically, walking you through simple examples to introduce the XML terminology, then adding nitty-gritty fine-level details demonstrating, in context, what would otherwise be abstract and complex terminology.

I enjoyed the casual, friendly writing style. There are asides about some features defined in the XML standard, but not used in the real world. Other times the author points out the way he generally does something. There are several quick procedures using the XMLSPY editor that would otherwise require repetitive or manual actions.

There's a chapter on WSDL. I haven't read it yet (loaned the book to a friend learning XML), but a local MSDN director raves about being able to edit and examine WSDL visually with XMLSPY.

THE BEST FEATURE of the book may well be the 90 day trial version of XMLSPY Enterprise Edition. The 3 months use of a $400/$500 program the CD gives you for the cost of this excellent instructional book!

NOTE: If you can read and write schemas by hand, you probably won't need all the info on XML terminology and simple examples, though you'd probably still benefit from how to do things with XMLSPY and the full 90 days to explore it.

Shipping a new CD is not an acceptable resolution. Why is there not an errata page on the Wiley web site along with downloads for the examples in the book? Why does the book not have its own URL? Why does it take at least three redirects and more than two minutes for the Wiley.com/compbooks web site to load?

The back of the book proclaims, "This is it - the only XMLSPY reference book authorized by Altova, Inc." which is not true, there is also the "XMLSPY 5 User & Reference Manual."

The content of the book is acceptable, if limited, but I am not happy with the quality of this book or the service given by the publisher. But if you are committed to use XMLSPY, which is a pretty good way to develop XML applications, this book and Wiley may be your only choice. The Tutorial in the software is very shallow.

I too found it difficult to find an XML book dealing with Specifically .NET. This book does a good job in alot of respects, but falls short and wanders off the subject a bit in some chapters (this of course can be skipped over.) The author does give alot of real world examples through out the book, which is always a plus. Overall highlights in what I learned:
Serializing / Deserializing XML in .NET
.NET XML Base classes and their Implementations
SQL Server 2000 interaction with .NET & XML
ASP.NET Web Services (you create a public Address book Web Service)

It even has a decent reference section at the end dealing with XSLT that I find I use frequently.
This book represents (at this time) a great bargain!

This book reads like a medical journal, point-by-point layout out the facts and presenting very narrow-minded interpretations of what ASP.NET and XML are designed to do. For one thing, the authors exude an opinion in their writing that ASP.NET is useless without XML, and that XML is the greatest thing to come along since the transistor. I disagree with the sentiments, but that's beside the point. This book doesn't accomplish anything in the end but to confuse the reader. It's as if the authors are trying to impress you with how many acronyms they can spit out in a single page (I counted over 30 on one particular page). This is not writing, this is not teaching, it is shooting facts at the reader with a shotgun.

In retrospect, I read this book a year ago when I was new to ASP.NET (but not to XML). I find it useful for storing read-only data in XML to be used in ASP.NET web sites. However, it's still one of the dryest books you will ever find.

This book (in my opinion) is for those more interested in XML alone than its use with ASP.NET. I was looking for a book that combined the two effectively, but found this one to be very difficult to read, with topics discussed without definitions (only references to chapters ahead of the current one), and little introduction to .NET or ASP.NET. There are very few examples, and even fewer pictures to display the effectiveness of the examples. Maybe I need to spend more time digesting the material, but there is little use of ASP.NET in this book... and even less integration of the two technologies. This is not for anyone interested in eCommerce or strictly internet programming.

This book is by far the best information out there on xml in the .net framework that I have seen yet. (And trust me, I've looked.)

This book is well-organized and jam-packed full of useful information on a very wide variety of subjects. More than just your run-of-the mill red covered book that regurgitates the documentation.

As for other reviews, I suspect it's like many newbies in programming. Laziness is clouding their judgements.

More about XML than "XML and ASP.NET." I have already read a lot on XML and this book just confused me about what I already knew. It is full of definitions that don't really define anything and is lacking in good examples. I have read many, many books on programming and on the .Net framework specifically and this is by far one of the worst. After I know XML well I am sure that I will come back to this book and understand it completely. I am very sorry that I wasted my money on this book.

I decided to purchase both Wrox's Professional PHP4 XML and New Rider's XML and PHP. Now, I'm not a dumb guy. I've been programming for awhile, but I'm still learning all the time. I like to build object oriented code in PHP as I believe it's the best way to go for several tasks (although not all). I'm still learning how to apply design patterns and the like and I find that very interesting. So when I pick up a book, I really want to see an author care about objects rather than putting all his code in the toilet - That's what this book does.

Even further, the examples are so basic and the chapters don't explain anything beyond those examples either. I'm surprised people found this book useful since everything is obvious that those university computer science monkeys who are still learning Windows can figure this book out.

But where are the best practices? Where are the examples used within an object oriented architecture? Do you think we are idiot programmers who only know how to code procedural programs that all reside within a single server page. Get real.

On the other hand, I was very impressed with the Wrox book. Although some of the intro chapters were fairly useless (since they covered intro to PHP concepts and so forth), the chapters talking about SAX, DOM, XSLT and XML-RPC are much better and totally outshine this book's counterparts. They even discuss Object oriented programs in all most cases and will provide you both versions a lot of the time! Even further, the Wrox book shows you various examples about solving common problems. I actually think the authors showed me all the potential problems you can have for that matter; they were pretty detailed, especially in the SAX and XSLT chapters.

After reading some of the reviews about XML and PHP, such as "This book doesn't suck" or Manual Lemos's review (a guy who contributes a lot of PHP code to the community) stating "this book was the best on PHP and XML available", it's obvious that they have ties to the author and want to see him succeed. Don't let them pull you in - this book isn't even worth the sympathy.

Xi Chi's review was right on the bull's eye. I should have listened to it and so should you. Avoid this book like the plague and get Wrox's PHP4 XML book instead.

Vikram Vaswani wrote a very focused book, covering every aspect of PHP and XML integration, with dedicated chapters on SAX and DOM parsers, XSL, WDDX, XML-RPC and SOAP. I think that PHP 4 is still lacking in the area of XML integration, but intermediate and advanced developers can still perform a lot of tasks using this combo. The book is clearly written; it covers a lot of different extensions and third party libraries with full code listings

Chapters two and three start the book with good examples of SAX and DOM use in PHP respectively. This provides a solid foundation for the rest of the book which shows examples of popular XML based technologies as applied to PHP. These include XSLT (Sablotron), XML-RPC, SOAP, XML in databases and other topics. Each of these discussions contains some real world examples to provide context.

It's a short and concise book that is well written. The use of graphics could be more effective. For example the screenshot in figure 6.8 is a single line in a vast sea of whtie browser space. The code sample could use some annotation or at the very least some bolding to hi-light the important segments.

The value of this book will depend on the degree to which you use XML in the PHP context. If you want a quick booster rocket to get you into SAX or DOM work within PHP this book will do the trick since it's far better than the documentation on the PHP site.

I've been reading this book recently (6/11/2004). With regards to DOM and XML, it's very out of date given the current development of PHP. Would advise newer, more up to date book if you're interested in DOM and XML.

I've been reading the book, and had a feeling it explained a lot.
Finally, i could use it, but the code used is very outdated (01-2005). That's why i visited their website.
as the book refers to the site often.
http://www.xmlphp.com/
check it yourself, no updates, the forum is closed.
why did i buy this book?

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.

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.

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.

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.

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

well after reading some parts of the books.I have to cry over my lost money. This books is taking you nowhere ,and I dont know what is the main purpose of this book.May be if you have enough time, take this book with you to the jungle or to a seaside perhaps. I can better peruse through many more sites in internet to get much better knowledge.

A book that takes the reader all over the place. The author pretty much cut and pasted the words from numeruous sources(plagiarism comes to mind) The author is neither an expert nor very good writer. The MSDN contains the same exact information so go there and save your dollars for a better book.

I can't say enough about this book. The content is well organized, and very well written. How often do you read every page of a book about programming?(esp. this publisher)

What is key in this book is not the choice of browser (or XML) , it is the principles.

Buy it or borrow it, but you must read it.

huh ?? what is this book about ? absolute waste of time.

I was more than excited through the first chapters to see that the level of the author was very high in theorical and/or philosophical content. But it faded out when I saw that this book did not really included real-life examples or case-studies.

A problem that I often see is that the examples included in the book are just like data island, they don't know about each other and let us decide where we can really use them.

This book does have one small case-study toward the end but it does not reflect so much the high theorical level of the beginning.

As mentionned in a different review, a lot of buzzwords, and it's true; then again, this book DOES give you a GREAT THEORICAL aproach to SOLVE Distributed Applications PROBLEMS, but lacks in it's bringing us a good implementation of solutions (even though the level of coding was fairly high).

What I hope in the future, is just a book that will join all those buzzwords into one great application with all those technologies & softwares.