Valid XHTML     Valid CSS2    

Développement Web et représentation de données :

       Comment conclure sur XML ?

           gilles.hunault "at" univ-angers.fr

 

Présentation

En fait, on n'a jamais fini de parler de XML. Lorsqu'on en a compris les fondamentaux, on se rend compte qu'il y a aussi de nouvelles spécifications, ou de nouvelles implémentations. Ou de nouvelles applications. Ainsi, nous avons vu les principes de base de XML, DTD et XSD. A l'aide de XPath 1.0, nous avons écrit des transformations XSLT 1.0. Comme tout le monde. Et avec les outils de 2012, qui utilisent les spécifications du début des années 2000. Oui, mais en 2007, les recommandations XSLT 2.0 ont été publiées, avec

  • XDM qui explicite le modèle des données ;

  • XPath 2.0 qui améliore notablement XPath 1.0 ;

  • XSLT 2.0 qui se base sur XPath 2.0 et qui améliore notablement XSLT 1.0 ;

  • XQuery 1.0 qui simplifie l'écriture de transformations XSL 2.0.

Les changements importants qu'apportent ces nouvelles spécifications ne sont pas tous implémentés. Ainsi, à ce jour (2012), la plupart des navigateurs ne savent pas effectuer de transformations XSLT 2.0. Heureusement, sous Linux, on peut utiliser libsaxonb-java qui inclut saxonb-xslt et saxonb-xquery.

Que manquait-il à XSLT 1.0 ?

Même si XSL 1.0 permet de programmer de nombreuses actions (voir par exemple progs_xsl.zip), il manque beaucoup de choses à XSLT 1.0. Par exemple une transformation XSLT 1.0 ne gère qu'un document de sortie. Si on veut produire un fichier des films et un fichier des artistes à partir de films2.xml, il faut deux transformations XSL 1.0. En XSLT classique, on ne peut pas demander à tester que le document produit par la transformation soit confronté à un schéma. Et on ne peut pas pas créer ses propres fonctions, ni regrouper les contenus. Ni produire du XHTML, ni traiter des séquences de valeurs, ni...

Voici une transformation XSL 2.0 qui affiche 5, 4, 3, 2, 1 nommée sequences_v2.xsl qu'on peut appliquer au fichier vide.xml (qui ne contient... rien !) : 


     <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
     <xsl:output method="text" indent="no" encoding="utf-8" />
     <!-- s'utilise via  saxonb-xslt -ext:on -xsl:sequences_v2.xsl vide.xml -->
     
     <xsl:template match="/">
        <xsl:sequence select='reverse( (1,2,3,4,5) )' />
        <xsl:text>
        </xsl:text>
     </xsl:template>
     </xsl:stylesheet>

Pour vérifier que votre navigateur ne connait pas XSL 2.0, il suffit de cliquer sur le lien essaixsl2.xml ce qui devrait aboutir à une erreur, contrairement au lien essaixsl1.xml.

Que manquait-il à XPath 1.0 ?

Là encore, beaucoup de choses. XPath 1.0 utilisait des ensembles de noeuds alors que XPath 2.0 sait gérer des séquences de noeuds et/ou de valeurs. On dispose désormais d'un vrai if/then/else, de boucles sur les variables, de fonctions min et max, de conversions majuscules/minuscules, de quantification de conditions (some, any, every), de suppression de doublon, de parcours de séquences, de fonctions pour la date et l'heure courante, de la gestion (partielle) de texte non XML...

A titre d'exemple, voici une transformation XSL 2.0 qui affiche la date et l'heure, nommée bonjour_v2.xsl qu'on peut aussi appliquer au fichier vide.xml : 


     <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
     <xsl:output method="text" indent="no" encoding="utf-8" />
     <!-- s'utilise via  saxonb-xslt -ext:on -xsl:bonjour_v2.xsl vide.xml -->
     
     <xsl:template match="/">
        <xsl:text>Bonjour. Nous sommes le </xsl:text>
        <xsl:value-of select="current-dateTime()"/>
        <xsl:text>.
        </xsl:text>
     </xsl:template>
     </xsl:stylesheet>

