RoclET – A Tool for Wrestling with OCL Specifications

In this paper, we describe the architecture and the functionality of our own OCL tool called RoclET. Besides standard features of OCL tools such as editing of class and object diagrams and parsing of OCL assertions (invariants, pre-/post-conditions), our tool supports also the evaluation of OCL constraints in a given system snapshot (object diagram), refactoring of UML/OCL models, and impact analysis. RoclET is deployed in form of an Eclipse plugin

Computing the Relevant Instances that May Violate an OCL constraint

Abstract. Integrity checking is aimed at efficiently determining whether the state of the information base is consistent after the application of a set of structural events. One possible way to achieve efficiency is to consider only the relevant instances that may violate an integrity constraint instead of the whole population of the information base. This is the approach we follow in this paper to automatically check the integrity constraints defined in a UML conceptual schema. Since the method we propose uses only the standard elements of the conceptual schema to process the constraints, its efficiency improvement can benefit any implementation of the schema regardless the technology used.

Computing the relevant instances that may violate an OCL constraint

Integrity checking is aimed at efficiently determining whether the state of the information base is consistent after the application of a set of structural events. One possible way to achieve efficiency is to consider only the relevant instances that may violate an integrity constraint instead of the whole population of the information base. This is the approach we follow in this paper to automatically check the integrity constraints defined in a UML conceptual schema. Since the method we propose uses only the standard elements of the conceptual schema to process the constraints, its efficiency improvement can benefit any implementation of the schema regardless the technology used

Generating alternative representations for OCL integrity constraints

Integrity constraints (ICs) play a key role in the definition of conceptual schemas. In the UML, ICs are usually specified as invariants written in the OCL language. However, due to the high expressiveness of the OCL, the designer has different syntactic alternatives to express each IC. In the context of the MDA, the choice of a particular definition has a direct effect on the efficiency of the automatically generated implementation. The method presented in this paper assists the designer during the definition of ICs by means of generating equivalent alternatives for the initially defined constraints. Our method can also be applied to help in the detection of equivalent (redundant) constraints and as a tool to facilitate the learning of the OCL.Postprint (published version

A Model-based Framework for System Configuration Management

A system can be viewed from different perspectives, each focusing on a specific aspect such as availability, performance, security. Configurations reflect the manageable resources of the system, their attributes and organization which are necessary for the management of the system for each aspect. Thus, for management purposes a system is generally described through various partial configurations (also known as configuration fragments). To form a consistent system con-figuration, these independently developed configuration fragments need to be integrated together. The integration of configuration fragments is a challenging task. This is mainly due to over-lapping entities (different logical representations of the same system resource) in the configuration fragments and/or complex relationships among the entities of the different configuration fragments. At runtime the system may be reconfigured to meet certain/new requirements or in response to performance degradations. These changes may lead to inconsistency as some changes may violate the constraints between entities. Maintaining the consistency and adjusting the system configuration at runtime is another challenging task. In our research, we propose to handle these two important issues in an integrated manner. We define a model-based framework for configuration management. We use the Unified Modeling Language (UML) and its profiling mechanism for representing the configuration fragments. Using model weaving and model trans-formation techniques, we propose a solution for the integration of configuration fragments targeting specific system properties. To handle runtime changes, we propose a configuration validation and adjustment solution to check and preserve the consistency of the system configuration. We introduce a partial validation technique in which the runtime reconfigurations are checked against a reduced set of consistency rules instead of the complete set of rules and the reconfigurations are applied only if they are safe, i.e. they preserve the configuration consistency. For handling the changes that violate the consistency rules, we propose an adjustment technique to automatically resolve (if possible) the inconsistencies. This is achieved by propagating the changes in the configuration according to the system constraints following the possible impacts of the configuration entities on each other. Some heuristics are used to reduce the complementary changes and to limit the propagation. We evaluate the complexity of our adjustment technique and conduct experiments to evaluate its efficiency. The Service Availability Forum middleware is used as an application domain in the examples throughout this thesis; however the proposed solutions are applicable in more general settings. We present proofs of concepts using different technologies. We use the Eclipse Modeling Framework (EMF) and Papyrus for implementing the UML profiles. The Atlas Model Weaver (AMW) and Atlas Transformation Language (ATL) are used to integrate the configuration fragments, and we also use the APIs of the Object Constraint Language (OCL) in the Eclipse environment and the Microsoft Z3 constraint solver to develop a prototype tool of our partial validation and adjustment agents

Model refactoring using transformations

Modern software is reaching levels of complexity encountered in biological systems; sometimes comprising systems of systems each of which may include tens of millions of lines of code. Model Driven Engineering (MDE) advocates raising the level of abstraction as an instrument to deal with software complexity. It promotes usage of software models as primary artifacts in a software development process. Traditionally, these MDE models are specified by Unified Modeling Language (UML) or by a modeling language created for a specific domain. However, in the vast area of software engineering there are other techniques used to improve quality of software under development. One of such techniques is refactoring which represents introducing structured changes in software in order to improve its readability, extensibility, and maintainability, while preserving behavior of the software. The main application area for refactorings is still programming code, despite the fact that modeling languages and techniques has significantly gained in popularity, in recent years. The main topic of this thesis is making an alliance between the two virtually orthogonal techniques: software modeling and refactoring. In this thesis we have investigated how to raise the level of abstraction of programming code refactorings to the modeling level. This resulted in a catalog of model refactorings each specified as a model transformation rule. In addition, we have investigated synchronization problems between different models used to describe one software system, i.e. when one model is refactored what is the impact on all dependent models and how this impact can be formalized. We have concentrated on UML class diagrams as domain of refactorings. As models dependent on class diagrams, we have selected Object Constraint Language (OCL) annotations, and object diagrams. This thesis formalizes the most important refactoring rules for UML class diagrams and classifies them with respect to their impact on object diagrams and annotated OCL constraints. For refactoring rules that have an impact on dependent artifacts we formalize the necessary changes of these artifacts. Moreover, in this thesis, we present a simple criterion and a proof technique for the semantic preservation of refactoring rules that are defined for UML class and object diagrams, and OCL constraints. In order to be able to prove semantic preservation, we propose a model transformation approach to specify the semantics of constraint languages

View-based textual modelling

This work introduces the FURCAS approach, a framework for view-based textual modelling. FURCAS includes means that allow software language engineers to define partial and overlapping textual modelling languages. Furthermore, FURCAS provides an incremental update approach that enables modellers to work with multiple views on the same underlying model. The approach is validated against a set of formal requirements, as well as several industrial case studies showing its practical applicability