Jakub Malý

Evolution and change management of XML-based systems

XML is de-facto a standard language for data exchange. Structure of XML documents exchanged among different components of a system (e.g. services in a Service-Oriented Architecture) is usually described with XML schemas. It is a common practice that there is not only one but a whole family of XML schemas each applied in a particular logical execution part of the system. In such systems, the design and later maintenance of the XML schemas is not a simple task. In this paper we aim at a part of this problem - evolution of the family of the XML schemas. A single change in user requirements or surrounding environment of the system may influence more XML schemas in the family. A designer needs to identify the XML schemas affected by a change and ensure that they are evolved coherently with each other to meet the new requirement. Doing this manually is very time consuming and error prone. In this paper we show that much of the manual work can be automated. For this, we introduce a technique based on the principles of Model-Driven Development. A designer is required to make a change only once in a conceptual schema of the problem domain and our technique ensures semi-automatic coherent propagation to all affected XML schemas (and vice versa). We provide a formal model of possible evolution changes and their propagation mechanism. We also evaluate the approach on a real-world evolution scenario.

XML data transformations as schema evolves

One of the key characteristics of XML applications is their dynamic nature. When a system grows and evolves, old user requirements change and/or new requirements accumulate. Apart from changes in the interface, it is also necessary to modify the existing documents with each new version, so they are valid against the new specification. The approach presented in this paper extends an existing XML conceptual model with the support for multiple versions of the model. Thanks to this extension, it is possible to define a set of changes between two versions of a schema. This work contains an outline of an algorithm that compares two versions of a schema and produces a revalidation script in XSL.

XCase - a tool for conceptual XML data modeling

Conceptual modeling of XML data was made easier with the introduction of the XSEM model, which utilizes the MDA (Model-driven architecture) ideas of multi-level modeling. XCase is an implementation of this model, enabling users to model their problem domain as a Platform-independent model (PIM), from which Platform-specific models (PSM), XML schemas in our case, can be derived. The main advantage of this approach is maintainability of multiple XML schemas describing the same data from different views as XCase maintains connections between PIM and PSM levels, so that in case of a change to some element, this change can be propagated to all the places where this element is used.

Efficient adaptation of XML data using a conceptual model

One of the prominent characteristics of XML applications is their dynamic nature. Changes in user requirements cause changes in schemas used in the systems and changes in the schemas subsequently make existing documents invalid. In this work, we study two tightly coupled problems—schema evolution and document adaptation. The presented approach extends an existing conceptual model for evolution of XML applications towards document adaptation, by introducing a formal framework for detecting changes between two versions of a schema. From the detected changes it is possible to create a script that transforms documents valid against the old version of the schema to documents valid against its new version.

On XML Document Transformations as Schema Evolves: A Survey of Current Approaches

The eXtensible Markup Language (XML) (Bray et al. 2008) is currently one of the most popular meta-formats for data representation on the Web. To enable data exchange, it is crucial to restrict structure of the exchanged XML documents by a set of rules, so that each communicating party is able to understand them. This restriction is achieved via XML schemas.

Model-driven approach to modeling and validating integrity constraints for XML with OCL and Schematron

The idea behind Model Driven Development (MDD) (Miller and Mukerji 2003) is to model the software system on several layers of abstraction. A designer starts from the very abstract specification (independent of the platform and language used) and progresses to more concrete models (using platform-specific constructs) and finally to code. Ideally, each step of the transformation of the model from the more abstract to the less abstract is achieved by a declarative transformation obtained (semi-)automatically. In our previous work, we have developed an approach for designing XML schemas based on MDD. We showed that a set of XML schemas representing different views of the same problem domain can be first modeled in a platform-independent level with a uniform conceptual schema expressed as a UML class diagram. Then each XML schema can be modeled as a view on this uniform UML class diagram. In this paper, we further extend our approach to modeling XML schemas using UML class diagrams with modeling integrity constraints using Object Constraint Language (OCL). We show that an integrity constraint expressed at the platform-independent level as an OCL expression can be translated to an expression at the XML schema level which can be used to validate XML documents. In particular, we propose a method which translates an OCL expression at the platform-independent level to a Schematron expression. Schematron is a language which enables to express integrity constraints at the XML schema level. We show that our approach saves time and prevents from errors made by designers when expressing Schematron constraints manually.

UCL: Universal Constraint Language

Current software applications typically consist of a system of multiple components, each being modeled using a different type of meta-model. In addition, when developing the application, various integrity-constraint languages are used for particular meta-models (e.g. OCL for UML, Schematron for XML schemas, or SQL triggers for relational databases). Hence, the constraint expressions need to be converted to expressions over the different meta-models (i.e. modeled) too, which is a non-trivial task. In this paper, a new universal language called Universal Constraint Language (UCL) for expressing integrity constraints over various data models is introduced. It is formally defined and also its parser is implemented within the DaemonX project. In particular, expressing constraints in UCL for UML class diagrams and for XML schemas is supported. Thanks to preserving mutual relations between models in DaemonX we can also we can also translate the respective constraints between the models.

Methodology for Design and Evolution of XML Schemas using Conceptual Modeling

XML has achieved the leading role among languages for data representation and, thus, the amount of related technologies and applications exploiting them grows fast. However, only a small percentage of applications is static and remains unchanged since its first deployment. Most of the applications change with newly coming user requirements and changing environment. In this paper we describe a framework and a methodology for management of evolution and change propagation throughout XML applications. We also introduce its proof-of-concept implementation called eXolutio, which has been developed and improved in our research group during last few years. We also provide an evaluation of the methodology in the domain of electronic health.

XML document versioning, revalidation and constraints

One of the prominent characteristics of XML applications is their dynamic nature. When a system grows and evolves, old user requirements change and/or new requirements accumulate. Apart from changes in the interfaces used/provided by the system or its components, it is also necessary to modify the existing documents with each new version, so they are valid against the new specification. In this doctoral work we will extend an existing conceptual modeling approach with the support for multiple versions of the model. Thanks to this extension, it will be possible to detect changes between two versions of a schema and generate revalidation script for the existing data. By adding integrity constraints to the model, it will be able to revalidate changes in semantics besides changes in structure.