An approach to high-level language bindings to XML

Values of existing typed programming languages are increasingly generated and manipulated outside the language jurisdiction. Instead, they often occur as fragments of XML documents, where they are uniformly interpreted as labelled trees in spite of their domain-specific semantics. In particular, the values are divorced from the high-level type with which they are conveniently, safely, and efficiently manipulated within the language.We propose language-specific mechanisms which extract language values from arbitrary XML documents and inject them in the language. In particular, we provide a general framework for the formal interpretation of extraction mechanisms and then instantiate it to the definition of a mechanism for a sample language core L. We prove that such mechanism can be built by giving a sound and complete algorithm that implements it.The values, types, and type semantics of L are sufficiently general to show that extraction mechanisms can be defined for many existing typed languages, including object-oriented languages. In fact, extraction mechanisms for a large class of existing languages can be directly derived from L's. As a proof of this, we introduce the SNAQue prototype system, which transforms XML fragments into CORBA objects and exposes them across the ORB framework to any CORBA-compliant language.     

Aspect and XML-oriented Semantic Framework Generator: SmartTools

SmartTools is a semantic framework generator, based on XML and object technologies. Thanks to a process of automatic generation from specifications, SmartTools makes it possible to quickly develop environments dedicated to domain-specific and programming languages. Some of these specifications (XML, DTD, Schemas, XSLT) are issued from the W3C which is an important source of varied emerging domain-specific languages. SmartTools uses object technologies such as visitor patterns and aspect-oriented programming. It provides code generation adapted to the usage of those technologies to support the development of semantic analyses. In this way, we obtain at minimal cost the design and implementation of a modular development platform which is open, interactive, uniform, and most important prone to evolution.     

XML schema language: taking XML to the next level

Schemas add data typing and inheritance features, giving XML the sophistication required to create enterprise-class business applications. The XML schema language describes the legal structure, content, and constraints of XML documents. The XML schema language provides the necessary framework for creating XML documents by specifying the valid structure, constraints, and data types for the various elements and attributes of an XML document. Schema language provides enhanced as well as more comprehensive and powerful features than a document type definition (DTD). The XML schema language provides the rich data typing associated with ordinary programming languages. The W3C XML schema specification defines several different built-in data types, such as string, integer, Boolean, date, and time, among others. The specification also provides the capability for defining new types. Developers can use these built-in as well as user-defined data types to effectively define and constrain XML document attributes and element values     

公共元素模型数据类型的XML Schema描述

AI-ESTATE标准中采用EXPRESS语言对其诊断知识进行描述,但EXPRESS不是程序设计语言,导致采用EXPRESS语言描述的诊断知识难以用程序设计实现,为诊断知识的共享和重用造成了一定困难;XML语言以其良好的灵活性、可读性和可扩展性,为信息交换带来了很大的方便,将EXPRESS语言映射为XML Schema,对诊断知识的共享意义重大.首先,分析了EXPRESS语言和XML Schema的数据类型;然后,分别研究了EXPRESS中简单数据类型、聚合数据类型和构造数据类型到XML数据类型的映射机制;最后,在分析AI-ESTATE标准公共元素模型数据类型的基础上,研究了将公共元素模型的诊断知识用XML Schema标准化描述的过程,实现了诊断知识的可移植和重用.     

扩展面向对象编程（XOOP）的理论和方法

针对使用继续的传统对象系统在映射真实世界的对象关系时遇到的各种困难,提出一种普遍的软件工程方法,即扩展的面向对象方法（XOO）,它通过支持双向派生、归纳、更一般的多态机制等技术,来补足继承机制的不足,并进一步增强对象方法在描述对象关系方面的能力。作者强调了虚归纳是一种普遍的软件工程方法,它使得归纳与继承的高效结合成为可能,可以作为重用已有类库代码和与继续类层次结合的有效方法。文中还描述了XOOP的一个较为完整的实现－－编程语言C。     

Static use-based object confinement

The confinement of object references is a significant security concern for modern programming languages. We define a language that serves as a uniform model for a variety of confined object reference systems. A use-based approach to confinement is adopted, which we argue is more expressive than previous communication-based approaches. We then develop a readable, expressive type system for static analysis of the language, along with a type safety result demonstrating that run-time checks can be eliminated. The language and type system thus serve as a reliable, declarative, and efficient foundation for secure capability-based programming and object confinement .     

How to Comprehend Queries Functionally

