Contributions published at Software Evolution and Architecture Lab (Harald Gall)

In software evolution analysis, many approaches analyze release history data available through versioning systems. The recent investigations of CVS data have shown that commonly committed files highlight their change couplings. However, CVS stores modifications on the basis of text but does not track structural changes, such as the insertion, removing, or modification of methods or classes. A detailed analysis whether change couplings are caused by source code couplings or by other textual modifications, such as updates in license terms, is not performed by current approaches. The focus of this paper is on adding structural change information to existing release history data. We present an approach that uses the structure compare services shipped with the Eclipse IDE to obtain the corresponding fine-grained changes between two subsequent versions of any Java class. This information supports filtering those change couplings which result from structural changes. So we can distill the causes for change couplings along releases and filter out those that are structurally relevant. The first validation of our approach with a medium-sized open source software system showed that a reasonable amount of change couplings are not caused by source code changes.

In this paper, we present TUAnalyzer, a novel tool that extracts the template structure of C++ programs on the basis of the GNU C/C++ Compiler’s internal representation of a C/C++ translation unit. In comparison to other such tools, our tool is capable of supporting the extraction of function invocations that depend on the particular instantiation of C++ templates and to relate them to their particular template instantiation. TUAnalyzer produces RSF format output that can be easily fed into existing visualization and analysis tools such as Rigi or Graphviz. We motivate why this kind of template analysis information is essential to understand real-world legacy C++ applications. We present how our tool extracts this kind of information to allow others to build on our results and further use the template information. The applicability of our tool has been validated on real code as proof of concept. The results obtained with TUAnalyzer enable us and other approaches and tools to perform detailed studies of large (open source) C/C++ projects in the near future.

null

Gaining higher-level evolutionary information about large software systems is a key challenge in dealing with increasing complexity and architectural deterioration. Modification reports and problem reports (PRs) taken from systems such as the concurrent versions system (CVS) and Bugzilla contain an overwhelming amount of information about the reasons and effects of particular changes. Such reports can be analyzed to provide a clearer picture about the problems concerning a particular feature or a set of features. Hidden dependencies of structurally unrelated but over time logically coupled files exhibit a good potential to illustrate feature evolution and possible architectural deterioration. In this paper, we describe the visualization of feature evolution by taking advantage of this logical coupling introduced by changes required to fix a reported problem. We compute the proximity of PRs by applying a standard technique called multidimensional scaling (MDS). The visualization of these data enables us to depict feature evolution by projecting PR dependence onto (a) feature-connected files and (b) the project directory structure of the software system. These two different views show how PRs, features and the directory tree structure relate. As a result, our approach uncovers hidden dependencies between features and presents them in an easy to assess visual form. A visualization of interwoven features can indicate locations of design erosion in the architectural evolution of a software system. As a case study, we used Mozilla and its CVS and Bugzilla data to show the applicability and effectiveness of our approach.

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 of this paper 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 for this paper is to provide a sound and flexible architecture for gluing together various Groupware systems using Web services technologies.

In this paper we present ArchView an approach for abstracting and visualizing software module views from source code. ArchView computes abstraction metrics that are used to filter out architectural elements and relationships of minor interest resulting in more reasonable and comprehensible module views on software architectures.

The existence of semantically tagged Web pages is crucial to bring the Semantic Web to life. But it is still costly to develop and maintain Web applications that offer data and meta-data. Several standard Web engineering methodologies exist for designing and implementing Web applications. In this paper we introduce a technique to extend existing Web engineering techniques to develop semantically tagged Web applications. The novelty of this technique is the definition and implementation of a mapping from XML Schema to ontologies that can be used to automatically generate RDF meta-data from XML content documents.

null