Pour vérifier que votre navigateur ne connait pas XPath 2.0, il suffit de cliquer sur le lien essaixpath2.xml ce qui devrait aboutir à une erreur, contrairement au lien essaixpath1.xml.

Qu'est-ce que XQuery 1.0 ?

XQuery est un langage de requêtes «à la SQL» dont la syntaxe n'utilise pas XML. XQuery, qui utilise XPath 2.0, est concis, lisible, assez facile à apprendre. De plus son mécanisme FLWOR n'est pas sans rappeler le mécanisme SFWGHOL (Select, From, Where, Group by, Having, Order, Limit) de SQL.

La syntaxe de ces expressions, disponible sur le site du W3C, disponible dans la section des transformations XML, à la rubrique xquery se réduit effectivement à une syntaxe de boucle avec des options de jointure, filtrage et tri.

Voici un exemple d'une requête XQuery (fichier demo.xql) : 


     (: un exemple simple :)
     
     <resultat>
     
     {  for $s in
         fn:doc("serv00.xml")//service
        return $s
     }
     
     </resultat>

Et son résultat si on l'utilise via saxonb-xquery demo.xql : 


     <?xml version="1.0" encoding="UTF-8"?>
     <resultat>
        <service>Achats</service>
        <service>Direction</service>
        <service>
     Courrier
     </service>
        <service>Direction</service>
     </resultat>

On notera au passage qu'il n'y a pas besoin de définir en ligne de commandes un document XML sur lequel appliquer la transformation puisqu'on dispose de la fonction doc. La programmation XSL et XPath ressemble donc avec XQuery à une programmation plus conventionnelle...

Bien sûr les navigateurs ne connaissent pas XQuery, mais Javascript peut l'implémenter, par exemple avec xqib. Ouf !

1. XML et les autres schémas

A l'utilisation, les DTD sont trop simples, les XSD trop verbeuses, surtout à écrire. Heureusement, d'autres formalismes permettent d'écrire des grammaires, comme Schematron qui se base sur des motifs et permet d'exprimer des contraintes, ou comme Relax NG qui peut s'écrire en forme standard (XML) ou selon une syntaxe plus "compacte". Un schéma en Relax NG peut ensuite être converti en XSD à l'aide d'un outil comme trang. Tous ces langages rentrent dans la catégorie des DSDL.

Voici un fichier écrit en syntaxe compacte en Relax NG nommé demo.rnc disponible sur le site de J. F. Perrot (on en profitera pour consulter ses cours de d'ingénierie multilingue et de traductique, tous deux liés à XML, à l'adresse inalco/XML)  : 


     default namespace = "http://www.malenfant.fr/meteo3"
     
     start = meteo
     
     meteo = element meteo { obs+ }
     
     obs   = element obs {
         identification, mesures, message?
     }
     
     identification =
         attribute num {
             xsd:NMTOKEN {
                 pattern = "[A-Z]{2,2}\d+V\d{3,3}"
             }
         },
         loc, moment
     
     loc = element loc { localisation }
     
     localisation = element nom { text }
     
     moment = element moment { xsd:dateTime }
     
     mesures =
         (attribute type { xsd:NMTOKEN "mobile" },
             temp, anemo)
         |
         (attribute type { xsd:NMTOKEN "fixe" },
             temp, hygro, nebulo, anemo, pluvio)
     
     temp = element temp {
         attribute unit { "celsius" | "farenheit" },
         xsd:decimal
     }
     
     hygro   = element hygro    { xsd:decimal     }
     nebulo  = element nebulo   { xsd:decimal     }
     anemo   = element anemo    { xsd:decimal     }
     pluvio  = element pluvio   { xsd:decimal     }
     message = element message  { langue?, string }
     langue  = attribute langue { xsd:language    }

