Recent Specifications

[CR: 20020820]

[December 17, 2003]   W3C Publishes First Working Draft for Extensible Stylesheet Language (XSL) Version 1.1.    W3C has released an initial public working draft for Extensible Stylesheet Language (XSL) Version 1.1, updating the W3C XSL Version 1.0 Recommendation published on October 15, 2001. This specification and a companion Extensible Stylesheet Language (XSL) Version 1.1 Requirements document have been produced as part of the W3C XML Activity by the XSL Working Group. The Extensible Stylesheet Language (XSL) is "a language for expressing stylesheets. Given a class of arbitrarily structured XML documents or data files, designers use an XSL stylesheet to express their intentions about how that structured content should be presented; that is, how the source content should be styled, laid out, and paginated onto some presentation medium, such as a window in a Web browser or a hand-held device, or a set of physical pages in a catalog, report, pamphlet, or book. New functionality has been added in XSL Version 1.1 to support change marks, indexes, multiple flows, and bookmarks. Existing functionality has been extended in the areas of graphics scaling, 'markers' and their retrieval in tables to support e.g., partial sums, and page number referencing. A number of errata changes have been incorporated into the text. This document is expected to be taken through the W3C Recommendation track process. Since first becoming a W3C Recommendation, XSL 1.0 has enjoyed widespread support. However, the user community has expressed requirements that have encouraged various implementations to provide extensions to the language. These extensions -- especially those implemented by more than one implementation -- are clear candidates for standardization so as to maximize interoperability. The XSL Working Group has surveyed and analyzed various existing extensions, user requirements, and features intentionally cut from XSL 1.0 due to lack of time. Using the results of this research, the Working Group is developing the XSL 1.1 version that incorporates current errata and includes a subset of relatively simple and upward compatible additions to XSL."

[August 20, 2002]   W3C Working Groups Update Specifications for XSLT, XML Query, and XPath.    Seven revised working draft specifications have been published by the W3C Working Groups for XML Query, XSL, and XML Schema. Several working drafts represent collaborative work by the XSL and XML Query Working Groups, which are jointly responsible for XPath 2.0, a language derived from both XPath 1.0 and XQuery; the XPath 2.0 and XQuery 1.0 Working Drafts are generated from a common source. The updated working drafts include: XSL Transformations (XSLT) Version 2.0; XML Path Language (XPath) 2.0; XML Query Use Cases; XQuery 1.0: An XML Query Language; XQuery 1.0 and XPath 2.0 Formal Semantics; XQuery 1.0 and XPath 2.0 Data Model; XQuery 1.0 and XPath 2.0 Functions and Operators. Comments on these drafts may be sent to the W3C Query and Transform mailing list ('public-qt-comments') set up for public feedback on W3C specifications published by the XML Query and XSL Working Groups. [Full context]

[December 20, 2001]   New W3C Version 2.0 Working Draft for XSL Transformations (XSLT).    W3C has published a first public working draft for XSL Transformations (XSLT) Version 2.0. The working draft constitutes a revised version of the XSLT 1.0 Recommendation published on 16-November-1999; it thus supersedes XSLT 1.1, which was never developed beyond the Working Draft stage. The version 2.0 XSLT specification "defines the syntax and semantics of XSLT, which is a language for transforming XML documents into other XML documents. XSLT is designed for use as part of XSL, which is a stylesheet language for XML. In addition to XSLT, XSL includes an XML vocabulary for specifying formatting, as defined in XSL Formatting Objects. XSL Formatting Objects are frequently used as the output of an XSLT transformation. XSLT is also designed to be used independently of XSL Formatting Objects. It is often used to produce HTML and XHTML documents, as well as for transformation of application-specific message formats. XSLT 2.0 is designed to be used together with XPath 2.0, which has been developed by the W3C XSL Working Group in collaboration with the XML Query Working Group." The non-normative Appendix E supplies a 'DTD Fragment for XSLT Stylesheets'. [Full context]

[October 16, 2001] Extensible Stylesheet Language (XSL) Version 1.0 Published as W3C Recommendation.

• The World Wide Web Consortium has announced the release of Extensible Stylesheet Language (XSL) Version 1.0 as a W3C Recommendation. The specification represents "cross-industry agreement on an XML-based language that specifies how XML documents may be formatted. It works in concert with XSL Transformations (XSLT), an XML language that performs transformations of structured documents. W3C Recommendation status indicates that a specification is stable, contributes to Web interoperability, and has been reviewed by the W3C Membership, who favor its widespread adoption. XSLT 1.0, the XML language which performs transformations on XML data and documents, has been a W3C Recommendation since November 1999, and already enjoys significant usage in both developer communities and in commercial products. XSL 1.0 builds on XSLT 1.0, and provides users with the ability to describe how XML data and documents are to be formatted. XSL 1.0 does this by defining 'formatting objects,' such as footnotes, headers, columns, and other features common to paged media. Designers would use XSL 1.0 stylesheets to indicate rendering preferences for a type of XML document, including how it is styled, laid out, and paginated onto a presentation medium such as a browser window, a pamphlet, or a book. An XSL engine would take the XML document and the XSL stylesheet, and would produce a rendering of the document. XSLT 1.0 makes it possible to significantly change the original structure of an XML document (automatic generation of tables of contents, cross-references, indexes, etc.), while XSL 1.0 makes complex document formatting possible through the use of formatting objects and properties. As XSL 1.0 is focused on the formatting of paged media, it makes it possible for professional printing capabilities and functions to perform with XML documents today. XSL 1.0 and XSLT make it possible for the needs of Web and print-based media formatting to be met."
• Bibliographic information: Extensible Stylesheet Language (XSL) Version 1.0. W3C Recommendation 15-October-2001. Version URL: http://www.w3.org/TR/2001/REC-xsl-20011015/. Latest version URL: http://www.w3.org/TR/xsl/. Previous version URL: http://www.w3.org/TR/2001/PR-xsl-20010828/. Authors and Contributors: Sharon Adler (IBM), Anders Berglund (IBM), Jeff Caruso (Pageflex), Stephen Deach (Adobe), Paul Grosso (Arbortext), Eduardo Gutentag (Sun), Alex Milowski, Scott Parnell (Xerox), Jeremy Richman, and Steve Zilles (Adobe). Other formats: PDF by RenderX, XML file, single file HTML, ZIP archive. [cache]

[August 29, 2001]   Extensible Stylesheet Language (XSL) Version 1.0 Published as W3C Proposed Recommendation.    The W3C XSL Working Group has published Extensible Stylesheet Language (XSL) Version 1.0 as a W3C Proposed Recommendation, indicating that "the specification is stable and that implementation experience has been gathered showing that the features of the specification can be implemented." The Extensible Stylesheet Language (XSL) "is a language for expressing stylesheets [which] builds on the prior work on Cascading Style Sheets (CSS2) and the Document Style Semantics and Specification Language (DSSSL). Apart from a stylesheet, a processor "could not possibly know how to render the content of an XML document other than as an undifferentiated string of characters. XSL provides a comprehensive model and a vocabulary for writing such stylesheets using XML syntax. Given a class of arbitrarily structured XML documents or data files, designers use an XSL stylesheet to express their intentions about how that structured content should be presented; that is, how the source content should be styled, laid out, and paginated onto some presentation medium, such as a window in a Web browser or a hand-held device, or a set of physical pages in a catalog, report, pamphlet, or book." The PR review period for XSL Version 1.0 which began on 28-August-2001 lasts through 25-September-2001, during which time the W3C Advisory Committee representatives return comments; following the review the W3C Director will announce the document's disposition (W3C Recommendation, Working Draft). [Full context]

[August 24, 2001] "XSL Transformations (XSLT) Version 1.1." W3C Working Draft 24-August-2001. Edited by James Clark. NOTICE: "As of 24-August-2001 no further work on this draft is expected. The work on XSLT 2.0 identified a number of issues with the approaches being pursued in this document; solutions to the requirements of XSLT 1.1 will be considered in the development of XSLT 2.0 [XSLT20REQ -*gt; XSLT Requirements Version 2.0. W3C Working Draft 14 February 2001]. Other than this paragraph, the document is unchanged from the previous version..." Version URL: http://www.w3.org/TR/2001/WD-xslt11-20010824/. Latest version URL: http://www.w3.org/TR/xslt11/. Previous version URL: http://www.w3.org/TR/2000/WD-xslt11-20001212/. Abstract: This specification defines the syntax and semantics of XSLT, which is a language for transforming XML documents into other XML documents. XSLT is designed for use as part of XSL, which is a stylesheet language for XML. In addition to XSLT, XSL includes an XML vocabulary for specifying formatting. XSL specifies the styling of an XML document by using XSLT to describe how the document is transformed into another XML document that uses the formatting vocabulary. XSLT is also designed to be used independently of XSL. However, XSLT is not intended as a completely general-purpose XML transformation language. Rather it is designed primarily for the kinds of transformations that are needed when XSLT is used as part of XSL."

