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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Summary: An XML document type definition (DTD) is provided for the description of taxonomic relationships between organisms. Two XSL stylesheets for the graphical presentation of simple taxonomic trees are also provided. Availability: The DTD and stylesheets along with sample files are available at http://www.albany.edu/~gilmr/pubxml/. Contact: gilmr@cnsvax.albany.edu

The problem that XML formally governs syntax only but not semantics has been recognized as a serious barrier for XML-Based data integration and the extension of current Web to the semantic Web. To address this problem, the XML Semantics Definition Language (XSDL) is proposed to explicitly express the XML author's intended meaning and a model-theoretic semantics for XML. In this way, the XML becomes a sub-language of RDF (resource description framework) in expressivity and the XML data can be semantics-preserving transformed to the RDF data. The semantic validity and entailment problem of XML documents are further provided and they are reduced to the knowledge base unsatisfiability problem in description logic language SHOIN�∆