«

Hello,

maybe of some interest:

http://pysch.sourceforge.net/ast.html

XML can be considered as an external representation of in-memory
tree-like structures, and XML-related standards — as methods of
processing such data. Some types of applications may benefit
from this approach. One of the examples are compilers with
theirs parse trees.

The Pysch distribution contains an example of representing Python
parse trees (abstract syntax trees, AST) as XML and applying an
XSLT transformation to these trees.

At the moment the whole code should be considered as a toy,
not as a production version. Anyway, it works.

....

--
Oleg

On 27 Oct 2004 23:09:02 -0700, (Oleg Paraschenko)
wrote:

>maybe of some interest:

Maybe 5 years ago, before we realised what a bad idea it was.


>http://pysch.sourceforge.net/ast.html
>
>[quote]
>XML can be considered as an external representation of in-memory
>tree-like structures,

Yes. But why would I want to ? XML is a clumsy _internal_
representation and it's only useful as an external representation if
you need some lowest-common-denominator more than you need a good and
appropriate representation. The best external representation of
Python is some Python source, not some over-abstracted XML version.


> and XML-related standards as methods of processing such data.

XML-related protocols don't process data, they process an XML
representation of that data. Their ability to do so is based on the
XML aspect of it, not the underlying data model. This makes them
somewhere between clumsy to develop wiith, or simply incapable of
addressing the problem.

"Lets make all our data standards interwork by using XSLT" was the
theme of late '99. It didn't work.

--
Smert' spamionam

Hello,

Andy Dingley <> wrote in message
news:<>. ..
> On 27 Oct 2004 23:09:02 -0700, (Oleg Paraschenko)
> wrote:
>
> >maybe of some interest:
>
> Maybe 5 years ago, before we realised what a bad idea it was.

Definitely, I'm not from this "we" set.

>
>
> >http://pysch.sourceforge.net/ast.html
> >
> >[quote]
> >XML can be considered as an external representation of in-memory
> >tree-like structures,
>
> Yes. But why would I want to ?

Have you used XPath to navigate in a tree? Have you wrote functions
to navigate in a tree manually, using some DOM-like interface? If yes,
then you know the difference. It is like using regexps vs manual string
processing.

> XML is a clumsy _internal_
> representation and it's only useful as an external representation if
> you need some lowest-common-denominator more than you need a good and
> appropriate representation.

No, I don't worry about lowest-common-denominator. I know a silver
bullet for tree processing (xpath + xslt) and want to use it.

> The best external representation of
> Python is some Python source, not some over-abstracted XML version.

It depends. How can you, for example, eliminate tail recursion
in the Python source form representation?

>
>
> > and XML-related standards as methods of processing such data.
>
> XML-related protocols don't process data, they process an XML
> representation of that data.

While data and XML representation are isomorphic, it is not
important.

> Their ability to do so is based on the
> XML aspect of it, not the underlying data model. This makes them
> somewhere between clumsy to develop wiith, or simply incapable of
> addressing the problem.

When data is tree, a gap between XML and data is minimal.

>
> "Lets make all our data standards interwork by using XSLT" was the
> theme of late '99. It didn't work.

--
Oleg

Andy Dingley <> wrote in message news:<>. ..
> On 27 Oct 2004 23:09:02 -0700, (Oleg Paraschenko)
> wrote:
>
> >maybe of some interest:
>
> Maybe 5 years ago, before we realised what a bad idea it was.

Actually, it's something I've considered before myself, and there are
apparently various extensions to GCC (the compiler suite, not just the
C compiler) which support similar concepts, so I suppose it's the
royal "we" you're using.

> >http://pysch.sourceforge.net/ast.html
> >
> >[quote]
> >XML can be considered as an external representation of in-memory
> >tree-like structures,
>
> Yes. But why would I want to ? XML is a clumsy _internal_
> representation and it's only useful as an external representation if
> you need some lowest-common-denominator more than you need a good and
> appropriate representation. The best external representation of
> Python is some Python source, not some over-abstracted XML version.

Unless you're writing tools in other languages. I personally find the
various Python modules for source code inspection to be adequate, but
you can't just import the compiler package in Java, for example.

> > and XML-related standards as methods of processing such data.
>
> XML-related protocols don't process data, they process an XML
> representation of that data. Their ability to do so is based on the
> XML aspect of it, not the underlying data model. This makes them
> somewhere between clumsy to develop wiith, or simply incapable of
> addressing the problem.
>
> "Lets make all our data standards interwork by using XSLT" was the
> theme of late '99. It didn't work.

It may not have worked in the royal court, but XSLT has lots of
interesting and productive uses provided you choose your problems
carefully. I can imagine that transforming various sections of Python
code (for simple macro implementations, for example) *is* one of those
problem areas in which XSLT can usefully be used. Moreover, by
choosing XML, the developer(s) have at least opened an area up to
various effective tools (including XSLT) which could not have been
readily used in that area before; that in itself suggests that the
project was worth undertaking, if only for the benefits subsequent
projects can derive from it.

Paul

"Oleg Paraschenko" <> wrote in message
news: om...
> Hello,
>
> maybe of some interest:
>
> http://pysch.sourceforge.net/ast.html

This is definitely of interest.

An AST as any tree is a perfect fit for XSLT processing. Many people
overlook the fact that XSLT operates on generic trees, which do not have to
necessarily originate from an XML document.

My personal experience in implementing graph-processing algorithms in XSLT
(e.g. Eulerisation of a graph -- the chinese postman and the N.Y street
sweeper algorithms) shows that XSLT is efficient programming language for
such problems -- similarly it will be efficient in rewriting and
optimization.

Do keep the good work, Oleg!


Cheers,

Dimitre.

>
>

> XML can be considered as an external representation of in-memory
> tree-like structures, and XML-related standards - as methods of
> processing such data. Some types of applications may benefit
> from this approach. One of the examples are compilers with
> theirs parse trees.
>
> The Pysch distribution contains an example of representing Python
> parse trees (abstract syntax trees, AST) as XML and applying an
> XSLT transformation to these trees.
>
> At the moment the whole code should be considered as a toy,
> not as a production version. Anyway, it works.
>
> ...
>

>
> --
> Oleg