XML Books

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.

This book is ok. I had to get it for a class. The writing is alittle hard to follow, but it is a good reference.

CD came damaged from xpresstext in which there is a large mark/scratch across the CD using priority shipping and after attempting to notify them and Amazon 4 times, no response until I contacted the BBB and Amazon will not help because I did complain to the BBB. Guess it is up to the BBB now.

Ok, my written english isn't good at all, but I'd just wanna say how much I love this book. I have been studying html and css for some time now, and I already knew something when I bought this book, and what I think great about it is that it's so detailed about how the things work in html, xhtml and css that it's like if I was learning everything from the beginning again, but this time knowing exactly what I was doing and why.

Well, that's it.. sorry for my english.

I purchased this book to use in a class I was taking. I had no prior knowledge of HTML, but this book does an excellent job of introducing the reader to designing web pages. I found the chapters very easy to follow and the exercises were kind of fun as you got to practice what you just read about. I highly recommend this to anyone wanting to learn HTML.

I've taught HTML and e-commerce at the university level for about a decade now. This book is the best I have found. I use it as my personal reference. I require it for my classes.

It covers the essentials. It gives clear examples. It is organized in a logical order that works. It can be used by someone who has never tried to build a web page, and also has enough 'meat' so that those who have been building pages for years can find useful information and tips throughout.

I just wish I could find books on some of my other subjects that are as well written and organized as this.

This book in an excellent review of the XForms standard. It is part tutorial and part reference book. It starts with about 50 pages of background material (XPath, XML Schema, XML, namespaces etc) and then starts with a conceptual overview with some examples. It then takes us through all the major XForms concepts and elements.

The book is well written in a compact and precise style. It also has several tables that I found to be handy as references although there is no full appendix listing all the XForms elements which would have been very useful. It does have some useful additional information such as how to use CSS with XForms.

T.V. Raman is also a very credible expert on XForms since he was on the w3c XForms standards body. He gives several insights into why the standard is structured to be device independent. This allows XForms to run on web pages and mobile phone applications.

The only reason I did not give this a 5 star is that the examples on the online on the web site have many problems. The book was written using LATEX and many of the examples on-line still have many LATEX codes in them and will not run without much editing. Somewhat sloppy.

My hope is that the author fixes these problems in the future so that all the examples would work with the FireFox XForms plug-in. That would be ideal for using this book in the XForms classes I teach. The book could also have used a bit more editing, I found several grammatical errors but no real conceptual errors.

Easy reading and a good explanation of XForms concepts. The book is about 230 pages with a CD. The XForms concepts are very well compressed into these pages, making it easy reading, yet less intimidating. I was able to read most of the book in the car when we went on a trip to Maine.

T.V's clear and structured thinking is well captured both in this book and in the technology itself. The simple writing style with the grasp of the subject matter and the interactivity model makes complex thing seem simple and beautiful at the same time.

Xforms is a ubiquitous technology. If more technologies were more like XFROMS, then specifications for accessibility, multimodal content, etc etc would all boil down to follow the speck, thank you.

XForms is one of those technologies that hasn't yet taken off, but could make a substantial impact if it ever does. I got a copy of XForms - XML Powered Web Forms by T. V. Raman in order to understand a bit more about the subject...

Contents:
Part 1 - Welcome to XForms: XML Powered Web Forms; Standard Building Blocks
Part 2 - XForms Components: XForms User Interface Controls; Creating Complex User Interfaces; XForms Model Properties; XForms Functions; XForms Actions; XForms Events
Part 3 - XForms and the Next Generation Web: Connecting the User to Web Services; Multimodal Access; XForms and Accessibility; Colophon; Bibliography; Index

In some ways, XForms is harder than just regular HTML forms in that there's more data architecture that needs to be considered beforehand. Conversely, you are able to achieve a much better separation of data and design than possible under the HTML model. Raman does a pretty good job in explaining the overall conceptual model of XForms, as well as how it hooks into all the other "X" technologies (XPath, XML Schemas, etc.). Once the groundwork is set in Part 1, Part 2 becomes the reference manual on how to use each XForm feature. It's not a huge reference manual, but the core information is laid out in such a way that you'd end up using it on a regular basis as you get up to speed. I found it all pretty easy to follow, and I see how this could become a fundamental part of your personal library if you're using XForms on a regular basis. Of course, the downside is that XForms isn't yet supported on any widely-available basis... :)

If I were asked to recommend a title for XForms information, this would probably be the one I'd point someone to...

XForms is just the right length and weight for reading in bed, or on a flight (two hours or more). So those are the places where I read Raman's book. I openly admit that I got more out of the book in flight than between sheets.

Raman belongs to the school of tell them what you are going to tell them, tell them it, then tell them what you told them. His English is rather academic in style, but it is always clear.

