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

Services computing is both, an academic _eld of study looking back at close to 15 years of fundamental research, as well as a vibrant area of industrial software engineering. Industrial practice in this area is notorious for its ever-changing nature, with the state of the art changing almost on a yearly basis based on the ebb and ow of various hypes and trends. In this paper, we provide a look \across the wall" into industrial services computing. We conducted an empirical study based on the service ecosystem of 42 companies, and report, among other aspects, how service-to-service communication is implemented, how service discovery works in practice, what Quality-of-Service metrics practitioners are most interested in, and how services are deployed and hosted. We argue that not all assumptions that are typical in academic papers in the _eld are justi_ed based on industrial practice, and conclude the paper with recommendations for future research that is more aligned with the services industry.

Written development communication (e.g. mailing lists, issue trackers) constitutes a precious source of information to build recommenders for software engineers, for example aimed at suggesting experts, or at redocumenting existing source code. In this paper we propose a novel, semi-supervised approach named DECA (Development Emails Content Analyzer) that uses Natural Language Parsing to classify the content of development emails according to their purpose (e.g. feature request, opinion asking, problem discovery, solution proposal, information giving etc), identifying email elements that can be used for specific tasks. A study based on data from Qt and Ubuntu, highlights a high precision (90%) and recall (70%) of DECA in classifying email content, outperforming traditional machine learning strategies. Moreover, we successfully used DECA for re-documenting source code of Eclipse and Lucene, improving the recall, while keeping high precision, of a previous approach based on ad-hoc heuristics.

Cloud computing is gaining more and more traction as a deployment and provisioning model for software. While a large body of research already covers how to optimally operate a cloud system, we still lack insights into how professional software engineers actually use clouds, and how the cloud impacts development practices. This paper reports on the first systematic study on how software developers build applications in the cloud. We conducted a mixed-method study, consisting of qualitative interviews of 25 professional developers and a quantitative survey with 294 responses. Our results show that adopting the cloud has a profound impact throughout the software development process, as well as on how developers utilize tools and data in their daily work. Among other things, we found that (1) developers need better means to anticipate runtime problems and rigorously define metrics for improved fault localization and (2) the cloud offers an abundance of operational data, however, developers still often rely on their experience and intuition rather than utilizing metrics. From our findings, we extracted a set of guidelines for cloud development and identified challenges for researchers and tool vendors.

The recent and fast expansion of OSS (Open-source software) communities has fostered research on how open source projects evolve and how their communities interact. Several research studies show that the inflow of new developers plays an important role in the longevity and the success of OSS projects. Beside that they also discovered that an high percentage of newcomers tend to leave the project because of the socio-technical barriers they meet when they join the project. However, such research effort did not generate yet concrete results in support retention and training of project newcomers. In this thesis dissertation we investigated problems arising when newcomers join software projects, and possible solutions to support them. Specifically, we studied (i) how newcomers behave during development activities and how they interact with others developers with the aim at (ii) developing tools and/or techniques for supporting them during the integration in the development team. Thus, among the various recommenders, we defined (i) a tool able to suggest appropriate mentors to newcomers during the training stage; then, with the aim at supporting newcomers during program comprehension we defined other two recommenders: a tool that (ii) generates high quality source code summaries and another tool able to (iii) provide descriptions of specific source code elements. For future work, we plan to improve the proposed recommenders and to integrate other kind of recommenders to better support newcomers in OSS projects.

App Stores, such as Google Play or the Apple Store, allow users to provide feedback on apps by posting review comments and giving star ratings. These platforms constitute a useful electronic mean in which application developers and users can productively exchange information about apps. Previous research showed that users feedback contains usage scenarios, bug reports and feature requests, that can help app developers to accomplish software maintenance and evolution tasks. However, in the case of the most popular apps, the large amount of received feedback, its unstructured nature and varying quality can make the identification of useful user feedback a very challenging task. In this paper we present a taxonomy to classify app reviews into categories relevant to software maintenance and evolution, as well as an approach that merges three techniques: (1) Natural Language Processing, (2) Text Analysis and (3) Sentiment Analysis to automatically classify app reviews into the proposed categories. We show that the combined use of these techniques allows to achieve better results (a precision of 75% and a recall of 74%) than results obtained using each technique individually (precision of 70% and a recall of 67%).

The paper presents iTrace, an Eclipse plugin that implicitly records developers' eye movements while they work on change tasks. iTrace is the first eye tracking environment that makes it possible for researchers to conduct eye tracking studies on large software systems. An overview of the design and architecture is presented along with features and usage scenarios. iTrace is designed to support a variety of eye trackers. The design is flexible enough to record eye movements on various types of software artifacts (Java code, text/html/xml documents, diagrams), as well as IDE user interface elements. The plugin has been successfully used for software traceability tasks and program comprehension tasks. iTrace is also applicable to other tasks such as code summarization and code recommendations based on developer eye movements. A short video demonstration is available at https://youtu.be/3OUnLCX4dXo.

