XML Books

I don't use XML very often. When I come back to it, it's like learning XML all over again. That's why I like Megginson's book. It's clear, detailed and gives all the basics needed for competent, flexible data design.

I said "data design," not "document design" as some might have expected. Although XML grew out of SGML, a document markup system, it's used for lots more than just text formatting. That's why Megginson focusess so heavily on the DTD, the "data type definition" for any XML application. Any one document uses XML commands to organize a specific set of data, and the DTD specifies a well-formed organization. It's the grammar of the document, like a database's schema. It's what defines the principles used to organize the data. Best of all, Megginson describes DTDs in terms of five well-known and freely available DTDs.

This book is old by internet standards, however. DTDs are being supplanted by XML schemas, which are not mentioned. Conversions between formats are now managed by XSLT most often, not "architectural forms." The DocBook standard has moved to the Oasis consortium (oasis-open.org). The XML standards family has grown, but this book is locked to the time in which it was written.

Even then, I had one real complaint about this book. Megginson took great care to distinguish XML from its SGML parent, giving detailed descriptions of SGML features not present in XML. It was sometimes confusing to read around the discussions of features that aren't there. If necessary at all, the information would have been better placed in footnotes, appendices, or some text typographically set off from the main discussion.

I'll have to replace this book sooner or later, but I haven't found anything that discusses newer XML usages and still meets this standard of clarity. In the mean time, I can keep puttering along with this book - it's old, but hardly obsolete.

//wiredweird

This is an excellent book for someone who is responsible for creating and maintaining dtds for large projects. The purpose of the book is not to teach the beginner what a dtd is. Rather it is meant to teach you to tell the difference between good dtd design and bad. The emphasis is on dtds that are for complex documents rather than those that are for transmission of database records. None the less, some of the material applies to both types of dtds. The author does not tell you what to do. Rather he tells you what issues you need to consider. There is a section that warns you of the problems that may arrise during the maintenance phase of a project. When a change is made to a dtd, there may be a backlog of legacy documents that were valid according to the old dtd but are no longer valid with the new one. I think this section of the book is a bit too methodical and long-winded. Even so the issue is crucial and needs some treatment.

The best book available... it covers everything you need to know about DTDs.

I guess this book may have originated as an SGML book so has examples oriented more towards SGML authors. These examples are not oriented towards Internet Programmers.

Still, the author did a pretty good job at seperating XML and SGML specific details.

Simply put, If you need to design a DTD then you need this book.

This is not a book for beginners. There's a brief introduction to XML, but you need a fairly good grounding there before picking this book up. The author uses five industrial-strength model DTDs for documents as a basis for discussing the analysis and design of DTDs. These are briefly introduced, compared and contrasted. HTML is one of the five, not so much because it's a good example, but because it's widely known and used. The heart of the book is devoted to principles for analysis and design. These focus on the user -- ease of learning, of use, and of processing. Some desirable features tend to conflict, for example, there's a trade-off between simplicity and providing sufficient features to meet authors needs. Throughout the model DTDs are used to illustrate principled (or unprincipled) desgin. All in all, the book provides a good basis for reading, writing and understanding non-trivial, real-world DTDs.

This book delivers exactly what it says it will: the _whole_ gist on the technical aspects of drafting a Document Type Definition and on the theoretical aspects of defining an optimal way of structuring information. The author dominates his subject and his discussion on the fine points of information structuring is clever and challenging.

The only thing that is keeping me from giving it an otherwise well-deserved five-star is the utterly meagre index, a surprising fact in such a book!

This book hit the spot for me. They provide a wealth of ideas and recommendations on how to create well structured, reusable XML schemas, along with good guidelines on the various strengths and weaknesses of different choices. It definitely gave me a lot of good information, and a good feeling for what is possible and what is important in designing XML data models. It's not an easy read, as it requires a reasonable comfort with XML Schema, and the terminology is fairly technical, but once you get used to their style, it's quite clear.

There isn't much real content in this book and you have to trudge through a lot of vague and cumbersome writing to get to it.

Here's a representative extract:

"What should be obvious to any practitionaer is that effective engineering of a schema requires expertise with metadata and related data archtitecture disciplines. Wihtout a metadata and data architecture focus, the broad proliferation of nonstandard and ad hoc XML transactions and schemas will be seen, resulting in increased data disparity, integration complexity, and a failure to reduce related technology costs." (page 197)

It also has a very poorly produced index, which makes it far less useful than it might have been as a XML schema reference book.

I must not have gotten the same book that the other reviewers got. I rarely write bad reviews. I've normally researched the books I buy pretty thoroughly. But I screwed up this time

It reminded of those "C" language style guide books. Some people get into that stuff I guess....

