Older blog entries for vdv (starting at number 16)

Why XML?
    Interesting thread about the RELAX NG "compact syntax". There is no doubt that the RELAX NG (non XML) compact syntax is more concise, easier to read and more elegant than the XML syntax, however, despite the efforts done by James Clark to provide an extension mechanism, John Cowan thinks that annotations are still so ugly that they should be removed from the compact syntax. The point here is that even though for each application taken alone, XML is frequently less appealing than other alternatives (XSLT and WikiMl are two other examples), XML is a clear winner as soon as there is a need for extensibility and interoperability between applications. BTW, the lack of extensibility of non XML syntaxes would also be an issue with if I wanted to integrate xvif into the compact syntax for RELAX NG...
WikiMl
    Published WikiMl as a project on advogato and freshmeat which gives it some visibility and got some interesting threads starting on its mailing list.
xvif
    Also published release 0.1.2 of xvif with a bug fix and the packaging of Relax NG test suites like I had done in 0.1.1 for the Regular Fragmentations test suite.

Links

    The links between those two projects? I am using WikiMl to write my next book. The subject of this book is Relax NG and I am testing the examples of the book against the Relax NG implementation which is part of xvif (that's how I have found the bug fixed today). So there are some links between these projects and I am already using both of them together for some real world work!
XML Schema book
    This morning I have received my copies of my XML Schema book. I had seen the PDFs, but that's really different to get the real book in the hands. It's nice to see the result of 18 months of hard work.

xvif

    Just published release 0.1.1 of xvif. The major update is the implementation of a test suite for Regular Fragmentations which relies on a new module (xmlcomp) performing simple but flexible comparisons between documents (you can define what you want to test and ignore things such as empty text nodes or namespace prefixes).
XmlSchemata.org
    Pushed by a need to find a home for xvif, I have finally started opening some sections of XmlSchemata.org, an "equal opportunity web site for XML schema languages". Currently available are: All this powered by "best of the breed" open source software.
    The next problem I'll have to face is the need for some level of integration and common look and feel for XmlSchemata. So far, I have been solving this kind of issues (for instance for XMLfr) the hard and classical way by using the customization features of each open source application to present it in the look and feel of the site. It's perfectly possible to achieve a pretty good result since most if not all these softwares are flexible enough to look as you like. It's painfull though since the customization is different for each of them and it's also very difficult to maintain: to apply any change to the whole site you need to edit the configuration of each of the applications you've installed.
    I am considering using a different approach for XmlSchemata.org and developing a kind of "presentation/proxy server" which would act as a proxy adding the presentation through XSLT transformations. I have started developing a simple prototype using Python and libxml/libxslt and this looks very promissing. The benefit of using libxml/libxslt is that it's very fast and has a good HTML parser.
    The idea is that this presentation server would receive the requests and apply a XSLT transformation on the HTTP request formalized as XML. This transformation would read some kind of site map and when needed either execute a CGI script or pass the request to another HTTP server and format the (X)HTML result of the CGI or HTTP request. I am quite confident that the customization of open source applications can be much less painfull and much easier to maintain using this kind of techniques... But I still need to prove it!
20 Jun 2002 (updated 20 Jun 2002 at 11:29 UTC) »
xvif
    I have, at last, published a first release of my proposal for an Xml Validation Interoperability Framework (xvif) to tie together Relax NG, XPath, XSLT, Regular Fragmentations and more if needed. It's written in Python and available under MPL. I am now eagerly waiting for feedback!
Regular Fragmentations
    Finished and posted today a first version of a Python implementation of simonstl's Regular Fragmentations including an online demo. Regular Fragmentations are one of the technologies which may be very usefull in a validation framework and I like their simplicity even though, as usual, things begin to get nasty when you want to deal with attributes!

Banana Republic
    It's more than depressing to see his country becoming a new banana republic.
Relax NG
    Finished yesterday a first decent-but-not-complete-yet version of my Relax NG validator and a very raw on line validator. There are still a number of limitations (includes and external refs, class names and datatypes others than Relax NG builtin "string" and "token" and some validity checks of the schemas themselves are not implemented yet) but the validator passes the 213 tests of the test suite corresponding to what is already implemented.
DSDL
    My next step will be to implement a prototype of the strawman I have proposed for the DSDL Interoperability Framework which enables to perform transformations during the validation of a document. BTW, I have noticed that Relax NG does already implement such a transformation in its "list" pattern which splits a text node into a list and I see it as a good sign that my proposal doesn't break the mathematical foundation of Relax NG...
Relax NG
    I have been busy with my Python implementation of Relax NG and it's nice to have found enough time to do some coding again. I have implemented most of the core features (ie except datatypes, external references and name classes) and it passes the 169 corresponding tests of the test suite except 13 which deal with the detection of nasty errors in the schemas. From there, I am wondering if my next step should be to continue the implementation or to start implementing some of the features of the Interoperability Framework which I am proposing to the ISO DSDL workgroup.
Relax NG

    Just started to hack a prototype of a Relax NG validator in Python. I am aware that this is duplication of work and that another Python implementation is on the way but I have thought that working on my own implementation would help me for the book I am starting to write on the subject and for the work I am doing on the interoperability framework of DSLD. I see my implementation as "self-didactical" and am not sure if it will eventually turn into something which can be used by others, but I have already learned quite a lot from it.

    I am following James Clark's derivative algorithm also described by A.M. Kuchling who is working on the other Python implementation and am also amazed by the elegance of the thing. The variation which I am bringing over this is borrowed from my Examplotron: having learned that instance documents can be seen as schemas, I am considering the instance document being validated as a set of Relax NG patterns following a different serialization.

    Using the same classes for the Relax NG patterns describing the schema and the nodes from the instance document makes these classes more generic and the validation become the computation of the derivations of patterns relative to other patterns which is kind of fun.

7 older entries...

New Advogato Features

New HTML Parser: The long-awaited libxml2 based HTML parser code is live. It needs further work but already handles most markup better than the original parser.

Keep up with the latest Advogato features by reading the Advogato status blog.

If you're a C programmer with some spare time, take a look at the mod_virgule project page and help us with one of the tasks on the ToDo list!