Search

In spite of its popularity, XML provides poor user experience and a lot of domain-specific languages can be improved by introducing custom, more humanfriendly notation. This paper presents an approach for design and development of the custom notation for existing XML-based language together with a translator between the new notation and XML. The approach supports iterative design of the language concrete syntax, allowing its modification based on users feedback. The translator is developed using a model-driven approach. It is based on explicit representation of language abstract syntax (metamodel) that can be augmented with mappings to both XML and the custom notation. We provide recommendations for application of the approach and demonstrate them on a case study of a language for definition of graphs.

This paper proposes an XML format for standard Z. We describe several earlier XML proposals for Z, the problems and issues that arose, and the rationales behind our new proposal. The new proposal is based upon a comparison of various existing Z annotated syntaxes, to ensure that the mark-up will be widely usable. This XML format is expected to become a central feature of the CZT (Community Z Tools) initiative.

We discuss three well-known languages for querying and manipulating XML documents: XQuery, XPath and XSLT. They are considered to be the standard languages for processing XML documents. However, specifying their complete semantics in a formal way seems almost impossible. Indeed, an attempt by the W3C XML Query Working Group to do so for XQuery was ultimately abandoned. We introduce three sublanguages, called MiXPath, MiXQuery and MiXSLT, and describe their syntax and formal semantics. The syntax and semantics of these languages are chosen such that they are consistent with the ones given in the related W3C recommendations. As such this provides a practical foundation for research and teaching of XML languages. For this purpose the sublanguages are chosen such that they contain the most crucial features, constructs and expressions of each of these three languages.

In this work, we focus on XML data integration by studying rewritings of XML target schemas in terms of source schemas. Rewriting is very important in data integration systems where the system is asked to find and assemble XML documents from the data sources and produce documents that satisfy a target schema. As schema representation, we consider Visibly Pushdown Automata (VPAs), which accept Visibly Pushdown Languages (VPLs). The latter have been shown to coincide with the family of (word-encoded) regular tree languages, which are the basis of formalisms for specifying XML schemas. Furthermore, practical semi-formal XML schema specifications (defined by simple pattern conditions on XML) compile into VPAs that are exponentially more concise than other representations based on tree automata. Notably, VPLs enjoy a “well-behavedness” that facilitates us in addressing rewriting problems for XML data integration. Based on VPAs, we positively solve these problems, and present detailed complexity analyses.

In this paper we model schema evolution for XML by defining formal language operators on Visibly Pushdown Languages (VPLs). Our goal is to provide a framework for efficient validation of streaming XML in the realistic setting where the schemas of the exchanging parties evolve and thus diverge from one another. We show that Visibly Pushdown Languages are closed under the defined language operators and this enables us to expand the schemas (for XML) in order to account for flexible or constrained evolution.

Approach is offered to the formal specification of Standard Life Cycle (LC) of the program systems (PS) by the ontology facilities with purpose automation and generation of the variants LC for making the appropriate kinds process for development different PS. Ontological approach to presentation LC model of the standard ISO/IEC 12207-2007 is included the specification of general, organizational and support processes. These processes are presented in the subject-oriented DSL, which than transformed to XML for realization. One of the processes, the testing process is given in terms of Protege systems. An eventual result of this system Protege got generally at accepted to the XML, suitable for implementation tasks testing PS on computer.

We developed three different rule-based systems, each designed to take XML as input and produce XML as output and manipulate intermediate facts as XML. They use very different methods of representing the XML during rule processing. Our series of benchmarks show when each representation is best. We also developed an XML language for representing the rules. The markup to recognize an input XML is a sample of that input; certain fields are replaced with special tags to match variables against text or subtrees within the input XML. The output or intermediate XML is also represented by a sample of the output XML. We also report on a graphical user interface developed for developing the rules in this special XML language.