Compilers and optimizers for declarative query languages use some form of intermediate language to represent user-level queries. The advent of compositional query languages for orthogonal type systems (e.g., OQL) calls for internal query representations beyond extensions of relational algebra. This work adopts a view of query processing which is greatly influenced by ideas from the functional programming domain. A uniform formal framework is presented which covers all query translation phases, including user-level query language compilation, query optimization, and execution plan generation. We pursue the type-based design—based on initial algebras—of a core functional language which is then developed into an intermediate representation that fits the needs of advanced query processing. Based on the principle of structural recursion we extend the language by monad comprehensions (which provide us with a calculus-style sublanguage that proves to be useful during the optimization of nested queries) and combinators (abstractions of the query operators implemented by the underlying target query engine). Due to its functional nature, the language is susceptible to program transformation techniques that were developed by the functional programming as well as the functional data model communities. We show how database query processing can substantially benefit from these techniques.     

Abstract interpretation and types for systems biology

Abstract interpretation is a theory of abstraction that has been introduced for the analysis of programs. In particular, it has proved useful for organizing the multiple semantics of a given programming language in a hierarchy corresponding to different detail levels, and for defining type systems for programming languages and program analyzers in software engineering. In this paper, we investigate the application of these concepts to systems biology formalisms. More specifically, we consider the Systems Biology Markup Language SBML, and the Biochemical Abstract Machine BIOCHAM with its differential, stochastic, discrete and boolean semantics. We first show how all of these different semantics, except the differential one, can be formally related by simple Galois connections. Then we define three type systems: one for checking or inferring the functions of proteins in a reaction model, one for checking or inferring the activation and inhibition effects of proteins in a reaction model, and another one for checking or inferring the topology of compartments or locations. We show that the framework of abstract interpretation elegantly applies to the formalization of these further abstractions, and to the implementation of linear or quadratic time type checking as well as type inference algorithms. Furthermore, we show a theorem of independence of the graph of activation and inhibition effects from the kinetic expressions in the reaction model, under general conditions. Through some examples, we show that the analysis of biochemical models by type inference provides accurate and useful information. Interestingly, such a mathematical formalization of the abstractions commonly used in systems biology already provides some guidelines for the extensions of biochemical reaction rule languages.     

Programming abstract data types,iterators and generic modules in C

A programming discipline to write abstract data types, iterators and generic modules using the C language is proposed. Program examples are presented making use of features of the ANSI standard for C. The discipline supports object-oriented development by allowing the programmer to implement abstractions through modules with well-defined interfaces. To use the abstractions, the programmer is not required to be aware of how they are implemented.     

DSMDiff: a differentiation tool for domain-specific models

Model differentiation techniques, which provide the capability to identify mappings and differences between models, are essential to many model development and management practices. There has been initial research toward model differentiation applied to Unified Modeling Language (UML) diagrams, but differentiation of domain-specific models has not been explored deeply in the modeling community. Traditional modeling practice using the UML relies on a single fixed general-purpose language (i.e., all UML diagrams conform to a single metamodel). In contrast, Domain-Specific Modeling (DSM) is an emerging model-driven paradigm in which multiple metamodels are used to define various modeling languages that represent the key concepts and abstractions for particular domains. Therefore, domain-specific models may conform to various metamodels, which requires model differentiation algorithms be metamodel-independent and able to apply to multiple domain-specific modeling languages. This paper presents metamodel-independent algorithms and associated tools for detecting mappings and differences between domain-specific models, with facilities for graphical visualization of the detected differences.     

Typical examples of using the atoment language

Atoment is a domain-specific language of executable specifications applied to describe methods and techniques of program verification. In this paper, a series of typical examples of using the Atoment language covering program models; the operational, transformational, and axiomatic semantics; and the formal specification of programming languages is presented.     

基于XML Schema抽象模型的XML模式验证方法

XML模式验证作为处理XML数据的前提和保证有着重要的地位,XML Schema作为XML的定义语言,其本身并不能保证XML数据的有效性.利用XML Schema抽象模型,定义了XML Schema中每个复杂类型的模式信息,并用非终节点序对集描述XML文档,最后给出了XML模式验证算法,可以有效地验证XML文档的组织结构和内容类型.     

Formal Verification of C Systems Code

Systems code is almost universally written in the C programming language or a variant. C has a very low level of type and memory abstraction and formal reasoning about C systems code requires a memory model that is able to capture the semantics of C pointers and types. At the same time, proof-based verification demands abstraction, in particular from the aliasing and frame problems. In this paper we present a study in the mechanisation of two proof abstractions for pointer program verification in the Isabelle/HOL theorem prover, based on a low-level memory model for C. The language’s type system presents challenges for the multiple independent typed heaps (Burstall-Bornat) and separation logic proof techniques. In addition to issues arising from explicit value size/alignment, padding, type-unsafe casts and pointer address arithmetic, structured types such as C’s arrays and structs are problematic due to the non-monotonic nature of pointer and lvalue validity in the presence of the unary &-operator. For example, type-safe updates through pointers to fields of a struct break the independence of updates across typed heaps or ∧^*-conjuncts. We provide models and rules that are able to cope with these language features and types, eschewing common over-simplifications and utilising expressive shallow embeddings in higher-order logic. Two case studies are provided that demonstrate the applicability of the mechanised models to real-world systems code; a working of the standard in-place list reversal example and an overview of the verification of the L4 microkernel’s memory allocator.     