The dependencies and interrelations between classes and modules affect the maintainability of object-oriented systems. It is therefore important to capture weaknesses of the software architecture to make necessary corrections. This paper describes a method for software evolution analysis. It consists of three complementary steps, which form an integrated approach for the reasoning about software structures based on historical data: 1) The Quantitative Analysis uses version information for the assessment of growth and change behavior; 2) the Change Sequence Analysis identifies common change patterns across all system parts; and 3) the Relation Analysis compares classes based on CVS release history data and reveals the dependencies within the evolution of particular entities. In this paper, we focus on the Relation Analysis and discuss its results; it has been validated based on empirical data collected from a Concurrent Versions System (CVS) covering 28 months of a Picture Archiving and Communication System (PACS). Our software evolution analysis approach enabled us to detect shortcomings of PACS such as architectural weaknesses, poorly designed inheritance hierarchies, or blurred interfaces of modules.

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 Microsoft’s 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 create 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 system’s 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.

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.

Modern software frameworks provide a set of common and prefabricated software artifacts that support engineers in developing large-scale software systems. Framework-related information can be implemented in source code, comments or configuration files, but in the latter two cases, current reverse engineering approaches miss important facts reducing the quality of subsequent analysis tasks. We introduce a generic fact extraction approach for framework-based systems by combining traditional parsing with lexical pattern matching to obtain framework-specific facts from all three sources. We evaluate our approach with an industrial software application that was built using the Avalon/Phoenix framework. In particular we give examples to point out the benefits of considering framework-related information and reflect experiences made during the case study.

Traditional approaches for program comprehension use static program analysis or dynamic program analysis in the form of execution traces. Our approach, however, makes use of runtime-data such as parameter and object values. Compared to traditional program comprehension techniques, this approach enables fundamentally new ways of program analysis which we have not seen so far. Reflection analysis which allows engineers to understand programs making use of reflective (dynamic) method invocations is one such analysis. Another is object tracing which allows engineers to trace and track the use of a given instance of a class within the program to be understood. In this paper, we present these techniques along with a case study to which we have applied them.

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.

Gaining higher level evolutionary information about large software systems is a key in validating past and adjusting future development processes. In this paper, we analyze the proximity of software features based on modification and problem report data that capture the system’s evolution history. Features are instrumented and tracked, the relationships of modification and problem reports to these features are established, and the tracked features are visualized to illustrate their otherwise hidden dependencies. Our approach uncovers these hidden relationships between features via problem report analysis and presents them in easy-to-evaluate visual form. Particular feature dependencies then can be selected to assess the feature evolution by zooming in into an arbitrary level of detail. Such visualization of interwoven features, therefore, can indicate locations of design erosion in the architectural evolution of a software system. Our approach has been validated using the large open source software project of Mozilla and its bug reporting system Bugzilla.

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 easyto- 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.

Architectural patterns and styles represent important design decisions and thus are valuable abstractions for architecture recovery. Recognizing them is a challenge because styles and patterns basically span several architectural elements and can be implemented in various ways depending on the problem domain and the implementation variants. Our approach uses source code structures as patterns and introduces an iterative and interactive architecture recovery approach built upon such lower-level patterns extracted from source code. Associations between extracted pattern instances and architectural elements such as modules arise which result in new and higher-level views of the software system. These pattern views provide information for a consecutive refinement of pattern definitions to aggregate and abstract higher-level patterns which finally enable the description of a software system’s architecture.

Large, global enterprises are increasingly faced with the problem of supporting employees that are on the move. Employees need to share business documents, locate expertise and knowledge through distributed searches, access effective subscription/notification mechanisms, and they need any time, anywhere access to the company’s information resources. We address these problems and requirements in theMObile Teamwork Infrastructure for OrganizationsNetworking (MOTION) project and aim to create an advanced Information and Communication Technology (ICT) infrastructure for mobile teamwork. This short paper gives a brief description of the MOTION peer-to-peer platform for mobile teamwork.

Access control is one of the key requirements in enterprise security. A number of approaches in distributed systems have been designed that support various (new) paradigms such as peer-to-peer, nomadic working, and teamworking. Few of them, however, explicitly take into account the possible superposition of these concepts. Such a superposition often results in conflicting and additional requirements. We present ongoing work in developing an access control system for Peer-to-Peer mobile teamwork environments. This system is developed as part of the MOTION project. The goal of this project is to develop a service architecture for mobile teamwork, providing support for various devices and taking into account diverse connectivity modes. We present the requirements for an access control system that simultaneously supports mobility, collaboration, and peer-to-peer, illustrate our solution, and discuss how it meets the requirements.

null