On the basis of regular tree grammars, we present a formal framework for XML schema languages. This framework helps to describe, compare, and implement such schema languages in a rigorous manner. Our main results are as follows: (1) a simple framework to study three classes of tree languages (local, single-type, and regular); (2) classification and comparison of schema languages (DTD, W3C XML Schema, and RELAX NG) based on these classes; (3) efficient document validation algorithms for these classes; and (4) other grammatical concepts and advanced validation algorithms relevant to an XML model (e.g., binarization, derivative-based validation).

The expressive power of XML Declarative Description (XDD), a unified XML-based representation language for the Knowledge Grid ,i senhanced by a well-defined mechanism for modeling arbitrary XML first-order logical constraints (FLCs)—a special kind of constraints comprising XML expressions and logical symbols. The resulting knowledge representation can uniformly express explicit and implicit information, ontologies, axioms as well as integrity, structural and FLCs. It facilitates direct use of ordinary XML elements as its basic language component and semantic units, and formally defines XML clauses for modeling advanced complex statements. It achieves sound, efficient, and flexible computation or inference by means of the Equivalent Transformation (ET) paradigm—a new computational model based on semantic preserving transformations. Basic ET computational rules for reasoning with XDD descriptions with FLCs are also presented. Due to its well-founded mechanism and expressiveness, employment of the proposed representation and computation framework to model a knowledge grid and its services not only enables direct representation of knowledge bases described by such emerging Semantic Web ontology languages as RDF(S) and OWL ,b ut also offers additional descriptive facilities by allowing expression of and reasoning with rules, relationships, and constraints. Moreover, in order to provide machine-interpretable descriptions of knowledge grid services, standard service description languages, e.g., WSDL, UDDI, OWL-S and WSMO are employed and extended with facilities to define additional service relationships, constraints, and composition rules.

This paper describes a graphical specification tool for Dia Gen , a diagram editor generator based on hypergraph grammars and hypergraph transformation. The specification tool greatly simplifies the process of specifying and generating diagram editors. It uses an XML-based specification language, and it is an extension of a generic XML editor which offers syntax-directed editing based on the DTD, i.e, syntax specification, of the underlying XML-based language.

XDuce is a statically typed programming language for XML processing. Its basic data values are XML documents, and its types (so-called regular expression types ) directly correspond to document schemas. XDuce also provides a flexible form of regular expression pattern matching , integrating conditional branching, tag checking, and subtree extraction, as well as dynamic typechecking. We survey the principles of XDuce's design, develop examples illustrating its key features, describe its foundations in the theory of regular tree automata, and present a complete formal definition of its core, along with a proof of type safety.

XML is spreading out as a standard for semistructured documents on the Web, so the possibility of querying XML documents which are linked by XML links is becoming a goal to achieve. In this paper we present XML-GLrec, an extended version of the graphical query language for XML documents XML-GL. XML-GL allows to extract and restructure information from XML specified WWW documents. We extend XML-GL in the following directions: (i) XML-GLrec allows to represent XML simple finks, so that it is possible to query whole XML specified WWW sites in a simple and intuitive way; (ii) XML-GLrec improves the expressive power of XML-GL, where only transitive closure can be expressed, by allowing generic recursion; (iii) finally, we permit the user to specify queries in an easier fashion, by allowing sequences of nested query, in the same way as in SQL.

Model Schema Language (MSL) is an attempt to formalize some of the core ideas in XML Schema. The benefits of a formal description are that it is both concise and precise. MSL has already proved helpful in work on the design of XML Query. We expect that similar techniques can be used to extend MSL to include most or all XML Schema.

The article gives a brief overview of the main keywords and structure used in the IEC 61499 Textual Syntax and XML format. It is provided to assist with the understanding of the examples of Textual Syntax and XML format given in the book. For a full description and the full and formal production rules of the Textual Syntax, the reader is advised to read Annex B of IEC 61499-1. For a full description of the XML format and the associated Document Type Definition, the reader is advised to read Annex A of IEC 61499-2.

