Harald Gall

Populating a Release History Database from version control and bug tracking systems

Version control and bug tracking systems contain large amounts of historical information that can give deep insight into the evolution of a software project. Unfortunately, these systems provide only insufficient support for a detailed analysis of software evolution aspects. We address this problem and introduce an approach for populating a release history database that combines version data with bug tracking data and adds missing data not covered by version control systems such as merge points. Then simple queries can be applied to the structured data to obtain meaningful views showing the evolution of a software project. Such views enable more accurate reasoning of evolutionary aspects and facilitate the anticipation of software evolution. We demonstrate our approach on the large open source project Mozilla that offers great opportunities to compare results and validate our approach.

Analyzing and relating bug report data for feature tracking

Gaining higher level evolutionary information aboutlarge software systems is a key in validating past and adjustingfuture development processes. In this paper, we analyzethe proximity of software features based on modificationand problem report data that capture the systems evolutionhistory. Features are instrumented and tracked, therelationships of modification and problem reports to thesefeatures are established, and the tracked features are visualizedto illustrate their otherwise hidden dependencies.Our approach uncovers these hidden relationships betweenfeatures via problem report analysis and presents them ineasy-to-evaluate visual form. Particular feature dependenciesthen can be selected to assess the feature evolution byzooming in into an arbitrary level of detail. Such visualizationof interwoven features, therefore, can indicate locationsof design erosion in the architectural evolution of asoftware system. Our approach has been validated usingthe large open source software project of Mozilla and itsbug reporting system Bugzilla.

Architectural concerns in distributed and mobile collaborative systems

There have been considerable attempts to integrate workflow management systems (WFMS), groupware systems, and business process modeling systems to provide a uniform platform for distributed and mobile collaboration (DMC) of geographically dispersed project teams. Such distributed and mobile teamwork defines new challenges for current IT platforms in terms of architecture and business-specific configurations. This paper discusses architectural concerns for such DMC systems and provides a framework for process aware distributed and mobile teamwork. This is achieved by integrating process- and workspace management requirements with peer-to-peer middleware, publish-subscribe, and community and user management. The paper discusses a three-layer architecture that integrates process awareness with the easy to use groupware (workspace) metaphor.

Web services for groupware in distributed and mobile collaboration

While some years ago the focus of many groupware systems has been the support of Web computing, i.e. to support access with Web browsers, the focus today is shifting towards a programmatic access to software services, regardless of their location and the application used to manipulate those services. Whereas the goal of Web computing has been to support group work on the Web (browser), Web services support for groupware has the goal to provide interoperability between many groupware systems. The contribution is threefold: (i) to present a framework consisting of three levels of Web services for groupware support, (ii) to present a novel Web services management and configuration architecture with the aim of integrating various groupware systems in one overall configurable architecture, and (iii) to provide a use case scenario and preliminary proof-of-concept implementation example. Our overall goal is to provide a sound and flexible architecture for gluing together various groupware systems using Web services technologies.

Architecture Recovery for Product Families

Software product families are rarely created right away but they emerge when a domain becomes mature enough to sustain their long-term investments. The typical pattern is to start with a small set of products to quickly enter a new market. As soon as the business proves to be successful new investments are directed to consolidating the software assets. The various products are migrated towards a flexible platform where the assets are shared and new products can be derived from. In order to create and maintain the platform, the organization needs to carry out several activities such as recovering the architectures of single products and product families, designing the reference architecture, isolating the variable parts, and generalizing software components. In this paper, we introduce a product family construction process that exploits related systems and product families, and we describe methods and tools used. We also present an approach for classifying platforms according to platform coverage and variation and describe three techniques to handle variability across single products and whole product families.

Revealer: a lexical pattern matcher for architecture recovery

Program comprehension is crucial for software maintenance activities and is supported by reverse engineering techniques. Many of them analyze source code and use parsers to create higher-level representations of software systems that are more meaningful to engineers. But the application of parsers is for some reasons not always desirable. In this paper, we introduce Revealer a lightweight source model extraction tool that combines advantages of lexical analysis with syntactical analysis. It uses an easy-to-use pattern language that supports engineers in defining pattern definitions of diverse granularity depending on the problem at hand In this way our tool enables fast extraction of simple and complex code patterns that allow engineers a quick insight into particular architectural aspects that are expressed via source code patterns.

Architecture recovery in ARES

Recovering the architecture of legacy systems requires more than just reverse engineering tools to generate some higherlevel descriptions of the system under study. Design decisions and logical groupings of functions have to be balanced with informal domain knowledge, domain standards and coding guidelines of the developers. Therefore, we combine domain aspects with coding aspects and use reverse engineering tools as one means of recovering the requested information to reason about the underlying architecture of the system. This reasoning is an alternating top-down and bottom-up approach. The’architecture recovery process we introduce is one part of the ESPRIT project ARES (Architectural Reasoning for Embedded Systems).’

Software configuration, distribution, and deployment of web-services

Web-Services can be seen as a newly emerging distributed computing model for the Web. They cater for the need to establish business-to-business (B2B) interactions on the Web. Web-Services consider a loosely coupled component model encapsulating business logic and interact with other components using XML protocols. Based on one case study, this paper discusses architectural issues and requirements for software configuration, distribution, and deployment of web-services.

Capsule Oriented Reverse Engineering for Software Reuse

Much research effort concerning the reuse of software components has been invested on questions such as classification, attribution and organization of modules in software components libraries. Further problems like the obtaining of reusable components and their interconnection to form new software systems have been discovered. Reverse engineering can be used for different purposes, like maintenance effort reduction, documentation improvement, etc., but also for software reuse. In the process of software reuse, reverse engineering can be used to extract reusable components from existing software systems.

Analyzing and understanding architectural characteristics of COM+ components

Understanding architectural characteristics of software components that constitute distributed systems is crucial for maintaining and evolving them. One component framework heavily used for developing component-based software systems is Microsofts COM+. In this paper we particularly concentrate on the analysis of COM+ components and introduce an iterative and interactive approach that combines component inspection techniques with source code analysis to obtain a complete abstract model of each COM+ component. The model describes important architectural characteristics such as transactions, security, and persistency, as well as creating and use dependencies between components, and maps these higher-level concepts down to their implementation in source files. Based on the model, engineers can browse the software systems COM+ components and navigate from the list of architectural characteristics to the corresponding source code statements. We also discuss the Island Hopper application with which our approach has been validated.