Sa traduction automatique par trang en DTD est impossible ; le message correspondant est demo.rnc:28:5: error: sorry, ambiguous attribute choice not handled (attribute "type" from namespace "") :

La version longue au format XML/RNG est : 


     <?xml version="1.0" encoding="UTF-8"?>
     <grammar ns="http://www.malenfant.fr/meteo3" xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
     
       <start>
         <ref name="meteo"/>
       </start>
     
       <define name="meteo">
         <element name="meteo">
           <oneOrMore>
             <ref name="obs"/>
           </oneOrMore>
         </element>
       </define>
     
       <define name="obs">
         <element name="obs">
           <ref name="identification"/>
           <ref name="mesures"/>
           <optional>
             <ref name="message"/>
           </optional>
         </element>
       </define>
     
       <define name="identification">
         <attribute name="num">
           <data type="NMTOKEN">
             <param name="pattern">[A-Z]{2,2}\d+V\d{3,3}</param>
           </data>
         </attribute>
         <ref name="loc"/>
         <ref name="moment"/>
       </define>
     
       <define name="loc">
         <element name="loc">
           <ref name="localisation"/>
         </element>
       </define>
     
       <define name="localisation">
         <element name="nom">
           <text/>
         </element>
       </define>
     
       <define name="moment">
         <element name="moment">
           <data type="dateTime"/>
         </element>
       </define>
     
       <define name="mesures">
         <choice>
           <group>
             <attribute name="type">
               <value type="NMTOKEN">mobile</value>
             </attribute>
             <ref name="temp"/>
             <ref name="anemo"/>
           </group>
           <group>
             <attribute name="type">
               <value type="NMTOKEN">fixe</value>
             </attribute>
             <ref name="temp"/>
             <ref name="hygro"/>
             <ref name="nebulo"/>
             <ref name="anemo"/>
             <ref name="pluvio"/>
           </group>
         </choice>
       </define>
     
       <define name="temp">
         <element name="temp">
           <attribute name="unit">
             <choice>
               <value>celsius</value>
               <value>farenheit</value>
             </choice>
           </attribute>
           <data type="decimal"/>
         </element>
       </define>
     
       <define name="hygro">
         <element name="hygro">
           <data type="decimal"/>
         </element>
       </define>
     
       <define name="nebulo">
         <element name="nebulo">
           <data type="decimal"/>
         </element>
       </define>
     
       <define name="anemo">
         <element name="anemo">
           <data type="decimal"/>
         </element>
       </define>
     
       <define name="pluvio">
         <element name="pluvio">
           <data type="decimal"/>
         </element>
       </define>
     
       <define name="message">
         <element name="message">
           <optional>
             <ref name="langue"/>
           </optional>
           <data type="string" datatypeLibrary=""/>
         </element>
       </define>
     
       <define name="langue">
         <attribute name="langue">
           <data type="language"/>
         </attribute>
       </define>
     
     </grammar>

