xml-dev - RE: Real XML Site

[Didier PH Martin <martind@netfolder.com>]

Hi Paul,

Paul said:
I realized that the real question is :
"is .xml closer to .txt or is it closer to .cgi?"

Didier replies:
Any xml document can be associated to a stylesheet. The stylesheet performs
some transformations and, according to the XSLT 1.0 recommendation it can
even transform the document into a non XML based language like HTML (which
is SGML based). Thus, if we agree that because of a stylesheet declaration,
something different than an XML document can be presented to you, so far so
good.

Now, the next step is that the transformation processing may occur on the
server side or the client side. Its a question of partitioning the process
on the server or on the client. The server may take the decision on where to
partition the process on the basis of the browser capabilities. Off course
this happens if, in one way or an other a stylesheet is associated to this
xml document. And thus, this document includes a processing instruction.
Probably what you find weird is the fact that an XML document may have a
processing instruction and that a processor may process the document in
acordance to this processing instruction. This is maybe the real issue here.

Thus, an XML document may be transformed by a stylesheet and then the
presentation can be different than the original model. So, if we find that
asking for an xml document and seeing an HTML document is weird, then we
obviously find the whole transformation process weird.

In the "weirdness" scale, what is more weird?
a) the browser requests a document through an HTTP GET mydir/mydoc.xml, it
gets the xml document, it finds an stylesheet PI and it displays it as an
HTML document - or
b) the browser requests a document through an HTTP GET mydir/mydoc.xml, it
gets an HTML document and it displays it.

In fact, the main difference between these two situation is only where the
transformation process occurs. for (a) the process occurs on the client
side. for (b) the process occurs on the server side. It is just a question
of
	** process partitioning **.
In the 21st century, as we catch up with the results of the research in
distributed computing that occurred in the 80s, we will see more and more of
this kind of ** process partitioning ** as a way to balance the work load or
as a way to adapt to different processing environments (resource
availability).

So perhaps, what can be perceived as equaly weird are requests like an HTTP
GET mydir/mydoc.asp returning as a result HTML document. idem for
- GET mydir/mydoc.php,
- GET mydir/mydoc.jsp,
- GET mydir/mydoc.class,
- GET mydir/mydoc.dll,
- GET mydir/mydoc.py
- and so on and so forth

in all the above cases, a processing occured. Idem for an xml document that
includes a processing instruction. It is the processing instruction that
makes the whole difference. Or to state this in a more general way, when a
stylesheet is associated to an XML document. As soon as this association is
present, we have now the choice to decide where this processing can occur
(the process localisation issue).

Bottom line: When a stylesheet PI is declared in an xml document, the
stylesheet provides an interpretation of this document. The xml document is
processed and not given as is to the requester. The processing instruction
just mention that...some processing can be performed on this document.

But I agree with you if the server or the browser has no provision to turn
ON or OFF this processing. For instance, in our case, the default behavior
which is to process the document can be turned OFF just by the following URL

get mydir/mydoc.xml?style=no

In that case, the server just won't perform the transformation operation and
simply return the original xml document. A browser, which would process an
XML document with the declared stylesheet should also provide such switch to
show the original document. Or, a different mechanism can be provided, as
Microsoft did in their preview technology (or in IE 5.x if you prefer) when
the document source is requested, the xml document is shown. In that case,
because you can retrieve the original xml document, a switch is unnecessary.

Conclusion: The real issue here is simply the processing instruction
included in an xml document or the association made between an xml document
and a stylesheet that state that a processing can occur on this document.
Moreover, this processing instruction may state that if the "media" X is the
rendering device, then the document will be transformed into the X rendering
language. Is this weird? Question of opinion( I myself always found weird
that my name is didier). Is this useful? you bet it is! We can separate the
model and the view. Is process partitioning a good thing? you bet! we are
finally starting to be in the 21st century and we see the first signs of
distributed computing? Like my good friend says:

"Sorry larry, the mainframe is gone,
Sorry Bill, the desktop is gone,
Sorry ms Robinson, forget the plastic, go in distributed computing"

cheers
Didier PH Martin
----------------------------------------------
Email: martind@netfolder.com
Conferences: xml devcon 2000 (http://www.xmldevcon2000.com)
		 Wireless Summit NY (http:www.pulver.com)
	       xml devcon 2001 London (http://www.xmldevcon2000.com)
Book: XML Professional (http://www.wrox.com)
column: xml.com (http://www.xml.com)