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

null

Software repositories such as versioning systems, defect tracking systems, and archived communication between project personnel are used to help manage the progress of software projects. Software practitioners and researchers increasingly recognize the potential benefit of mining this information to support the maintenance of software systems, improve software design or reuse, and empirically validate novel ideas and techniques. Research is now proceeding to uncover ways in which mining these repositories can help to understand software development, to support predictions about software development, and to plan various evolutionary aspects of software projects. This chapter presents several analysis and visualization techniques to understand software evolution by exploiting the rich sources of artifacts that are available. Based on the data models that need to be developed to cover sources such as modification and bug reports we describe how to use a Release History Database for evolution analysis. For that we present approaches to analyze developer effort for particular software entities. Further we present change coupling analyses that can reveal hidden change dependencies among software entities. Finally, we show how to investigate architectural shortcomings over many releases and to identify trends in the evolution. Kiviat graphs can be effectively used to visualize such analysis results.

The Semantic Web uses Web page annotations to enable machines to access the semantics of the pages content. This is done by the use of the data representation languages RDF and OWL to define ontologies for specific application domains. By the decentralized organization of the Web, it is not feasible to expect that only one ontology for each domain will be defined and used by everyone. There already are multiple ontologies that relate to the same or overlapping domains and this will not change in the future. Thereby, it is getting more and more difficult for developers of Semantic (Web) applications to support all these existing and future vocabularies. This problem could be solved with the help of a transformation service that can map between different ontologies from related domains. With it, applications would no longer need to understand unknown ontologies as they could inquire the transformation service to exchange data with other applications that use different ontologies. In this thesis, we present an approach to such a transformation service that performs transformations based on mapping definition files expressed in a simple and easy to understand XML syntax. We introduce a flexible mapping language that is applicable to a wide variety of transformation situations. In addition, we provide a prototype implementation of such a service that understands the proposed mapping language and therefore demonstrate its feasibility. The contributions of this thesis are the general applicable mapping language expressed as an XML application and the prototype implementation of the transformation service that understands such mappings and uses them to translate between different ontologies. Thereby, it becomes feasible to create many different mappings in an easy to use definition language. To further demonstrate the value of our transformation service, we integrate it into an application, the Semantic Clipboard, that is able to copy semantic data from Web pages to applications which use different ontologies.

Software repositories such as versioning systems, defect tracking systems, and archived communication between project personnel are used to help manage the progress of software projects. Software practitioners and researchers increasingly recognize the potential benefit of mining this information to support the maintenance of software systems, improve software design or reuse, and empirically validate novel ideas and techniques. Research is now proceeding to uncover ways in which mining these repositories can help to understand software development, to support predictions about software development, and to plan various evolutionary aspects of software projects. This chapter presents several analysis and visualization techniques to understand software evolution by exploiting the rich sources of artifacts that are available. Based on the data models that need to be developed to cover sources such as modification and bug reports we describe how to use a Release History Database for evolution analysis. For that we present approaches to analyze developer effort for particular software entities. Further we present change coupling analyses that can reveal hidden change dependencies among software entities. Finally, we show how to investigate architectural shortcomings over many releases and to identify trends in the evolution. Kiviat graphs can be effectively used to visualize such analysis results.

A number of design principles deal with dependencies and interrelations of software modules. They all strive for tight cohesion within, and loose coupling between modules. In the objectoriented paradigm the goal of loose coupling is mirrored at package and class level. Dependencies, for instance, stem from class inheritance, subtyping, method calls, and attribute accesses. The maintainability of object-oriented systems is affected by dependencies. It is therefore important to identify the inherent design to avoid breaking of existing design rules or to make necessary corrections for future changes. Revere engineering helps to understand software systems by analyzing the source code and creating representations at a higher level of abstraction. Visualization plays an important role in reverse engineering and allows to quickly gain an overview of a large system. Since the revision history of a software system also contains important information about its evolution, including data from versioning systems is valuable. In this thesis we developed a tool for visualizing Java class dependencies and changes. Our approach is based on existing visualization techniques and uses hierarchical graphs to represent the structure of the system. For visualizing dependencies and expressing the strength of coupling, the polymetric view principle is adopted. The focus of our work was on browsing and navigating dependency relationships. Most of the existing visualization approaches initially load a visual representation of the whole system and provide browsing facilities to focus on the demanded issues. We support this top-down strategy to software analysis as well by providing powerful filter facilities. Those filter techniques help to break down a cluttered image of a large system and to focus on the relevant parts. In addition, we support a bottom-up approach to reverse engineering. We provide a navigation technique that lets the user create a visualization of the portions she is interested in. We allow to start with a visualization of a small part and let the user incrementally expand it through adding dependent elements. By allowing to focus on the portions of interest, our approach is scalable and can be used to address specific questions in the mass of underlying information.

