María Antonia Zapata

Evolving XML schemas and documents using UML class diagrams

The widespread use of XML brings new challenges for its integration into general software development processes. In particular, it is necessary to keep the consistency between different software artifacts and XML documents when evolution tasks are carried out. In this paper we present an approach to evolve XML schemas and documents conceptually modeled by means of UML class diagrams. Evolution primitives are issued on the UML class diagram and are automatically propagated down to the XML schema. The XML documents are also automatically modified to conform to the new XML schema. In this way, the consistency between the different artifacts involved is kept. This goal is achieved by using an intermediate component which reflects how the UML diagrams are translated into the XML schemas.

MeDEA: A database evolution architecture with traceability

One of the most important challenges that software engineers (designers, developers) still have to face in their everyday work is the evolution of working database systems. As a step for the solution of this problem in this paper we propose MeDEA, which stands for Metamodel-based Database Evolution Architecture. MeDEA is a generic evolution architecture that allows us to maintain the traceability between the different artifacts involved in any database development process. MeDEA is generic in the sense that it is independent of the particular modeling techniques being used. In order to achieve this, a metamodeling approach has been followed for the development of MeDEA. The other basic characteristic of the architecture is the inclusion of a specific component devoted to storing the translation of conceptual schemas to logical ones. This component, which is one of the most noteworthy contributions of our approach, enables any modification (evolution) realized on a conceptual schema to be traced to the corresponding logical schema, without having to regenerate this schema from scratch, and furthermore to be propagated to the physical and extensional levels.

Noesis: Towards a situational method engineering technique

Standard methods as such are not normally used for information system development. The particular circumstances of each project make it necessary to adapt the methods to deal with the situation at hand. This is the concern of situational method engineering, where the term situational method is used to refer to a method tailored to the needs of a particular development setting. Situational method engineering prescribes the performance of this method customization within the framework of a meta-modelling technique provided with mechanisms to manipulate methods (or fragments of them) for their modification, integration, adaptation or evolution. As a first step towards the definition of a situational method engineering technique, in this paper we propose the Noesis meta-modelling technique together with a complete and minimal family of transformations. The Noesis technique allows recursive and decompositional structures to be captured in the meta-models (which is a demandable requirement for meta-modelling techniques) and situational methods to be obtained by the assembly of method fragments. In addition, the family of transformations allows method fragment customization processes to be accomplished. The main contribution of this paper is the definition of this family and the proof of its completeness and minimality (which is an important open issue with respect to customization of method fragments), the Noesis technique being the scaffolding needed to show this.

A systematic review of code generation proposals from state machine specifications

Context: Model Driven Development (MDD) encourages the use of models for developing complex software systems. Following a MDD approach, modelling languages are used to diagrammatically model the structure and behaviour of object-oriented software, among which state-based languages (including UML state machines, finite state machines and Harel statecharts) constitute the most widely used to specify the dynamic behaviour of a system. However, generating code from state machine models as part of the final system constitutes one of the most challenging tasks due to its dynamic nature and because many state machine concepts are not supported by the object-oriented programming languages. Therefore, it is not surprising that such code generation has received great attention over the years. Objective: The overall objective of this paper is to plot the landscape of published proposals in the field of object oriented code generation from state machine specifications, restricting the search neither to a specific context nor to a particular programming language. Method: We perform a systematic, accurate literature review of published studies focusing on the object oriented implementation of state machine specifications. Results: The systematic review is based on a comprehensive set of 53 resources in all, which we have classified into two groups: pattern-based and not pattern-based. For each proposal, we have analysed both the state machine specification elements they support and the means the authors propose for their implementation. Additionally, the review investigates which proposals take into account desirable features to be considered in software development such as maintenance or reusability. Conclusions: One of the conclusions drawn from the review is that most of the analysed works are based on a software design pattern. Another key finding is that many papers neither support several of the main components of the expressive richness of state machine specifications nor provide an implementation strategy that considers relevant qualitative aspects in software development.

Evolution of XML schemas and documents from stereotyped UML class models: A traceable approach

