Udo Kelter

Differences between versions of UML diagrams

This paper addresses the problem of how to detect and visualise differences between versions of UML documents such as class or object diagrams. Our basic approach for showing the differences between two documents is to use a unified document which contains the common and specific parts of both base documents; the specific parts are highlighted. The main problems are (a) how to abstract from modifications done to the layout and other (document type-specific) details which are considered irrelevant; (b) how to deal with structural changes such as the shifting of an operation from one class to another; (c) how to reduce the amount of highlighted information. Our approach is based on the assumption that software documents are modelled in a fine-grained way, i.e. they are stored as syntax trees in XML files or in a repository system, and that the version management system supports fine-grained data. Our difference computation algorithm detects structural changes and enables their appropriate visualisation. Highlighting can be restricted on the basis of the types of the elements and on the basis of the revision history, e.g. only changes which occurred during a particular editing session are highlighted.

Difference computation of large models

Modern software engineering practices lead to large models which exist in many versions. Version management systems should offer a service to compare, and possibly merge, these models. The computation of a difference between large models is a big challenge; current algorithms are too inefficient here. We present a new technique for computing differences between models. In practical tests, this technique has been an order of magnitude faster than currently known algorithms. The main idea is to use a high-dimensional search tree for efficiently finding similar model elements. Individual elements are mapped onto a vector of numerical values using a collection of metrics for models and a numerical representation of the names which occur in a model.

A rule-based approach to the semantic lifting of model differences in the context of model versioning

In model-based software engineering, models are primary artifacts which iteratively evolve and which are often developed in teams. Therefore, comparison and merge tools for models are indispensable. These tools must compare models in a technology-dependent runtime representation and will initially derive low-level changes, which can differ considerably from user-level editing commands. Low-level differences are often incomprehensible and should be semantically lifted to the level of editing operations. This transformation of differences depends on the model type, supported editing operations, and user preferences; thus specific transformers are needed, and building them is a challenge. We present a rule-based approach to this problem: low-level differences are represented based on the Eclipse Modeling Framework. They are transformed into representations of editing operations using a rule-based model transformation engine. The necessary transformation rules are automatically derived from basic transformation rules for the editing operations.

Consistency-preserving edit scripts in model versioning

In model-based software development, models are iteratively evolved. To optimally support model evolution, developers need adequate tools for model versioning tasks, including comparison, patching, and merging of models. A significant disadvantage of tools currently available is that they display, and operate with, low-level model changes which refer to internal model representations and which can lead to intermediate inconsistent states. Higher-level consistency-preserving edit operations including refactorings are better suited to explain changes or to resolve conflicts. This paper presents an automatic procedure which transforms a low-level difference into an executable edit script which uses consistency-preserving edit operations only. Edit scripts support consistent model patching and merging on a higher abstraction level. Our approach to edit script generation has been evaluated in a larger real-world case study.

A fine-grained version and configuration model in analysis and design

In this paper we present a model of version and configuration management in the early phases of software development and an implementation of this model. We assume that software documents are modeled in a fine-grained way, that they are stored as syntax trees in XML files or a repository system, and that tools directly operate on these syntax trees. In contrast to file-based systems, structural changes in the document, e.g. the shifting of a method between two classes, can be identified in our model. Configurations allow us to manage groups of single modifications; such a group will mostly correspond to a specific design task or a similar activity. Configurations are thus a means to establish a connection to a change management system.

H-PCTE-a high performance object management system for system development environments

H-PCTE is an object management system (OMS) for distributed, open, and integrated system development environments. H-PCTE performs up to several thousand simple operations per second. H-PCTE is intended to be a basis for environments in which tools operate directly on fine-grained data stored in the object base. Fine-grained data modeling has several important implications for the architecture of environments, for tool design, and for the necessary functionality of the OMS. H-PCTEs performance is due to main-memory-oriented implementation techniques and to a careful adaptation of the OMS services to the data management needs of tools. As a result, tools need not pay for OMS services which they do not really need. This applies in particular to recovery and the external view facilities.<<ETX>>

Difference tools for analysis and design documents

This paper presents a concept and tools for the detection and visualization of differences between versions of graphical software documents such as ER, class or object diagrams, state charts, etc. We first analyze the problems which occur when comparing graphical documents and displaying their similarities and differences. Our basic approach is to use a unified document which contains the common and specific parts of both base documents with the specific parts being highlighted. The central problem is how to reduce the amount of highlighted elements and enable the developer to have a certain amount of control over the changes be selectively highlighted. With regard to tool construction, we assume that software documents are modeled in a fine-grained way, that they are stored as syntax trees in XML (eXtensible Markup Language) files or a repository system and that a version management system is used. By using the features of the data model and the version model we are able to detect and visualize differences between diagram versions, including structural changes (e.g. shifting of a method from one class to another). We further exploit information about the version history delivered by the underlying version management system by highlighting only differences based on structural or logical changes.

Understanding model evolution through semantically lifting model differences with SiLift

In model-based software development, models are primary artifacts which iteratively evolve and which have many versions during their lifetime. A clear representation of the changes between different versions of a model is the key to understanding and successfully managing the evolution of a model-based system. However, model comparison tools currently available display model differences on a low level of abstraction, namely in terms of basic graph operations on the abstract syntax graph of a model. These low-level model differences are often hard or even impossible to understand for normal tool users who are not familiar with meta-models. In this paper we present SiLift, a generic tool environment which is able to semantically lift low-level differences of EMF-based models into representations of user-level edit operations.

Adaptability of model comparison tools

Modern model-based development methodologies require a large number of efficient, high-quality model comparison tools. They must be carefully adapted to the specific model type, user preferences and application context. Implementing a large number of dedicated, monolithic tools is infeasible, the only viable approach are generic, adaptable tools. Generic tools currently available provide only partial or low-quality solutions to this challenge; their results are not satisfactory for model types such as state machines or block diagrams. This paper presents the SiDiff approach to model comparison which includes a set of highly configurable incremental matchers and a specification language to control their application.

Discretionary access controls in a high-performance object management system

A method for efficiently implementing access control lists (ACLs) in the main memory object-oriented database systems (OODBSs) is proposed. The main features of the method are the following: ACLs are not stored directly, but via ACL numbers; and each process has a cache which records results of evaluations of ACLs for this process and certain ACL numbers. The particular implementation of ACL numbers in the High-Performance Portable Common Tool Environment (H-PCTE) is considered, and a set of measures which speed up access controls in the most time-critical data manipulation operations is presented. The author then compares the proposed method with other approaches, and discusses whether and how the proposed method can be used to implement ACLs in a disc-oriented system.<<ETX>>