[December 12, 2000] XSLT Revision: W3C Publishes XSL Transformations (XSLT) Version 1.1. XSL Transformations (XSLT) Version 1.1. W3C Working Draft 12 December 2000, edited by James Clark. An HTML version with color-coded revision indicators has been prepared to reveal changes vis-à-vis the W3C Recommendation of 1999-11-16. The non-normative Appendix G supplies a listing of "Changes from XSLT 1.0." Appendix D provides a "DTD Fragment for XSLT Stylesheets." Document abstract: "This specification defines the syntax and semantics of XSLT, which is a language for transforming XML documents into other XML documents. XSLT is designed for use as part of XSL, which is a stylesheet language for XML. In addition to XSLT, XSL includes an XML vocabulary for specifying formatting. XSL specifies the styling of an XML document by using XSLT to describe how the document is transformed into another XML document that uses the formatting vocabulary. XSLT is also designed to be used independently of XSL. However, XSLT is not intended as a completely general-purpose XML transformation language. Rather it is designed primarily for the kinds of transformations that are needed when XSLT is used as part of XSL." Document status: The working draft is based on the W3C XSLT 1.0 Recommendation. The changes made in this document are intended to meet the requirements for XSLT 1.1 and to incorporate fixes for errors that have been detected in XSLT 1.0."

[November 21, 2000] Extensible Stylesheet Language (XSL) Version 1.0. W3C Candidate Recommendation 21-November-2000. See the announcement for details. The new CR has been produced by the XSL Working Group as part of the W3C Style Activity. The Candidate Recommendation review period ends on February 28, 2001. The following exit criteria for the CR (preceding advancement to PR) are proposed: "(1) Sufficient reports of implementation experience have been gathered to demonstrate that XSL processors based on the specification are implementable and have compatible behavior. (2) An implementation report shows that there is at least one implementation for each basic formatting object and property. (3) Providing formal responses to all comments received." [alt URL announcement]

[October 18, 2000] XSL Working Draft. Max Froumentin (W3C XSL Staff Contact) announced the release of a new working draft for Extensible Stylesheet Language (XSL) Version 1.0. Reference: W3C Working Draft 18-October-2000. By Sharon Adler (IBM), Anders Berglund (IBM), Jeff Caruso (Pageflex), Stephen Deach (Adobe), Paul Grosso (ArborText), Eduardo Gutentag (Sun), Alex Milowski (Lexica), Scott Parnell (Xerox), Jeremy Richman (BroadVision), and Steve Zilles (Adobe). Document overview: "This specification defines the Extensible Stylesheet Language (XSL). XSL is a language for expressing stylesheets. Given a class of arbitrarily structured XML documents or data files, designers use an XSL stylesheet to express their intentions about how that structured content should be presented; that is, how the source content should be styled, laid out, and paginated onto some presentation medium, such as a window in a Web browser or a hand-held device, or a set of physical pages in a catalog, report, pamphlet, or book. Formatting is enabled by including formatting semantics in the result tree. Formatting semantics are expressed in terms of a catalog of classes of formatting objects. The nodes of the result tree are formatting objects. The classes of formatting objects denote typographic abstractions such as page, paragraph, table, and so forth. Finer control over the presentation of these abstractions is provided by a set of formatting properties, such as those controlling indents, word- and letter-spacing, and widow, orphan, and hyphenation control. In XSL, the classes of formatting objects and formatting properties provide the vocabulary for expressing presentation intent. The XSL processing model is intended to be conceptual only. An implementation is not mandated to provide these as separate processes. Furthermore, implementations are free to process the source document in any way that produces the same result as if it were processed using the conceptual XSL processing model." WD status: "This version supersedes the previous draft released on March 27, 2000. The working group is issuing this interim public draft as it sets out a number of changes made in response to comments received on the Last Call draft. The Working Group intends to submit a revised version of this specification for publication as a Candidate Recommendation in the near future. Items under consideration for change for Candidate Recommendation include the name of the font-height-override-before and font-height-override-after properties. Discussion is invited and comments can be sent to the editors at xsl-editors@w3.org." The WD is available in several formats: PDF, XML file, HTML single file and .ZIP file.

[August 28, 2000] XSLT 1.1 Requirements. Vincent Quint (W3C/INRIA) recently posted an announcement for the first public release of a new requirements document for XSLT version 1.1: "The W3C Working Group on XSL has just released a document describing the requirements for the XSLT 1.1 specification. The primary goal of the XSLT 1.1 specification is to improve stylesheet portability. The new draft is available at http://www.w3.org/TR/xslt11req. Discussion is invited and comments can be sent to the editors." See XSL Transformations Requirements Version 1.1, W3C Working Draft 25-August-2000, edited by Steve Muench. Description: "In addition to supporting user-defined extensions, numerous XSLT 1.0-compliant processors have exploited the XSLT 1.0 extension mechanism to provide additional built-in transformation functionality. As useful built-in extensions have emerged, users have embraced them and have begun to rely on them. However the benefits of these extensions come at the price of portability. Since XSLT 1.0 provides no details or guidance on the implementation of extensions, today any user-written or built-in extensions are inevitably tied to a single XSLT processor. The XSLT user community has consistently voiced the opinion that the non-portability of stylesheets is a key problem. The primary goal of the XSLT 1.1 specification is to improve stylesheet portability. This goal will be achieved by standardizing the mechanism for implementing extension functions, and by including into the core XSLT specification two of the built-in extensions that many existing vendors XSLT processors have added due to user demand: (1) Support for multiple output documents from a transformation (2) Support for converting a result tree fragment to a nodeset for further processing By standardizing these extension-related aspects which multiple vendor implementations already provide, the ability to create stylesheets that work across multiple XSLT processors should improve dramatically. A secondary goal of the XSLT 1.1 specification is to support the new XML Base specification. This document provides the requirements that will achieve these goals. The working group has decided to limit the scope of XSLT 1.1 to the standardization of features already implemented in several XSLT 1.0 processors, and concentrate first on standardizing the implementation of extension functions. Standardization of extension elements and support for new XML Schema data type aware facilities are planned for XSLT 2.0"

[March 28, 2000] Last Call Working Draft for the W3C Extensible Stylesheet Language (XSL) Version 1.0. The W3C XSL Working Group has released a last call working draft specification for the Extensible Stylesheet Language (XSL) Version 1.0. Reference: W3C Working Draft 27-March-2000, by Sharon Adler (IBM), Anders Berglund (IBM), Jeff Caruso (Bitstream), Stephen Deach (Adobe), Paul Grosso (ArborText), Eduardo Gutentag (Sun), Alex Milowski (Lexica), Scott Parnell (Xerox), Jeremy Richman (Interleaf), and Steve Zilles (Adobe). The draft is available in XML, HTML source, and ZIP archive formats. "The XSL Working Group considers that this draft is stable and ready to move to Candidate Recommendation status, following the successful resolution of comments. This is therefore the last call for comments on this Working Draft. . ." The specification documents "an XML vocabulary for specifying formatting semantics. An XSL stylesheet specifies the presentation of a class of XML documents by describing how an instance of the class is transformed into an XML document that uses the formatting vocabulary. . . Given a class of arbitrarily structured XML documents or data files, designers use an XSL stylesheet to express their intentions about how that structured content should be presented; that is, how the source content should be styled, laid out, and paginated onto some presentation medium, such as a window in a Web browser or a hand-held device, or a set of physical pages in a catalog, report, pamphlet, or book. . . An XSL stylesheet processor accepts a document or data in XML and an XSL stylesheet and produces the presentation of that XML source content that was intended by the designer of that stylesheet. There are two aspects of this presentation process: first, constructing a result tree from the XML source tree and second, interpreting the result tree to produce formatted results suitable for presentation on a display, on paper, in speech, or onto other media. Formatting is enabled by including formatting semantics in the result tree. Formatting semantics are expressed in terms of a catalog of classes of formatting objects. The nodes of the result tree are formatting objects. The classes of formatting objects denote typographic abstractions such as page, paragraph, table, and so forth. Finer control over the presentation of these abstractions is provided by a set of formatting properties, such as those controlling indents, word- and letter-spacing, and widow, orphan, and hyphenation control. In XSL, the classes of formatting objects and formatting properties provide the vocabulary for expressing presentation intent." [cache]

[March 01, 2000] W3C Releases New Working Draft for Extensible Stylesheet Language (XSL) Version 1.0. As part of the W3C Style Activity, the W3C XSL Working Group has published an updated working draft specification for Extensible Stylesheet Language (XSL) Version 1.0. Reference: W3C Working Draft 01-March-2000, edited by Sharon Adler (IBM), Anders Berglund (IBM), Jeff Caruso (Bitstream), Stephen Deach (Adobe), Paul Grosso (ArborText), Eduardo Gutentag (Sun), Alex Milowski (Lexica), Scott Parnell (Xerox), Jeremy Richman (Interleaf), and Steve Zilles (Adobe). Abstract: "XSL is a language for expressing stylesheets. It consists of two parts: (1) a language for transforming XML documents, and (2) an XML vocabulary for specifying formatting semantics. An XSL stylesheet specifies the presentation of a class of XML documents by describing how an instance of the class is transformed into an XML document that uses the formatting vocabulary."