Building highly scalable and automatized software systems is fostered by Cloud Computing and Microservice Architectures. While loosely-coupled and independently scalable services in the cloud are charged according to actual resource consumption, costs of operation can often be traded against performance. On the contrary, autoscaling is often used to keep the response time on a desired level, while scaling resources up and down. Understanding such complex systems and assessing the costs of operation is difficult for developers. The central issue is the lack of tools. While a plethora of tools bring static code analysis to the IDE, dynamic runtime feedback from production systems is limited to performance-related metrics. We developed a novel approach that brings cost-related metrics into the IDE of developers. The so-called CostHat consists of (1) the Analytical CostHat that maps dynamic information about a microservice such as the number of incoming requests or running instances to the corresponding service method and (2) the Predictive CostHat that predicts the impact of modifying the number of requests to another microservice on its costs of operation. A prototype was implemented and evaluated in a semi-structured interview study that investigated the relationship of software engineers to costs of operation and how they perceive the CostHat tooling. Our findings indicate that costs currently treated in a reactive rather than proactive manner. Also, it is indicated that the overall understanding of the system can be increased by the Analytical CostHat and developers are driven to optimize by the Predictive CostHat. While a serious overhead in build times is shown in the quantitative evaluation, results from the interview study indicate that developers are more concerned about the monitoring overhead.

Cloud computing is an ongoing trend in Internet computing. In cloud computing, resources, such as CPU processing time, disk space, or networking capabilities, are rented and released as a service. Today, the most important model for delivering on the cloud promise is the Infrastructure-as-a-Service (IaaS) model. In IaaS, virtual computing resources (most importantly virtual machines) are acquired and released on demand, either via a Web interface or programmatically via an Application Programming Interface (API). As IaaS is receiving a significant hype in industry, a large number of commercial vendors have started to appear, providing IaaS services (e.g., Amazon's EC2 - AWS, Google's Compute Engine - GCE, Microsoft's Azure, or Rackspace's Public Cloud Hosting). Functionally, these services are largely equivalent, however, the non-functional properties (performance, reliability, costs, etc.) vary significantly. In order to support software engineers in selecting the best cloud service for their applications, many researchers have started initiatives to evaluate the performance of these services. This work performs a deep comparison and analysis of two major IaaS service providers - AWS and GCE. A number of benchmarks had been run on different virtual machine (instance) types of both providers, analysis performed, and according to the benchmarks' results and costs of running a virtual machine, recommendations were given, which machines from which provider suit certain task better.

Software developers working on change tasks commonly experience a broad range of emotions, ranging from happiness all the way to frustration and anger. Research, primarily in psychology, has shown that for certain kinds of tasks, emotions correlate with progress and that biometric measures, such as electro-dermal activity and electroencephalography data, might be used to distinguish between emotions. In our research, we are building on this work and investigate developers' emotions, progress and the use of biometric measures to classify them in the context of software change tasks. We conducted a lab study with 17 participants working on two change tasks each. Participants were wearing three biometric sensors and had to periodically assess their emotions and progress. The results show that the wide range of emotions experienced by developers is correlated with their progress on the change tasks. Our analysis also shows that we can build a classifier to distinguish between positive and negative emotions in 71.36% and between low and high progress in 67.70% of all cases. These results open up opportunities for improving a developer's productivity. For instance, one could use such a classifier for providing recommendations at opportune moments when a developer is stuck and making no progress.

The interlinking of commit and issue data has become a de-facto standard in software development. Modern issue tracking systems, such as JIRA, automatically interlink commits and issues by the extraction of identifiers (e.g., issue key) from commit messages. However, the conventions for the use of interlinking methodologies vary between software projects. For example, some projects enforce the use of identifiers for every commit while others have less restrictive conventions. In this work, we introduce a model called PaLiMod to enable the analysis of interlinking characteristics in commit and issue data. We surveyed 15 Apache projects to investigate differences and commonalities between linked and non-linked commits and issues. Based on the gathered information, we created a set of heuristics to interlink the residual of non-linked commits and issues. We present the characteristics of Loners and Phantoms in commit and issue data. The results of our evaluation indicate that the proposed PaLiMod model and heuristics enable an automatic interlinking and can indeed reduce the residual of non-linked commits and issues in software projects.

null

Software quality assessment monitors and guides the evolution of a software system based on quality measurements. Continuous Integration (CI) environments can provide measurement data to feed such continuous assessments. However, in modern CI environments, data is scattered across multiple CI tools (e.g., build tool, version control system). Even small quality assessments can become extremely time-consuming, because each stakeholder has to seek for the data she needs. In this thesis, we introduce an approach to enable rapid and systematic software quality assessments. In the context of our work, systematic stands for the ability to do a comprehensive assessment of a software system based on data integrated from different CI tools. Rapid on the other hand, stands for the ability to increase the efficiency during an assessment by tailoring integrated CI data to the information needs of a stakeholder. Based on our findings from mining software repositories and best-practices of practitioners, we present an approach to (i) integrate CI data, (ii) profile stakeholder activities, (iii) tailor the integrated data, and (iv) present it in accordance to the individual needs of a stakeholder. We employed different kinds of studies to evaluate the core concepts of our approach. Additionally, we carried out a user and a case study to investigate the overall potential of our approach in a software quality assessment. The evaluation results clearly indicate that our approach can indeed enable more comprehensive quality assessment within less time.

Building Infrastructure-as-a-Service (IaaS) applications today is a complex, repetitive and error-prone endeavor, as IaaS does not provide abstractions on top of virtual machines. This paper presents JCloudScale, a Java-based middleware for moving elastic applications to IaaS clouds, with minimal adjustments to the application code. We discuss the architecture, technical features, and evaluate our system with regard to user acceptance and performance overhead. Our user study reveals that JCloudScale indeed allows many participants to build IaaS applications more efficiently, compared to industrial Platform-as-a-Service (PaaS) solutions. Additionally, unlike PaaS, JCloudScale does not lead to a control loss and vendor lock-in.