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

Having successful apps in the Google Play Market or the Apple App Store has evolved to an important component of today’s business plan. Previous research has shown that response to individual user reviews and integration into the ongoing maintenance and evolution of an app, leads to higher ratings and success of an app. Because of the exorbitance number of reviews single apps can receive, we introduce URR (User Request Referencer), an approach (and prototype) able to gather useful reviews for maintenance perspectives (according to a manual defined taxonomy), and suggesting the location of the corresponding source code artifacts to modify to perform the recommended changes. URR represents a useful tool for help developers automatically link user’s (change) requests and the corresponding source code artifacts to maintain.

Research has yielded approaches to predict future defects in software artifacts based on historical information, thus assisting companies in effectively allocating limited development resources and developers in reviewing each others’ code changes. Developers are unlikely to devote the same effort to inspect each software artifact predicted to contain defects, since the effort varies with the artifacts’ size (cost) and the number of defects it exhibits (effectiveness). We propose to use Genetic Algorithms (GAs) for training prediction models to maximize their cost-effectiveness. We evaluate the approach on two well-known models, Regression Tree and Generalized Linear Model, and predict defects between multiple releases of six open source projects. Our results show that regression models trained by GAs significantly outperform their traditional counterparts, improving the cost-effectiveness by up to 240%. Often the top 10% of predicted lines of code contain up to twice as many defects.

Awareness in development teams has been thoroughly investigated over the past few years. Empirical studies have shown that one of the most sought informations in development team awareness is the information about the ongoing work items of team colleagues [KDV07]. Most of the related research has investigated awareness in situations where evelopers had access to a computer. This thesis approaches the field of awareness in a different way by providing a prototype implementation of an application for the Recon JET augmented reality glasses, designed to support spontaneous awareness within development teams in situations without access to a computer. Furthermore, this thesis presents the results of interviews conducted with experienced developers based on the aforementioned application. In the evaluation of this thesis, we found that our prototype application is able to support certain situations to foster awareness within development teams, especially in stand-up meetings. Also, we found that the functionality which would be used the most by the participants on a daily basis is finding meeting times with other developers. Bibliography: [KDV07] Andrew J. Ko, Robert DeLine, and Gina Venolia. Information needs in collocated software development teams. In ICSE í07: Proceedings of the 29th international conference on Software Engineering, page 344ñ353,Washington, DC, USA, May 2007. IEEE Computer Society.

Container-based application deployments have received significant attention in recent years. Operating system virtualization based on containers as a mechanism to deploy and manage complex, large-scale software systems has become a popular mechanism for application deployment and operation. Packaging application components into self-contained artifacts has brought substantial flexibility to developers and operation teams alike. However, this flexibility comes at a price. Practitioners need to respect numerous constraints ranging from security and compliance requirements, to specific regulatory conditions. Fulfilling these requirements is especially challenging in specialized domains with large numbers of stakeholders. Moreover, the rapidly growing number of container images to be managed due to the introduction of new or updated applications and respective components, leads to significant challenges for container management and adaptation. In this paper, we introduce Smart Brix, a framework for continuous evolution of container application deployments that tackles these challenges. Smart Brix integrates and unifies concepts of continuous integration, runtime monitoring, and operational analytics. Furthermore, it allows practitioners to define generic analytics and compensation pipelines composed of self-assembling processing components to autonomously validate and verify containers to be deployed. We illustrate the feasibility of our approach by evaluating our framework using a case study from the smart city domain. We show that Smart Brix is horizontally scalable and runtime of the implemented analysis and compensation pipelines scales linearly with the number of container application packages.

Quality gates, steps required to ensure the reliability of code changes, are supposed to increase the confidence stakeholders have in a release. In today's fast paced environments, we have less time to perform the necessary precautions to minimize the risk of a faulty release. This leads to an inherent trade-off between risk of lower release quality and time to market. We provide a model for this trade-off of release confidence and velocity that led to the formulation of 4 categories (cautious, balanced, problematic, madness), in which companies can be classified in. We showcase real examples of these categories as case studies based on previous empirical studies. We close by presenting possible transitions between categories that guide future research.

