Markup Languages Books

It's February 2001, and this book still does a better job of explaining what XML is all about than ones with a 2001 copyright date. St. Laurent's understanding of a Primer is right on target. Instead of having tons of code for the reader to cluelessly hammer out, he explains how XML works, and so when the reader does code the examples, he understands far better what's going on. The explanation of the Document Object Model is unmatched in any of the other books published on XML. Likewise, the crucial topic of Document Type Definitions (DTD) is handled far better and in intelligent detail than anything published since.

Unfortunately, XML is deceptively complex. While it doesn't take a rocket scientist to crank up an XML file, toss in some CSS and claim XML is yet another programming language one has conquered, understanding how the DTD works requires more than a couple of examples and a reassuring pat on the shoulder that the reader can do it in an afternoon. What St. Laurent does, and does well, is to prepare the serious developer/programmer for understanding XML. To be sure, the book represents a foundation for using XML and is not an entire treatise on all that XML can do. However, unlike some of the books I've seen on XML that contain code that will not validate (including on their CD ROMs), this book gets it right. If you want to get XML right, this book is the place to start.

Data organization is XML's strength, making it an excellent mechanism for transfering information from one application to another -- whether it is a database, a legacy system, or a web site. Strangely, the author never really gets the point across.

Even near the end of the book, the author only briefly mentions the XML parsing tool called SAX (the popular XML/Java API). Unfortunately, he fails to provide details on it use. SAX offers an easy way for computers to read an XML file and extract the data. Perl and Active Server Page APIs are also available for those who do not program in Java. But, data organization is only one of the strengths of XML. Many others exist. (The author misses these, too.)

This book is the worst technical book I've ever purchased. If it were feasible, I'd give it negative stars. If you are interested in learning AND using XML's capabilities, check out David Hunter's "Beginning XML". Compare the table of contents. You'll see the difference.

I'm a web developer who knows both HTML and CSS. I bought this book wondering what the world of XML could be about. I was told that it was the "future" of the internet or something. I browsed some online tutorials, and found that this was not just some simple language you could learn in a couple weeks. As I opened the book, I started reading the introduction. The beginning of the book is very interesting because St. Laurent gets into much detail about where XML came from and the roots of practically every language it derived from (like C). But as I read on into the book, he was very wordy. this book needed a CD-ROM with it. The language itself is very simple. But there are many rules that you must follow. To a typical, experienced developer his language is probably most understandable. As I was reading about DTDs n such (i had to read it over a bzillion times) I got even more confused. Finally, I just decided to put it down. His explanations were NOT in layman's terms so the curious user could understand. True, he did give lengthy explanations, but it could be because I read it all during school in small snippets. I never tried out his onlione stuff he has pasted all over the book. What I'm saying is I don't think this book is for curious new users. Maybe users thatr understand all the basic stuff, then just wanna use it as a reference or be told why exactly something does something. A user said earlier that he doesn't leave the reader guessing random code. Well, if you flip thru the back, you can see that the lengthy code pages offer tiny explanations. The IS a ton of code pages. Just thought I'd point that out. I would not recommend this book to anyone. The cheapest is not always the best.

I first read this book a few years ago, and still read excerpts from it periodically as friends get involved. In one of the early chapters, St Laurent basically asserts that WYSIWYG was actually a technological setback. I knew at that point I was going to enjoy the book.

If you're into computer science, and want to understand the technology - this is a great place to start.

Some people appear to really like this book. It has received many glowing reviews, but I can only shake my head in disagreement. This book is a dud -- too much text, and not enough practical advise or code examples.

The author could not adequately describe how to use basic XML components such as Document Type Definitions (DTDs), and failed to show how Cascading Style Sheets (CSS) can be used to display XML on the web.

If you are a web programmer or need to do something useful with

XML, look elsewhere. This is not the book for you. In fact, I'm selling this book. Wanna buy it? I'll use the proceeds to purchase "Beginning XML" by Kurt Cagle. That book looks promising.

At the time, I was determined to learn HTML 3.2 without the help of a purchased book. I downloaded the W3 consortium's HTML 3.2 document. I soon realized that examples would be nice. I broke my promise and bought Laura Lemay's book. I was glad that I did! Her style might not please everyone but, I found it humerous and enlightning.

I found the chapters on tables and frames very, very helpfull. For me, Laura's book was an excellent buy and would recommend it to any beginner!

