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

The Faculty of Economics, Business Administration and IT of the University of Zurich is being certified by the European EQUIS and the American AACSB accreditation authorities. In order to apply for an accreditation, the faculty must provide self-assessment reports that contain comprehensive information about publications, scientific staff, research and teaching as well as service issues on a yearly basis. Currently, this information is gathered by compiling data into Excel sheets. Because of the faculty’s great number of research groups, this results in an almost unmanageable amount of files that must be consolidated and formatted by hand. To improve this process, the idea for a Web-based information management system called Merlin came up. Its main purpose is to be a centralized repository for employee and publication data. The focus of this master thesis lies in the conception and implementation of a role-based security system and the development of user and organizational unit related management functionalities using Java’s next generation Web application framework Grails. The authentication service of the security system was developed to integrate with the University of Zurich’s Authentication and Authorization Infrastructure (AAI), which is based on the Shibboleth open source project. The authorization service implements the concepts of a role-based access control (RBAC) model by supporting role hierarchies, multiple role inheritance, role delegations and instance level access control. Merlin was developed to integrate into the existing application landscape and to make use of employee and organizational unit data provided by the University of Zurich’s enterprise resource planning software SAP. Organizational unit data is imported initially by parsing a XML file whereas employee data is integrated based on nightly CSV file imports triggered by a cron job. The employee centric functionality covers customizable profile page containing all necessary information such as personal data, education or appointment. Merlin’s organizational unit centric functionalities aim to provide an editable organizational unit profile, a clear organizational structure of the faculty with a correct affiliation of the its members. To achieve this, an interactive setup wizard with automatic employee membership requests has been implemented. Finally, functionality for CSV employee data export is provided to support the generation of selfassessment reports. For quality assurance purposes, an evaluation based on user tests has been carried out. The users were assigned to groups based on the function they have in the organization. Each group had to perform a defined set of task. The tests showed that the functionality concerning authentication and authorization worked as expected. However, there were some issues with comprehensibility of the workflow related to tasks. The users wish a comprehensive documentation in form of a FAQ and more help texts. With these tests, we were able to fix some issues and thus improve the quality of the application.

The Faculty of Economics of the University of Zurich is currently making efforts to get certified by an American and a European accreditation institute. To get these certificates, self-assessment reports including data about publications, the scientific staff and the teaching activities have to be submitted every year. Gathering the required data was a manual task and quite tedious. The university therefore decided to implement an information system (Merlin) that manages the report data and serves as a centralized platform where employees manage their personal information. The goal of this master thesis was to implement Merlin’s functionality related to publications. We implemented Merlin as aWeb application using the Grails framework – a Java related technology that enables rapid application development. We provide functionality to manage publications and neatly integrate in the university’s IT environment. Publication data is exchanged with existing repositories (ZORA).We offer our users advanced search functionality and provide export mechanisms for BibTeX and XML. We implemented an intuitive user interface (UI) that adheres to the (new) corporate design of the University of Zurich and make use of modern Web technologies. AJAX and other Javascript related features support our users in their information submission by providing autocompletion and tooltips. Furthermore, the use of these client side technologies results in a very responsive user interface known from desktop applications. Last but not least, we implemented the report generation that is required for the accreditation institutes. The results are provided as comma-separated values (CSV) that can be manipulated or used for further calculations in Excel. To ensure the quality of our work, we did an evaluation with selected test users. The users had to accomplish several tasks and comment about their success. The results show that most of the functionality related to publication management is intuitively accessible. The documentation could be extended in some parts of the application to further support the users. In addition to this, the tests exposed that Javascript is still platform dependent. Especially some older versions of the Internet Explorer had problems with our application. Firefox or Google Chrome turned out to be the most tolerant browsers. With the feedback of our test users, we were able to address most of the problems of Merlin and improved the quality of our user interface.

null

Throughout the years software engineers have come up with a myriad of specialized tools and techniques that focus on a certain type of software analysis such as source code analysis, duplication analysis, co-change analysis, bug prediction, or detection of bug fixing patterns. However, easy and straight forward synergies between these analyses and tools rarely exist because of their stand-alone nature, their platform dependence, their different input and output formats and the variety of data to analyze. As a consequence, distributed and collaborative software analysis scenarios and in particular interoperability are severely limited. We describe a distributed and collaborative software analysis platform that allows for a seamless interoperability of software analysis tools across platform, geographical and organizational boundaries. We realize software analysis tools as services that can be accessed and composed over the Internet. These distributed analysis services shall be widely accessible in our incrementally augmented Software Analysis Broker where organizations and tool providers can register and share their tools. To allow (semi)-automatic use and composition of these tools, they are classified and mapped into a software analysis taxonomy and adhere to specific meta-models and ontologies for their category of analysis.