Written development discussions occurring over different communication means (e.g. issue trackers, development mailing lists, or IRC chats) represent a precious source of information for developers, as well as for researchers interested to build recommender systems. Such discussions contain text having different purposes, e.g. discussing feature requests, bugs to fix etc. In this context, the manual classification or filtering of such discussions in according to their purpose would be a daunting and time-consuming task. In this demo we present DECA (Development Emails Content Analyzer), a tool which uses Natural Language Parsing to classify the content of development emails according to their purpose, identifying email fragments that can be used for specific maintenance tasks. We applied DECA on the discussions occurring on the development mailing lists related to Qt and Ubuntu projects. The results highlight a high precision (90%) and recall (70%) of DECA in classifying email content providing useful information to developers interested in accomplishing specific development tasks. Demo URL: https://youtu.be/FmwBuBaW6Sk Demo Web Page: http://www.ifi.uzh.ch/seal/people/panichella/tools/DECA.html

Automated test generation tools have been widely investigated with the goal of reducing the cost of testing activities. However, generated tests have been shown not to help developers in detecting and finding more bugs even though they reach higher structural coverage compared to manual testing. The main reason is that generated tests are difficult to understand and maintain. Our paper proposes an approach, coined TestDescriber, which automatically generates test case summaries of the portion of code exercised by each individual test, thereby improving understandability. We argue that this approach can complement the current techniques around automated unit test generation or search-based techniques designed to generate a possibly minimal set of test cases. In evaluating our approach we found that (1) developers find twice as many bugs, and (2) test case summaries significantly improve the comprehensibility of test cases, which is considered particularly useful by developers.

Finding and fixing code quality concerns, such as defects or poor understandability of code, decreases software development and evolution costs. A common industrial practice to identify code quality concerns early on are code reviews. While code reviews help to identify problems early on, they also impose costs on development and only take place after a code change is already completed. The goal of our research is to automatically identify code quality concerns while a developer is making a change to the code. By using biometrics, such as heart rate variability, we aim to determine the difficulty a developer experiences working on a part of the code as well as identify and help to fix code quality concerns before they are even committed to the repository. In a field study with ten professional developers over a two-week period we investigated the use of biometrics to determine code quality concerns. Our results show that biometrics are indeed able to predict quality concerns of parts of the code while a developer is working on, improving upon a naive classifier by more than 26% and outperforming classifiers based on more traditional metrics. In a second study with five professional developers from a different country and company, we found evidence that some of our findings from our initial study can be replicated. Overall, the results from the presented studies suggest that biometrics have the potential to predict code quality concerns online and thus lower development and evolution costs.

The pace of software development has steadily increased, being transformed by the notion of agile and iterative development. In the meantime, the process of turning source code into releasable software artifacts is similarly transforming using techniques such as continuous integration, delivery and deployment. By automating and streamlining the process of releasing software, developers receive a new set of methods to leverage real-time customer feedback in their development processes. Fueled by scalable and flexible approaches to software such as microservices-based architecture, companies start to integrate live-testing methods into their applications to benefit from real-time user data e.g. by conducting A/B tests, silently launching new functionality or gradually testing new features in production. However, these kind of data-driven release strategies exist solely in large-scale corporations and few research has been conducted in this area. This thesis formalizes a general model of data-driven release strategies to allow complex and multi-staged software releases. Furthermore, a prototype based on the developed model is implemented to showcase its potential and to discover its pitfalls. In a qualitative evaluation, it is demonstrated how the prototype and thus the model allows for more complex scenarios in comparison to existing tools. Furthermore, a quantitative evaluation of the prototype shows that the chosen approach can be integrated into existing web applications with minimal performance constraints.

“Smart city” has emerged as an umbrella term for the pervasive implementation of information and communication technologies (ICT) designed to improve various areas of today’s cities. Areas of focus include citizen well-being, infrastructure, industry, and government. Smart city applications operate in a dynamic environment with many stakeholders that not only provide data for applications, but can also contribute functionality or impose (possibly conflicting) requirements. Currently, the fundamental stakeholders in a smart city are energy and transportation providers, as well as government agencies, which offer large amounts of data about certain aspects (for example, public transportation) of a city and its citizens. Increasingly, stakeholders deploy connected Internet of Things (IoT) devices that deliver large amounts of near-real-time data and can enact changes in the physical environment. Efficient management of these large volumes of data is challenging, especially since data gathered by IoT devices might have critical security and privacy requirements that must be honored at all times. Nevertheless, this presents a significant opportunity to closely integrate stakeholders and data from different domains to create new applications that can tackle the increasingly complex challenges of today’s cities, such as autonomous traffic management, efficient building management, and emergency response systems. Currently, smart city applications are usually deployed on premises. Cloud computing has matured to a point where practitioners are increasingly comfortable with migrating their existing smart city applications to the cloud to leverage its benefits (such as dynamic resource provisioning and cost savings). However, future smart city applications must also be able to operate across cities to create a global, interconnected system of systems for the future Internet of Cities.1 Therefore, such applications have to be designed, implemented, and operated as cloud-native applications, allowing them to elastically respond to changes in request load, stakeholder requirements, and unexpected changes in the environment. Here, we outline our recent work on the smart city operating system (SCOS), a central element of future smart city application ecosystems. The SCOS is designed to resemble a modern computer operating system, providing unified abstractions for underlying resources and management tasks, but specifically tailored to city scale. We present the specific foundations of SCOS that enable a larger smart city application ecosystem,2 allowing stakeholders and citizens to create applications within the smart city domain. This approach enables them to build applications by only focusing on their specific demand, while completely freeing them from the complexities and problems they’re currently facing.