After a half dozen editions you would think Lemay would be able to get this right! This simply isn't the case. The main reason HTML 4 is in the title is to get your money! HTML 4 is little more than a footnote in this book. Lots of other things are little more than footnotes as well. This is very distrubring. If the book doesn't cover what you need what does is cover? I can't answer that. I can say that this isn't a book for anyone who want s to learn HTML

Notoriety maybe. A good book? Teach Yourself HTML may have brought Lemay notoriety but it was hardly because the original book was good. It was more a matter of timing. At the time there were only a few other HTML books and lots of people wanted to learn publishing for the Web. Lemay has a knack for timing. Her Teach Yourself Java hit the peak demand period as well. It too sold well in the first edition but again this was timing not because it was a good book.

Teach Yourself hit the streets with the Mosaic browser and Netscape version 1. The Web has advanced tremendously since the days of Mosaic and Netscape 1. Unfortunately Lemay's understanding of Web technology hasn't. Lemay doesn't have a clue about the current state of the web and this book reflects that lack of understanding.

As far as web books go this one is a dud. Readers of all skill levels (Yes beginners too!) should look elsewhere. For beginners who just want the basics I recommend Castro's Visual Quickstart Guide to HTML. For beginners and intermediate who want to know the whole story I recommend Web Publishing Unleashed Professional Reference Edition.

Lemay has been slammed lately for spreading herself too thin, and in many cases this criticism is deserved. But this book (or its predecessors) is what brought her enough notoriety to be able to spread herself thin, and I personally don't believe that it deserves the criticism other people are giving it on this page. Would I buy it to learn about HTML 4? No. But it is a good introduction to and a solid reference guide for HTML; a well-used copy of the previous edition sits within reach of my desk. If you don't really care about all the cutting-edge intricacies of HTML, but are more concerned with creating a usable site, I would definitely recommend this book, along with a copy of the CGI/Perl Cookbook

This book is great if you want to start creating a wepbage in a week. I read the parts I felt I needed but nothing is left out if you are just starting, and the books gets to the point telling you directly what you need to do to get what result.

...and not for a beginner. Filled with samples and graphs-which somewhat help the extremely confusing writing style. Bradley's style reminds me of the teacher I had when I was 10 years old who found it very easy to go off on a new tangent--and very difficult to be brief, concise or clear.
Fine for a reference, if you already know what you want.

I loved this book. I've got about eight or ten XML books, but this is the one I turn to for my "Why?" questions.

It's not a tutorial or cookbook, but it explains XML logically and historically. I don't sit down at my computer with this book ready to type in stuff. This is the book that I sit down with in my comfortable armchair ready to understand XML in a way that makes sense and sticks with me. It's very readable.

I bought this book when I was still trying to get my head around XML and found it much more confusing than clarifying. However, many years later, once I had a solid foundation of XML, I pulled this book back out and actually did find it mostly useful. The author covers a lot of minutia that is difficult if not impossible to find elsewhere (he devotes an entire chapter to whitespace issues, for example), and if you really have a need to understand what is going on under the hood, this book can actually serve as a handy reference. Still, I do think the material could have been better presented - chapter 6 discusses "Architectural Forms", for example. I have read and re-read the explanation several times and still cannot fathom what they are or why they would be useful... there are quite a few such topics in the book.

1. Depth and breadth of topics being covered with real application make this a solid reference for XML applications, such as Apache Cocoon 1 & 2 Frameworks. Java is indeed a natural companion to XML.

2. It is not a cookbook of raw XML/XSLT/CSS/XSchema/XLink/XInclude/XPointer, etc... It actually explains the Design behind the implementation leaving one to approach implementation with foresight and focus on planning before one wastes needless hours of frustration during rushed implementations.

3. It is for someone with a solid understanding of MVC (Model/View/Controller) abstraction approaches that are pervasive in OOA/OOD that includes Smalltalk, Objective-C, Java, C++, C#, Javascript, Python, Ruby, etc...

4. It describes XML as a means to be both a boon for turning publishing into an Art of Reuse as well as how XML solidifies many failed attempts of standards that were not able to become language agnostic. XML and all her siblings are that meta bridge.

5. With the XSL Companion those who complained about it being either difficult to grasp or tediously complex will be vindicated and appreciate returning to this book to explain all the questions that surface along the way during any project they become involved in helping solve.

6. Neil is very honest that this book is about wrapping your head around the XML paradigm and not about being a Dictionary of answers to all your XML application(s) needs. It should become clear the reason behind so many XML application standards. There are just so many avenues to address how could they all possibly be expressed in just one book?