Over the years relational databases were optimized to handle large amounts of data. While they provide scalability, they do not fully preserve the semantics of the application domain. The Semantic Web however provides a common framework to give the data a well defined meaning using RDF to describe the data and OWL to define the vocabulary. The explicit definition of the semantics facilitates the exchange and integration of data, hence the data from relational databases could be mapped to a Semantic Web representation to gain ontology-based access. To bridge the conceptual gap between the relational model and an ontology, we must create a mapping of an existing relational database schema. This process should be largely automated since creating a mapping manually is time-consuming and error-prone. Certainly, an automated mapping generation cannot meet all user needs, therefore customization is necessary afterwards. However, it is highly desirable to provide additional tool support for customization to further decrease the user effort and error rate. In this thesis, we present how such a mapping can be generated automatically from an existing relational database schema. Therefore we implement a Mapping Library that is applicable to a wide range of database systems and can be embedded into other applications. In addition, we provide graphical tool support to customize the generated mapping. The prototype is developed as a plugin for the ontology editor Protege.

Generating accurate recommendations for items, such as locations, movies or books, is challenging. Common Web-based recommender systems require information about the users’ past to generate suitable recommendations for them. In this thesis we first present spotting.li, a location recommender system based on Facebook, which allows users to rate locations and generates recommendations inferred by their friends’ ratings. In doing so, we examine requirments to successfully implement such a system using the latest web technologies (i.e., Grails) and describe key elements of our approach. Our focus is put on performance and providing an easy-to-use interface incorporating Google Maps. Furthermore, we analyse different recommendation approaches which leverage structural information from a social network to predict ratings. In particular, we examine the use of social network patterns, such as cliques and trendsetters, as well as direct friends and two levels of indirect friends. We finally conduct an extensive evaluation of these approaches, based on real data collected during the time of the thesis. To prove our findings, we test our dataset, based on 139 users, for statistical significance. We demonstrate that even a simple algorithm, such as the average rating, bares similar results to more elaborate algorithms.

Source code comments are a valuable instrument to preserve design decisions and to communicate the intent of the code to programmers and maintainers. Nevertheless, commenting source code and keeping them up-to-date is often neglected for reasons of time or programmer’s obliviousness. In this paper, we investigate the question whether developers comment their code and to which extent they add comments or adapt them when they evolve the code. We present an approach to associate comments with source code entities to track their co-evolution over multiple versions. A set of heuristics are used to decide whether a comment is associated to its preceding or its succeeding source code entity. We analyzed the co-evolution of code and comments in eight different open source and closed source software systems. We found with statistical significance that (1) the relative amount of comments and source code grows at about the same rate; (2) the type of a source code entity, such as a method declaration or an if-statement, has a significant influence on whether or not it gets commented; (3) in six out of the eight systems, code and comments co-evolve in 90 percent of the cases; and (4) surprisingly, API changes and comments do not co-evolve but they are re-documented in a later revision. As a result, our approach enables a quantitative assessment of the commenting process in a software system. We can, therefore, leverage the results to provide feedback during development to increase the awareness when to add comments or when to adapt comments because of source code changes.

Finding issues in software usually requires a serie of comprehension tasks. After every task, an engineer explores the results and decides whether further tasks are required. Software comprehension therefore is a combination of tasks and a supported exploration of the results typically in an adequate visualization. In this paper, we describe how we simplify the combination of existing automated procedures to sequentially solve common software comprehension tasks. Beyond that we improve the understanding of the outcomes with interactive and explorative visualization concepts in a time efficient workflow. We validate the presented concept with basic comprehension tasks in an extended CocoViz tool implementation.

Issue tracking repositories contain a wealth of information for reasoning about various aspects of software development processes. In this paper, we focus on bug triaging and provide visual means to explore the effort estimation quality and the bug life-cycle of reported problems. Our approach follows the Micro/Macro reading technique and uses a combination of graphical views to investigate details of individual problem reports while maintaining the context provided by the surrounding data population. This enables the detection and detailed analysis of hidden pat- terns and facilitates the analysis of problem report outliers. In an industrial study, we use our approach in various problem report analysis scenarios and answer questions related to effort estimation and resource planning.

In this thesis we implement a 3D visualization for software systems. We use a 3D city metaphor and display the source code entities as city objects. This allows users to intuitively understand what they see. The tool can be used for the analysis of complex software systems. Our prototype of the tool helps in understanding, maintenance and reverse engineering of large systems. One of our main goals is to outperform currently available software visualizations in performance and usability. We use the powerful jMonkeyEngine for the rendering of the 3D view. Our tool is written in Java. The current architecture of our tool was developed keeping extensibility in mind. Test persons evaluate our tool. The results show that the testers are pleased with the 3D visualization. The strengths of our tool lie in its abilities to give an overview of a software system and that it allows to find code smells easily. The use of a game engine results in a smooth 3D view.

Issue tracking repositories contain a wealth of information for reasoning about various aspects of software development processes. In this paper, we focus on bug triaging and provide visual means to explore the effort estimation quality and the bug life-cycle of reported problems. Our approach uses a combination of graphical views to investigate details of individual problem reports while maintaining the context provided by the surrounding data population. This enables the detection and detailed analysis of hidden patterns and facilitates the analysis of problem report outliers.