A concept and implementation of higher-level XML transformation languages

In the software development (e.g. with product lines or refactoring) transformations play an increasing role. To ease and automate these transformations, we propose a solution based on the operator hierarchy concept. It allows to define transformation operator hierarchies containing different levels of transformation operators. The operators capture reusable knowledge units. The concrete realization of such a higher-level transformation language construction is demonstrated by an application of the XML operator hierarchy concept to the transformation language XSLT. XSLT serves as an example which is employed to provide the elementary transformation operators. On top of these elementary operators the layered concept allows the definition of new higher-level operators, e.g. domain-independent and domain-specific ones. In an application example the construction of the higher-level language XML2DSV is presented. This is a stand-alone domain-specific transformation language, which can be used to create delimiter-separated values (DSV) files from XML documents, on the base of XSLT. We developed XTC (XML Transformation Coordinator) to automate the multi-level transformation process.     

Implementation of the XML linking language XLink by functional methods

This paper is devoted to the construction of processors of a language for describing links between resources in XML documents, which is based on the application of functional programming methods and representation of XML data as S-expressions. An implementation in the high-level functional programming language Scheme, the system SXLink compatible with the XLink specification of the W3 consortium, is considered. A survey and comparative analysis of the existing implementations of the XLink language are given. Typical difficulties associated with the implementation and use of the language are identified, and methods to overcome them are discussed. Examples of the application of the SXLink system to solving problems of processing links between resources in XML documents are considered. An SXLink application program interface based on the use of functions of the Scheme language as first-class objects is suggested. The application of this approach to constructing simple and powerful XLink processors is discussed.Translated from Programmirovanie, Vol. 31, No. 1, 2005. Original Russian Text Copyright © 2005 by Lizorkin, Lisovsky.     

Teapot: a domain-specific language for writing cache coherenceprotocols

In this paper, we describe Teapot, a domain-specific language for writing cache coherence protocols. Cache coherence is of concern when parallel and distributed systems make local replicas of shared data to improve scalability and performance. In both distributed shared memory systems and distributed file systems, a coherence protocol maintains agreement among the replicated copies as the underlying data are modified by programs running on the system. Cache coherence protocols are notoriously difficult to implement, debug, and maintain. Moreover, protocols are not off-the-shelf, reusable components, because their details depend on the requirements of the system under consideration. The complexity of engineering coherence protocols can discourage users from experimenting with new, potentially more efficient protocols. We have designed and implemented Teapot, a domain-specific language that attempts to address this complexity. Teapot's language constructs, such as a state-centric control structure and continuations, are better suited to expressing protocol code than those of a typical systems programming language. Teapot also facilitates automatic verification of protocols, so hard to find protocol bugs, such as deadlocks, can be detected and fixed before encountering them on an actual execution. We describe the design rationale of Teapot, present an empirical evaluation of the language using two case studies, and relate the lessons that we learned in building a domain-specific language for systems programming     

Transformation of structure-shy programs with application to XPath queries and strategic functions

Various programming languages allow the construction of structure-shy programs. Such programs are defined generically for many different datatypes and only specify specific behavior for a few relevant subtypes. Typical examples are XML query languages that allow selection of subdocuments without exhaustively specifying intermediate element tags. Other examples are languages and libraries for polytypic or strategic functional programming and for adaptive object-oriented programming.In this paper, we present an algebraic approach to transformation of declarative structure-shy programs, in particular for strategic functions and XML queries. We formulate a rich set of algebraic laws, not just for transformation of structure-shy programs, but also for their conversion into structure-sensitive programs and vice versa. We show how subsets of these laws can be used to construct effective rewrite systems for specialization, generalization, and optimization of structure-shy programs. We present a type-safe encoding of these rewrite systems in Haskell which itself uses strategic functional programming techniques. We discuss the application of these rewrite systems for XPath query optimization and for query migration in the context of schema evolution.     

The Pegasus heterogeneous multidatabase system

Pegasus, a heterogeneous multidatabase management system that responds to the need for effective access and management of shared data across in a wide range of applications, is described. Pegasus provides facilities for multidatabase applications to access and manipulate multipole autonomous heterogeneous distributed object-oriented relational, and other information systems through a uniform interface. It is a complete data management system that integrates various native and local databases. Pegasus takes advantage of object-oriented data modeling and programming capabilities. It uses both type and function abstractions to deal with mapping and integration problems. Function implementation can be defined in an underlying database language or a programming language. Data abstraction and encapsulation facilities in the Pegasus object model provide an extensible framework for dealing with various kinds of heterogeneities in the traditional database systems and nontraditional data sources