We propose regular expression types as a foundation for statically typed XML processing languages. Regular expression types, like most schema languages for XML, introduce regular expression notations such as repetition (*), alternation (|), etc., to describe XML documents. The novelty of our type system is a semantic presentation of subtyping, as inclusion between the sets of documents denoted by two types. We give several examples illustrating the usefulness of this form of subtyping in XML processing.The decision problem for the subtype relation reduces to the inclusion problem between tree automata, which is known to be EXPTIME-complete. To avoid this high complexity in typical cases, we develop a practical algorithm that, unlike classical algorithms based on determinization of tree automata, checks the inclusion relation by a top-down traversal of the original type expressions. The main advantage of this algorithm is that it can exploit the property that type expressions being compared often share portions of their representations. Our algorithm is a variant of Aiken and Murphy's set-inclusion constraint solver, to which are added several new implementation techniques, correctness proofs, and preliminary performance measurements on some small programs in the domain of typed XML processing.

In this article the transformation language ELaX E volution La nguage for X ML-Schema for modifying existing XML Schemas is introduced. This domain-specific language was developed to fulfill the crucial need to handle modifications on an XML Schema and to express such modifications formally. The language has a readable, simple, base-model-oriented syntax, but it is able to also express more complex transformations by using add, delete and update operations. A small subset of operations of the whole language is presented and illustrated partially by dealing with a real life XML Schema of the WSWC W estern S tates W ater C ouncil. Finally, the idea of integrating an ELaX interface into an existing research prototype for dealing with the co-evolution of corresponding XML documents is presented.

Regular expressions can be found in a wide array of technology for data processing on the web. We are motivated by two such technologies: schema languages for XML and query languages for graph-structured or linked data. Our focus is on theoretical aspects of regular expressions in these contexts.

The main contribution of this paper is a generic grammarware for validating XML integrity constraints. Indeed, we use an attribute grammar to describe XML documents and constraints. We thus explain the main parts of this novel algorithm and we report on experiments showing that our method allows for an effective and efficient validation of XML functional dependencies (XFD).

By deeply studying the E-LOTOS standard and the XML language, this paper has analyzed the E-LOTOS text that is used to describe the protocol running mechanism, and has designed the structure of XML that is preserve the abstract test case, the file class supported by JAVA is used to parse the E-LOTOS text, and the adjacency FSM(finite state machine) is obtained meanwhile the FSM`s graph is drawn. Based on the FSM the abstract test case is generated by using the U method, and it converted into XML document relying on XML parser and DOM (document object model). Finally E-LOTOS description of BGP-4 protocol is used to generate the XML format abstract test cases.

In this paper, we propose algorithms that extend a given regular tree grammar G0 to a new grammar G respecting the following two properties: (i) G belongs to the sub-class of local or single-type tree grammars and (ii) G is the least grammar (in the sense of language inclusion) that contains the language of G0. Our algorithms give rise to important tools in the context of web service composition or XML schema evolution. We are particularly interested in applying them in order to reconcile different XML type messages among services. The algorithms are proven correct and some of their applications are discussed.

XML has been widely applied in kinds of areas and applications as a data exchange format. Recently, plenty of of languages based on XML emerge. There are many constraints specified by natural language in these XML-based language specifications to regulate the rules that are supposed to be obeyed by designers or programmers. To specify those constraints precisely, we present a relational calculus to capture them. Meanwhile, by means of the constraint solvers (SAT or SMT solver), we can decide that whether a XML-based document satisfies the constraints specified in its corresponding specification.

The first half of the paper presents the Unified Modeling Language (UML) and the Extensible Markup Language (XML). It describes some of the key types of UML diagrams defined for the description of static structures of complex systems and the dynamic behavior between the different objects in the system, as well as the structure and components of an XML files. The second part of the paper discusses the use of UML diagrams and XML files in the definition of the object models in IEC 61850 and the Substation Configuration Language defined in Part 6 of the standard.

XML Schema Definitions (XSDs) can be adequately abstracted by the single-type regular three languages. It is well-known, tha these form a strict subclass of the robust class of regular unranked three languages. Sadly, in this respect, XSDs are not closed under the basic operations of union and set difference, complicating important tasks in schema integration and evolution. The purpose of this paper is to investigate how the union and difference of two XSDs can be approximated within the framework of single-type regular three languages. We consider both optimal lower and upper approximations. We also adress the more general question of how to approximate an arbitrary regular tree language by an XSD and consider the complexity of associated decision problems.

This paper presents XLOP (XML Language-Oriented Processing), an environment that permits the description of XML processing applications with attribute grammars (formalism used to describe the semantics of computer languages). The environment also includes a generator able to translate attribute grammar-based specifications into the specification language of CUP, a well-known YACC-like environment for writing language processors. The final goal of XLOP is to facilitate the development and maintenance of XML processing applications, whilst preserving the flexibility of general-purpose XML processing models. Also, since it is based on attribute grammars, XLOP provides a higher abstraction level than other similar translation scheme-based approaches.

In this article we define a new type of integrity constraint in XML, called an XML inclusion constraint (XIND), and show that it extends the semantics of a relational inclusion dependency. This property is important in areas such as XML publishing and `data-centric' XML, and is one that is not possessed by other proposals for XML inclusion constraints. We also investigate the implication and consistency problems for XINDs in complete XML documents, a class of XML documents that generalizes the notion of a complete relation, and present an axiom system that we show to be sound and complete.