[October 30, 2000] XSL Spec of 18-Oct-2000 self-formatted. "This page presents XSL Working Draft of October 18, 2000, formatted as an XSL Formatting Objects document conformant to this same draft. The document has been prepared by the RenderX development team as a contribution to XSL Formatting Objects community." And the related message from Nikolai Grigoriev: We at RenderX have prepared an early XSL FO version of the last XSL Working Draft, (presumably) conformant to this same draft. It can be found at http://www.renderx.com/~grig/xsl2k/, with an example of its formatting by XEP. Please excuse defects in the PDF version - this version of XEP is still under testing. We hope that the XSL Spec may be useful as a maxi-testcase for XSL FO formatters. Any comments/suggestions are welcome. I would be particularly glad to hear opinions about the conformance; I have had nothing but a homegrown DTD to control it..." FO [cache]; PDF [cache]

[October 24, 2000] RenderX DTD for XSL FO. "This DTD has been developed in order to validate XSL FO documents conformant to XSL WD of October 18, 2000. The namespace prefix is xmlns:fo="http://www.w3.org/1999/XSL/Format". This DTD also makes provision for few extensions to XSL WD..." [cache 2000-10-24]

[March 27, 2000] See previous entry. DTD for XSL FO documents. "We (RenderX) have published a DTD for XSL FO WD (March 27 version); used by FOP team to check their tests." [...] This DTD has been developed in order to validate XSL FO documents conformant to XSL WD of March 27, 2000. The namespace prefix is xmlns:fo="http://www.w3.org/1999/XSL/Format". This DTD also makes provision for few extensions to XSL WD, put into a separate namespace: xmlns:rx="http://www.renderx.com/XSL/Extensions". From Nikolai Grigoriev. [cache 2000-03-27 version]

[January 12, 2000] As part of the W3C Style Activity, the XSL Working Group has released a new working draft specification for the Extensible Stylesheet Language (XSL) Version 1.0. Reference: W3C Working Draft 12-January-2000, by Sharon Adler (IBM), Anders Berglund (IBM), Jeff Caruso (Bitstream), Stephen Deach (Adobe), Alex Milowski (Lexica), Scott Parnell (Xerox), Jeremy Richman (Interleaf), and Steve Zilles (Adobe). The revised specification "describes the XSL formatting model, the formatting objects and their properties." This WD updates the previous working draft of 1999-04-21 and provides "additional functionality." Abstract: "XSL is a language for expressing stylesheets. It consists of two parts: (1) a language for transforming XML documents, and (2) an XML vocabulary for specifying formatting semantics. An XSL stylesheet specifies the presentation of a class of XML documents by describing how an instance of the class is transformed into an XML document that uses the formatting vocabulary." The draft describes the general process of formatting, including the "area model and the formatting-object descriptions and properties and [...] the process of refinement. Formatting is the process of turning the result of an XSL transformation into a tangible form for the reader or listener. This process comprises several steps, some of which depend on others in a non-sequential way. Our model for formatting will be the construction of an area tree, which is an ordered tree containing geometric information for the placement of every glyph, shape, and image in the document, together with information embodying spacing constraints and other rendering information; this information is referred to under the rubric of traits, which are to areas what properties are to formatting objects and attributes are to XML nodes. . . Formatting objects are elements in the formatting-object tree, whose names are from the XSL namespace; a formatting object belongs to a class of formatting objects identified by its element name. The formatting behavior of each class of formatting objects is described in terms of what areas are created by a formatting object of that class, how the traits of the areas are established based, and how the areas are structured hierarchically with respect to areas created by other formatting objects. . . Central to this model of formatting is refinement. This is a computational process which finalizes the specification of properties based on the attribute values in the XML result tree. Though the XML result tree and the formatting-object tree have very similar structure, it is helpful to think of them as separate conceptual entities. Refinement involves (1) propagating the various inherited values of properties (both implicitly and those with an attribute value of 'inherit';), (2) evaluating expressions in property value specifications into actual values, which are then used to determine the value of the properties (3) converting relative numerics to absolute numerics, (4) constructing some composite properties from more than one attribute, (5) converting text nodes to sequences of fo:character formatting objects, (6) creating implied fo:bidi-override formatting objects to support mixed writing directions. Some of these operations (particularly evaluating expressions) depend on knowledge of the area tree. Thus refinement is not necessarily a straightforward, sequential procedure, but may involve look-ahead, back-tracking, or control-splicing with other processes in the formatter..."

[November 16, 1999] XSL Transformations (XSLT) Version 1.0. W3C Recommendation 16-November-1999. Edited by James Clark. Also available in XML format. "This specification defines the syntax and semantics of XSLT, which is a language for transforming XML documents into other XML documents. XSLT is designed for use as part of XSL, which is a stylesheet language for XML. In addition to XSLT, XSL includes an XML vocabulary for specifying formatting. XSL specifies the styling of an XML document by using XSLT to describe how the document is transformed into another XML document that uses the formatting vocabulary. XSLT is also designed to be used independently of XSL. However, XSLT is not intended as a completely general-purpose XML transformation language. Rather it is designed primarily for the kinds of transformations that are needed when XSLT is used as part of XSL."

[October 8, 1999] XSL Transformations (XSLT) Version 1.0 Published as a W3C Proposed Recommendation. The W3C XSL Transformations (XSLT) specification has now been released as a Proposed Recommendation: XSL Transformations (XSLT) Version 1.0. Reference: W3C Proposed Recommendation 8-October-1999, edited by James Clark. This PR is part of the W3C Style activity. The XSLT specification "defines the syntax and semantics of XSLT, which is a language for transforming XML documents into other XML documents. XSLT is designed for use as part of XSL, which is a stylesheet language for XML. In addition to XSLT, XSL includes an XML vocabulary for specifying formatting. XSL specifies the styling of an XML document by using XSLT to describe how the document is transformed into another XML document that uses the formatting vocabulary. XSLT is also designed to be used independently of XSL. However, XSLT is not intended as a completely general-purpose XML transformation language. Rather it is designed primarily for the kinds of transformations that are needed when XSLT is used as part of XSL. . . A transformation in the XSLT language is expressed as a well-formed XML document conforming to the Namespaces in XML Recommendation, which may include both elements that are defined by XSLT and elements that are not defined by XSLT. A transformation expressed in XSLT describes rules for transforming a source tree into a result tree. The transformation is achieved by associating patterns with templates. A pattern is matched against elements in the source tree. A template is instantiated to create part of the result tree. The result tree is separate from the source tree. The structure of the result tree can be completely different from the structure of the source tree. In constructing the result tree, elements from the source tree can be filtered and reordered, and arbitrary structure can be added. A transformation expressed in XSLT is called a stylesheet. This is because, in the case when XSLT is transforming into the XSL formatting vocabulary, the transformation functions as a stylesheet..." Comments on the PR draft may be sent to xsl-editors@w3.org before 5-November-1999, though the working group does not anticipate "further substantial changes to this specification, and encourages active implementation to test this specification during the Proposed Recommendation review period." Public discussion of XSL, including XSL Transformations, is expected to take place on the XSL-List mailing list. The document is available in both XML and HTML formats.

[October 8, 1999] XML Path Language (XPath) Version 1.0 Published as a W3C Proposed Recommendation. As part of the W3C Style activity and W3C XML activity, the XML Linking Working Group and XSL Working Group have published the XPath specification as a PR: XML Path Language (XPath) Version 1.0. Reference: W3C Proposed Recommendation 8-October-1999, edited by James Clark and Steve DeRose. XPath specifies a language for addressing parts of an XML document, designed to be used by both XSLT and XPointer. "XPath is the result of an effort to provide a common syntax and semantics for functionality shared between XSL Transformations and XPointer. The primary purpose of XPath is to address parts of an XML document. In support of this primary purpose, it also provides basic facilities for manipulation of strings, numbers and booleans. XPath uses a compact, non-XML syntax to facilitate use of XPath within URIs and XML attribute values. XPath operates on the abstract, logical structure of an XML document, rather than its surface syntax. XPath gets its name from its use of a path notation as in URLs for navigating through the hierarchical structure of an XML document. In addition to its use for addressing, XPath is also designed so that it has a natural subset that can be used for matching (testing whether or not a node matches a pattern); this use of XPath is described in XSLT. XPath models an XML document as a tree of nodes. There are different types of nodes, including element nodes, attribute nodes and text nodes. XPath defines a way to compute a string-value for each type of node. Some types of nodes also have names. XPath fully supports XML Namespaces. Thus, the name of a node is modeled as a pair consisting of a local part and a possibly null namespace URI; this is called an expanded-name. The data model is described in detail in section 5, 'Data Model'." Available in both XML and HTML formats. Send comments to www-xpath-comments@w3.org until November 05, 1999; such comments are publicly archived.

On July 09, 1999, the W3C issued a revised working draft of the XSLT specification: XSL Transformations (XSLT) Version 1.0, W3C Working Draft 9-July-1999. Edited by James Clark. "Some material that was previously part of this draft has been separated out into XPath; the XPath draft describes the status of everything that is part of XPath. This version of the WD is said to be "nearly stable. The XSL Working Group does not anticipate making technical changes except as necessary to resolve the issues explicitly mentioned in this document." Abstract: "XSLT is a language for transforming XML documents into other XML documents. XSLT is designed for use as part of XSL, which is a stylesheet language for XML. In addition to XSLT, XSL includes an XML vocabulary for specifying formatting."

