Hi Carsten!

On Tue, 24 Jul 2001, Carsten Ziegeler wrote:

> > Stefano Mazzocchi wrote:
> >
> > ...
> > Yes, that's a solution, but I believe the design mistake here is that
> > "aggregation" is seen as "generation" while I see it as
> > "transformation".
> >
> > Suppose you have something like this:
> >
> >   generator -> layout page
> >   transformer -> aggregator
> >
> If I understand you right, you can already do this by simply using the
> generator you want and then using the CIncludeTransformer, or did I miss
> a point?

        This is amazing deja-vu, I was thinking about this just yesterday.

        Yesterday I was looking at the uses of aggregation, thinking it might
        be useful in our project. The idea behind it sounds great, but in
        practice I came up against some concerns.

        Take the simplest case - we have many HTML pages in our application
        which have 'headers' and 'footers', as most commercial applications
        probably do. Currently this is solved by included xsl templates, which
        are called in each html page before serialization.

        I thought aggregation would help here, removing the need to have these
        templates included and called, but after thinking about it for a while
        I unded up a little confused about whether aggregation could help.

        The keypoint I think is that aggregation solves the problem of
        aggregating multiple data sources together (which is extremely useful),
        but when one wants to aggregate multiple presentation components
        together it's difficult.

        Example, IMHO adding a header and footer to a document should be
        something done towards the end of a pipeline, just before serialization,
        not at the beginning, especially where long transforms are involved.

        We have some pipes where data is generated, created and then either
        formatted into html or csv. To aggregate the html part is difficult as
        we have to carry the header and footer markup all the way from
        generation through each transform, and then either use or discard it
        based on the final transform before serialization.

        It would be much better if we could aggregate in the 'header' and
        'footer' towards the end of the pipeline. This is kind-of possible
        using 2 pipelines, one to create the data, the second (invoked first)
        used to aggregate the header/footer together with the data from the
        first pipeline.

        But, as I said, perhaps I've not understood the full power of how to
        use aggregration.

        Any comments at all mate ? Is CIncludeTransformer useful for this
        purpose ?

        Cheers,

        Marcus

-- 
        .....
     ,,$$$$$$$$$,      Marcus Crafter
    ;$'      '$$$$:    Computer Systems Engineer
    $:         $$$$:   Open Software Associates GmbH
     $       o_)$$$:   82-84 Mainzer Landstrasse
     ;$,    _/\ &&:'   60327 Frankfurt Germany
       '     /( &&&
           \_&&&&'     Email : [EMAIL PROTECTED]
          &&&&.        Business Hours : +49 69 9757 200
    &&&&&&&:


---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, email: [EMAIL PROTECTED]

Reply via email to