Enfin sa traduction en XSD, précédée du message demo.rnc:28:5: warning: choice between attributes and children cannot be represented; approximating est  : 


     <?xml version="1.0" encoding="UTF-8"?>
     <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
       elementFormDefault="qualified"
       targetNamespace="http://www.malenfant.fr/meteo3"
       xmlns:meteo3="http://www.malenfant.fr/meteo3">
     
       <xs:element name="meteo">
         <xs:complexType>
           <xs:sequence>
             <xs:element maxOccurs="unbounded" ref="meteo3:obs"/>
           </xs:sequence>
         </xs:complexType>
       </xs:element>
     
       <xs:element name="obs">
         <xs:complexType>
           <xs:complexContent>
             <xs:extension base="meteo3:identification">
               <xs:sequence>
                 <xs:group ref="meteo3:mesures"/>
                 <xs:element minOccurs="0" ref="meteo3:message"/>
               </xs:sequence>
               <xs:attributeGroup ref="meteo3:mesures"/>
             </xs:extension>
           </xs:complexContent>
         </xs:complexType>
       </xs:element>
     
       <xs:complexType name="identification">
         <xs:sequence>
           <xs:element ref="meteo3:loc"/>
           <xs:element ref="meteo3:moment"/>
         </xs:sequence>
         <xs:attribute name="num" use="required">
           <xs:simpleType>
             <xs:restriction base="xs:NMTOKEN">
               <xs:pattern value="[A-Z]{2,2}\d+V\d{3,3}"/>
             </xs:restriction>
           </xs:simpleType>
         </xs:attribute>
       </xs:complexType>
     
       <xs:element name="loc" type="meteo3:localisation"/>
       <xs:complexType name="localisation">
         <xs:sequence>
           <xs:element ref="meteo3:nom"/>
         </xs:sequence>
       </xs:complexType>
     
       <xs:element name="nom" type="xs:string"/>
     
       <xs:element name="moment" type="xs:dateTime"/>
     
       <xs:group name="mesures">
         <xs:choice>
           <xs:sequence>
             <xs:element ref="meteo3:temp"/>
             <xs:element ref="meteo3:anemo"/>
           </xs:sequence>
           <xs:sequence>
             <xs:element ref="meteo3:temp"/>
             <xs:element ref="meteo3:hygro"/>
             <xs:element ref="meteo3:nebulo"/>
             <xs:element ref="meteo3:anemo"/>
             <xs:element ref="meteo3:pluvio"/>
           </xs:sequence>
         </xs:choice>
       </xs:group>
     
       <xs:attributeGroup name="mesures">
         <xs:attribute name="type" use="required">
           <xs:simpleType>
             <xs:restriction base="xs:NMTOKEN">
               <xs:enumeration value="mobile"/>
               <xs:enumeration value="fixe"/>
             </xs:restriction>
           </xs:simpleType>
         </xs:attribute>
       </xs:attributeGroup>
     
       <xs:element name="temp">
         <xs:complexType>
           <xs:simpleContent>
             <xs:extension base="xs:decimal">
               <xs:attribute name="unit" use="required">
                 <xs:simpleType>
                   <xs:restriction base="xs:token">
                     <xs:enumeration value="celsius"/>
                     <xs:enumeration value="farenheit"/>
                   </xs:restriction>
                 </xs:simpleType>
               </xs:attribute>
             </xs:extension>
           </xs:simpleContent>
         </xs:complexType>
       </xs:element>
     
       <xs:element name="hygro"  type="xs:decimal"/>
       <xs:element name="nebulo" type="xs:decimal"/>
       <xs:element name="anemo"  type="xs:decimal"/>
       <xs:element name="pluvio" type="xs:decimal"/>
     
       <xs:element name="message">
         <xs:complexType>
           <xs:simpleContent>
             <xs:extension base="xs:string">
               <xs:attribute name="langue" type="xs:language"/>
             </xs:extension>
           </xs:simpleContent>
         </xs:complexType>
       </xs:element>
     
       <xs:attributeGroup name="langue">
         <xs:attribute name="langue" use="required" type="xs:language"/>
       </xs:attributeGroup>
     
     </xs:schema>

Un autre exemple est celui du fichier 07exercice03.rnc extrait du livre XML de G. Chagnon et F. Nolot aux éditions Pearson. Le voici en version concise (extension .rnc) 


     datatypes xsd = "http://www.w3.org/2001/XMLSchema-datatypes"
     
     start = element annuaire {
        elt.personne +
     }
     
     type.heure = xsd:time
     
     elt.téléphone = element téléphone {
              attribute numéro {
                 list{
                    xsd:byte{
                       minInclusive="0"
                       maxInclusive="99"
                    }
                 }
              },
              element heureDAppel {
                 attribute heureDébut {type.heure},
                 attribute heureFin {type.heure}
              }
           }
     
     elt.personne = element personne {
           attribute nom { text },
           attribute prénom { text }?,
           element dateAnniversaire {xsd:date},
           element idéesCadeaux {text},
           elt.téléphone
        }