A key issue in software evolution analysis is the identification of particular changes that occur across several versions of a program. We present change distilling, a tree differencing algorithm for fine-grained source code change extraction. For that, we have improved the existing algorithm of Chawathe et al. for extracting changes in hierarchically structured data. Our algorithm extracts changes by finding both a match between the nodes of the compared two abstract syntax trees and a minimum edit script that can transform one tree into the other given the computed matching. As a result, we can identify fine-grained change types between program versions according to our taxonomy of source code changes. We evaluated our change distilling algorithm with a benchmark we developed that consists of 1,064 manually classified changes in 219 revisions of eight methods from three different open source projects. We achieved significant improvements in extracting types of source code changes: Our algorithm approximates the minimum edit script by 45% better than the original change extraction approach by Chawathe et al. We are able to find all occurring changes and almost reach the minimum conforming edit script, i.e., we reach a mean absolute percentage error of 34%, compared to 79% reached by the original algorithm. The paper describes both our change distilling algorithm and the results of our evaluation.

Comments are valuable especially for program understanding and maintenance, but do developers comment their code? To which extent do they add comments or adapt them when they evolve the code? We examine the question whether source code and associated comments are really changed together along the evolutionary history of a software system. In this paper, we describe an approach to map code and comments to observe their co-evolution over multiple versions. We investigated three open source systems (i.e., ArgoUML, Azureus, and JDT Core) and describe how comments and code co-evolved over time. Some of our findings show that: 1) newly added code|despite its growth rate|barely gets commented; 2) class and method declarations are commented most frequently but far less, for example, method calls; and 3) that 97% of comment changes are done in the same revision as the associated source code change.

Metrics are powerful when it comes to summarize characteristics of a software system. It helps us to understand, steer and control the future development of the software application. But metrics often appear in plain numbers, what makes it sometimes hard to really understand them. This is the point where visualization comes into the play. Visualization has helped, since rembrance of mankind, to easy the understanding of a problem or concept while using graphics, sketches and signs. This benefit can also be used when it comes to metrics and software systems. Visualizing metrics while using treemaps allows to combine different base metrics with each other in a graphic, which can be easier understood rather than using plain numbers only. A second advantage is the fact, that the base metrics can be used to build a customized metric profile which is important. In this bachelor thesis metrics visualization capability is enabled to a research tool called Evolizer, which is a release history databases with the goal to analyze Java projects in terms of releases. Since it is not capable of viewing metrics, it is a perfect candidate for extending with a Treemap plugin,which will be built for this purpose and can be integrated to the existing structure of the Evolizer.

A Banking Simulation, developed several years ago by Prof. Dr. Meyer of the Institute of Accounting and Controlling of the University of Zurich in cooperation with IBM, was written using the framework Personal AS/2 and requires certain releases of the former operating system OS/2 of IBM to run. Because of the lack of know-how and the non-availability of development tools under OS/2, changes and further development are no longer applicable. Therefore the need of a reengineering has arisen to analyze the old Banking Simulation and reconstitute it in a new form. The central goal of this thesis is to transform the old and inflexible Banking Simulation into a new state-of-the-art web application. In a first step a detailed analysis and reverse engineering of the Banking Simulation is made to assess its current state. In a second step the requirements of the new Banking Simulation are elaborated and described. The results of this two processes provide the basis to specify and design the new architecture and choose the technologies to implement the reengineered Banking Simulation. The evaluation of an usability survey concludes this thesis by presenting some information about the user acceptance of the new Banking Simulation.

Test automation is considered as essential in the field of modern software development. In the context of test driven development within the IBM Cloud project and the creation and integration of software increments to an application we have to automate regression testing. Common test automation techniques like test scripting, capture/replay, or keyword driven approaches have remaining problems. The main problem is the fragileness due to the relative low abstraction level of the resulting test scripts. Model based test automation solves this by using a model of the application under test (AUT). Test cases are derived from this model. At execution time an adaptor maps the model back to the AUT. This leads to an easy to adapt and to maintain test automation approach. The applied test automation tool for the IBM Cloud project is the Eclipse based Rational Functional Tester (RFT). Because the RFT is a hybrid test automation tool based on the test scripting and the capture/replay approach it has some of the mentioned problems. We improved the RFT functionality by creating a plug-in for model based testing. The model based testing plug-in is based on the core functionalities and data structures of the RFT. Such a data structure is the object map. This map is a XML file which maps AUT test objects to executable test scripts. The MBT plug-in uses the XML information to build an inheritance tree of the test objects. The aim is to build an AUT model by declaring test objects as states and their transitions to other states. With the aid of an example we prove the concept of the plug-in and point out the implemented abilities of model based test automation.