The content of the book is very appealing, but I found many problems:

- a good knowledge of XML schema is required
- a good knowledge of data modeling topics is required

If you have the required knowledge, you will find a lot of obvious things, that you maybe already know. Some hints and methodologies are useful, but they represent only a small portion of the book.

If you don't have the required knowledge, you will find difficult understanding the "big picture" from which the ideas in the book are derived.

I don't suggest buying this book.

At first I was somewhat skeptical due to a couple of negative reviews. However, I was desparate. The other XML books I've read (and fallen asleep with) seem to be restatements of the W3C specifications. I am a DBA/Data Architect in the midst of an international Web Services and SOA project and I needed something fast. As it turns out, this was probably the best investment in reference materials I've made in a long time. I guess I am not really sure what the other reviewers missed, but this book was perfect for me. I hold mixed roles of DBA as well as Data Architect - data modelling mostly. Recently, I was tasked with trying to determine why and how all of this XML stuff fits in a SOA project, and from the data perspective. Although I've been a DBA for too many years to share, I've positioned myself mostly at the persistence layer. This book really opened my eyes. Thorough, concise, and very focused on what "data folks" need. Five stars were a must for me.

Superb organization and presentation of the material. All code functions, all examples are relevant. Excellent development of the topics. Were all texts to be this will organized.

I am just learning XML for the first time and this book walks me through it the way I need to be walked through it.

Some experience with HTML might be mandatory. But, the examples are excellent and easy to follow. And the text is neither dry nor simple minded.

I am one of those freaks who would look at a bezillion books before settling with one. (Talking about computer books ofcourse!). This is especially significant when it comes to XML because there is so much tech jargon out there & it is really hard find a book that does not get lost in the details & instead introduce us to the core right away. This book does exactly that. You will start writing decent xml right away.

The following will be helpful.

1. HTML knowledge (a little)
2. The concept of scripts
3. The concept of CSS
4. The concept of XML

When I say 'the concept of', I am only talking about a surface level, "Purpose of existence" kind. Even if you don't know anything about XML, you will be fine with this book.

The book gradually introduces the concepts & does a very neat job of explaining new ideas.

Peace.

This is a book for beginners. I bought the first edition and it gave me all the important information about XML before I started working with it. When I first read it, I thought it was a wonderful book and it was very easy to understand. You will now what's XML in one week and you'll be able to start using it in only two days just by looking at the examples.

Unfortunately, right now I know there's so much more out there about XML than the information contained on the book and believe me, once that you read it, you are never going to used it again because it's not a good book for reference.

I would recommend you to look for a different book with more examples, source code, advanced features or even one that can be used as a reference in your future work.

I didn't really read this book because I didn't need the information yet, but I think it's a great book to have in your collection.

When I was told that this book was going to be used for my technology class I was kind of excited because I am fairly familiar with the Lynda.com material. I had picked up her Learning Flash 5 CD-ROM and walked away with a feeling that it was money well spent, and that I had come away with a great deal of knowledge about Flash. Now keeping this in mind, when I picked up this title and read through it (mind you unlike some reviewers I read cover to cover), I did not feel like there was too much content that I could walk away with and use in any real world situtation. The techniques she used, produced very amateur-like pages that would not pass for a high school student's work. Mind you, for some of the fundamental HTML concepts the book was good, but for any real world stuff I felt like I was lookig at those pages where you know the person made it in Frontpage 98' without the plug-ins. Any of the cool stuff like the Javascript Rollovers was gone over so rushed and with so little detail, that it would have been better to have omitted it from the book. I am sorry this book just really was not worth the money.. I would look to that HTML Quickstart book over this one any day.

Five stars. I recommend to any one getting started with the creation of web sites. This book should be on the short list of books to read for creating websites. It covers more than html, and that is good. I benefited from reading it after having taken courses in web design and web programming. Reading it would be also be excellent preparation for taking a web related course. Several of its strengths are: it is co-authored by a graphic designer and techie/programmer (brother and sister), it includes a CD with the files referenced in the book, in includes an excellent html reference section, and there are a number of exercises. As many exercise as there are I would have liked more. The copyright date is 2001. I did not identify any soft spots but would estimate its shelf life will expire the end of 2003. That is the way it is with books about topics such as this. Even then it is should be a solid reference for a number of years.

I like the idea of combining a designer and a developer to create an HTML book. The "family reunion" at the front of the book is banal and adds nothing to the book, but once by that, it's pretty smooth sailing.

What the book successfully does is to show that creating a good Web site is not a matter of simply knowing the code but correctly preparing the graphics and working them into HTML. They use PhotoShop 6, but I was able to fumble through using an older version of PhotoShop and even Fireworks for readying the graphics. The exercises are helpful and simple enough for beginners.