XML is successful as a machine processable data interchange format, but it is often too verbose for human use. For this reason, many XML languages permit an alternative more legible non-XML syntax. XSLT stylesheets are often used to convert from the XML syntax to the alternative syntax; however, such transformations are not reversible since no general tool exists to automatically parse the alternative syntax back into XML.We present XSugar, which makes it possible to manage dual syntax for XML languages. An XSugar specification is built around a context-free grammar that unifies the two syntaxes of a language. Given such a specification, the XSugar tool can translate from alternative syntax to XML and vice versa. Moreover, the tool statically checks that the transformations are reversible and that all XML documents generated from the alternative syntax are valid according to a given XML schema.

Martens et al. defined a pattern-based specification language equivalent in expressive power to the widely adopted XML Schema definitions (XSDs). This language consists of rules of the form (r, s) where r and s are regular expressions and can be seen as a type-free extension of DTDs with vertical regular expressions. Sets of such rules can be interpreted both in an existential or universal way. In the present paper, we study the succinctness of both semantics w.r.t. each other and w.r.t. the common abstraction of XSDs in terms of single-type extended DTDs. The investigation is carried out relative to three kinds of vertical pattern languages: regular, linear, and strongly linear patterns. We also consider the complexity of the simplification problem for each of the considered pattern-based schemas. (C) 2010 Elsevier Inc. All rights reserved.

In the recent time the Extensible Markup Language (XML) is playing an increasing role in the exchange of nearly all kind of Web-based data and elsewhere. Hence, the development and enhancement of XML document transformation technologies and concepts become essential in the future. However, numerous specific transformation approaches specify their transformation definitions in XML files themselves. In this paper we present the XML Transformation Coordinator (XTC) which supports the composition and adaptation step in the development of these XML transformation definitions implementing a hierarchy concept of transformation operators. This hierarchy concept allows the specification of complex transformation operators without changing the underlying transformation technology. The complex operators are either generic or specifically suited to develop transformations in a certain domain or application area.

XML is successful as a machine processable data interchange format, but it is often too verbose for human use. For this reason, many XML languages permit an alternative more legible non-XML syntax. XSLT stylesheets are often used to convert from the XML syntax to the alternative syntax; however, such transformations are not reversible since no general tool exists to automatically parse the alternative syntax back into XML. We present XSugar, which makes it possible to manage dual syntax for XML languages. An XSugar specification is built around a context-free grammar that unifies the two syntaxes of a language. Given such a specification, the XSugar tool can translate from alternative syntax to XML and vice versa. Moreover, the tool statically checks that the transformations are reversible and that all XML documents generated from the alternative syntax are valid according to a given XML schema.

