ICSE 2012 Workshops
2012 34th International Conference on Software Engineering (ICSE)
Powered by
Conference Publishing Consulting

2012 Third International Workshop on Recommendation Systems for Software Engineering (RSSE), June 4, 2012, Zurich, Switzerland

RSSE 2012 – Proceedings

Contents - Abstracts - Authors

Third International Workshop on Recommendation Systems for Software Engineering (RSSE)


Title Page

This workshop brings together researchers and practitioners with interest and experience in the theory, elaboration, and evaluation of concepts, techniques, and tools for providing recommendations to developers and managers involved in software engineering tasks.

Formal Presentations

Recommendation System for Design Patterns in Software Development: An DPR Overview
Francis Palma, Hadi Farzin, Yann-Gaël Guéhéneuc, and Naouel Moha
(École Polytechnique de Montréal, Canada; Université du Québec à Montréal, Canada)
Software maintenance can become monotonous and expensive due to ignorance and misapplication of appropriate design patterns during the early phases of design and development. To have a good and reusable system, designers and developers must be aware of large information set and many quality concerns, e.g., design patterns. Systems with correct design pattern may ensure easy maintenance and evolution. However, without assistance, designing and development of software systems following certain design patterns is difficult for engineers. Recommendation systems for software engineering can assist designers and developers with a wide range of activities including suggesting design patterns. With the help of pattern recommenders, designers can come up with a reusable design. We provide a Design Pattern Recommender (DPR) process overview for software design to suggest design patterns, based on a simple Goal-Question-Metric (GQM) approach. Our prototype provides two-fold solution. In the primary-level, DPR only proposes one or more design patterns for a problem context, and in the secondary level, for a initial set of design, DPR refactors models and suggests design patterns. Our preliminary evaluation shows that DPR has a good trade-off between accuracy and procedural complexity, comparing to other state-of-the-art approaches.

Annotation Support for Generic Patches
Georg Dotzler, Ronald Veldema, and Michael Philippsen
(University of Erlangen-Nuremberg, Germany)
In large projects parallelization of existing programs or refactoring of source code is time consuming as well as error-prone and would benefit from tool support. However, existing automatic transformation systems are not extensively used because they either require tedious definitions of source code transformations or they lack general adaptability. In our approach, a programmer changes code inside a project, resulting in before and after source code versions. The difference (the generated transformation) is stored in a database. When presented with some arbitrary code, our tool mines the database to determine which of the generalized transformations possibly apply. Our system is different from a pure compiler based (semantics preserving) approach as we only suggest code modifications.
Our contribution is a set of generalizing annotations that we have found by analyzing recurring patterns in open source projects. We show the usability of our system and the annotations by finding matches and applying generated transformations in real-world applications.

Actionable Identification of Emergent Teams in Software Development Virtual Organizations
Giuseppe Valetto, Kelly Blincoe, and Sean P. Goggins
(Drexel University, USA)
We present a method for identifying emergent teams of developers who need to work together and coordinate, within larger software development organizations. Our goal is to identify these socio-technical constructs as they emerge, so that we can provide timely awareness and actionable recommendations to managers, technical leads and members of the emergent team alike. Our technique is rooted in the analysis of Social Networks, which are constructed from real-time traces of the activity of each individual developer within her development environment, contextualized with respect to her assigned tasks and the corresponding artifact working set.

Facilitating Reuse in Model-Based Development with Context-Dependent Model Element Recommendations
Lars Heinemann
(TU Munich, Germany)
Reuse recommendation systems suggest code entities useful for the task at hand within the IDE. Current approaches focus on code-based development. However, model-based development poses similar challenges to developers regarding the identification of useful elements in large and complex reusable modeling libraries. This paper proposes an approach for recommending library elements for domain specific languages. We instantiate the approach for Simulink models and evaluate it by recommending library blocks for a body of 165 Simulink files from a public repository. We compare two alternative variants for computing recommendations: association rules and collaborative filtering. Our results indicate that the collaborative filtering approach performs better and produces recommendations for Simulink models with satisfactory precision and recall.

A Cost-Benefit Approach to Recommending Conflict Resolution for Parallel Software Development
Nan Niu, Fangbo Yang, Jing-Ru C. Cheng, and Sandeep Reddivari
(Mississippi State University, USA; U.S. Army Engineer Research and Development Center, USA)
Merging parallel versions of source code is a common and essential activity during the lifespan of large-scale software systems. When a non-trivial number of conflicts is detected, there is a need to support the maintainer in investigating and resolving these conflicts. In this paper, we contribute a cost-benefit approach to ranking the conflicting software entities by leveraging both structural and semantic information of the source code. We present a study by applying our approach to a legacy system developed by computational scientists. The study not only demonstrates the feasibility of our approach, but also sheds light on the future development of conflict resolution recommenders.