Some of the chapters, like one on bullets and horizontal rules was a bit overblown even for beginners. However, the bulk of the book is a gentle path to working with HTML and graphics. The online site (Ducks in a Row) is only so-so design wise, and the CD files needed for the exercises aren't always complete but enough to work through the exercises. The chapter on transparencies in GIF files was excellent and contained lots of good information and exercises.

My favorite part of the book lies in the Appendices. The authors compile the tags and their associated attributes in several tables so it is a good reference for later use at a more advanced level. They did not include every Maverick tag and attribute that Netscape and Microsoft like to drop in but stuck with the W3C standard as far as I could see.

Overall, when a beginner is finished with this book she'll be ready for intermediate level material for developing Web sites, and if that is the book's goal, it accomplishes it nicely.

The book covers all the topics you may encounter while designing a web page, whether it's a simple personal one, or a complex site. The layout of the book is great, it's easy to find everything and includes a comprehensive HTML 4.01 reference. Lots and lots of examples in the book and on the CD, so you see everything in action while you're learning the techniques. Great for both beginners and those with a knowledge of HTML, because it is so comprehensive, you will no doubt find many many things that you haven't learned yet or are not aware of.

The best thing that can be said about this book is it's a confused ramble though Oracle. The book tries to cover Java, PL/SQL and XML, and fails to cover any depth in any of these subjects.

Some other reviewers have stated that this book is uneven in quality. I agree with that assessment but argue that is unavoidable. I cannot think of any one person who possesses the knowledge to write intelligently about all of this material in the depth this book has.

In a few areas it is dated (obviously 9i is out NOW, but wasn't when this book was published), but it is still overall extremely valuable. I have had my copy for about a year now and have read it almost completely once (you can't read a 1200 page tech book cover to cover) and have referred to it in a pinch more times than I can remember.

In short, a must have for any serious Oracle developer.

Good book, but goes more detail into
tools provided by Oracle. If you will be using
only oracle tools, this is a good book.

This is an excellent book as it covers a lot of ground in one volume. If you work in a organisation that has Oracle as the engine for their web based applications, you must have this book.
Many books cover Java or XML or SQL and the like; but this is one of the few books that delves into HOW to put all of these together to make it work! As this book is released in newer additions, I shall be buying it as soon as it is available.