Prediction of software defects works well within projects as long as there is a sufficient amount of data available to train any models. However, this is rarely the case for new software projects and for many companies. So far, only a few have studies focused on transferring prediction models from one project to another. In this paper, we study cross-project defect prediction models on a large scale. For 12 real-world applications, we ran 622 cross-project predictions. Our results indicate that cross-project prediction is a serious challenge, i.e., simply using models from projects in the same domain or with the same process does not lead to accurate predictions. To help software engineers choose models wisely, we identified factors that do influence the success of cross-project predictions. We also derived decision trees that can provide early estimates for precision, recall, and accuracy before a prediction is attempted.

Software becomes more and more complex. For this reason we need other possibilities to understanding large software systems. CocoViz want to vizualize the code with common metaphors for an intuitive understanding of software structures and evolution. The work show an implementation on .NET that allow you to filter the metric data and visualize shapes in a 3D world. Thereby well-designed visual object represent a well-designed class. This application help to remedy deficiencies in a intuitive form.

Software systems have to evolve continually to meet their changing requirements. Refactorings are systematic, behavior-preserving changes to software systems intended to improve their inter- nal structure. Today, refactoring is considered a state of the art technique in software develop- ment. Refactorings have a positive impact on the understandability and maintainability of a software system. Another important property is that their catalogued names capture the intent of the underlying changes and provide an accurate vocabulary for communicating changes at a much higher level of abstraction than the insertion or removal of individual lines of code. A similar property has been attributed to the design patterns of Gamma et al.; giving mean- ingful names not only reveals the intent and structure of a pattern but also allows for efficient communication of design concepts. It is not only crucial to understand what changes have hap- pened but also what changes need to be made in order to maintain the understandability and extensibility of a software system. Therefore, another goal of refactoring research is to develop approaches for anticipating and suggesting possible refactorings to developers—which requires understanding past changes and refactorings. Based on the EVOLIZER framework, which offers advanced modeling and data extraction fa- cilities, and FAMIX, a meta model for modeling the structure of object-oriented software systems, this thesis presents the approach, implementation and evaluation of REFACTORIZER, a prototype tool for detecting refactorings in the development history of a software system. The main goals of the approach are to be intuitive and light-weight. This means that the ap- proach builds on the vocabulary and understanding of a software developer about how programs are composed and uses a simple representation of the structure of a software system to formulate intuitive FAMIX-based heuristics.

Online stores and Web portals bring information about a myriad of items such as books, CDs, restaurants or movies at the user's fingertips. Although, the Web reduces the barrier to the information, the user is overwhelmed by the number of available items. Therefore, recommender systems aim to guide the user to relevant items. Current recommender systems store user ratings on the server side. This way the scope of the recommendations is limited to this server only. In addition, the user entrusts the operator of the server with valuable information about his preferences. In this thesis, we introduce our recommender system OMORE, a private, personal movie recommender, which learns the user model based on the user's movie ratings. To preserve privacy, OMORE is implemented as a Mozilla Firefox add-on, which stores the user's ratings and the learned user model locally at the client side. Although OMORE makes use of the movie features, which are provided by the different movie pages on the IMDb Web site, it is not restricted to IMDb only. The current implementation covers movie pages from Amazon.com, Blockbuster, Netflix and Rotten Tomatoes.

Visualization helps to overcome the complexity of investing. The metaphor of driving a car is chosen as practical approach to fulfill this task. First of all it is shown how the theory of efficient portfolios, the capital market line and the capital asset pricing model, in combination provide a set of potential portfolios. In a next step behavioral finance has been introduced. The prospect theory, the central message of behavioral finance, measures the risk ability and the risk prefer- ences of an investor. So both modern finance and behavioral finance provide the tools to deliver a fitting asset allocation to the investor. An application has been developed that maps the essential elements from both worlds of finance onto the metaphor. The application provides a wide range of configuration settings and shows possible scenarios of driving the assembled car under various conditions. An extended evaluation with test users was carried out that showed, that the every- day experience of driving a car was a great advantage. Through using the provided analogy, an investor could select a suiting portfolio in a much better way.

Within the analysis of software, metric values can be helpful to quantify certain aspects of the source code as size or complexity. Therefore we enhanced EVOLIZER and DA4JAVA with metrics. The metric addition provides a flexible infrastructure administrating different strategies for metric calculations and handling incoming requests for metric values.In addition an interface for additive strategies for metric calculations is defined, such as a mechanism making all found implementations of that interface automaticaly available for calculations. The calculated metrics can be selected as dimensions in polymetric views provided by DA4JAVA. Such views are helpful for source code understanding or during the refactoring process. The solution is finally evaluated with two applications.

We present an approach for ontology-based read and write access to existing Relational Databases (RDBs). SPARQL/Update serves as the data manipulation language that is translated to equivalent SQL commands according to mappings between the RDBs and the Semantic Web. This addition of write support enables a full integration of existing relational data into Semantic Web applications.

This proposal explores the promotion of existing relational databases to Semantic Web Endpoints. It presents the benefits of ontology-based read and write access to existing relational data as well as the need for specialized, scalable reasoning over that data. We introduce our approach for translating SPARQL/Update operations to SQL, describe how scalable reasoning can be realized by using the power of the database system, and outline two case studies for evaluating our approach.