Bradley's book is a pretty complete guide to XML and related technologies. The main chapters are almost tutorial in style, with plenty of code examples to follow. The end of the book contains a small reference section. The topics covered are XML, XSL, XSLT, DOM, SAX, XPath, Schemas, XLink, XHTML, and CSS. Discussions are for the most part clear and accurate. I have two main complaints about Bradley. First, the prose, while accurate, is often overly verbose. It could be written more concisely and compactly. Second, each chapter is broken into sections, but the sections are not numbered, so it is difficult to locate material in the text. The main advantage is the comprehensive general coverage of XML-related technologies. Buying this one book will arm you with the knowledge to develop XML applications and content, and it will save you money. If you have very specific needs, you may need to supplement Bradley with another more focused text that delves deeper into a particular technology. Also, if you want to see longer applications presented as case studies, you might want a different text. I recommend this book for beginning and intermediate XML users who want broad, general coverage in a single book.

The careful reader will observe _Core JSP's_ chapters and examples extend further into areas of in-the-trenches applicability more than any other book on the subject. It's sitting on every one of our programmers' shelves.

At first this book seemed great, but now that I have had to work a lot with JSPs, I have seen some serious shortcomings. The TagExtraInfo class get's way too little coverage. The book doesn't even begin to explain how to actually use it in real work. That's a serious shortcoming.

I only just started this book and I am already frustrated. No instructions on how to get the software you need or how to use it. The versions on the CD-ROM are outdated meanwhile. But what is really bad, the first "useful" JSP script in chapter 2 is already so full of code errors that you cannot run it! It took me hours of debugging before I made it run - how are you supposed to be debugging the stuff you are supposed to learn from? I will try to read a bit further but probably have to get another book.

The book has a lot of information about a lot of things but never nails down the subjects completely. For example, the book states you can do this, that and the next thing but never actually guides you through it.--> I guess you gotta spend [more money] to get that information. Another example is Chapter 11 on Custom tags. I read that chapter three times and still didn't get the point until I read some other literature on the subject. After that ordeal I felt as though my head had been used as a speed bag!

I also have found errors in the code and that should not be. Don't these authors have someone test the examples before they put out the code?

I wish the authors of computer books would just get to the point when they are trying to explain a subject(much the way Herbert Schildt does). I went through about 70% of the examples and found better ways to accomplish the same tasks on my own with less code. Learning programming is not difficult if the material is presented in an appropriate manner, however, this book will remain on my shelf and probably never be opened again.

My advice -> Try another one!

This is a good book under any circumstances, and if you develop with Oracle, it is even better, because there are many examples of JSP and Oracle JDBC, and while JSP/JDBC is intended to be database independant, it is easier to learn when the code is written for the database you use. There is a lot of useful information that will help you speed up your connections, pooled connections (which Oracle supports), and techniques for using synchronized statement to protect them. Synchronization is familiar to thread users, but well explained if you aren't familiar with the concept.

One thing the authors omit is setting autocommit off after making your JDBC connection. The idea of autocommit is to make JDBC "friendly" to certain non-Oracle databases, but if you understand transactions, you want to control when a commit occurs, and undo the entire transaction if you don't like it. To quote Tom Kyte, you never want to commit until you have to (slows database down) and you never want to commit part of a transaction. If your procedure should just update a single row, you can check the result before you commit. Setting all the banks accounts to zero may not be a transaction you will chose to commit. Checking a result is easier than explaining one. This is the kind of database specific information that perhaps authors writing for many platforms should ignore, but you may find it useful if you work with Oracle.