The increased importance of XML as a data representation format has led to several proposals for facilitating the development of applications that operate on XML data. These proposals range from runtime API-based interfaces to XML-based programming languages. The subject of this paper is XJ, a research language that proposes novel mechanisms for the integration of XML as a first-class construct into Java™. The design goals of XJ distinguish it from past work on integrating XML support into programming languages --- specifically, the XJ design adheres to the XML Schema and XPath standards. Moreover, it supports in-place updates of XML data thereby keeping with the imperative nature of Java. We have built a prototype compiler for XJ, and our preliminary experiments demonstrate that the performance of XJ programs can approach that of traditional low-level API-based interfaces, while providing a higher level of abstraction.

The benefits of using XML to encode program- ming language's source code have already been identified and XML syntaxes developed for this purpose. However, there is an absence of a systematic identification of the requirements that need to be met in order to fully leverage the potentials of XML and the key concept of the abstract syntax is being misinterpreted. Due to this the syntaxes have various deficiencies, a number of which are common to many of them. This paper clarifies the concepts, identifies these deficiencies, and proposes a new syntax for the Java programming language which avoids them. The superiority of the new syntax is demonstrated by comparing it with two of the most relevant publicly available syntaxes with the same purpose. I. INTRODUCTION The benefits of using XML to encode programming languages' source code have already been identified (1), (2) and XML syntaxes developed for this purpose (3), (4), (5). However, there is a lack of a systematic approach to the identification of more precise goals the syntax should achieve in order to fully leverage the potentials of this approach. Particularly, it appears that the central concept in the application of XML to source code, that of the abstract syntax, is not being interpreted properly. In order to explore this subject, a research project named Jezix was started. The main goal of the project was the development of an XML syntax for the Java pro- gramming language that is based on the correct treatment of the concept of the abstract syntax, which allows it to optimally leverage the identified potentials of XML. The results of the research were validated by demonstrating the proposed syntax's superiority over existing syntaxes. This was achieved by solving several code analysis prob- lems for the proposed and two of the most relevant existing syntaxes and then comparing the amount of effort needed and the properties of the resulting query code. The next section gives an overview of source code and XML. It repeats some well-known results of the formal language theory, but also clarifies important concepts and defines some terms used later. Section III presents the two key benefits of using XML for source code. Section IV reflects on the effects of using XML on the quality of the machine-to-human interface. Section V presents the most sensitive requirements the XML syntax has to meet. Section VI gives a critical overview of other existing syntaxes and identifies the common root of many of their deficiencies. Section VII briefly introduces the proposed syntax and proceeds to the presentation of the results of its comparison with the two other syntaxes. Finally, the closing section summarizes the achievements and conclusions of the Jezix project. II. OVERVIEW OF SOURCE CODE AND XML A programming language has two important compo- nents

We present an approach in which the semantics of an XML language is defined by means of a transformation from an XML document model (an XML schema) to an application specific model. The application specific model implements the intended behavior of documents written in the language. A transformation is specified in a model transformation language used in the Model Driven Architecture (MDA) approach for software development. Our approach provides a better separation of three concerns found in XML applications: syntax, syntax processing logic and intended meaning of the syntax. It frees the developer of low-level syntactical details and improves the adaptability and reusability of XML applications. Declarative transformation rules and the explicit application model provide a finer control over the application parts affected by adaptations. Transformation rules and the application model for an XML language may be composed with the corresponding rules and application models defined for other XML languages. In that way we achieve reuse and composition of XML applications.

XML applications are becoming increasingly popular to define structured or semi-structured constrained data in XML for special application areas. In pursuit there is a growing momentum of activities related to XML representation of source code in the area of program comprehension and software re-engineering. The source code and the artifacts extracted from a program are necessarily structured information that needs to be stored and exchanged among different tools. This makes XML to be a natural choice to be used as the external representation formats for program representations. Most of the XML representations proposed so far abstract the source code at the AST level. These AST representations are tightly coupled with the language grammar of the source code and hence require development of different tools for different programming languages to perform the same type of analysis. Moreover AST abstracts the program at a very fine level of granularity and hence not suitable to be used directly for higher-level sophisticated program analysis. As such, we propose XML applications for language neutral representation of programs at different levels of abstractions and by combining them we present a program representation framework in order to facilitate the development of generic program analysis tools.