As software systems enter the maintenance phase in their life cycle, their quality tends to rotten. This is due to continuous enhancements of system functionality and adaptations to ever changing environments. The experience of many developers out in the field has led to commonly accepted heuristics on good object oriented design. Martin Fowler proposed Refactorings for improving the design of existing software without changing its behavior. The problem in large systems is, that potential problem areas are hard to spot. Robert C. Martin has collected a set of Object Oriented Design Principles. The theoretical concept of these principles can be utilized to discover such problem hot spots. In this thesis, we develop detection strategies for breaches of these principles. By the use of evolutionary information on software systems, we suggest concepts that complement current static strategies as proposed, for example by Michele Lanza and Radu Marinescu. We investigate in the Single Responsibility Principle (SRP) and the Dependency Inversions Principle (DIP). For the SRP we show how CVS commits can be used to find out if a class possibly breaches the SRP. And by relating the change volatility of one class to another, we try to find breaches of the DIP. We evaluated our approach on five different projects.

Software continually changes. Most middle and large scale software systems use version control and bug tracking systems to store historical data. Many changes made to a software system are corrective changes. In our analysis of two open source projects (Eclipse JDT and ArgoUML) we identified 19.5% to 22.8% of all source code changes as bug fixes. Our goal is to investigate those changes in order to find bug fixing change patterns. In this thesis we present our approach of investigating change patterns that fix bugs and an implementation of Eclipse plug-ins that enable such an analysis. As a result of case studies conducted on the two projects, we provide change pattern statistics and a detailed description of 19 bug fixing change patterns that were identified using our approach.

This thesis is about the evaluation of an architecture and a design for an extension of the X-Ray Tutor Network Administration Tools. X-Ray Tutor is a learning tool for airport police officers who visually assess x-ray images of passenger baggage in order to identify threat items. X-Ray Tutor is used at many hundred airports worldwide and is the leading training solution in the field of x-ray image assessment training. An X-Ray Tutor Environment consists of a headquarter server, a site server for each airport and several Tutor workstations at each airport. The Tutor workstations communicate with the site servers and the site servers communicate with the headquarter server. The goal of the thesis is to elaborate the architecture and design and to implement a program suite which can be used to create and remotely distribute image library updates to connected airports. Before this project took place, image library updates needed to be installed locally at every airport. Obviously, since airports are usually very far away from each other, a solution for remote updates is very desirable. The focus during the development lay on the reliable transmission of packages, secure network connections and a design that allows easy extension for future modifications. Using stateof-the-art programming techniques and following object oriented paradigms the X-Ray Tutor Image Updater Program Suite solves the problem of the geographic distribution of the sites, which is inherent to airport locations.

When using operating system clipboards to copy and paste data between applications, the information’s context is usually lost. In this thesis we introduce the semantic clipboard SemClip, which uses Semantic Web technologies to formally define the semantics of the exchanged data and therefore preserves the context during the data transfer. Additionally SemClip provides an ontology mediation service, to allow for the exchange of data between applications that are based on different syntactical or semantical definitions. This way SemClip augments content negotiation protocols of existing operating system clipboards. Our prototype implementation shows the feasibility and the added value of SemClip based on everyday scenarios with standard desktop applications.

Semantic Web Applications describe their data as RDF graphs. They differ in this regard in the choice of the ontology, in the way they annotate data and how they provide their RDF data. In addition, heterogeneities in the data itself exist. This work introduces an architecture and a prototype for an infrastructure that integrates RDF data from various heterogeneous sources into a central knowledge base while dealing with heterogeneity. The main focus of this work addresses the latter by identifying similarity relations between RDF resources. An ontology designed by our-selves for creating similarity definitions will be presented and its application exemplified.

Source comments and API documentation are an important part of the source code of software systems. Proper documentation increases the readability as well as the maintainability of source code. In this diploma thesis we investigate whether and when source comments change. We want to know whether comment changes are based on a change of the source code or not. If the comment changes are based on source code changes we are interested to know if the changes to the comments are done together with source code changes or if they are done in a later revision. To investigate this, we take advantage of CVS versioning data. Based on CHANGEDISTILLER, an existing Eclipse plugin, we implemented a plugin to find matching source code and comment changes. We used the plugin to evaluate two mid-size Java projects.

Since large and complex software projects consist of people playing different roles, the communication and collaboration among the team members are key success factors. This interaction is reflected in the organization and has an influence on the project and its outcome. High-quality Open Source Software (OSS) relies on having a large and sustainable community. This implies that community members must understand the project’s environment. We aim at providing a visualization prototype tool that allows the project members to interactively explore the project dynamics. This visualization extends social network graphs by work packages representing software contribution. The visualisation approach is evaluated on the Eclipse OSS community. It is shown that different scenarios and roles can be discovered, providing deeper insight into the project.

Web applications for managing scientific publications on an institute's, research group's, and researcher's homepage can hardly be found. This thesis presents the implementation of such a Web Application called PAX. It makes use of Ajax for providing a user friendly interface, supporting drag and drop as well as dynamic changes of the Web pages. It handles the import of BibTeX files as well as the export formats BibTeX and CSV. The semantic annotation, which is available in RDF and RDFa, follows the SWRC-unizh ontology, which is an extension of the SWRC ontology. An approach for incorporating the generation of semantic data into a Web application is presented.

null