The authors show you how to use bind variables with prepared statements, and callable statements, but don't really go into the downside of not taking their advice; if you don't use bind variables, you will not have a scalable application. A lot of JSP examples (even in Oracle documention) do not bother with bind variables (example code is shorter if you don't) but "Core JSP" shows you code that is proper for scalable applications, and you can follow it (use the examples you find elsewhere as concepts, not as code to put in your applications).

This is a tiny portion of what this book will teach you, and if you are new to JSP and want to get a non-trivial application working, and scalable, this is a good place to start (also this is not an expensive book, which helps). This is all you need to get started, and see the value of JSP.

Don't waste your money. This book isn't supported any longer by the author and publisher so the code is no longer on the web. The code inside the book is so disjointed that I found it impossible to follow. They shouldn't be selling expired books.

This book was suprisingly useful. I bought it to understand how to connect Flash to XML server back ends, but it quickly taught me much more that I was not expecting. The true value of this book is teaching how to use Actionscript 1.0 to make Flash Clients talk to servers with the fastest, leanest possible code (Not necessarily XML.)

The author does a great job of teaching how to make reusable, tiny, elegantly structured modules to build a trivia game. The lessons in here should be required reading for any Flash Actionscript programmer BEFORE they can use any fat Actionscript 2.0 components. By reading this book, you can avoid torturing your users with the "Loading Forever" progress bars which result from using Flash without understanding it's elegant, fast loading, optimized roots.

I used this book to add database capabilities to our flash app, and could not have done it with out it. Well, perhaps that's an exaggeration, but it would have taken *significantly* longer.

Getting flash connected to a database requires a combination of good strategy and lots arcane nitpicking details that span multiple knowledge domains. The book brings you along, step by step, in making the app dynamic. The discussions of database design and implementation via PHP and mySQL were very useful.

The book was written during the day of Flash 5, but aside from a couple of outdated screen shots, the ActionScript is current with the version 7.

There were a couple of places where some explanations were a little light, but all in all, it was worth many times the price I paid for it.

Authors have deep understanding of the subject, which is
eveident in their clear and simple way of explaining things.

I have to agree with other users who point out the book's awkward construction. It's sort of a mutant blend of a hands-on how-to book and a broader discussion of Flash and XML. As the authors ramble through the creation of an XML-based quiz engine, they abruptly propose different ways of addressing coding issues, then move on to the discussion of another coding aspect without telling you which of the two or three or four options you should have plugged in in order for the next set of code to work with it.

By mid-2004 this approach is even more awkward as you discover that some of the hands-on steps they tell you to carry out no longer work in Flash MX or Flash MX 2004; there's nothing on the cover or the introductory material to warn you that the authors wrote this for Flash 5.

According to an e-mail I recieved from Wiley, "Wrox Press Book Company was liquidated in the Spring and no longer exists. The books were sold to various companies. Wiley acquired only 34 of the over 350 books and the rights to the www.wrox.com website address. You'll find the complete list of books currently available from Wiley/Wrox Press at http://www.wrox.com/misc-pages/booklist.shtml "

This book is not on that list. That means that the publisher no longer provides support for it, and it will probably never be updated.

I bought this book because it was one of the very few books available that covers using XML in Visual Basic. Altho not the easiest book to follow, it does contain a great deal of useful information. Unfortunately, both VB and XML are changing rapidly, and the information is getting out of date fast.

By the way, don't even bother sending in the registration card that comes with this book. Wiley didn't renew the business reply permit, so the card will just bounce back in the mail.

Although Microsoft has moved on to VB.net, many developers are still using VB6. It has become increasingly hard to find VB6 XML info on, say, MSDN, so a book like this is essential.

The code examples are clear and practical. The book manages to work well both as a how-to and a reference. If I were to nitpick, there are two things would mention. First, because of when the book was published, it does not cover the most currenrt version MSXML. However, porting the code samples to newer versions of the DLL is quite easy. Second, the book does not come with a CD. An HTML or PDF version of the book, with a searchable index, would be sweet.

Overalll, though, this is a good deal if, like so many, you are still working with VB6.

This is has been a disappointment for me. I purchased this book because of a project I am working on. It told me everything I already know and gave terribly laid out examples.

I was never quite sure working through the examples if the code was required or if the Authors were merely showing us what they could do with XML/VB.

I purchased this book to learn to do DOM programming, not to use the code provided by the authors. I was hoping for clear examples, instead I got a book that expects me to download their sample code or type it all in (and there is ALOT) in order to easily follow the samples. Typically this would be fine, but a majority of the functions and classes you can download are poorly explained, or not explained at all. This book is more like instructions on how to use a lot of code written by the authors to manipulate XML.
I own two other WROX books, these book were easy to follow and gave just the right amount of code to get me going. This book does neither. Big disappointment.

The following is a sentence from page 131 paragraph 1 of this book: "After declaring a generic Node object to serve as the parent node for the new node, and a variable to hold our function response, which we optimistically set to True - which will be changed if our attempt at adding the node fails, we check to see if the node index is within bounds, using IsNodeIndexOK, described just after this function."

The logical flow to the entire book in not much better.

This makes learning anything about XML and VB difficult. I have spent more time attempting to determine what the authors are tring to say than I have learning about XML.

I was able to work with the sample code to some extent. But even the sample code was incomplete and more difficult to follow than necessary.

With a complete rewrite this could possibly be a good book.

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.