Et en version longue, au format XML (extension .rng) 


     <?xml version="1.0" encoding="ISO-8859-15" ?>
     <grammar xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
     
       <start>
         <element name="annuaire">
           <oneOrMore>
             <ref name="elt.personne"/>
           </oneOrMore>
         </element>
       </start>
     
       <define name="type.heure">
         <data type="time"/>
       </define>
     
       <define name="elt.téléphone">
         <element name="téléphone">
           <attribute name="numéro">
             <list>
               <data type="byte">
                 <param name="minInclusive">0</param>
                 <param name="maxInclusive">99</param>
               </data>
             </list>
           </attribute>
           <element name="heureDAppel">
             <attribute name="heureDébut">
               <ref name="type.heure"/>
             </attribute>
             <attribute name="heureFin">
               <ref name="type.heure"/>
             </attribute>
           </element>
         </element>
       </define>
     
       <define name="elt.personne">
         <element name="personne">
           <attribute name="nom"/>
           <optional>
             <attribute name="prénom"/>
           </optional>
           <element name="dateAnniversaire">
             <data type="date"/>
           </element>
           <element name="idéesCadeaux">
             <text/>
           </element>
           <ref name="elt.téléphone"/>
         </element>
       </define>
     
     </grammar>

Et enfin la verson schéma XSD correspondante, la traduction étant assurée par trang : 


     <?xml version="1.0" encoding="ISO-88859-15" ?>
     <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
     
       <xs:element name="annuaire">
         <xs:complexType>
           <xs:sequence>
             <xs:element maxOccurs="unbounded" ref="personne"/>
           </xs:sequence>
         </xs:complexType>
       </xs:element>
     
       <xs:simpleType name="type.heure">
         <xs:restriction base="xs:time"/>
       </xs:simpleType>
     
       <xs:element name="téléphone">
         <xs:complexType>
           <xs:sequence>
             <xs:element ref="heureDAppel"/>
           </xs:sequence>
           <xs:attribute name="numéro" use="required">
             <xs:simpleType>
               <xs:restriction>
                 <xs:simpleType>
                   <xs:list>
                     <xs:simpleType>
                       <xs:restriction base="xs:byte">
                         <xs:minInclusive value="0"/>
                         <xs:maxInclusive value="99"/>
                       </xs:restriction>
                     </xs:simpleType>
                   </xs:list>
                 </xs:simpleType>
                 <xs:length value="1"/>
               </xs:restriction>
             </xs:simpleType>
           </xs:attribute>
         </xs:complexType>
       </xs:element>
     
       <xs:element name="heureDAppel">
         <xs:complexType>
           <xs:attribute name="heureDébut" use="required" type="type.heure"/>
           <xs:attribute name="heureFin" use="required" type="type.heure"/>
         </xs:complexType>
       </xs:element>
     
       <xs:element name="personne">
         <xs:complexType>
           <xs:sequence>
             <xs:element ref="dateAnniversaire"/>
             <xs:element ref="idéesCadeaux"/>
             <xs:element ref="téléphone"/>
           </xs:sequence>
           <xs:attribute name="nom" use="required"/>
           <xs:attribute name="prénom"/>
         </xs:complexType>
       </xs:element>
     
       <xs:element name="dateAnniversaire" type="xs:date"/>
       <xs:element name="idéesCadeaux" type="xs:string"/>
     
     </xs:schema>

Le terme de schéma pour XML n'est pas sans rappeler celui de schéma pour les bases de données. Sur les rapports entre XML et les bases de données, on pourra lire les documents xmlBD, XMLDBLinks et enfin Mapping DTDs to Databases car il est relativement naturel (quoique parfois pas très optimal) de convertir des tables d'un schéma relationnel en éléments et balises...

2. XML et les pages Web

Une application très importante de XML est la reprise de HTML en XML, ce qui se nomme XHTML. Au delà des versions (1.0, 1.1, strict, transitional, frameset), les navigateurs savent utiliser XML et même effectuer des transformations XSL. Par contre, les validations par grammaire ne sont pas implémentées, les navigateurs se contentant de tester si les pages sont bien formées lorsqu'on prévient qu'il s'agit de pages XML. Sinon, comme à l'habitude, les navigateurs essaient d'afficher, page "correcte" ou pas...