The development of standards for describing format, structure and semantic content of data is essential for its automatic manipulation within a grid. We describe two related pieces of work that aim to address this need. BinX is a language with supporting tools and library for describing binary data, developed as part of the eDIKT project at the National eScience Centre. The data format description language (DFDL) is a global grid forum working group, which draws on the BinX work and aims to develop an extensible standard for describing these features of data formats.

According to the requirements of the XML-based network management interface testing system and the syntax and semantic rules of XML, a design scheme for DTD-based XML parser is proposed in this paper. Meanwhile, an implementation method for DTD-based XML parser based on the outlined design scheme is also presented.

In the last few years, XML has been widely used as a logical data model, and several database applications are modeled in XML. To model a database application in XML, we should first come up with a conceptual design for representing the application requirements, and then translate this conceptual design to XML. Existing conceptual models like the ER (Entity Relationship) model, UML and ORM do not have modeling capabilities to represent main features provided by XML, such as union types. In this work, we extend the ER model with additional features; we call our conceptual model as EReX (ER extended for XML). Translating an EReX design to XML enables us to make use of the different features provided by XML. Our approach further enables us to study a fundamental problem facing XML database community today: what structural and constraint specification should be provided in XML so that any generic database application can be modeled in XML.

The World-Wide Web Consortium (W3C) promotes XML and related standards, including XML Schema, XQuery, and XPath. This paper describes a formalization of XML Schema. A formal semantics based on these ideas is part of the official XQuery and XPath specification, one of the first uses of formal methods by a standards body. XML Schema features both named and structural types, with structure based on tree grammars. While structural types and matching have been studied in other work (notably XDuce, Relax NG, and a previous formalization of XML Schema), this is the first work to study the relation between named types and structural types, and the relation between matching and validation.

This paper describes an XML query language called XML-QBE, which can be used to both query and update XML documents and databases. The language itself has a simple XML form, and uses a query by example paradigm. This language was designed as a middleware layer between UML data models and backend database schemas, as part of a solution to the distributed, heterogeneous data-base problem and legacy database problem. Because the XML layer is derived from UML, XML-QBE is object-oriented. Queries and updates have a very similar form, and the form itself is XML. Therefore this language is also easy to process and analyze. We describe the language, the rationale, and our solution architecture.

In this paper, we study the different steps of translation from XML to relational models, while maintaining semantic constraints. Our work is based on the theory of regular tree grammars, which provides a useful formal framework for understanding various aspects of XML schema languages. We first study two normal form representations for regular tree grammars. The first normal form representation, called NF1, is used in the two scenarios: (a) Several document validation algorithms use the NF1 representation as the first step in the validation process for efficiency reasons, and (b) NF1 representation can be used to check whether a given schema satisfies the structural constraints imposed by the schema language. The second normal form representation, called NF2, forms the basis for conversion of a set of type definitions in a schema language L1 that supports union types (e.g., XML-Schema), to a schema language L2 that does not support union types (e.g., SQL), and is used as the first step in our XML to relational conversion algorithm.

In this paper we address the problem of how to extend the definition of functional dependencies (FDs) in incomplete relations to XML documents. An incomplete relation is said to strongly satisfy a FD if every completion of the relation, obtained by replacing all null values by data values, satisfies the FD in the ordinary sense. We propose a syntactic definition of strong FD satisfaction in a XML document (called a XFD) and then justify it by proving that for a very general class of mappings of a relation into a XML document, a relation strongly satisfies a unary FD if and only if the XML document also strongly satisfies the equivalent XFD.

The XML standards that are currently emerging have a number of characteristics that can also be found in database management systems, like schemas (DTDs and XML schema) and query languages (XPath and XQuery). Following this line of reasoning, an XML database might resemble traditional database systems. However, XML is more than a language to mark up data; it is also a language to mark up textual documents. In this chapter we specifically address XML databases for the storage of `document-centric' XML (as opposed to `data-centric' XML [42]).