Cities are becoming increasingly ""smart,"" but they need an underlying foundation that handles and manages all the lower-level complexities. In this article, the authors discuss the relevant challenges and building blocks of a Smart City Application Ecosystem (SCALE).

Producing great software requires great productive developers. Yet, what does it really mean for an individual developer to be productive, and what can we do to best help developers to be productive? To answer these questions, research has traditionally focused on measuring a developer’s output and therefore suffered from two drawbacks: the measures can only be calculated after a developer finished her work and these measures do not account for individual differences between developers. The recent advances in biometric sensor technology offer new opportunities to measure a developer’s cognitive and emotional states in real-time and thus allow us to know more about what an individual developer is currently experiencing and what might foster or impede the developer’s productivity. Results from recent research studies demonstrate the potential that biometric data has to accurately predict aspects of a developer’s work, such as perceived task and code difficulty, progress and interruptibility of a developer. This opens up new opportunities for better supporting developers in their work and, for instance, prevent bugs from entering the code, reduce costly interruptions, and foster a better and more productive work day. Our vision is that biometric sensing will be integrated into a developer’s work and that biometrics can be

Mobile multimedia devices such as smartphones and tablets have grown rapidly in importance and prevalence. Partly caused by the availability of an immense number of apps for every circumstance they have become very important or even indispensable for many aspects of our daily lives. One of the main restrictions of mobile devices is the dependency on a battery and therefore a limited uptime. Developers of mobile apps often face great complexity and little support when trying to maximize the utility of the available battery capacity for the end-user of the device. One of the reasons for this is the fact that the battery usage is often coupled to the quality of service of an app. Thus lowering the battery energy consumption will result in a reduced quality of service. Also, the utility a certain quality of service of an app provides to a user can depend on many parameters, such as the current charging state, remaining battery capacity or personal preferences of the user. In this thesis, we gathered known source code patterns which are notorious for excessive battery consumption. We present an approach which first enables developers to detect these patterns during the coding of an app by means of static code analysis. Then, the source code is modified using a customizable transformation to achieve a higher utility for the user by lowering the quality of service in specific circumstances, thus using the available energy to full capacity. As a proof of concept we implemented this approach in the form of the BAT plugin (Battery Aware Transformations) for IntelliJ IDEA/Android Studio which provides full functionality for two of these patterns. It allows detection of patterns, configuration and tailoring of a transformation to lower the energy consumption and modification of the source code by automatic application of this code transformation. We evaluated our approach and tooling by performing the transformations on an Android app with this tool and measured the energy consumption of the transformed app. This energy consumption profile was then compared to the profile of the original app and shows that the reduction in service quality resulted in a reduction in energy consumption of up to 30% for the app. This corresponds to 16% of the energy consumption of the entire device in our experiment.

The development of software is a cost- and people-intensive process. For years, the software development industry has been coping with a shortage of software developers. Besides just training even more software developers, an alternative and particularly promising way to tackle this problem, is to boost the productivity of every single developer. Traditionally, research on developers’ productivity has primarily focused on assessing their output using certain metrics and has therefore suffered from two major drawbacks: most of these approaches do not take into account the individual differences that exist between software developers, and the metrics used for these approaches can, in most cases, only be calculated once the work is done. Emerging biometric sensors offer a new opportunity to gain a better understanding of what developers perceive during their work and thereby a new way to better understand what aspects are affecting developers’ productivity. The basic idea behind biometric sensing is to measure a person’s physiological features that in turn can be linked to a person’s psychological states. A multitude of studies in psychology have already shown that biometric measurements can be used to assess the emotional and cognitive states of a developer. In our research, we investigate the use of biometric measurements to assess a developer’s perceived difficulty, progress and emotions while working on a change task. Based on the assumption that more difficult code has a higher likelihood to contain a bug compared to code that is perceived as being easier, we also investigate the use of biometric measurements to identify code quality concerns in the code developers are changing. Our vision is to gain a better understanding of what every individual developer experiences, feels or perceives during his/her work, and how these aspects affect his/her productivity, to suggest approaches which increase every individual developer’s productivity. In our research, we conducted three studies, ranging from lab experiments to a two-week field study, to investigate the use of biometric sensors in a software development context. The results of our studies provide initial evidence that biometrics can be used to better understand what a developer perceives in realtime, while s/he is working on a change task. In particular, using biometric data, we were able to distinguish between positive and negative emotions, phases of high and low progress and to predict a developer’s perceived difficulty while working on a change task with high accuracy. Additionally, we were able to use biometrics to predict code quality concerns that were identified in peer code reviews. These findings open up many opportunities for better supporting developers in their work, for instance by automatically and instantaneously detecting potential quality concerns in the code, before they are committed to the code repository, or by avoiding costly interruptions when a developer is in the flow and making a lot of progress.