Une révolution importante liée à XML est la technologie AJAX qui, si elle n'utilise pas toujours XML (le X de AJAX correspond pourtant à XML) utilise le modèle objet des documents (DOM) via Javascript, et vient dynamiquement (sans recharger la page) modifier les attributs, les éléments de la page... Voir par exemple notre tuteur AJAX.

Une extension pour le navigateur Firefox est un fichier XPI, qui est une archive, contenant entre autres un fichier XML nommé install.rdf et souvent une ou plusieurs archives jar dans lesquelles on trouve des fichiers XUL.

Prenons l'exemple de l'extension ShowIP qui affiche l'IP du serveur contenant la page courante : 


     $gh> wget http://firefox-showip.googlecode.com/files/showip_1.2rc4.xpi
     
     $gh> unzip showip_1.2rc4.xpi
     
     Archive:  showip_1.2rc4.xpi
        creating: chrome/
       inflating: chrome/ipv6ident.jar
       inflating: chrome.manifest
       inflating: install.rdf
       inflating: install.js
       inflating: COPYING
     
     $gh> cd chrome/
     
     $gh/chrome> unzip ipv6ident.jar
     
     Archive:  ipv6ident.jar
        creating: content/
        creating: locale/
        creating: locale/da-DK/
        creating: locale/da-DK/showip/
        creating: locale/en-US/
        creating: locale/en-US/showip/
        creating: locale/sv-SE/
        creating: locale/sv-SE/showip/
        creating: locale/zh-CN/
        creating: locale/zh-CN/showip/
       inflating: content/contents.rdf
       inflating: content/favicon.svg
       inflating: content/ipv6ident-pref.js
       inflating: content/ipv6ident-pref.xul
       inflating: content/ipv6ident.css
       inflating: content/ipv6ident.js
       inflating: content/ipv6ident.xul
       inflating: content/showip-lru-test.html
       inflating: content/showip-lru.js
       inflating: content/showip.xul
       inflating: locale/da-DK/showip/contents.rdf
       inflating: locale/da-DK/showip/showip.dtd
       inflating: locale/da-DK/showip/showip.properties
       inflating: locale/en-US/showip/contents.rdf
       inflating: locale/en-US/showip/showip.dtd
       inflating: locale/en-US/showip/showip.properties
       inflating: locale/sv-SE/showip/contents.rdf
       inflating: locale/sv-SE/showip/showip.dtd
       inflating: locale/sv-SE/showip/showip.properties
       inflating: locale/zh-CN/showip/contents.rdf
       inflating: locale/zh-CN/showip/showip.dtd
       inflating: locale/zh-CN/showip/showip.properties
     
     $gh/chrome> cd content
     
     $gh/chrome/content> cat showip.xul
     
     <?xml version="1.0"?>
     <?xml-stylesheet href="chrome://ipv6ident/content/ipv6ident.css" type="text/css"?>
     
     <!-- [...] -->
     
     <overlay id="ipv6ident-overlay"
       xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
     
        <script type="text/javascript" src="showip-lru.js"/>
        <script type="text/javascript" src="ipv6ident-pref.js"/> <!-- for preferences -->
        <script type="text/javascript" src="ipv6ident.js"/>
     
        <stringbundleset id="stringbundleset">
        <stringbundle id="showip_strings" src="chrome://ipv6ident/locale/showip.properties"/>
        </stringbundleset>
     
     
     <toolbarpalette id="BrowserToolbarPalette">
      <toolbaritem id="showip_status_item">
       <hbox>
       <toolbarbutton label="" type="" id="showip_status_domain"
          orient="horizontal" image="" context="_child">
       </toolbarbutton>
       <toolbarbutton label="ShowIP" type="menu" id="showip_status_text"
          orient="horizontal" image="" context="_child">
        <menupopup id="showip_popup" />
       </toolbarbutton>
       </hbox>
      </toolbaritem>
     </toolbarpalette>
     
     </overlay>
     
     
     $gh> cat contents.rdf
     
     <?xml version="1.0"?>
     <RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
       xmlns:chrome="http://www.mozilla.org/rdf/chrome#">
     
     <!-- [...] -->
     
     <RDF:Seq about="urn:mozilla:package:root">
        <RDF:li resource="urn:mozilla:package:ipv6ident"/>
     </RDF:Seq>
     
     <RDF:Description about="urn:mozilla:package:ipv6ident"
       chrome:displayName="ShowIP"
       chrome:author="Jan Dittmer"
       chrome:authorURL="http://l4x.org/showip"
       chrome:name="ipv6ident"
       chrome:extension="true"
       chrome:description="Show the IP Address of the current site in the statusbar and allow some lookups.">
     </RDF:Description>
     
     <RDF:Seq about="urn:mozilla:overlays">
        <!-- firefox -->
        <RDF:li resource="chrome://browser/content/browser.xul"/>
        <!-- mozilla -->
        <RDF:li resource="chrome://navigator/content/navigator.xul"/>
     </RDF:Seq>
     
     <RDF:Seq about="chrome://browser/content/browser.xul">
        <RDF:li>chrome://ipv6ident/content/ipv6ident.xul</RDF:li>
     </RDF:Seq>
     
     <RDF:Seq about="chrome://navigator/content/navigator.xul">
        <RDF:li>chrome://ipv6ident/content/ipv6ident.xul</RDF:li>
     </RDF:Seq>
     
     </RDF:RDF>