Harnessing Stack Overflow for the IDE
Alberto Bacchelli, Luca Ponzanelli, and Michele Lanza ORCID logo
(University of Lugano, Switzerland)
Developers often consult online tutorials and message boards to find solutions to their programming issues. Among the many online resources, Question & Answer websites are gaining popularity. This is no wonder if we consider a case like Stack Overflow, where more than 92% questions on expert topics are answered in a median time of 11 minutes. This new resource has scarcely been acknowledged by any Integrated Development Environment (IDE): Even though developers spend a large part of their working time in IDEs, and the usage of Q&A services has dramatically increased, developers can only use such resources using external applications.
We introduce Seahawk, an Eclipse plugin to integrate Stack Overflow crowd knowledge in the IDE. It allows developers to seamlessly access Stack Overflow data, thus obtaining answers without switching the context. We present our preliminary work on Seahawk: It allows users to (1) retrieve Q&A from Stack Overflow, (2) link relevant discussions to any source code in Eclipse, and (3) attach explanative comments to the links.


Recommendations as Learning: From Discrepancies to Software Improvement
Kurt Schneider, Stefan Gärtner, Tristan Wehrmaker, and Bernd Brügge
(Leibniz Universität Hannover, Germany; TU Munich, Germany)
Successful software development requires software engineering skills as well as domain and user knowledge. This knowledge is difficult to master. Increasing complexity and fast evolving technologies cause deficits in development and system behavior. They cause discrepancies between expectations and observations. We propose using discrepancies as a trigger for recommendations to developers. Discrepancies in using a software application are combined with discrepancies between development artifacts. To efficiently support software engineers, recommendations must consider knowledge bases of discrepancies and resolution options. They evolve over time along with evolving experience. Hence, recommendations and organizational learning are intertwined.

Connecting User Stories and Code for Test Development
Mathias Landhäußer and Adrian Genaid
(KIT, Germany)

Example Overflow: Using Social Media for Code Recommendation
Alexey Zagalsky, Ohad Barzilay, and Amiram Yehudai
(Tel-Aviv University, Israel)
Modern Q&A websites, such as Stack Overflow, use social media to provide concise answers, and offer rich technical context with quality assessment capabilities. Although some of the answers may include executable code snippets, they are entangled in free text and are not easily extracted. Q&A websites are not designed for such direct code reuse. We present Example Overflow, a code search and recommendation tool which brings together social media and code recommendation systems. Example Overflow enables crowd-sourced software development by utilizing both textual and social information, which accompany source code on the Web. Its browsing mechanism minimizes the context switch associated with other code search tools. In this paper we describe the development of the tool, provide preliminary evaluation, and discuss its contribution to an example centric programming paradigm.

Combining Activity Metrics and Contribution Topics for Software Recommendations
Konstantinos Christidis, Fotis Paraskevopoulos, Dimitris Panagiotou, and Gregoris Mentzas
(National Technical University of Athens, Greece)
In this paper we outline work in progress for the development of a recommender system for open source software development communities that takes into account information from multiple sources. Specifically our approach combines latent semantics of contributed information artifacts with quantitative metrics that indicate developer activity.

Software Feature Model Recommendations Using Data Mining
Abdel Salam Sayyad, Hany Ammar, and Tim Menzies
(West Virginia University, USA)
Abstract—Feature Models are popular tools for describing software product lines. Analysis of feature models has traditionally focused on consistency checking (yielding a yes/no answer) and product selection assistance, interactive or offline. In this paper, we describe a novel approach to identify the most critical decisions in product selection/configuration by taking advantage of a large pool of randomly generated, generally inconsistent, product variants. Range Ranking, a data mining technique, is utilized to single out the most critical design choices, reducing the job of the human designer to making less consequential decisions. A large feature model is used as a case study; we show preliminary results of the new approach to illustrate its usefulness for practical product derivation.

Automated Assessment of Correctness of Recommendation Systems
Angela Lozano, Andy Kellens, and Kim MensORCID logo
(Université Catholique de Louvain, Belgium; Vrije Universiteit Brussel, Belgium)
Using a concrete example, this position paper makes a case for evaluating the correctness of software recommendation systems in an automated way, prior to conducting user studies, in order to assess the validity of the results and ideal configuration of the system to be evaluated.

A Comparison of Recommender Systems for Mashup Composition
Paolo Cremonesi, Matteo Picozzi, and Maristella Matera
(Politecnico di Milano, Italy)
Web mashups are a new generation of applications created by composing contents and functions available through Web services and APIs. A central activity in mashup develop- ment is the retrieval and selection of components to be included in the composition. The adoption of recommender systems can alleviate some of the difficulties arising in this activity. Based on the results of an empirical study, this paper tries to shed light on the application of recommender systems to the mashup composition domain, and discusses the performance of different recommendation systems when applied to a very large collection of mashups and mashup components.

Group Recommendation Algorithms for Requirements Prioritization
Alexander Felfernig and Gerald Ninaus
(TU Graz, Austria)
Group recommendation is successfully applied in different domains such as Interactive Television, Ambient Intelligence, and e-Tourism. The focus of this paper is to analyze the applicability of group recommendation to requirements prioritization. We provide an overview of relevant group recommendation heuristics and report the results of an empirical study which focused on the analysis of the prediction quality of these heuristics.