Individual organisations as well as industry consortia are currently defining application and domain-specific languages using the eXtended Markup Language (XML) standard of the World Wide Web Consortium (W3C). The paper shows that XML languages differ in significant aspects from generic software engineering artifacts and that they therefore require a specific approach to version and configuration management. When an XML language evolves, consistency between the language and its instance documents needs to be preserved in addition to the internal consistency of the language itself. We propose a definition for compatibility between versions of XML languages that takes this additional need into account. Compatibility between XML languages in general is undecidable. We argue that the problem can become tractable using heuristic methods if the two languages are related in a version history. We propose to evaluate the method by using different versions of the Financial products Markup Language (FpML), in the definition of which we participate.

XML has become a popular data interchange and storage format, which in recent times has precipitated the rise of XML-enabled relational databases as well as native XML databases. This paper outlines a data definition and manipulation language for XML repositories that enables users to perform data management tasks such as creation and deletion of indices, collections and documents. The language proposed also provides the ability to perform queries, transformations and updates on the documents in the XML repository either singly or across an entire collection. A syntax for the language is presented as extensions to the W3C's XML Query language (XQuery) and also as a new language with syntax borrowed heavily from SQL for the relational model and DL/1 of IBM's IMS system for the hierarchical model. A prototype implementation of the language has been partially completed.

The growing use of XML languages has spurred the demand for means to transform XML documents. Many XML transformation systems are, however, limited in their expressive power, and fail to provide a useful collection of combinators for several tasks.This paper describes SXSLT, a practical, higher-order, concise, expressive and readable declarative XML transformation language. The language is a head-first rewriting system over abstract XML syntax trees, implemented as a library extension of Scheme. SXSLT features local scoping of re-writing "templates", first-class stylesheets, flexible traversal strategies, the ability to re-traverse the original or the transformed trees. The language can emulate XSLT in whole or in part, in a more coherent and expressive manner. By virtue of being a Scheme library, SXSLT is seamlessly integrated with Scheme.We illustrate the power of SXSLT with several examples abstracted from practical projects. We and other people have used SXSLT for over two years for real-life projects, ranging from authoring of static and dynamic Web pages to content-distribution engines. Our experience and user comments show that SXSLT is expressive and easy to use. We argue that this outcome is a consequence of SXSLT providing right abstractions for XML transformations, of being higher-order, declarative and extensible.

The basic mechanism of CLaRK for linguistic processing of text corpora is the cascade regular grammar processor. The main challenge to the grammars in question is how to apply them on XML encoding of the linguistic information. The system offers a solution using an XPath language for constructing the input word to the grammar and an XML encoding of the categories of the recognized words.

MPEG-7 provides a set of tools for the definition of a standard description for multimedia information. It uses XML Schema as its own Description Definition Language (DDL) to provide an ability to extend standard description to user application domains. However, due to its lack of expressive power, XML Schema cannot represent the implicit information of multimedia contents and hence cannot yield derived descriptions. In order to enhance the expressive power of multimedia annotations--described in terms of an XML document--and to maintain the advantages of XML Schema, there appears to be a need of a new schema language which can handle those abilities. XML Declarative Description (XDD) is a representation framework which can encode any XML document and application (e.g., XML Schema, RDF, RDF Schema, and DAML+OIL). It enhances XML expressive power by employing Declarative Description (DD) theory and also provides a mechanism for reasoning about new information from existing data. Moreover, it can specify constraints as well as ontological axioms. Thus, it is employed to construct a schema language for MPEG-7.

The World-Wide Web Consortium (W3C) promotes XML and related standards, includingXM L Schema, XQuery, and XPath. This paper describes a formalization XML Schema. A formal semantics based on these ideas is part of the official XQuery and XPath specification, one of the first uses of formal methods by a standards body. XML Schema features both named and structural types, with structure based on tree grammars. While structural types and matching have been studied in other work (notably XDuce, Relax NG, and previous formalizations of XML Schema), this is the first work to study the relation between named types and structural types, and the relation between matchinga nd validation.