On April 21, 1999, the W3C XSL Working Group published a working draft version of the XSL Transformations (XSLT) Specification. (W3C Working Draft 21-April-1999). In this draft, XSLT is described as "a language for transforming XML documents into other XML documents. XSLT is designed for use as part of XSL, which is a stylesheet language for XML." On April 21, 1999, a new working draft of the Extensible Stylesheet Language (XSL) Specification was also issued by the W3C in conjunction with the release of the XSL Transformations (XSLT) Specification. With the publication of these two draft documents, the two XSL sub-processes (tree transformation, formatting) are explicitly split out, as described in the XSL introduction: "An XSL stylesheet processor accepts a document or data in XML and an XSL stylesheet and produces the presentation of that XML source content as intended by the stylesheet. There are two sub-processes to this presentation process: first, constructing a result tree from the XML source tree and second, interpreting the result tree to produce a formatted presentation on a display, on paper, in speech or onto other media. The first (sub-)process is called tree transformation and the second (sub-)process is called formatting. The process of formatting is performed by the formatter. Splitting the processing of a stylesheet into two sub-processes allows greater flexibility in constructing the presentation of the source content. With tree transformation, the structure of the result tree can be totally different from the structure of the source tree. In constructing the result tree, the source tree can be filtered and reordered, and arbitrary structure and generated content can be added. For example, one could add a table-of-contents a filtered selection of an original source document or one could map the result of a database query (expressed in XML) into a sorted tabular presentation of the relevant portion of the query result. In constructing the result tree, the tree transformation process also adds the information necessary to format that result tree. The second process, formatting, is enabled by making the result tree have formatting semantics. In this recommendation, formatting semantics are expressed in terms of a catalog of formatting objects. The nodes of the result tree are instances of formatting objects. The formatting objects denote typographic abstractions such as page, paragraph, rule, and so forth. Finer control over the presentation of these abstractions is provided by a set of formatting properties, such as indents; word- and letter-spacing; and widow, orphan, and hyphenation control. The formatting objects and formatting properties provide the vocabulary for expressing presentation intent."

On December 18, 1998, Vincent Quint of W3C/INRIA announced the availability of a new Working Draft of the Extensible Stylesheet Language (XSL) Version 1.0 specification. References: WD-xsl-19981216, World Wide Web Consortium Working Draft 16-December-1998. The editors are James Clark (responsible for the 'Tree Construction' portion) and Stephen Deach of Adobe (responsible for the 'Formatting Objects' portion). Abstract: "XSL is a language for expressing stylesheets. It consists of two parts: 1) a language for transforming XML documents, and 2) an XML vocabulary for specifying formatting semantics. An XSL stylesheet specifies the presentation of a class of XML documents by describing how an instance of the class is transformed into an XML document that uses the formatting vocabulary." The new WD specification is available in HTML, XML, and PDF formats. Discussion on this second WD version is invited and comments can be sent to the editors at xsl-editors@w3.org.

On August 18, 1998, the World Wide Web Consortium (W3C) published the first public Working Draft of XSL 1.0, Extensible Stylesheet Language (XSL) Version 1.0." References: WD-xsl-19980818, World Wide Web Consortium Working Draft, 18-August-1998. The editors are James Clark and Stephen Deach. Abstract: "XSL is a language for expressing stylesheets. It consists of two parts: 1) a language for transforming XML documents, and 2) an XML vocabulary for specifying formatting semantics. An XSL stylesheet specifies the presentation of a class of XML documents by describing how an instance of the class is transformed into an XML document that uses the formatting vocabulary." According to the W3C press release, "W3C will be developing both the XSL and CSS style sheet languages in parallel, as they are both useful for Web sites and they give Web designers an expanded set of tools to do their work. CSS is used to style HTML and XML documents on the Web. In addition to styling XML documents, XSL is also able to generate new XML documents from XML data. XSL and CSS will share the same underlying concepts and will use the same terminology as much as possible. XSL allows XML data to be abstracted and displayed to the reader in many different ways, generating different virtual XML documents in response to user queries. XSL aims to allow the specification of print styling of Web documents at least as well as a typical wordprocessor. In addition, future support for high-end print typography is planned. XSL allows documents to be written in any language, including historical languages. It allows the specification of any writing direction; the uses for this range from modern Japanese vertical text to ancient Greek and Aztec for scholarly publication." Testimonials for the new XSL Working Draft have been provided by Adobe, Bitstream, Enigma, IBM, Inso, Lotus, Microsoft, Netscape, RivCom, and Sun Microsystems. The press release provides other summary description: "W3C Publishes First Public Working Draft of XSL 1.0. Additional style sheet language extends Web developer toolkit." The announcement is also available in Japanese, Dutch, and Swedish.

The previous XSL 'specification' was (only) in the form of a W3C NOTE: A Proposal for XSL. Reference: NOTE-XSL.html. Dated August 21, 1997 and submitted to W3C on 27 August 1997. Submitted to the W3C by Microsoft, Inso, and Arbortext. Authors: Sharon Adler, Inso Corporation [2000-02 IBM]; Anders Berglund, [IBM]; James Clark; Istvan Cseri, Microsoft Corporation; Paul Grosso, ArborText; Jonathan Marsh, Microsoft Corporation; Gavin Nicol, Inso Corporation; Jean Paoli, Microsoft Corporation; David Schach, Microsoft Corporation; Henry S. Thompson, University of Edinburgh; Chris Wilson, Microsoft Corporation.

The World Wide Web Consortium (W3C) also issued a Working Draft entitled "XSL Requirements Summary" (WD-XSLReq-19980511, W3C Working Draft 11-May-1998). Its editor is Norman Walsh (ArborText, Inc.). Published as part of the W3C Style Activity pertaining to the Extensible Style Language, this requirements document delineates a list of requirements which the XSL Working Group "considers to be in scope for XSL in general with no reference to timing or target version. [it] makes no statement about what specific requirements will be addressed in any particular Working Draft or version of XSL." Requirements are specified for applications that will run in batch as well as in interactive environments. Areas covered in the Working Draft include: General Formatting Issues; Columns, Floats, Keeps, etc.; Fonts; Color; Math; Internationalization; Scripting; Interactivity; Accessibility; Extensibility; Packaging; Meta-information.

Sources:

• Revised Working Draft of XSLT, July 09, 1999

  • XSL Transformations (XSLT) Version 1.0. W3C Working Draft 9 July 1999. HTML Format.

  • XML Format

• Working Drafts of April 21, 1999 (XSLT and XSL)

  • XSL Transformations (XSLT) Specification Version 1.0. W3C Working Draft 21 Apr 1999. Edited by James Clark. Also available in XML format. Local archive copies: HTML, and XML.

  • Extensible Stylesheet Language (XSL) Specification. W3C Working Draft 21 Apr 1999. Edited by Stephen Deach (Adobe Systems Inc.). [local archive copy]

  • XSLT stylesheet - The XSLT stylesheet used to generate the HTML for the April 21, 1999 XSLT draft from the XML source. 'This stylesheet was originally created by Eduardo Gutentag of Sun for an earlier version of the XSL WD and was hacked up by [James Clark] to match the current WD.' [local archive copy]

• Working Draft Version 1.0

  • [December 16, 1998] Extensible Stylesheet Language (XSL) Version 1.0. - World Wide Web Consortium Working Draft 16-December-1998. Available also in XML and PDF formats.

  • [August 18, 1998] Extensible Stylesheet Language (XSL) Version 1.0 - WD-xsl-19980818, Working Draft 18-August-1998. [local archive copy. HTML]

  • Extensible Stylesheet Language (XSL) Version 1.0 - In XML format. [local archive copy, XML]

  • Extensible Stylesheet Language (XSL) Version 1.0 - In PDF format.

  • Press release: "W3C Publishes First Public Working Draft of XSL 1.0. Additional Style Sheet Language Extends Web Developer Toolkit." [local archive copy]

  • Testimonials for XSL 1.0 WD - From: Adobe, Bitstream, Enigma, IBM, Inso, Lotus, Microsoft, Netscape, RivCom, and Sun Microsystems. [local archive copy]

  • James Clark released the alpha version of XT, a Java implementation of the tree construction/transformation half of the W3C's new 1998-08-18 XSL (Extensible Stylesheet Language) Working Draft specification. Revision 1998-08-29.

• XSL Proposal and Requirements Specification

  • "A Proposal for XSL." Dated August 21, 1997; submitted to W3C on 27 August 1997. In HTML format from the W3C Web server

  • XSL Proposal: HTML local archive copy

  • The Proposal Overview. [local archive copy]

  • The press release: from Microsoft, or from ArborText; local archive copy

  • XSL Proposal from Microsoft, Word format

  • "XSL Requirements Summary." WD-XSLReq-19980511, W3C Working Draft 11-May-1998. [local archive copy]