To produce this book, Wrox took twenty expert Oracle developers and had each of them write about their area of expertise. The result is that whether you are a manager, a developer, or a DBA, if you are working with Oracle 8i this book should be on your desk. This book covers virtually every topic that you need to understand about the Oracle 8i development platform. It does not cover each topic completely but it provides a thorough and in most cases sufficient introduction on each topic. For a particular topic of interest you may need an additional book but to get all the information found in this book you would need ten volumes at least. The book opens with an introduction to Oracle 8i and some of its components including Net8 (Oracle's network solution) and Designer 6i (Oracle's development environment). The next section covers PL/SQL and PSP (this is similar to JSP). This is followed by an extensive section covering Java. This section covers JDBC, SQLJ, EJB, and interMedia (Oracle's powerful search tool). The last section covers XML and includes information on DOM and SAX parsers, SOAP, XSL, XSQL, and more. Extensive case studies are scattered throughout the book. Examples show how to use Oracle tools such as BC4J to develop enterprise applications. The book even includes primers on Java and XML. As a tour of all the features of Oracle 8i, this book is without competition.

A key factor for BPM is the capturing and effective expression of a business process in a way that enables a shared understanding between both the business community and the technical community. I had thought that this book dealt with this aspect in detail, but not really.

What it is, however, is a very clear overview of the technical architecture of a BPM solution and the related standards that support that architecture. The book gives a very clear theoretical background (Petri Nets etc) which is helpful as well. Whether it should have spent so much time and space on the description of proposed or stillborn standards efforts I guess is open to question.

So get this book if you want a solid description of what a BPM solution should look like, that is clearly based on experience that is informed by a correct appreciation of the appropriate theory.

Don't get it if you want advice on modelling techniques or best practises in developing business process models.

Excellent combination of history, standards and methodolocical material related to BPM. On my wish list: a book of corresponding quality related to the business side of BPM.

Trying to document and model the business processes in your organization is an ever-changing target. There has been a lot of work in the industry lately to come up with a standard way to do that. Michael Havey attempts to cover that work in the book Essential Business Process Modeling.

Contents:
Part 1 - Concepts: Introduction to Business Process Modeling; Prescription For a Good BPM Architecture; The Scenic Tour of Process Theory; Process Design Patterns
Part 2 - Standards: Business Process Execution Language (BPEL); BPMI Standards - BPMN and BPML; The Workflow Management Coalition (WFMC); World Wide Web Consortium (W3C) - Choreography; Other BPM Models
Part 3 - Examples; Example - Human Workflow In Insurance Claims Processing; Example - Enterprise Message Broker; Key BPM Acronyms; Index

This isn't necessarily one of those subjects that sets my heart racing as a developer. There are a lot of acronyms and standards from different agencies all trying to interact and coordinate a very difficult subject. But I can appreciate the work that Havey has done in trying to tie together all this material into a single volume. I got the most out of the concepts section, as that's where I am in my experience/knowledge of BPM. Once you get beyond that level of understanding, the second part can add the details on the specific standards that come into play here. I also appreciate the real-life examples at the end, as it puts some flesh on the theoretical concepts.

Although not a book I'd pick up for an entertaining technical read, it does work well for its intended purpose.

Gregor Hohpe should have read past the first 100 pages. This book is good on theory, poor on practice (does that remind you of any other SOA book?).
The examples Havey provides of "non-trivial" systems in the back are, in fact, quite trivial. What's worse is that when he ventures into the territory of "advanced" features, he gets lost. For example, on p.270, he provides an eventHandlers section, but comments it out saying that it doesn't work. I was able to get it to work as written with just a minor tweak, but he slags off the vendor instead (p.284) and proposes an awkward hack for a workaround (p.277). Then, on p.308, he presents us with a piece of parallelism that depends for its success on the use of a correlationSet. This is supposed to be clever, but is, in fact, just poor programming practice. Not only that, but it doesn't work! It can't possibly, not the way it's written. He just sent it off to the publisher without testing. We're not talking about simple syntax errors here... this is a fundamental conceptual flaw in what he's proposing. Pretty basic stuff for him to be stubbing his toe on.

This book is about Business Process Management, and its technical and standards sides. The book explains almost all the technical standards, who creates it and for what purpose.

So, I think the title of the book is not correct. I think it must be "Understanding the Business Process modelling technology and standards". With this title in mind I gave five stars. If you want to know what is BPM, BPEL, BPMN,BPML, WSDL, XLANG, WS-CDL, BPDM and other standards and want to know who creates it and why, buy this book.

People who search a "cookbook" for BPM wil be certainly disappointed.

I found this book to be a very helpful introduction to the use of XSLT in Java. The text is well written and easy to follow, with examples that truly illuminate the concepts being demonstrated. While other reviewers have found the author's focus on transformations from XML to HTML to be a limitation, I found that this approach helped me focus on XSLT concepts without getting bogged down in discussions of other languages simply for the purpose of illustration.

I found the first chapter synopsis of XML in Java to be very helpful in navigating my way through the "alphabet soup" of SAX, JAXP, DOM, JDOM, etc. I also appreciated that the book did not devote substantial space to reference information, which quickly becomes dated and is more easily searched online.

I am very much impressed with the content of the book and the examples in particular. The book covers the breadth of using java and XSLT and also gives a nice case study using MVC architecture.

This book chooses to forgoe some of the more standard tools for XSL translation that are on the market. The author instead uses alternate opensourced implementations (JDOM vs DOM). The problem with this is that in the real world, constraints often exist on your project such that you cannot use alternatives (oh no!). So instead of getting a robust book that explains how to implement DOM and translate, you get a book that wallows in the use of alternate methods and focuses on one thing: creating dynamic HTML. Honestly, this is a rahter tired subject in the XML world. I am more interested in how to translate XML to PDF or RTF or XL. I am not asking for a plain answer, but I was at least hoping for a very beginner approach.

I have spent a week trying to get an implementation going and there is so much that I do not understand. I was hoping that this book would remedy that. It, sadly, does not. The example code is too specific to really help with a real world (constrained) application (I am developing for Oracle systems and they include the standard parsers from org.wc3.dom and org.xml.sax, using others requires server updates that are not recommended). I cannot recommend other titles as I have not read many others and the ones I have read are not too helpful.

Good luck, but steer clear of this one, unless you don't mind losing fifteen dollars.

This book is definitely showing it's age. It covers XSLT as it was in 2001. It's all about having a flexible front-end and serving XML out as HTML and WML, or using it for internationalization. It's coverage of code generation is very, very minimal. There is also very little in the way of advice about increasing processing efficiency. There are also small mistakes; for example the misstatements about CGI and Servlets, which is a common error in Java articles and books.

That being said, the examples are well annotated and the XML is highlighted for readability. The code is loosely annotated, which is the O'Reilly style, but it still makes some of the larger code fragments had to follow.

As long as you know that this book is a little dated you will find reasonable material in here about XML, XSLT and how to get it into Java. It could use a second edition with more topical material.

This book is not what I hope for. Although it has been out for a couple of years the author has not even aknowledged some of the major typos in the book (see O'Reilly web site).

Although nicely written in a style that can be fairly easily followed, it is missing a substantial amount of needed reference material. For example in the section on conditional statements it refers to boolean expressions. Nowhere does he provide a list of operators or build-in functions available. You either have to build your own incomplete list gleaned from his examples or go find a good reference book.

O'Reilly authors generally do a better job.

good book for html db beginner developers. many GUI and detail instructions you can follow to develop your own application. very easy to read and play on your own.

This is a great book, I know this becuase I've read it. I've also passed it along to other developers within my group, three, to be exact and they like it as well. I'm finding it to be much more useful then the online documentation.
=============================================
I would recommed this book to anyone who wants a great resource for Oracle HTMLDB.

The authors state that this book is for beginning and intermediate htmldb developers but my opinion is that it is a confused conglomerate of descriptions of very obvious details through to details that only an advanced user would consider.

For example, there is a long description of the SQL Workshop. In my opinion, anyone who knows enough about constraints, triggers, defaults, nulls (:)) to make sensible use of this facility will be able to work out the workshop without much trouble.

In one place the authors point to useful information on the web, mainly the oracle "htmldb" home page, saying that there is no need to repeat the details in the book. On the other hand, the appendices (and other places) contain details which are readily available in manuals. I would have documented the former and referred readers to the latter.

Steps are listed in detail to perform many, often basic, functions. "and follow the prompts" would have been more than sufficient in many/most places and would have allowed the authors more space to actually get around to providing useful information. On the subject of useful information, in my opinion the manuals describe what can be done but useful information is what should be done. I purchased the book expecting the latter, that the authors would elaborate on lessons learned from experience (how-to information) so that readers would not have to go through the same pain to get workable applications most easily. But not so. The Tips and Techniques & Best Practices chapters are only 20 pages total; and are categorized as Advanced Topics. Neither is there any indication of things that logically htmldb could do for you but doesn't - such as (not) setting the max length of fields and incorporating column comments.

Want to know about checkboxes? Radio buttons? Well, don't expect to find index entries for these. Not what I would expect from a handbook.

There is detail on replacing XL and MSAccess with htmldb. Maybe this should have been left to a book on XE. In any case, I would assume that the push for this comes from the IT crowd, or some enlightened end user/developer, in order to get data under some corporate control. It is surprising therefore that there is no mention of data backups. Excel and access files are more than likely on network drives and so would be backed up periodically. Bundling multiple htmldb workspaces together might provide different challenges with respect to backup and recovery regimes.

I was not enlightened by the chapters in the Website and Application Examples section. Certainly not why I bought the book. Besides, harking back to the beginner and intermediate target audience, these examples are too complex in design. Furthermore, I half expected the source to be available so that the code could at least be examined in order to see how the design details were actually implemented. Perhaps this is more marketing than substance; though not as direct marketing as in the section on PL/SQL Error Handling.

OK, maybe I should admit that my negativity may have something to do with the fact that I am a DBA and have been using htmldb for almost a month. And that I expected the book to tell me what I now know about how to approach htmldb developments and to fill in the gaps where I am still grasping for elegant/generic solutions. It doesn't do either.

There are some good sections in the book. The sections on templates for example; though changing templates requires a reasonable knowledge of html and css (and javascript) and so is probably more an advanced topic.

If you haven't started with htmldb, application express that is, then find a simple application and some time; install XE; create a schema owner; design the schema and include surrogate PKs populated by triggers as well as defaults, FKs etc; build the tables; create views for the LOVs you need and then create the LOVs; set PICK_DATE_FORMAT_MASK; setup UI Defaults; build an application using 1 level tabs and using "form on table with report" for all tables; well, you might want tabular forms for tables that resolve M-M relationships; read the Issue Tracking tutorial from the oracle website and try out on your new website anything that you find that looks appropriate, useful or interesting; research and fix anything else that needs fixing and add anything that needs adding; get some constructive feedback; determine what the design should have been; re-jig or re-start.

I bought Oracle HTML DB Handbook, because I needed to write an application in HTML DB and I didn't know the language. With this book and google I was able to create an application with forms, tables, collections, email with links, and the ability to upload and download files.

I asked the authors a question about one of the procedures and I received a response in less than 24 hours.

The book is well worth the money.

To compare APEX (formerly HTMLDB) to .NET is like comparing a ready-made-sandwich to a gourmet meal. One (APEX) is a web-page generator with extensions, the other (.NET) is a bona-fide development environment. To suggest otherwise is at best disingenuous. That said, HTMLDB has a niche. This is the first book available and it is essentially a rehash of the online documentation. It says a lot when the author posts his own review and gives it 5 stars... next..

This book is definitely interesting in understanding how code generation works and how to utilize some of the newer technologies like XML and XSL to generate software. I am very impressed with some of the new, advanced code generators like CodeCharge, which utilize XML and XSL but do not give us insight to the internals of how it works. While those tools prove that XML and XSL are great for generatng code, this book explains how it is done.

The ideal reader for this book would know Java, but would know nothing about program generators (or compilers) and nothing about XML. They'd want to take things slowly, and wouldn't mind if they didn't get very far. In return, they'd get a surprisingly long introduction to "domain analysis", a decent medium-length introduction to XML and XSL, a quick look at using the Java DOM parser for XML, and some examples.

I was disappointed with the lack of discussion of program generator basics, most fundamentally when to write a program generator versus when to write an interpreter, a parametric program, or as is more typically required, some mix of these approaches. And what about wizards, the most transparent modern incarnation of program generators? And how does this all interact with frequency of program generation and version control? There was no discussion of programming language basics like semantic versus syntactic well-formedness and error reporting, which have their peculiarities in XML and Java.

A primary concern with the whole XML (not to mention Java) enterprise is scalability. There was no discussion of writing efficient program generators; SAX is only mentioned in passing! Even more surprisingly, there is no discussion of generating efficient code, the latter being a primary motivator for many program generation efforts.

Despite the daunting number of pages, this book can be read in one sitting due to the huge font and wide margins.

Agreed that XML may not be the best language to capture domain
specification expressiveness. But use of XML/XSLT to do
custom code generation has the benifit of rapid application
prototyping and development. The crucial fact is that the
domain specification is captured in XML only relatively few times
and project software developers mainly use the generated code.
The question is how many people in the project is exposed
to 'ugliness' of XML and how many times. The advantages
of 'neat' code generation far outweigh the disadvantages
of 'ugliness' of domain specification in XML.

In a real Network Management Software development I achieved
60% of generated code (EJB, SNMP, Java utilities) by using
custom code generation by XML/XSLT. Only myself dealt with
XML other software developers happily used generated code. You
can imagine the lead the project had and continues to have
because of use of XML/XSLT in project specific custom code
generation. The code generation system is stable now -- any new
addition in EJB, SNMP model results in thousands of lines of
Java/SQL/XML/SVG code without any additional effort.

I would, therefore, continue to recommend the book as worth
exploring. This book really contributed new techniques in
software development. More specically with XML/XSLT you have
freely available tools to implement "model driven programming"
in your software project.

I can only assume that Mr. Cleaveland was attempting to woo the legions of Web site developers into writing program generators (PG) with this book. The book centers around a pointless example of how to generate pop-up web pages which call each other when their respective buttons are pressed.
Out of the 13 chapters, 3 are worth mentioning. Chapters 4, 6, and 7 deal with what to consider when writing a PG and how to make it flexible and Mr. Cleveland does bring some worthwhile points to the table. Throughout the other chapters, trivial code snippets are given of how to write the code (in Java, DOM, and XSLT) to generate the pages, however, because the examples are so simplistic any one who knows these languages would know how to write them anyway.
In the future, I would strongly recommend the following:
1. Give examples that people will actually want to use
2. Give examples that highlight your points
3. Get rid of chapters 2 and 3 (domain analysis), they are useless.

Cleaveland hits just the right balance in his unique
book on program generators. Just look at the negative reviews.
The review by Carpenter whines about not getting enough XML
in his book. Thank God, Cleaveland doesn't waste
our time and money on just learning XML. There are
plenty of other books that do that. Cleaveland
rightly focuses on how to apply XML to Program
Generators. The other negative review, "Soso", whines
about the exact opposite; that there is too much XML.

Again, thank God, Cleaveland doesn't do that either,
but rather shows the proper role of XML in the
design of Program Generators, namely that XML is
an abstraction interface for the separation of concerns
between expressing specifications
and transforming specifications. Kudos to
Cleaveland for getting it just right!

I need not say more. Its the best book I have read on web services.

Web Services. I can't believe there is anyone left alive in the technology sector that hasn't heard these two words. Everywhere you look there are articles, books, and web sites that talk about this technology. Do a book search for "Web Services" on amazon.com and you will be quite amazed how many Web Services books there are. With so many available picking one buy may seem overwhelming. The good news is it just got a little easier to do.

Real World XML Web Services is an absolute "must have" for anyone who wants to learn more about XML Web Services. Even if you are not a VB/VB.net developer you will find great value in this book. It goes into extensive detail, and will surely teach even more savvy Web Services folks a thing or two.

Because of the books detail level, I don't think that it is a first-read on the subject though. I think that someone who really doesn't know much about Web Services will be drowned in the detail (which is incredible). A person can get more out of this book by doing some tutorials, and experimenting with Web Services first. Then, after having a good base of understanding is when this book should be cracked.

Summary

Chapter 1. Introduction to Web Services.
This is a brief intro chapter that gives some history and background info about Web Services. Some of the overview consists of typical Web Service architecture, and when to use (and NOT to use) Web Services.

Chapter 2. XSD: The Web Services Type System.
Great chapter. Goes into the concepts of XSD. Topics include the XSD Type System, XSD and XML namespaces, authoring XSD Schemas, and a ton of information about XML Serialization.
.
Chapter 3. SOAP: Invoking Web Services.
This chapter covers what SOAP is, SOAP architecture, SOAP message formats, RPC with SOAP, and also covers error handling.

Chapter 4. Describing Web Services.
A chapter all about the Web Services Description Language (WSDL), which is the language used to describe Web Service interfaces. I liked this chapter a lot because Yasser does a great job of really illustrating and explaining it well. Clear, easy to follow examples are used to drive concepts home.

Chapter 5. The Microsoft SOAP Toolkit.
As you might have guessed, this chapter is all about using the Microsoft SOAP Toolkit to invoke and expose Web Services. If you would like to know more about the toolkit you will like this chapter. Exposing and invoking Web Services via the high and low-level API's is covered, as well as using header handlers to invoke and expose.

Chapter 6. .NET Web Services.
This chapter discusses creating .Net Web Services with Visual Studio .Net, as well as customizing the WSDL of the Web Service to meet your needs.

Chapter 7. SOAP Header and Fault.
All about SOAP headers and SOAP Fault. There is some great information about communicating errors in a common way so that any platform can get to it.

Chapter 8. Interface-Based Web Service Development.

Explains about Interfaces and the .Net Web Services world. Defining interfaces, implementing multiple interfaces, and programming against interfaces are some of the topics covered.

Chapter 9. Handling Data IN.NET Web Services.
This is a chapter that shows how to take data from many different types of sources and be able to manipulate it using XML Schemas, ADO.Net, and the XML Framework. Typed Datasets are also covered.

Chapter 10. Reusable Infrastructure with Soap Extensions.
This chapter teaches how to built a flexible and reusable infrastructure using SOAP extensions.

Chapter 11. UDDI: A Web Service.
This huge chapter pretty much tells us everything about UDDI that you could want to know. The chapter starts with an explanation of what it is and what it is made of. Then the chapter goes into different usage scenarios and various other UDDI topics. Programming, querying, and publishing Web Services with UDDI are just some of the other topics covered. This is an excellent chapter.

Chapter 12. Other SOAP Toolkits.
This chapter talks about Web Services Interop . Different clients are discussed including JAVA clients, VB 6 clients, and NET clients.

Chapter 13. A Web Service Walkthrough.
This chapter wraps up the book by walking the reader through building a Web Service. This is a great way to end the book as it ties together all the things that were discussed.

Appendix A: Data Type Mappings
Appendix B: .NET Web Services Tips and Tricks.

Two good appendixes that give us more information, as well as tips and tricks.

I give this book a 10 out of 10. Yasser did a fantastic job on it. Again, although I do not think this is a "first read" book on Web Services, I believe it is a "must have" Web Services book. Any developer that works with, or wants to work with Web Services will find it valuable.

Web Services. I can't believe there is anyone left alive in the technology sector that hasn't heard these two words. Everywhere you look there are articles, books, and web sites that talk about this technology. Do a book search for "Web Services" on amazon.com and you will be quite amazed how many Web Services books there are. With so many available picking one buy may seem overwhelming. The good news is it just got a little easier to do.

Real World XML Web Services is an absolute "must have" for anyone who wants to learn more about XML Web Services. Even if you are not a VB/VB.net developer you will find great value in this book. It goes into extensive detail, and will surely teach even more savvy Web Services folks a thing or two.

Because of the books detail level, I don't think that it is a first-read on the subject though. I think that someone who really doesn't know much about Web Services will be drowned in the detail (which is incredible). A person can get more out of this book by doing some tutorials, and experimenting with Web Services first. Then, after having a good base of understanding is when this book should be cracked.

Summary

Chapter 1. Introduction to Web Services.
This is a brief intro chapter that gives some history and background info about Web Services. Some of the overview consists of typical Web Service architecture, and when to use (and NOT to use) Web Services.

Chapter 2. XSD: The Web Services Type System.
Great chapter. Goes into the concepts of XSD. Topics include the XSD Type System, XSD and XML namespaces, authoring XSD Schemas, and a ton of information about XML Serialization.
.
Chapter 3. SOAP: Invoking Web Services.
This chapter covers what SOAP is, SOAP architecture, SOAP message formats, RPC with SOAP, and also covers error handling.

Chapter 4. Describing Web Services.
A chapter all about the Web Services Description Language (WSDL), which is the language used to describe Web Service interfaces. I liked this chapter a lot because Yasser does a great job of really illustrating and explaining it well. Clear, easy to follow examples are used to drive concepts home.

Chapter 5. The Microsoft SOAP Toolkit.
As you might have guessed, this chapter is all about using the Microsoft SOAP Toolkit to invoke and expose Web Services. If you would like to know more about the toolkit you will like this chapter. Exposing and invoking Web Services via the high and low-level API's is covered, as well as using header handlers to invoke and expose.

Chapter 6. .NET Web Services.
This chapter discusses creating .Net Web Services with Visual Studio .Net, as well as customizing the WSDL of the Web Service to meet your needs.

Chapter 7. SOAP Header and Fault.
All about SOAP headers and SOAP Fault. There is some great information about communicating errors in a common way so that any platform can get to it.

Chapter 8. Interface-Based Web Service Development.

Explains about Interfaces and the .Net Web Services world. Defining interfaces, implementing multiple interfaces, and programming against interfaces are some of the topics covered.

Chapter 9. Handling Data IN.NET Web Services.
This is a chapter that shows how to take data from many different types of sources and be able to manipulate it using XML Schemas, ADO.Net, and the XML Framework. Typed Datasets are also covered.

Chapter 10. Reusable Infrastructure with Soap Extensions.
This chapter teaches how to built a flexible and reusable infrastructure using SOAP extensions.

Chapter 11. UDDI: A Web Service.
This huge chapter pretty much tells us everything about UDDI that you could want to know. The chapter starts with an explanation of what it is and what it is made of. Then the chapter goes into different usage scenarios and various other UDDI topics. Programming, querying, and publishing Web Services with UDDI are just some of the other topics covered. This is an excellent chapter.

Chapter 12. Other SOAP Toolkits.
This chapter talks about Web Services Interop . Different clients are discussed including JAVA clients, VB 6 clients, and NET clients.

Chapter 13. A Web Service Walkthrough.
This chapter wraps up the book by walking the reader through building a Web Service. This is a great way to end the book as it ties together all the things that were discussed.

Appendix A: Data Type Mappings
Appendix B: .NET Web Services Tips and Tricks.

Two good appendixes that give us more information, as well as tips and tricks.

I give this book a 10 out of 10. Yasser did a fantastic job on it. Again, although I do not think this is a "first read" book on Web Services, I believe it is a "must have" Web Services book. Any developer that works with, or wants to work with Web Services will find it valuable.

This is a good book but suffers from bad writing style.
The author uses many "and/or" clauses one is forced to
pause to understand what he is really attempting to say.
He also asks questions in the middle of an explanation.

For example on page 38 section 2.4.7 he says:
"An element doesn't need to have content;it may be empty. An empty element is an element that has no text content and no child elements. Would such an element be of complex or simple type? it depends; if the element has attributes it is of complex type. Note that attributes are not considered part of an element's content, therefore whether or not an element has attributes has nothing to do with whether or not the element is empty: an empty element may nor may not have attributes."

Does the author have to use 108+ words to tell us that an empty element is just that. Empty!
For example read his last sentence and see whether you understand what he is talking about.

He could simply state the last part: "an empty element may or may not have attributes" for us to understand. Where "therefore whether or not an element has attributes has nothing to do with whether or not the element is empty:" came from I have no idea!

I am not sure whether the author is affected by English as a second language or whether he bothered to understand what he was writing. In an attempt to simplify the content he ends up in verbosity and ruins what would have been a good book.

Overall if one can put up with long winded paragraphs it is a good book.

I purchased this book from Amazon mainly relying upon the reviews written by other people. As it turns out I can only assume that the other reviews were paid for either by the author or by the press.

The book is REALLY HARD TO READ, we are talking as dry as the sphinx's arm pit. The CD rom that comes with it contains the examples, however these are a mish-mash of VB6 and some .Net neither of which run easily. The .Net versions require updating in Visual Studio and can have some odd results. Some examples are even written with the server component in VB6 and the client in .Net - confusing to say the least.

If you want to learn how to practically implement a Web Service using VB then you should NOT look at this book. Most of the first 4 chapters are all about XML schemas and what they mean - with no "Real World" examples of how to create them in VB just the code of the schemas already created.

And another thing there is a large chunk of information about a "Real World" authentication and encryption implementation, however and I quote "I recommend that you use off-the shelf security implementations" - The author wouldn't even use this code! Microsoft has a Web services extension designed for authentication which the author doesn't mention anywhere.

Very disappointment to have spent good dollars on this book. I will be trying desperately to get my money back from Amazon.