De même, XAML est un langage basé sur XML prévu pour Windows et sert à la création d'interfaces "riches". Plus sur xaml.fr avec un exemple sur scriptol.fr.

Enfin, pour la mise à disposition des ressources d'un site, sitemaps se code facilement en XML suivant le protocole idoine.

3. XML et les services Web

Un domaine privilégié pour XML est celui de l'échange d'informations sur Internet. La notion de SOA qui débouche sur les WSDL dont RPC/SOAP est le genre de phrase à jargon qui malheureusement doit faire partie de la culture XML liées aux échanges de données et aux protocoles. On y ajoutera profitablement le sigle ebXML.

On peut certainement ajouter la syndication et en particulier la syndication de flux à cette rubrique avec les incontournables RSS et ATOM.

Nous n'en dirons pas plus sur le sujet car il y a un cours prévu sur les services Web dans ce module.

4. XML et le Web sémantique

Le web sémantique ne s'oppose pas au Web syntaxique mais au contraire veut le compléter. Il utilise un mécanisme logique simple basé sur des ressources de données (RDF en anglais) représentées par des graphes de triplets sujet, prédicat, objet. Ce mécanisme, issu des logiques de description permet, à l'aide d'ontologies structurées en fichiers XML via OWL, de faire des déductions basées sur le sens. Un des langages de requêtes associé se nomme SPARQL.

Il faut certainement le complèter à son tour par le Web de données comme à la BNF.

Là encore, nous n'en dirons pas plus sur le sujet car il y a aussi un cours prévu sur le Web sémantique dans ce module.

5. XML et l'imprimerie

SGML a été historiquement développé pour aider à séparer le fond et la forme dans les documents techniques. Au niveau de l'imprimerie et de l'édition d'ouvrages, DocBook s'est à peu près imposé. Vous trouverez plus d'informations sur docbookg.org. Il ne faut pas oublier non plus BiblioML qui est en quelque sorte la version XML des formats UNIMARC pour les échanges de données bibliographiques ni Onix (ONline Information eXchange) qui regroupe les formats XML pour la vente de livres.

6. XML, la voix, la musique et la télévision