---

Earlier Specifications Documents

• A discussion document "XML Part 3: [NOT YET] Version 1.0" was made available by Jon Bosak as XS-970522 on May 22, 1997. It was a (the final?) version of the DSSSL-o Application Profile produced in the style of a W3C working draft. Available from Jon Bosak via the UNC Sunsite server: Draft for discussion, Postscript format. Part 3 draft: local archive copy in Postscript and in RTF
• Announcement of May 22, 1997 for the preceding XS-970522, from Jon Bosak. The merger of the dsssl-o application profile was referred to as "xs" (xml-style), and the draft document was one "that puts the existing DSSSL Online (dsssl-o) specification in a form that can easily be made into a Working Draft for XML Part 3"
• See also: DSSSL-o, below

---

XSL/XSLT Books

[CR: 20021026]

• XSLT and XPath: A Guide to XML Transformations. By John Robert Gardner and Zarella L. Rendon. Upper Saddle River, NJ: Prentice Hall PTR. ISBN: 0-13-040446-2. xxii + 558 pages, with CD. The book "shows XML programmers how to use XSLT to transform XML documents: XSLT as an XML document instance: leveraging your existing XML skills; XSLT stylesheet concepts and constructs: fundamental through advanced level; XPath patterns and functions; XSLT subroutine functions and variables; XSLT processing of multiple nodes: iterative and conditional XSLT elements; Controlling output options; XSLT extensions." See the sample chapter "Anatomy of an XSLT Stylesheet."

• Practical Formatting Using XSLFO. Extensible Stylesheet Language Formatting Objects. Book excerpt (179 of 341 pages). By G. Ken Holman, from Crane Softwrights Ltd. First Edition, 2001-12-05. ISBN: 1-894049-07-1. 341 Pages. Ken writes: "The XSLFO book is in its first release. This book has hyperlinks from the text of the renditions directly to the W3C Recommendation document, allowing you to learn from our book yet have instant access to the W3C documents. Both editions have the following hyperlinks [note in Acrobat reader the ctrl-left arrow is the Back key]: (1) page references in text (2) chapter references in module summary (3) section references in chapter summary (4) table of subsections at back of book (5) external links to web browser... In addition to the PDF renditions, we now include an accessible version of each of our books and the previews for the books. These renditions use monospaced fonts that are friendly to screen readers. These are produced using XSLFO using RenderX (previous editions were published using DSSSL) ... all our training material is authored in XML..."

• The XSL Companion: Styling XML Documents. By Neil Bradley. London/New York: Addison-Wesley/Pearson Education, [May] 2000. ISBN: 0-201-67487-4. xiv + 318 pages. "A concise, comprehensive and accessible guide to the scope, strengths and limitations of the XSL (eXtensible Stylesheet Language) family of stylesheet standards for XML, this book explains the practical ways in which XSL can be utilized for formatting and manipulating information held in the hugely popular XML data format. This book covers in detail the family of three separate stylesheet which make up XSL: (1) Xpath locates specific information within XML Documents (2) XSLT transforms XML documents into other data formats (3) XSL embeds formatting information in XML documents." See the summary.

