Abstract not found

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 XMLbased 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 inplace 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.

Abstract not found

Communication in and with sensor networks often lacks of exchangeability. Furthermore handling communication data formats during sensor node programming is often complex and programming errors can result in unstable programs. In this poster we introduce the easy to use programming framework XOBESensorNetwork, which provides the direct use of XML in a sensor node programming language, while ensuring stable and space-, time- and energy-efficient programs handling XML data. 1. XOBE for Sensor Networks Using XML in sensor networks encourages the interchangeability of different types of sensors and systems, e.g. making it easy to interconnect a sensor network to the WWW. In this poster we introduce XOBESensorNetwork 1 a programming environment, which helps developers using XML within sensor network programming and encourages simple query possibilities using XML query languages. XOBESensorNetwork is integrated into an existing sensor node programming language as a precompiler as shown in figure 1. With XOBESensorNetwork we ensure transparency by integrating the possibility of directly using XML within the programming language. The XOBESensorNetwork prototype is beeing developed for the BTnode sensor node platform. Therefore it integrates XML into C, which is a wide spread programming language for sensor nodes. By using the XOBESensorNetwork precompiler the developer does not have to handle XML within the C Code manually. Using the keyword xml at variable declaration defines using an xml variable, where plain XML can be assigned to. The XOBESensorNetwork precompiler automatically transforms the assignment into correct C code using efficiency optimized transformation rules. In general XML documents generated at runtime must be validated dynamically. This is a problem because it

XML Schema awareness has been an integral part of the XQuery language since its early design stages. Matching XML data against XML types is the main operation that backs up XQuery type expressions, such as typeswitch, instance of, or certain XPath operators. This interaction is particularly vital in data-centric XQuery applications, where data come with detailed type information from an XML Schema document. So far there has been little work on the optimization of those operations. This work presents an efficient implementation of the runtime aspects of XML Schema support. We propose type ranks as a novel and uniform way to implement all facets of type matching in the W3C XQuery Recommendation. As a concise encoding of the type hierarchy defined by an XML Schema document, type ranks minimize the cost of checking the runtime type of XQuery singleton items. By aggregating type ranks, we leverage the grouping capabilities of modern DBMS implementations to efficiently execute type matching on XQuery sequences. In addition, we improve the complexity bounds incurring with typeswitch expressions over existing approaches. Experiments on an off-the-shelf database system demonstrate the potential of our approach.

XML transformation languages, such as XQuery, take an XML document as input and produce another XML document as output. It is useful to know statically that such transformations always produce valid documents, for static debugging of the transformation program or for eliminating dynamic checks on the output documents. This gives rise to the XML type checking problem. Typeand automata-theoretic techniques have been proposed to address this type checking problem, exploiting XML’s tree structure. However, existing approaches are not capable of reasoning about dimensional information of produced XML documents, such as that two locations in the output documents always have the same number of elements. This paper presents a type-based analysis for XQuery to discover dimensional relationships in output documents from XQuery programs through refined type checking. For example, it can identify program fragments producing the same number of elements for all input documents. The novel aspects of our analysis are techniques to deal with the rich tree structure of XML types, whereas array analyses (e.g., bounds checking) for languages such as C deal with flat arrays. In this paper, we present our type system and give a sketch of its soundness.

XML transformation languages (e.g., XSLT) take an XML document as input and produce another XML document as output. It is useful to know statically that such transformations always produce valid documents, for static debugging of the transformation program or for eliminating dynamic checks on the output documents. Type- and automatatheoretic techniques that exploit XML’s tree structure have been proposed to address this problem. However, existing approaches are not capable of reasoning about size information of produced XML documents, such as that two locations in the output documents always have the same number of elements, which occurs when data is repeated. This paper presents a type-based inference system to discover size relationships in output documents from XML transformation programs through refined type checking. For example, our system can identify program fragments producing the same number of elements for all input documents. Programs that use or produce parallel or repeated data will benefit from this analysis. The novel aspects of our system are techniques to deal with the rich tree structure of XML types (i.e., schemas), whereas array analyses (e.g., bounds checking) for languages such as C deal with flat arrays.

Abstract. The development of data centric applications should be performed in a high-level and transparent way. In particular, aspects concerning the persistency and distribution of business objects should not influence or restrict the application design. Furthermore applications should be platform independent and should be able to exchange data independently of their programming language origin. There are several approaches for an architecture for distributed objects. One example is CORBA. JDO and EJB allow specifications for distributed persistent objects offering transparent persistency up to a certain degree. Nevertheless, the programmer is still forced to write explicit code for making objects persistent or for connecting to distributed objects. In contrast to existing approaches, the XOBEDBPL project develops a database programming language with transparency with respect to types, and persistency and distribution with respect to objects. Application development is performed on a high-level business object level only. A web service for realizing distributed persistency and data exchange is internal and completely integrated in the XOBEDBPL runtime environment. Although the XOBEDBPL language is an extension of the Java programming language, the introduced concepts could be easily transferred to other object-oriented programming languages. 1

XML is the de facto standard for exchanging data between aribtrary applications. There are many efforts to integrate XML into object-oriented programming languages reaching from the simple document object model (DOM) to XML class generators or even to the introduction of new programming languages. Another as desired feature as XML is persistency. The integration of persistency into object-oriented programming languages has been realized with database programming languages as well as current frameworks like Hibernate or approaches like EJB. Nevertheless, the integration of XML suffers from mapping problems or, if at all, efficient static typechecking mechanisms, in particular concerning update operations. Additionally, existing persistency integration concepts are often intransparent and support limited object-oriented concepts. This paper introduces a holistic, transparent approach concerning the integration of statically typechecked XML and persistency aspects into the object-oriented programming language Java. It is shown that this can be achieved without syntax changes. 1

Abstract not found