Processing XML. RFC.

Paul Tchistopolskii paul at
Tue Nov 30 07:47:06 GMT 1999


    It is not about SML ;-)

    Let us think about some technologies people use to process  
    XML files. Simplified a bit.
    1.  SAX API  - streaming. 

            a. Dataflow is 'read-only'.  
            b. Processing Rules are very simple and callbacks usualy 
            don't care about what happens on 'level up',  what is the 
            hierarchy e t.c. Callback  receives the node ( and attributes ).
            Easy to use if your node has only attributes, but not 
            elements ;-)
            c. Processing Rules are hardcoded by developer.

    2.  DOM. Document eats the entire memory. ;-)

            a. Dataflow could be 'read-write'.
            b. Processing Rules could be much more complex, because 
            at any point it is possible to get information about the hierarhy, 
            what happens in some other nodes e t.c. 
            c. Processing Rules are hardcoded by developer.

            d. Some twist here is to consider DOM to be a 
            stream of serialized objects and then map those 
            objects into appropriate Java Classes. There is 
            some framework of this kind advertized as 
            'Say no to DOM'. Because it only simplifies the 
            code for accessing  the nodes , but gives no       
            big advantage with Processing Rules - it should  
            be considered to be just a twist.

    3.   XT.  Document eats the entire memory.

            a. Dataflow is 'read-only'. 
            ( I'm not talking about existing vendor-specific 
            extensions yet ).

            b. Processing Rules are cool.
            c. Processing Rules are not hardcoded.
    What looks missing to me is: 

    XT1        XT  + streaming and 
    XT2        XT  + dataflow is 'read-write' 

    Q0. Something tells me that because SAX and DOM are 2 different things - 
    XT1 and XT2 are also different things. Right ?

    Q1. I think XT and alikes are very close to become XT2, but they 
    are getting  there supporting  DOM as an output. 
    (Do they ?  I think XT does. ) 

    That means that we'l need to have 2 DOM Objects in the memory
    ( input and transformed output ).

    Could it be even possible to have only one DOM object in the 
    memory... Transformating 'itself' ...  ?

    Is there any idea or any effort in W3C to get  something  similiar 
    to 'read-write'  XSLT and if yes - maybe there is any URL there ?

    Q2. Maybe there is already something similiar to XT1 and/or  XT2  ?

    Q3. I could live with such XT1 / XT2 if they are not xml-ish, but I think 
    they should be ?


xml-dev: A list for W3C XML Developers. To post, mailto:xml-dev at
Archived as: and on CD-ROM/ISBN 981-02-3594-1
To unsubscribe, mailto:majordomo at the following message;
unsubscribe xml-dev
To subscribe to the digests, mailto:majordomo at the following message;
subscribe xml-dev-digest
List coordinator, Henry Rzepa (mailto:rzepa at

More information about the Xml-dev mailing list