Recommending Mentors to Software Project Newcomers
Igor Steinmacher, Igor Scaliante Wiese, and Marco Aurélio Gerosa
(Federal University of Technology Paraná, Brazil; University of São Paulo, Brazil)
Open Source Software projects success depends on the continuous influx of newcomers and their contributions. Newcomers play an important role as they are the potential future developers, but they face difficulties and obstacles when initiating their interaction with a project, resulting in a high amount of withdrawals. This paper presents a recommendation system aiming to support newcomers finding the most appropriate project member to mentor them in a technical task. The proposed system uses temporal and social aspects of developer’s behavior, in addition to recent contextual information to recommend the most suitable mentor at the moment.

Optimizing a Search-Based Code Recommendation System
Naoya Murakami and Hidehiko Masuhara
(University of Tokyo, Japan)
Search-based code recommendation systems with a large-scale code repository can provide the programmers example code snippets that teach them not only names in application programming interface of libraries and frameworks, but also practical usages consisting of multiple steps. However, it is not easy to optimize such systems because usefulness of recommended code is indirect and hard to be measured. We propose a method that mechanically evaluates usefulness for our recommendation system called Selene. By using the proposed method, we adjusted several search and user-interface parameters in Selene for better recall factor, and also learned characteristics of those parameters.

Interaction Histories Mining for Software Change Guide
Takashi Kobayashi, Nozomu Kato, and Kiyoshi Agusa
(Nagoya University, Japan)
This paper presents a prediction model for change propagation based on the developers' interaction history. Since artifacts have internal and external dependencies, a change will cause some changes on related artifacts. In order to guide change operations in software development, our proposed method generates a change guide graph by mining developers' interaction histories which consist of write and read accesses to artifacts. Using a change guide graph, we can guide change using the context of previous changes. To evaluate proposed change guide method, we perform a case study with an open- source software. We show that the context information is effective for file level and method level change predictions.

Recommending Relevant Code Artifacts for Change Requests Using Multiple Predictors
Oliver Denninger
(FZI, Germany)
Finding code artifacts affected by a given change request is a time-consuming process in large software systems. Various approaches have been proposed to automate this activity, e.g., based on information retrieval. The performance of a particular prediction approach often highly depends on attributes like coding style or writing style of change request. Thus, we propose to use multiple prediction approaches in combination with machine learning. First experiments show that machine learning is well suitable to weight different prediction approaches for individual software projects and hence improve prediction performance.

Context-Aware Recommender Systems for Non-functional Requirements
Antonina Danylenko and Welf Löwe
(Linnaeus University, Sweden)
For large software projects, system designers have to adhere to a significant number of functional and non-functional requirements, which makes software development a complex engineering task. If these requirements change during the development process, complexity even increases. In this paper, we suggest recommendation systems based on context-aware composition to enable a system designer to postpone and automate decisions regarding efficiency non-functional requirements, such as performance, and focus on the design of the core functionality of the system instead.
Context-aware composition suggests the optimal component variants of a system for different static contexts (e.g., software and hardware environment) or even different dynamic contexts (e.g., actual parameters and resource utilization). Thus, an efficiency non-functional requirement can be automatically optimized statically or dynamically by providing possible component variants. Such a recommender system reduces time and effort spent on manually developing optimal applications that adapts to different (static or dynamic) contexts and even changes thereof.

Context-Based Recommendation to Support Problem Solving in Software Development
Joel Cordeiro, Bruno Antunes, and Paulo Gomes
(University of Coimbra, Portugal)
During the software development process, developers are often faced with problem solving situations. For instance, it is common the occurrence of exceptions, that originate stack traces in the Console View of the IDE. These situations motivate the developer to use the Web to search for information. However, there is a gap between the IDE and the Web, requiring developers to spend significant time searching for relevant information and navigating through web pages in a Web browser. We propose to process the information of exception stack traces and retrieve question-answering web resources to help developers. We developed a tool that integrates recommendation of question/answer web resources in Eclipse, according to the context of these exception stack traces. The results of a preliminary experimentation are promising, showing that our approach performs better than a simple keyword-based approach.

Automatically Detecting Architecturally-Relevant Code Anomalies
Roberta Arcoverde, Isela Macia, Alessandro Garcia ORCID logo, and Arndt von Staa
(PUC-Rio, Brazil)
Software architecture degradation is a long-standing problem in software engineering. Previous studies have shown that certain code anomalies - or patterns of code anomalies - are likely to be harmful to architecture design, although their identification is far from trivial. This study presents a system for not only detecting architecturally-relevant code anomalies, but also helping developers to prioritize their removal by ranking them. We detect code anomaly patterns based on static analysis that also exploit architecture information.

Extending Recommendation Systems with Software Maps
Jonas Trümper and Jürgen Döllner
(HPI, Germany)

proc time: 0.74