L'avènement de la synthèse vocale et de la reconnaissance de la parole ont permis d'automatiser l'interrogation par téléphone de nombreux serveurs. Une contribution majeure liée à XML est VoiceXML. Comme le montre la page du VBWG il s'agit d'un domaine toujours en pleine activité en 2012. Dans le domaine de la musique, on pourra citer MusicXML comme initiative intéressante et pour ceux qui connaissent iTunes, le lien HT1660 explique où sont les fichiers XML utilisés.

Bien évidemment, XMLTV est un format XML dédié au stockage des programmes de télévision qui prend tout son sens depuis que les TV sont devenues connectées (sous-entendu "au Web").

7. Encore d'autres langages basés sur XML

Afin de rester dans un domaine proche du développement Web et qui embauche encore beaucoup en ces années 2010, nous ne parlerons ici que de GML dont les schémas sont sur le site opengis, sans oublier XMS et WFS. Google maps n'est pas en reste, bien sûr, par exemple pour android ou encore, avec KML (wiki). On l'aura compris, en XML, tout est sigle et culture encyclopédique...

8. Soyons critiques et réalistes

Il ne faut pas s'effrayer de l'apparente complexité du vocabulaire technique. XML est conceptuellement simple : on fait des choix de structure, de cardinalité et de typage, comme en systèmes d'information et en bases de données, puis on fournit des outils de vérification, contrôle et garantie de qualité (les grammaires) et enfin on transforme pour assurer la diffusion dans tous les formats et medias requis. Le reste n'est que codage informatique...

Les bons points de XML sont :

  • le format texte qui est un format libre et «zippable» ;

  • l'intégration aisée des contenus des bases de données ;

  • la structure hiérarchique en arbre ;

  • le balisage issu de SGML ;

  • la vérification via les grammaires ;

  • le typage, la cardinalité via les schémas XSD ;

  • la transformation via la programmation fonctionnelle en XSLT.

Malgré tous ces bons points, il reste quelques difficultés à tout intégrer via XML et à tout traiter en XML.

La première critique qu'on peut faire est que XML impose une structure et rend les textes peu lisibles. Quand un fichier texte est très court, ou quand on veut relire un fichier XML «simple», il faut enlever les balises, choisir puis imposer cette structure.

La deuxième critique qu'on peut faire est la technicité requise pour réaliser les grammaires-schémas XSD. C'est pourquoi les grammaires DTD, beaucoup moins puissantes, mais nettement plus simples, sont souvent utilisées, au moins dans un premier temps. Mais les DTD ne s'écrivent pas en XML. Il en va de même avec les grammaires Relax NG, qui utilisent un formalisme et une écriture beaucoup plus lisibles. On les traduit ensuite en XSD, mais on ne les écrit pas en XML.

C'est la même raison qui pousse à utiliser le langage N3 au lieu de XML/RDF dans le [petit] monde du Web sémantique. Et c'est ce qui fera qu'on utilisera certainement beaucoup plus dans les années à venir XQuery et SPARQL que XSLT directement...

Enfin, il ne faut pas oublier que XML n'est pas la seule solution pour la structuration dans les fichiers-textes. Ainsi, JSON est une alternative simple et rapide à utiliser, qui n'est pas réservée à Javascript. Par exemple, PHP sait gérer des objets et du code JSON via une API simple. Et si XML et JSON ne suffisent pas, il y a aussi YAML.

Les extremistes XML vous diront que la transformation [en XSLT 2] json2xml.xsl transforme du JSON en XML, et que son équivalent javascript ne prend qu'une quinzaine de lignes (voir par exemple json2xml.js) mais cela ne prouve pas qu'il faut tout faire avec XML...

Pour conclure cette conclusion (!), on pourra replacer XML dans son contexte grâce à l'excellent site bdpedia.fr de Philippe RIGAUX et s'ouvrir ainsi l'esprit à Docker, Kitematic, Cassandra, MongoDb, CouchDB, BaseX, MapReduce, Soir et SoirCloud, ElasticSearch, ZooKeeper, Pig...

 

 

retour gH    Retour à la page principale de   (gH)