Raman has put considerable thought into the problems addressed by XForms.The book ought not be read as a description of XForms syntax, nor is it really a tutorial on how to use XForms. Rather, Raman's book is a treatise that sets out the desirable characteristics of electronic forms, especially those deployed over the Web. By explaining requirements, and illustrating, by means of those examples, how XForms meets his requirements, Raman has produced a compelling justification for the design of XForms. He has also gone a long way towards providing a clear set of criteria against which other forms technologies might be measured.

XForms is divided into three parts. Very roughly, Part One describes the mess we are in today, and sets out the characteristics of a means to salvation, and just how these are embodied in XForms. The second is a blow by blow account of the act of salvation; while the third points to the state of grace we might achieve in the future, if we pursue the principles on which XForms is based.

So, Raman sets off on the journey with a description, by means of a simple example, of the tools and approaches used in typical Web forms projects at the moment. He then spends some time reworking the example as an XForms implementation, and highlights the key advantages of using XForms. In doing so he introduces us to the major components of Xforms.

The rest of Part One is an introduction to the array of other XML standards the potential XForms developer will face when using XForms. Raman lists six standards on which XForms has some dependency, including XML itself. This is a strength of XForms. Processors, can, at least partly, be amalgamations of existing implementations of standards, such as W3C XML Schema. Furthermore authors are likely to be using skills that are useful in other contexts.

Part Two consists of a more detailed examination of XForms. Raman first takes us through the UI itself, moving from simple constructs to the more sophisticated. Each section describes the use of XForms components, with worked examples, and so helps to put into context the architectural principles sketched out in Part One.

As an example, let's look at Section 3.4, Types of Selection Controls. Raman tells us that it is a common requirement that a user make a selection from a predefined list of values. He cites the various ways that this can be physically represented on different devices, but then makes the point that "XForms defines selection controls based on the functionality provided, rather than their appearance in a given environment. This design has the advantage of capturing the underlying intent in a given user interaction rather than its mere visual appearance." (p.63). Raman expands his argument with a worked example, that contrasts how a voice browser might struggle with an HTML implementation of a choice, but work very naturally with the XForms equivalent.

Having described the basic building blocks of the UI, Raman tells us how to combine them within groups, repeating groups, and the XForms equivalent of tabbed groups.

Next come accounts of the bits the author needs to make a form function; Model Item Properties (MIPs), Functions, Actions and Events. In these chapters Raman explains and justifies XForms declarative style, whilst carefully acknowledging that techniques such as scripting have proved their worth in allowing people to "experiment and innovate on the Web" (p.163). As an example of the power of the declarative approach, Raman sets out how an author can use dynamically evaluated MIPs such as relevant, and read-only, combined with CSS, to control the physical representation of forms, by hiding controls, or groups that are bound to nodes that become irrelevant, for example.

The last section of XForms lays before the reader Raman's hopes for a future Web in which XForms acts as a mediator between humans and Web services and so; "allows users to interact naturally with complex, structured data; and does so across many modalities, in a way that makes the Web universally accessible".

Raman devotes a chapter to each aspect of his vision. In the first, he points out that web services rely on the transfer of "well structured, rigorously validated" XML, all ready for machine processing. XForms allows people to interact directly with such user unfriendly data. Furthermore, XForms allows authors to create islands of well structured data within oceans of the kind of semi-structured document that people use all the time. So "XForms makes the original promise of the document is the interface a reality".

The last two chapters establish that XForms does not impose any particular view of what that interface should be. Raman makes very forcefully the point that XForms is through designed to support multi-modality and accessibility principles, and so makes it trivial for form authors to create forms that will work pretty much any way that is appropriate. Raman emphasises that accessibility and support for multiple modalities are all part and parcel of the same thing. Moreover he has illustrated his points very carefully, to make clear that accessibility is about improving everyone's experience of the Web. We all find ourselves in situations when we are functionally blind, or deaf, or physically impaired, every day of our lives, if we just stop to think about it.

This book provides a great overview of XHTML, from its origins and relationship to HTML, to adjacent technologies designed to work in conjunction with it. You'll primarily learn (1) how to migrate legacy HTML markup and (2) how to write new XHTML from the ground up. This book does well to cite available software to help you with both the conversion as well as the creation of XHTML. Towards the end of the book, the authors go into application-specific XML vocabularies and technologies designed to transform or style XHTML.

Novices will do great with this approach, but experienced web developers already knowledgeable with XML technologies may find the coverage of XSLT, CSS, etc. redundant with their other readings and/or life experiences. I've been in web dev for 6 years, so I was able to stop reading after Chapter 5. Perhaps this book may be construed as too shallow for the experienced developer. Or, perhaps there really isn't much more to say about XHTML to justify a thicker book. I won't know personally until I read at least one other book on the subject.