Smart city applications generate large amounts of operational data during their execution, such as information from infrastructure monitoring, performance and health events from used toolsets, and application execution logs. These data streams contain vital information about the execution environment that can be used to fine-tune or optimize different layers of a smart city application infrastructure. Current approaches do not sufficiently address the efficient collection, processing, and storage of this information in the smart city domain. In this paper, we present Ahab, a generic, scalable, and fault-tolerant data processing framework based on the cloud that allows operators to perform online and offline analyses on gathered data to better understand and optimize the behavior of the available smart city infrastructure. Ahab is designed for easy integration of new data sources, provides an extensible API to perform custom analysis tasks, and a DSL to define adaptation rules based on analysis results. We demonstrate the feasibility of the proposed approach using an example application for autonomous intersection management in smart city environments. Our framework is able to autonomously optimize application deployment topologies by distributing processing load over available infrastructure resources when necessary based on both, online analysis of the current state of the environment, as well as patterns learned from historical data.

With the advent of the smart city paradigm, modern cities have become complex systems of systems with a host of increasingly entangled dependencies and interactions among systems as well as stakeholders from multiple different domains. Efficient design, engineering, and operation of such systems is challenging due to the large number of involved stakeholders and their requirements, which might be conflicting and will change over time. In this paper, we present results from our ongoing efforts towards engineering next-generation smart city applications to provide stakeholders with a holistic and tailored view on their problem domain to support them in managing relevant aspects of the city, and furthermore provide effective assistance for important decision processes. We introduce the URBEM Smart City Application (\usca), an interdisciplinary decision support system, and present different views on its use by involved experts from four central smart city domains in the context of a smart city research initiative in the city of Vienna.

Stream processing applications have emerged as a popular way for implementing high-volume data processing tasks. In contrast to traditional data processing models that persist data to databases and then execute queries on the stored data, stream processing applications continuously execute complex queries on incoming data to produce timely results in reaction to events observed in the processed data. To cope with the request load, components of a stream processing application are usually distributed across multiple machines. In this context, performance monitoring and testing are naturally important for stakeholders to understand as well as analyze the runtime characteristics of deployed applications to identify issues and inform decisions. Existing approaches for monitoring the performance of distributed systems, however, do not provide sufficient support for targeted monitoring of stream processing applications, and require changes to the application code to enable the integration of application-specific monitoring data. In this paper we present MOSAIC, a service oriented framework that allows for in-depth analysis of stream processing applications by non-intrusively adding functionality for acquiring and publishing performance measurements at runtime, to the application. Furthermore, MOSAIC provides a flexible mechanism for integrating different stream processing frameworks, which can be used for executing and monitoring applications independent from a specific operator model. Additionally, our framework provides an extensible approach for gathering and analyzing measurement data. In order to evaluate our solution, we developed a scenario application, which we used for testing and monitoring its performance on different stream processing engines.

We study the performance and cost efficiency as perceived by the end user of a specific class of Infrastructure-as- a-Service (IaaS) cloud instances, namely credit-based bursting instances. This class of instance types has been introduced by Amazon EC2 in summer 2014, and behaves on a fundamental level differently than any other existing instance type, either from EC2 or other vendors. We introduce a basic formal model for fostering the understanding and analysis of these types, and empirically study their performance in practice. Further, we compare the performance of credit-based bursting cloud instance types to existing general-purpose types, and derive potential use cases for practitioners. Our results indicate that bursting instance types are cost-efficient for CPU-bound applications with an average utilization of less than 40%, as well as for non-critical IO-bound applications. Finally, we also discuss a simple boosting scheme that enables practitioners to improve the cost efficiency of their bursting instance usage under given constraints.