Context: UML and XML are two of the most commonly used languages in software engineering processes. One of the most critical of these processes is that of model evolution and maintenance. More specifically, when an XML schema is modified, the changes should be propagated to the corresponding XML documents, which must conform with the new, modified schema. Objective: The goal of this paper is to provide an evolution framework by which the XML schema and documents are incrementally updated according to the changes in the conceptual model (expressed as a UML class model). In this framework, we include the transformation and evolution of UML profiles specified in UML class models because they are widely used to capture domain specific semantics. Method: We have followed a metamodeling approach which allowed us to achieve a language independent framework, not tied to the specific case of UML-XML. Besides, our proposal considers a traceability setting as a key aspect of the transformation process which allows changes to be propagated from UML class models to both XML schemas and documents. Results: As a general framework, we propose a Generic Evolution Architecture (GEA) for the model-driven engineering context. Within this architecture and for the particular case of the UML-to-XML setting, our contribution is a UML-to-XML framework that, to our knowledge, is the only approach that incorporates the following four characteristics. Firstly, the evolution tasks are carried out in a conceptual model. Secondly, our approach includes the transformation to XML of UML profiles. Thirdly, the proposal allows stereotyped UML class models to be evolved, propagating changes to XML schemas and documents in such a way that the different elements are kept in synch. Finally, we propose a traceability setting that enables evolution tasks to be performed seamlessly. Conclusions: Generic frameworks such as that proposed in this paper help to reduce the work overload experienced by software engineers in keeping different software artifacts synchronized.

A survey of UML models to XML schemas transformations

UML is being increasing used for the analysis and design of Web Information Systems. At the same time, many XML-based languages are cornerstones in the development of this kind of system. As a consequence of the predominance of these languages, there are many works in the literature devoted to exploring the relationships between UML and XML. In this paper we present a survey of current approaches to the transformation of UML models into XML schemas. The study is focused on the case of transformation of UML class diagrams to XML schemas, since we have not found any proposal regarding other kinds of UML diagrams.

An Architecture for Managing Database Evolution

This paper presents an architecture for managing database evolution when all the components of the database (conceptual schema, logical schema and extension) are available. The strategy of evolution in which our architecture is based is that of ‘forward database maintenance’, that is, changes are applied to the conceptual schema and propagated automatically down to the logical schema and to the extension. In order to put into practice this strategy, each component of a database is seen under this architecture as the information base of an information system. Furthermore, a translation information system is considered in order to manage the translation of conceptual elements into logical schema elements. A current Oracle implementation of this architecture is also presented.

Dynamic Semantics of UML State Machines: A Metamodeling Perspective

A clear understanding of the dynamic semantics of UML State Machines is essential for a large and varied audience such as final users of the language, CASE tool builders or method engineers. Our proposal aims at achieving such an understanding by suggesting a different metamodeling approach. This approach is based on a two-layer architecture which puts forward the explicit distinction between the generic behavior represented in a dynamic model (Base Layer) and the behavior represented in relation to a particular situation (Snapshot Layer). Using this architecture as a starting point, a metamodel of UML State Machines is proposed, which consists basically of two UML class diagrams (one diagram for each layer of the architecture) and two maps. These maps represent, respectively, the determination of the initial status and the process performed by a run-to-completion step as defined in the UML semantics.

A Conceptual Approach to Meta-Modelling

In this paper we propose a conceptual-based approach to meta-modelling as a technique in which modelling knowledge can be expressed. Our approach claims to be sufficiently flexible and to homogenize the construction of meta-models, independently of the field of application. Besides, the components of meta-models have been thought up for improving the properties of adaptability, understandability and usability. A meta-model is defined as a perspective, a system of concepts and a so-called conceptual support. A conceptual support is, in essence, an IS-A hierarchy of concepts whose purpose it is to establish the specification elements that can be used to construct models. In order to illustrate the different notions that appear in the paper we present two examples of meta-models (statecharts and data flow diagrams) taken from two different application fields.

Mappings and Interoperability: A Meta-modelling Approach

In this paper we propose a meta-modelling technique for helping in the construction of mappings which make feasible the interoperability demanded between different modelling techniques. A concrete method for conducting the construction of a mapping is presented. In order to facilitate the understanding of this method, we explain, as an example, the construction of a mapping from the Cooperative Objects Meta-Model to the Classes with Objectcharts Meta-Model.