If you are new to XHTML -- as well as XML technology in general -- this book is great way to learn about the related technologies quickly.

I got this as I felt that XHTML was going to help me in my job.

Now I'm hoping the knowledge I've found in this book will help me
GET a job.

It's a good way to help an HTML designer make the transition to XHTML, but a good XML reference may be in order!

You do need some knowledge of HTML(at least know how to do a CSS!)

This book has good explanations. If you are planning to migrate from HTML to XHTML this is a good choice. Other than migrating, this book offers great working examples in the provided CD. The book covers CSS with XHTML, Intoduction to XML technologies like XForms, Xlink, and XSL. So get this book to be ready for the future. Note : Some chapters are hard to understand. You might have to read again to understand it correctly.

What is XHTML? Is it just another trendy acronym for web developers to toss around? Is it the child of a marriage between Hypertext Markup Language (HTML) and Extensible Markup Language (XML)? Is it worth worrying about?

The authors of XHTML have chosen to answer in a variety of ways. This book takes several approaches to explaining XHTML. They range from a high-level view of "Where did XHTML come from?" to an attribute-by-attribute listing of valid XHTML syntax to an in-depth look at Cascading Style Sheets (CSS). There are also several chapters of "What's next?" topics, each touching on an aspect of internet development (multimedia, forms, graphics, and scripts).

So what is XHTML? It is the Extensible Hypertext Markup Language. It's brings order to chaotic world of HTML by forcing adherence to XML standards. It promises to separate presentation from information (data). It can force a web page to act like data, with the benefit that anything that can access data can use your web page (like text-to-speech devices, mobile devices, and more). It's a W3C standard that has progressed beyond the 1.0 specification referred to in this book (and this book was published in 2001!).

This book could have easily been called XHTML and CSS - because they devote many pages to the key role that CSS will play in the deployment of XHTML. CSS is the way that the presentation elements are extracted from the HTML document - leaving only the data behind.

The book mostly succeeds in bringing XHTML to a wide audience. It tries to be an introduction, migration guide, and language reference. I recommend it to anyone interested in taking their internet development to the next level.

Know your goals. If you expect to have mastered XHTML after this book, look elsewhere. As said by another reviewer all the details are not covered and one is referred to other sources, but it is a good place for beginners to start. You will have to visit online tutorials to complete this book and you'll still need to purchase a XHTML book that can be used as a reference.

The author's expertise provides one with an excellent historical section, but I personally found it to be more on the side of information overload.

XML related subjects are mentioned, but only seasoned HTML'ers will be able to comprehend the explanations, which I found too brief to really be enriching.

For those with some HTML experience there are better books out there and one should continue their search for another XHTML book. Beginners will be will served with this book.

and I've read quite a few. At least the authors of "HTML for dummies" or whatever don't imagine that they are genuises setting the world on fire.

This book is pretentious, repetitious, phenomenally boring, and completely useless. It consists of little but vacuous management-speak sentences. For example what is one to make of
"A process is something that someone wants to accomplish, including the flow of actions from start to completion"? In the world of normal people, a process is a means to an end, not an end in itself. But the book is riddled with this sort of meaningless juxtaposition of jargon.

There is no point so trivial that this book doesn't feel it's worth repeating at least ten times. There is no technical detail about XML so trivial that this book feels it should include. If you feel that saying that XML uses a tree structure is well illustrated with a picture of what looks like an actual christmas tree (as opposed to something with nodes and edges) then this is probably the book for you. But if you have the slightest interest in the technicalities of XML (even if your interest is limited to ecommerce and management level issues), don't waste your time. Typing XML into google and reading ten random hits will teach you more.

I'm really tired of e-business people coming to me with comments like "I can't see why we can't do ..." and other comments which reflect the absolute lack of technical interest e-business people show for what should be their profession. This book continues this sad tradition. I imagine its effect is to fire up over-enthusiastic MBAs to make XML programmers lives misery.

Especially if you're in the IT field or seeking to break into it (lots of interview fodder here). Most books start with the differences between XML and HTML, how to create a valid XML document, intro the DTD, etc. Simon explains why we need XML! In clear, concise, readable prose, the author explains XML's practical applications. He does an admirable job of conveying XML's importance in terms of ecommerce and B2B applications.

Simon writes with a twinkle in his eye, as he explains the technical aspects of XML in business terms. His business focus provides a general understanding to both business people and college students. His large number of examples and metaphors will also prove useful for others who are trying to explain the amazing powerful of the XML technology.

If you are in business and IT, read this book. Go elsewhere to learn how to program XML. Read this to learn WHY you need to understand XML, its applications, its potential -- make a wise, informed business decision (and if you don't use it, be prepared to explain why not).