Bernhard Westfechtel

Version models for software configuration management

After more than 20 years of research and practice in software configuration management (SCM), constructing consistent configurations of versioned software products still remains a challenge. This article focuses on the version models underlying both commercial systems and research prototypes. It provides an overview and classification of different versioning paradigms and defines and relates fundamental concepts such as revisions, variants, configurations, and changes. In particular, we focus on intensional versioning, that is, construction of versions based on configuration rules. Finally, we provide an overview of systems that have had significant impact on the development of the SCM discipline and classify them according to a detailed taxonomy.

DYNAMITE: dynamic task nets for software process management

Managing the software development and maintenance process has been identified as a great challenge for several years. Software processes are highly dynamic and can only rarely be planned completely in advance. Dynamic task nets take this into account. They are built and modified incrementally as a software process is executed. Dynamic task nets have been designed to solve important problems of process dynamics, deciding product-dependent structure evolution, feedback, and concurrent engineering. In order to describe editing and enactment (and their interaction) in a uniform way, task nets are formally defined by means of a programmed graph rewriting system.

Using UML for software process modeling

We examine the benefits of using an object-oriented modeling language for software process modeling. We show how the Unified Modeling Language (UML) can be used to model software processes based on dynamic task nets, which evolve continuously during enactment. We have selected UML for various reasons: it is wide-spread, provides a comprehensive set of diagrams for both structural and behavioral modeling, and supports the early phases of process modeling (analysis and design).

Structure-oriented merging of revisions of software documents

Merging revisions of software documents after development has branched into multiple lines is a difficult task. Previous approaches to merging are either based on text files or refer to specific languages. These approaches do not meet the requirements to a merge tool which is to be integrated into a multilingual structure-oriented environment. In this paper, we present a structure-oriented merge tool that is applicable to software documents (requirements definitions, software architecture descriptions, module implementations, etc.) written in arbitrary languages, preserves their context-free correctness, and also takes binding of identifiers to their declarations into account.

GRAS, a graph oriented (software) engineering database system

Abstract Modern software systems for application areas such as software engineering, CAD, or office automation are usually highly interactive and deal with rather complex object structures. For the realization of these systems a nonstandard database system is needed which is able to efficiently handle different types of coarse- and fine-grained objects (like documents and paragraphs), hierarchical and non-hierarchical relations between objects (like composition-links and cross-references), and finally attributes of rather different size (like chapter numbers and bitmaps). Furthermore, this database system should support incremental computation of derived data, undo/redo of data modifications, error recovery from system crashes, and version control mechanisms. In this paper, we describe the underlying data model and the functionality of GRAS, a database system which has been designed according to the requirements mentioned above. Furthermore, we motivate our central design decisions concerning its realization, and report on experiences and applications.

A layered architecture for uniform version management

Version management is a key part of software configuration management. A big variety of version models has been realized in both commercial systems and research prototypes. These version models differ with respect to the objects put under version control (files, directories, entities, objects), the organization of versions (version graphs versus multidimensional version spaces), the granularity of versioning (whole software products versus individual components), emphasis on states versus emphasis on changes (state-versus change-based versioning), rules for version selection, etc. We present a uniform version model-and its support architecture-for software configuration management. Unlike other unification approaches, such as UML for object-oriented modeling, we do not assemble all the concepts having been introduced in previous systems. Instead, we define a base model that is built on a small number of concepts. Specific version models may be expressed in terms of this base model. Our approach to uniform version management is distinguished by its underlying layered architecture. Unlike the main stream of software configuration management systems, our instrumentable version engine is completely orthogonal to the data model used for representing software objects and their relationships. In addition, we introduce version rules at the bottom of the layered architecture and employ them as a uniform mechanism for expressing different version models. This contrasts to the main stream solution, where a specific version model-usually version graphs-is deeply built into the system and version rules are dependent on this model.

Beyond stereotyping: metamodeling approaches for the UML

UML is being used as the universal technique for modeling object-oriented applications across a wide range of domains. Developing a truly adequate uniform modeling technique in the face of these diverse domains seems an unsolvable quest and contrasts domain specific software engineering activities. Recently, many adaptations to UML have been made to reflect a domains world view. These adaptations often exceed the UMLs own extension mechanisms and result in yet another urban UML slang. However, domain-specifically adapting the UML metamodel becomes increasingly important in the context of model checking and code generation mechanisms. Therefore solutions should be found to fully support metamodeling within the UML and UML CASE tools. The paper discusses and evaluates the UMLs inherent as well as proprietary metamodeling approaches and provides domain driven ideas for a meta-modeling approach for a diversely used Unified Modeling Language.

Models and tools for managing development processes

Management of Development Processes: State of the Art.- Process Management.- Product Management.- Activity Management.- Resource Management.- Tool Integration.- A Management System for Mechanical Engineering.- The SUKITS Project.- Management Model: Informal Description.- Management Model: Formal Specification.- Management System.- Applications, Experiences, and Evaluation.- Toward an Adaptable Environment for Modeling and Managing Development Processes.- Overview.- Dynamic Task Nets.- Unified Multi-Project Resource Management.- Object-Oriented Process Modeling.- Current Status and Future Work.

On Integration Mechanisms within a Graph-based Software Development Environment

An integrated software development environment (abbr. SDE) is a comprehensive set of tools which support the activities for developing and maintaining any kind of software document in a software life cycle. These activities may relate to one or to different problem areas (programming in the large, programming in the small, documentation, project management, etc.).

AHEAD: A Graph-Based System for Modeling and Managing Development Processes

Management of development processes in different engineering disciplines is a challenging task. The AHEAD system addresses these challenges by providing an integrated environment for modeling and managing development processes. Products, activities, and resources are managed in an integrated way; furthermore, AHEAD supports evolving development processes by seamless interleaving of planning and execution. AHEAD is based on programmed graph transformations; tools are generated from a graph-based specification. Finally, a wide-spread object-oriented modeling language (UML) is employed for acquiring process knowledge from domain experts.