• Practical Transformation Using XSLT and XPath (XSL Transformations and the XML Path Language. By G. Ken Holman. ISBN 1-894049-05-5. Eighth Edition. Date: 2000-07-07. "This comprehensive guide to XSL Transformations (XSLT) and the XML Path Language (XPath) according to the XSLT/XPath 19991116 1.0 Recommendations is over 300 pages of explanatory material, diagrams, tables, and code samples. Every markup construct used for XSLT and XPath is identified and described. The focus is primarily on the W3C work and not on archaic definitions or implementations." See details in an online version. To be published in book form by Prentice Hall [2001].

• XSLT Programmer's Reference. By Michael Kay (WWW). Wrox Series: 'Programmer to Progammer'. Chicago / Birmingham, UK: Wrox Press Inc., [April] 2000. ISBN: 1-861003-12-9. Extent: xiv +778 pages. Appendix A: Microsoft MSXML3; Appendix B: Glossary. 3 indexes [Elements, Functions, General]. "XSL (Extensible Stylesheet Language) is the styling language to match XML. XSLT Programmer's Reference is a compact, up-to-date, and relevant explanation of the W3C's XSLT and XPath recommendations. XSLT is notoriously difficult to understand, but this book provides code examples showing how it all ties together and can be effectively employed in a real world development scenario. At the most basic level it allows the programmer to manipulate XML on a template model - XSL provides the template to fit XML data into for displaying on a web page. However, it is capable of much more than that, and allows programmers to selectively query, display and manipulate data, perform scripting-like operations on the XML document and transform it into pure HTML for use on browsers which don't support XML." See the sample chapter (pages 9-43) "XSLT in Context." The Wrox web site provides source code (sample) XML/XSLT documents for tutorial purposes [cache]. See also: (1) the Wrox Press XML book collection on Amazon.com; and (2) the Wrox Press overview.

• XSL-FO: Making XML Look Good in Print. By Dave Pawson. Sebastopol, CA: O'Reilly, August 2002. ISBN: 0-596-00355-2. 282 pages. "Extensible Style Language-Formatting Objects, or XSL-FO, is a set of tools developers and web designers use to describe page printouts of their XML (including XHTML) documents. If you need to produce high quality printed material from your XML documents, then XSL-FO provides the bridge... This book offers in-depth coverage of XSL-FO's features and strengths. XSL-FO teaches you how to think about the formatting of your documents and guides you through the questions you'll need to ask to ensure that your printed documents meet the same high standards as your computer-generated content... Part 1 provides an overview of the technology and introduces the XSL-FO vocabulary. The author discusses how to choose among today's implementations, explains how to describe pages, and shows you what is going on in the processor in terms of layout. You'll learn about the basics of formatting and layout as well as readability. The second part focuses on smaller pieces: blocks, inline structures, graphics, color and character level formatting, concluding by showing how to integrate these parts into a coherent whole." See the description, table of contents, and sample Chapter 6.

• Beginning XSLT. By Jeni Tennison. Wrox Press, May 2002. 700 pages. ISBN: 1-861005-94-6. "This book is divided into two parts. The first part introduces XML and XSLT bit by bit, gradually demonstrating the techniques that you need to generate HTML (and other formats) from XML. The second part pulls together the theory by looking at some of the other things that you can do with XSLT, including generating graphics. Covers: how to create HTML from XML using XSLT; how to organize your XSLT stylesheets using templates; how to sort and number your results; how to use XPath expressions for numerical calculations and string manipulation; how to build dynamic XSLT applications; how to create Scalable Vector Graphics, SVG." See the table of contents and sample Chapter 4 ("Templates"). With sample code. [cache/sample]

News, Articles and Papers: XSL, XSLT, XPath

Surveys, white papers, introductions, tutorials, proposals, posters, news articles, etc.

• [December 03, 2003] "Trees, Temporarily." By Bob DuCharme. From XML.com (December 03, 2003). ['In his latest Transforming XML column Bob DuCharme explains XSLT 2.0's Temporary Trees, and then he demonstrates how to use them.'] " XPath 1.0 has a special data type called Result Tree Fragments. For example, an xsl:variable element can store a single string, but it can also store an XML element with all the descendants and attributes you like. This structure is a Result Tree Fragment... There's little you can do with result tree fragments in XSLT 1.0; you can treat them as strings and you can use xsl:copy-of to copy them to the result tree, and that's it. Because many XSLT developers longed for a way to pass composite structures to named templates, and then use the pieces of those structures individually inside the named template, instead of merely copying the structure to the result tree or pulling substrings out of it, several XSLT 1.0 processors offer extension functions such as Xalan's nodeset() and Saxon's node-set() that convert these fragments to node sets whose nodes can be addressed with XPath expressions. XSLT 2.0 eliminates result tree fragments and replaces them with a more powerful feature: temporary trees. Once you create a temporary tree in an xsl:variable, xsl:param, or xsl:with-param element, you can do anything with it that you can do with a source tree..."

• [September 30, 2003] "Integrating Services with XSLT." By Will Provost. From O'Reilly WebServices.XML.com (September 30, 2003). "For all the magic that XML, SOAP, and WSDL seem to offer in allowing businesses to interoperate, they do not solve the more traditional problems of integrating data models and message formats. Analysts and developers must still plod through the traditional process of resolving differences between models before the promise of XML-based interoperability is even relevant. Happily, there's more magic out there: having committed to XML, companies can take great advantage of XSLT to address integration problems. With XSLT one can adapt one model to another, which is a tried-and-true integration strategy, implemented in a language optimized for this precise purpose. In this article I'll discuss issues and techniques involved in bringing XSLT into web service scenarios and show how to combine it with application code to build SOAP intermediaries that reduce or eliminate the stress between cooperating data structures... XSLT can make many annoying integration problems go away and with relatively low effort at that. We remember that almost all integration issues will require bidirectional transformation. That is, data that's transformed on its way in, and perhaps stored somewhere, will eventually be requested and sent back out, and it will have to look right to the requester. Form is not the only problem here. It is important to avoid the trap of inbound transformations that produce redundant results for different inputs. In other words, there must be a one-to-one mapping between the external and internal value spaces. Precisely preserving information is key to service adaptation, and this is not always so simple.. As wonderful as XSLT is, it's not designed to solve all possible transformation problems. Generally, it's strong on structural work using node sets and progressively weaker working with single values and their components. String arithmetic, algorithms, and math are notable weak points..."

• [September 9, 2003] "Advent 3B2 Launches 3B2-FO, A New XSL-FO Rendering Tool, At Seybold San Francisco 2003." - "Advent 3B2, a leading supplier of standards-based publishing software, is announcing a new, quality-oriented, Extensible Stylesheet Language Formatting Object (XSL-FO) rendering engine called 3B2-FO at Seybold San Francisco 2003. Advent 3B2-FO software has been singled out as a Hot Pick by the editorial staff of The Seybold Report: Analyzing Publishing Technologies, as a product that should not be missed on the show floor... Advent 3B2-FO software supports both simplified yet flexible document production workflows for adding composition and page formatting information to XML documents so they can be printed. In operation 3B2-FO takes either ready-made XSL-FO files containing layout and formatting data, or files containing raw XML content plus an XSLT transformation script, and converts them into printable Postscript or PDF files. Advent 3B2-FO software was developed in accordance with the W3C XSL 1.0 recommendation of October 15, 2001. In addition to providing compliance with the W3C XSL-FO specification, the software engine includes a number of additional functions that provide extended composition and page layout controls. These will give users more versatile document formatting capabilities resulting in higher quality document aesthetics. The additional capabilities in 3B2-FO include controls over vertical justification on a page, extensive hyphenation controls, and the ability to add crop marks and registration marks to a page. Hyphenation features include the ability to specify the number of characters in words that can be hyphenated, the ability to prevent hyphenation at the end of a block and to use caps to keep capitalized words together, spacing controls (plus and minus) for letter and word spacing of text. Advent intends to add additional extended functionality to 3B2-FO over time. 'We announced our intention to develop an XSL-FO rendering tool last year at our annual International Conference in Atlanta,'comments George Punton, President of Advent Publishing Systems. 'We believe that publishers of XML documents will appreciate the advantages 3B2-FO delivers in terms of expanded functionality and the ability to produce higher quality documents compared to the other engines on the market. Should they eventually require even more comprehensive composition and pagination formatting capabilities, our high-end 3B2 software which is also fully XML compliant, is a logical upgrade path.' 3B2-FO is based on the composition and pagination formatting capabilities of Advent's 3B2 professional publishing software which has been in use in high end STM journal, legal, financial, book, and technical documentation publishing environments worldwide for over 16 years. Because it is based on this mature foundation, Advent expects its 3B2-FO software will provide an unprecedented level of performance and reliability... Advents global customer base includes The European Parliament, Boeing, GlaxoSmithKline, the US Patent and Trademark Office, Bertelsmann and the Canadian House of Commons. The Advent Group consists of Advent Publishing Systems UK (the parent company), Advent 3B2 GmbH (Germany), and Advent 3B2 Inc.(USA)..."

• [August 18, 2003] "XSLT Recipes for Interacting with XML Data." By Jon Udell. From XML.com (August 13, 2003). ['Udell explores alternative ways of making XML data interactive using XSLT.'] "In last month's column, 'The Document is the Database', I sketched out an approach to building a web-based application backed by pure XML (and as a matter of fact, XHTML) data. I've continued to develop the idea, and this month I'll explore some of the XSLT-related recipes that have emerged. Oracle's Sandeepan Banerjee, director of product management for Oracle Server Technologies, made a fascinating comment when I interviewed him recently. 'It's possible,' he said, 'that developers will want to stay within an XML abstraction for all their data sources'. I suppose my continuing (some might say obsessive) experimentation with XPath and XSLT is an effort to find out what that would be like. It's true that these technologies are still somewhat primitive and rough around the edges. Some argue that we've got to leapfrog over them to XQuery or to some XML-aware programming language in order to colonize the world of XML data. But it seems to me that we can't know where we need to go until we fully understand where we are... It's crucial to be able to visualize data. As browsers are increasingly able to apply CSS stylesheets to arbitrary XML, the XHTML constraint becomes less important. The Microsoft browser has been able to do CSS-based rendering of XML for a long time. Now Mozilla can too. Safari doesn't, yet, but I'll be surprised if it doesn't gain that feature soon. So while I'm sticking with XHTML for now, that may be a transient thing. Of more general interest are the ways in which XPath and XSLT can make XML data interactive... The techniques I've been exploring for the past few months are, admittedly, an unorthodox approach to building Web applications. The gymnastics required can be strenuous, and some of the integration is less than seamless. But the result is useful, and along the way I've deepened my understanding of XPath and XSLT. Is it really advisable, or even possible, to make XML the primary abstraction for managing data? I'm still not sure, but I continue to think it's a strategy worth exploring..."

• [August 09, 2003] "New and Improved String Handling." By Bob DuCharme. From XML.com (August 06, 2003). ['In the Transforming XML column Bob DuCharme explains some of the new and improved string handling functions -- for concatenation, search, and replace -- in XSLT/XPath 2.0.'] "In an earlier column, I discussed XSLT 1.0 techniques for comparing two strings for equality and doing the equivalent of a 'search and replace' on your source document. XSLT 2.0 makes both of these so much easier that describing the new techniques won't quite fill up a column, so I'll also describe some 1.0 and 2.0 functions for concatenating strings. Notice that I say '1.0' and '2.0' without saying 'XSLT'; that's because these are actually XPath functions available to XQuery users as well as XSLT 2.0 users. The examples we'll look at demonstrate what they bring to XSLT development. The string comparison techniques described before were really boolean tests that told you whether two strings were equal or not. The new compare() function does more than that: it tells whether the first string is less than, equal to, or greater than the second according to the rules of collation used. 'Rules of collation' refers to the sorting rules, which can apparently be tweaked to account for the spoken language of the content... New features such as data typing and a new data model may make XSLT and XPath 2.0 look radically different from their 1.0 counterparts, but many of these new features are straightforward functions that are familiar from other popular programming languages. The compare(), replace(), and string-join() functions, which will make common coding tasks go more quickly with less room for error, are great examples of this...

• [May 14, 2003] "Style Stylesheets to Extend XSLT, Part 2. Improving the Trace Generator." By Joseph Kesselman (Advisory Scientist, IBM). From IBM developerWorks, XML zone. ['In Part 1 of the series, Joe demonstrated the basics of using an XSLT stylesheet to enhance another stylesheet. In this installment he develops a more polished version, making the trace generator more detailed, more selective, and more controllable -- and as a bonus, he includes a reusable XPath generator template.'] "My previous article demonstrated the concept of using a stylesheet to compile new features into another stylesheet. Specifically, I showed you how to write a simple execution tracing tool, which automatically modifies a stylesheet so it will generate comments in the output document as it runs, showing which parts of the latter were produced by each template. However, I ended the article by pointing out that the basic version I'd developed was quite limited, and suggesting a number of ways in which it could be improved. In this installment I'll add some of those missing features, and turn this proof-of-concept into a much more useful tool..." With source code.

• [May 06, 2003] "Style Stylesheets to Extend XSLT, Part 1. Use XSLT as a Macro Preprocessor." By Joseph Kesselman (Advisory Scientist, IBM). From IBM developerWorks, XML zone. May 6, 2003. ['XSLT isn't just about styling documents for presentation. It's actually a very general-purpose document transformation processor. And as Joe demonstrates in this two-part series, stylesheets are themselves documents, so XSLT can be used as a portable preprocessor to automatically enhance the behavior of a stylesheet.'] Joe's note to the XSL list (xsl-list@lists.mulberrytech.com): "The first installment of my article on using XSLT stylesheets to annotate/enhance other XSLT stylesheets just went live on developerWorks. This part's largely motivation and context-setting, though it does introduce the basic tricks which are needed to generate new stylesheet behaviors. The second part (already written, just needs final polishing) will start with this limited prototype and polish it into a more robust and useful tool." From the introduction: "As one of the contributors to Apache's open-source Xalan processor, I've been impressed by the wide range of applications folks are finding for XSLT. Stylesheets have established themselves as a very general-purpose tool, not just for rendering XML documents for display, but for automatically generating new documents... XSLT does have the concept of extensions, which provide an architected way to enhance the stylesheet language. With the extensions, Xalan developers can provide some additional features without conflicting with the standard. But we really can't afford to build every requested extension directly into the processor; we'd wind up with a huge library of infrequently-used features. Xalan does let you write and plug in your own extensions. But extensions are usually limited to defining new stylesheet operations rather than altering existing ones, and usually require that someone write code in a traditional programming language. Future versions of XSLT may let you write extensions in the XSLT language. Also, user-written extensions aren't supported by all XSLT processors, and the details of writing, accessing, and invoking them vary, so this isn't a very portable solution. For example, an extension written for the Java-based Xalan-J processor can't be invoked from the C++ version, Xalan-C, nor vice versa... In this pair of articles, I'll show you another way to enhance XSLT stylesheets, which can do some things extensions can't and which will work in any XSLT processor: write a stylesheet that compiles custom features into other stylesheets! Essentially, we can leverage the fact that an XSLT stylesheet is itself an XML document and automatically apply a set of modifications to add or modify its behavior..." With source files.

• [April 15, 2003] "What's New in XSLT 2.0." By Jeff Kenton. In XML Journal Volume 4, Issue 04 (April 2003). "The XSLT version 1.0 language definition has been an official recommendation of the W3C since 1999. Its use has expanded dramatically in the past 18 months, for processing XML and XML/SOAP security policies and for generating HTML Web pages... Nearly as soon as the language became official, people began proposing to change it. The [revision] effort began as a version 1.1 proposal, which was abandoned in favor of the current Working Draft (WD)... XSLT 1.0 dealt with four types of data: strings, numbers, Booleans, and nodesets. XSLT 2.0 has 48 atomic (built-in) data types, plus lists and unions constructed from them. There are now 16 numeric types; 9 variations of date, time, and duration; plus hexBinary and base64Binary, among others. Users may also create others from the built-in types to suit their needs... XPath 2.0 has generalized its path expressions. Now, a primary expression (literal, function call, variable reference, or parenthesized expression) can appear at any step in the path, rather than just the first step. Basically, this allows any expression that returns a nodeset (sequence of nodes) to appear on either side of a /... One issue that has proven somewhat divisive in version 2.0 is the inclusion of schemas. There are those, including Microsoft and others, who believe that schemas are necessary to what people are doing with the language. Schemas provide both validation of data types in input documents, and clues to the XSLT processor about which data structures to expect. There are others who think it is too complicated, and that schema validation should be a separate process. There are reasonable arguments on both sides. In the end, it was decided to define a conformance level for which schema support was optional. With schema support, there is a new xsl:import-schema declaration. Every data type name that is not a built-in name must be defined in an imported schema. XPath expressions will be able to validate values against in-scope schemas, and will be able to use constructors and casts to imported data types. There are still issues to be resolved before the Working Drafts turn into official W3C Recommendations. Committee members have said that they hope the process will be complete by late this summer or early fall [2003]. Meanwhile, Michael Kay, who is both the editor of the XSLT 2.0 WD and the creator of Saxon, has made a version of Saxon available that supports most of the new proposal. And, of course, most suppliers of XSLT processors are working to support version 2.0 of the language as soon as it becomes official. The committees are doing a great job improving XSLT, and I expect it to be enthusiastically adopted by the XML community..." [alt URL]

• [April 08, 2003] "Fast XSLT." By Steve Punte. From XML.com (April 02, 2003). ['The article focuses on the need for speed in XSLT. The widespread adoption of the W3C's XML transformation language has led to a demand for fast, conformant XSLT processors. One way of achieving speed is to pre-compile XSLT stylesheets. Steve Punte concentrates on that technique in "Fast XSLT." Steve tracks the emergence of Apache XSLTC and its modern competitor, Gregor.'] "This article reviews the birth and development of the promising compiled-XSLT engine, Apache XSLTC, and the fierce competition among developers of XSLT engines to be the performance leader... Apache XSLTC began in early 2000 at Sun Microsystems, first with Jacek Ambroziak and eventually turning into a small team. XSLTC is most significantly differentiated from other transformer engines by its distinctive two-phase operation. The XSL stylesheet is first compiled into a Java class called a 'translet' ('transformer servlet', not related to a web application servlet). This stand-alone translet can be loaded as a Java class and run in a different process or even on an entirely different machine. The core translet accepts a DOM-like object for input and produces a SAX-like output stream. Adaptors are provided to convert to all conventional standards. But Jacek Ambroziak has wiped the plate completely clean and started a new XSLT engine, which he calls 'Gregor', at his new firm Ambrosoft. As Jacek says, 'In the case of XSLTC (and especially Gregor) it is not only compilation but sets of particular algorithmic ideas that matter a lot for performance (speed/memory)'. In early testing, Gregor is tentatively showing nearly ten times the performance of Xalan-J and twice that of XSLTC; but it is not a complete product yet. Benchmarks can be misleading... In the end, the question always remains, 'are their sufficiently radical and advantageous architectural approaches that can improve performance yet unexplored and untapped?' In the case of XSLT engines, the answer is 'probably', since it's a very young field... Compilation to bytecode is just one of many tactics being utilized in the XSLT performance race. It is possible that additional significant gains will also be obtained in other areas such as intelligent pre-optimization of stylesheets, clever internal data structures, or even a more hot-spot like run-time optimizer. Most likely the field will remain competitive, each product achieving improvements and gains on a year-to-year basis, new contenders coming onto the scene, and some old ones slipping off. Performance is difficult to quantify and predict and highly dependent upon the exact customer usage. For performance in critical situations it is recommended that a small handful of the dominant engines be tested in a particular application before a final decision is made..."

• [April 08, 2003] "Conditional Execution." By Bob DuCharme. From XML.com (April 02, 2003). ['Bob DuCharme is back for his monthly Transforming XML column. Bob explains the use of the conditional constructs xsl:if and xsl:choose in order to selectively execute part of a stylesheet.'] "Most programming languages provide some means of conditional execution, which allows a program to execute an instruction or block of instructions only if a particular condition is true. Many programming languages do this with if statements; the XSLT equivalent is the xsl:if instruction. There's ultimately only one instruction that can or can't happen in XSLT based on the boolean value of an xsl:if element's test expression: nodes get added to the result tree or they don't. The addition of nodes to the result tree is the only end result of any XSLT activity, and the xsl:if element gives you greater control over which nodes get added than template rule match conditions can give you. For example, an xsl:if instruction can base its behavior on document characteristics such as attribute values and the existence (or lack of) specific elements in a document. Many programming languages also offer case or switch statements. These list a series of conditions to check and the actions to perform when finding a true condition. XSLT's xsl:choose element lets you do this in your stylesheets...

• [March 07, 2003] "Peek Into the Future of XSLT 2.0." By Charles White. From DevX.com (March 04, 2003). ['XSLT 2.0 provides powerful new features that XSLT 1.0 was missing. Although XSLT 2.0 is still under development, Mike Kay's Saxon 7 implementation lets you experiment with the new capabilities now.'] "XSLT is beginning to take root into a large base across the enterprise. So what happens? Just as developers begin to get comfortable with XSLT, XSLT 2.0 and XPath 2.0 begin to creep up on them from around the corner. And it's fair to say that XSLT 2.0 is not your mother's XSLT. In fact, XSLT 2.0, XPath 2.0, and XQuery are now so interconnected that if you master one, you can easily master them all. So when you're done with this article, make a note to yourself to study XPath 2.0 when it receives formal recommendation status as a standard from the W3C. This article will introduce you to some of the most interesting core concepts of XSLT 2.0 and its companion, XPath 2.0. While it doesn't cover all the changes to these languages, it will introduce you to the most interesting new features. The brief example at the end of this article may help to tie some of this information together. Like its predecessor XSLT 2.0 relies heavily on XPath (now XPath 2.0) for many of its core features. XPath 2.0 is itself intertwined with yet another emerging standard, XQuery 1.0, which relies on XPath 2.0 so much that after mastering XPath 2.0 you'll have a pretty good idea how XQuery works. It's important to note though that XSLT 2.0 does not rely on XQuery. XQuery is a language for querying XML documents and is already finding substantial support in most of the native XML databases such as XIndice, Ipedo, XHive, and others. In addition, both Microsoft and Oracle plan to support XQuery in their next major releases, which will have native XML database capabilities. Eric Brown, Microsoft's Product Manager for SQL Server, says that the next release of SQL Server, code-named Yukon, will support the following XML features: (1) Native XML Storage, (2) XQuery Support, (3) Cross domain querying between relational and XML data. Some developers are even suggesting that XQuery will supplant XSLT as the primary XML processing language. Other than their common bond to XPath, however, there is no direct relationship between XSLT 2.0 and XQuery... In XSLT 1.0 (and XPath 1.0), there were four kinds of data types: Strings, Booleans, Node-sets, and Numbers. Node-sets, of course, contain nodes, which in turn contain some properties. There are seven types of nodes, the document, element, attribute, text, namespace, processing instruction, and comment nodes. XPath 2.0 has a much richer data model. At the very top of the list is the sequence, which in addition to nodes can consist of XML Schema Language simple types such as xs:int or xs:date, and is equivalent to an ordered list. The addition of XML Schema data types is the biggest change. There are 16 simple data types available through Schema, and XQuery provides for functional access to all of them..."

• [February 19, 2003]   XSL-FO Implementation in the Sun xmlroff XSL Formatter SourceForge Project.    A communiqué from Eduardo Gutentag describes the release of the Sun xmlroff XSL formatter as a SourceForge project. The xmlroff XSL Formatter "is written in C and currently produces PDF output using the PDFlib library. It uses libxml2 and libxslt plus the GLib, GObject and Pango libraries that underlie GTK+ and GNOME, although it does not require either GTK+ or GNOME. xmlroff represents Sun's newest open source donation is an implementation of the W3C's Extensible Stylesheet Language specification, also known as the Extensible Stylesheet Language Formatting Objects specification (XSL-FO). Drawing on previous work in CSS2 and DSSSL and and other information formatting standards, XSL-FO defines a collection of page layout semantics in XML -- such as page numbering -- that makes it easier for data to be both easily navigable through Web-based readers, such as Web browsers or PDF readers, as well as cleanly read when printed. Sun's open source XSL-FO engine helps developers to create consistent formatting results for published data across an array of languages, which equals lower costs through reduced development time and minimized errors and is designed to support full internationalization.

• [February 18, 2003] "EXSLT By Example. How to Put the Community Standard XSLT Extensions to Work." By Uche Ogbuji (Principal Consultant, Fourthought, Inc). From IBM developerWorks, XML zone. February 2003. ['Community standards have had a very important role in XML technology, from SAX to RDDL. The most important community standard for XSLT is the EXSLT initiative for standard extension functions and elements. In this article, Uche Ogbuji uses practical examples to introduce and demonstrate some useful EXSLT functions.'] "... the EXSLT extensions make XSLT far more useful in general-purpose data-manipulation tasks. Just to select a few random examples: (1) The EXSLT Math module contains trigonometric mathematical functions, which makes it feasible to generate pie charts in SVG. (2) The EXSLT Regular Expressions module makes it easier to parse and process user input and other variable data sources. (3) The EXSLT Dates and Times module makes it easier to render Web pages with date-sensitive content, or to process data containing date fields... In these and many other real-life tasks, EXSLT makes using XSLT feasible in a way that is portable across the many processors that support the standard. In prior articles, I have already shown how EXSLT functions such as exsl:node-set and exsl:object-type are useful for even the most basic processing tasks. In this article I try to cover a cross-section of EXSLT's capabilities by solving a couple of simple and practical problems using EXSLT. I also try to avoid ground I've already covered to introduce the many useful EXSLT facilities that have not received the attention they deserve. If you are completely unfamiliar with EXSLT, please read the Kevin Williams article first. The resources in that article include pointers to XSLT processors that support EXSLT, which you should install so you can play with the examples and use EXSLT yourself... EXSLT includes tools for making things easier and others for making things possible in the first place. For example, the date:date-time function is impossible to replace in XSLT but dyn:evaluate() can usually be replaced by a system, whereas you use XSLT to generate another XSLT script which is what you actually run to get the desired result. EXSLT includes much more than I can hope to cover in future articles, but one nice thing about EXSLT is that it is very well documented. You'll find a world of riches to improve your XSLT development by checking out the Web site and taking advantage of this community standard..."

• [February 11, 2003] "HTML to Formatting Objects (FO) Conversion Guide. Use These XSLT Templates to Speed Your Conversions of HTML Elements to FO and Thence to PDF." By Doug Tidwell (developerWorks' Cyber Evangelist, IBM developerWorks). From IBM developerWorks, XML zone. February 2003. ['Need help converting HTML documents to PDF? This reference guide shows by example how to use XSLT templates to convert 45 commonly used HTML elements to formatting objects from the XSL-FO vocabulary for easy transformation to PDF using XSLT. The examples assume that you're using the Java-based XSLT processor Xalan and the Apache XML Project's FOP tool, but most of the methods would work just as well with other tools.'] "We all design our HTML pages to look good on the screen, but printing those Web pages is usually an afterthought. To create printable versions of Web pages, the best approach is to use XSLT and XSL-FO to generate a PDF file. You can do the job with an open-source XSLT processor, the XSL Formatting Objects (XSL-FO) vocabulary, and a formatting-object engine. If you already know how to work with XSL-FO and XSLT, this guide provides a valuable resource: It goes through the most common HTML tags and defines how to convert each of them into formatting objects... This guide includes dozens of examples that illustrate how to write XSLT style sheets to do the conversion from HTML element to the corresponding formatting object, the basic building block of documents rendered with XSL-FO..."

• [January 08, 2003]   Xerox Announces Circus-DTE Programming Language for Document Transformation.    [Not XSLT.] An experimental programming language developed at the Xerox Research Centre of Europe in Grenoble, France has been released for testing. Circus-DTE is a "new, innovative programming language designed for document transformation processing. Circus-DTE natively supports XML (DTDs) and is particularly suited to data processing or the transformation of structured documents: it automatically validates the results produced so that input into another application is sure to function properly. XRCE scientists believe that Circus-DTE could be especially useful when there are multiple document transformations, such as document content processing, Internet publishing, publishing on handheld devices and database-to-XML conversions. For example, processing a customer order requires a series of transformations -- data must be input into applications that check inventory and availability, that prepare shipping documentation, that generate an invoice, that process payments and perhaps even publish to the Web so a customer can track progress online. Circus-DTE is a mixture of functional, imperative and declarative programming styles. It is a type-safe compiled language with an embedded interpreter for compile-time evaluation of testing clauses. Circus-DTE incorporates structural matching operators that operate on all types of data. Matching operations involve typechecked filters which are combined up to arbitrary complex levels. Circus-DTE also offers a Linda-like Coordination Memory. Such a model relies on a few basic synchronization primitives and an associative memory that together simplify complex synchronization schemes." The software is downloadable; it runs on Win32, Linux, or Solaris/SunOS platforms.

• [December 19, 2002] "Automatic Numbering, Part Two." By Bob DuCharme. From XML.com December 11, 2002. ['Here we have the second part of "Automatic Numbering", part of Bob DuCharme's "Transforming XML" column. This month, Bob shows how to control section numbering and examines an alternative to <xsl:number> for simple numbering tasks.'] "In last month's column, we saw how XSLT's xsl:number element lets you add numbers to your output for numbered lists or chapter and section headers. We looked at some of the attributes of this element that let you control its appearance -- for example, how to output the numbers as Roman numerals, as letters instead of numbers, and how to add leading zeros. We also saw the basics of numbering sections and subsections, but only the basics. This month we'll learn how to gain real control over section numbering, and we'll look at a more efficient alternative to xsl:number that's sometimes better for simple numbering..."

• [December 18, 2002] "Using XSL Formatting Objects for Production-Quality Document Printing." By Kimber W. Eliot (ISOGEN International, LLC). Presentation given at the IDEAlliance XML 2002 Conference, Baltimore, December 2002. 16 pages. ['PDF paper version produced from XML source via XSL, Saxon and Antenna House's XSL Formatter product.'] Abstract: "The XSL Formatting Objects specification has been a published recommendation for over a year. During that time a number of commercial XSL-FO implementations have become available that make it possible to use XSL-FO for true production-quality creation of printed documents. While there are functionality limitations in XSL 1.0 that limit the types of page layouts that can be created, the page layouts that are supported are sufficient for most technical documentation, such as user manuals, maintenance manuals, and so on. This paper evaluates the XSL 1.0 specification and the currently-available implementations against the print requirements typical of a variety of document types, including technical documents, magazines, and newspapers. We then report our experience in using XSL-FO with commercial tools to produce hardware user manuals for a line of consumer computer peripherals. We discuss the XSLT and XSL issues, as well as XSL-FO extensions that may be required to satisfy typical print production requirements. Finally, we provide a set of recommendations, based on the current state of the XSL specification and the current state of tools, as to when the use of XSL-FO is appropriate and which XSL-FO implementations are best suited to which tasks or disallowed by certain sets of requirements." Summary: "Our experience to date with using XSL-FO for production of high-quality printed documents, primarily technical manuals, has been tremendously positive. At almost every step of the process of implementing FO-based publishing solutions the task has been easier than we expected. We have been pleasantly surprised by the how much easier it is to create and maintain FO style sheets using XSLT as the transformation technology than any other publishing technology we have used in the past. We have been impressed by the quality of the FO implementations and the responsiveness of vendors to problem reports and feature requests." Note the update provided in the posting "Production Quality XSL-FO": "This paper reflects the state of the world as of late October 2002. Since I wrote it, the following FO implementations have been released or announced: (1) Adobe Document Server. Includes an FO-to-PDF component based on top of Framemaker. Doesn't implement as many features as XEP or XSL Formatter, but lets you use Frame-specific functionality from the FO, such as Frame templates. Provides some extensions, including a revision bar mechanism. (2) SUN's xmlroff open-source FO implementation. Written in C. Provides internationalization features, including support for right-to-left writing modes. Feature support is 'almost basic conformance'. Should be released Real Soon Now (just waiting for final approvals). (3) 3B2's to-be-named 'free or almost-free' FO implementation, built on top of the 3B2 formatting engine. (4) Antenna House announced Unix and Linux support in 1Q2003 (they are doing final release testing now). (5) IBM's XFC FO implementation was released as part of a larger AFP product. IBM assures me that it is under active development... It was standing room only by the time I was done presenting my talk, which is pretty good considering I was up against Norm Walsh. From the questions I got asked, it was clear that a lot of enterprises are starting to investigate the use of XSL-FO to do sophisticated page composition..." See the source at IDEAlliance and other ISOGEN white papers. [cache]

• A posting from W. Eliot Kimber (ISOGEN International) announces the creation of an EXSLFO project on SoureFor