Marko Gasparic

What recommendation systems for software engineering recommend

RSSEs mainly output source code artifacts and experts, other types are less explored.RSSEs providing a comprehensive support for testing phase were not identified.RSSEs are very task specific, but not environment specific. A recommendation system for software engineering (RSSE) is a software application that provides information items estimated to be valuable for a software engineering task in a given context. Present the results of a systematic literature review to reveal the typical functionality offered by existing RSSEs, research gaps, and possible research directions. We evaluated 46 papers studying the benefits, the data requirements, the information and recommendation types, and the effort requirements of RSSE systems. We include papers describing tools that support source code related development published between 2003 and 2013. The results show that RSSEs typically visualize source code artifacts. They aim to improve system quality, make the development process more efficient and less expensive, lower developers cognitive load, and help developers to make better decisions. They mainly support reuse actions and debugging, implementation, and maintenance phases. The majority of the systems are reactive. Unexploited opportunities lie in the development of recommender systems outside the source code domain. Furthermore, current RSSE systems use very limited context information and rely on simple models. Context-adapted and proactive behavior could improve the acceptance of RSSE systems in practice.

A context model for IDE-based recommendation systems

We introduce a new context model that can characterize many aspects of IDE usage.The model may improve the accuracy and timing of recommendations produced by RSSEs.All included factors statistically correlate with the usage of different commands. Context, as modeled through variables called contextual factors, can improve human-computer interaction. To date, in applications supporting software development, such as integrated development environments (IDEs) and recommendation systems for software engineering (RSSEs), contextual factors have generally been constrained to project artifacts, such as source code. In this paper, we present a context model that includes thirteen contextual factors, which capture various situations in which developers interact with an IDE. This context model can be used to support and enhance user interaction with an IDE or to improve the accuracy and timing of recommendations produced by RSSEs.To assess whether the proposed contextual factors are informative for a context model, we statistically evaluated the correlations between IDE command usage and different situations, as they are described by the factors. If a contextual factor correlates with the usage of a command this means that the user is using the command differently when the values of the contextual factor change. We discovered that different factors correlate with different commands and that all the factors correlate with some commands, hence, when a context change is detected, we can also expect a change in the interaction with an IDE.

GUI Design for IDE Command Recommendations

This paper describes a novel design of a graphical user interface (GUI) to recommend useful command within an integrated development environment. The recommendation GUI contains a description of the suggested command, an explanation why the command is recommended, and a command usage example. The proposed design is based on the analysis of relevant guidelines identified in the literature. Its perceived usability and acceptance were evaluated in a live user study with 36 software developers. Our findings, partially contradicting existing literature, indicate that the presentation of the command-the description and the example-is perceived as more useful than the explanation of the rationale for the recommendation.

A graphical user interface for presenting integrated development environment command recommendations: Design, evaluation, and implementation

Abstract Context A set of algorithms exist to generate integrated development environment (IDE) command recommendations. The recommendations are aimed at improving software developer’s interaction with an IDE. Even though the interface is a critical element of every recommender system, we are not aware of any existing graphical user interface to present such recommendations. Objective This paper describes and evaluates a novel design of a graphical user interface to recommend commands within an IDE. The interface contains a description of the suggested command, an explanation of why the command is recommended, and a command usage example. Method The proposed design is based on the analysis of guidelines identified in the literature. Its acceptance and usability were evaluated through a user study with 36 software developers and semi-structured interviews with 11 software developers. Results The results indicate that the suggested interface is well accepted, but it can be further improved. Through the interviews and the implementation of the interface, we identified a series of requirements important for the development of future IDE command recommender systems. Conclusions This paper shows that a convenient graphical user interface is critical to achieve high acceptance of IDE command recommendations. Our work also illustrates steps useful for undertaking user studies related to IDE command recommendations in a practical setting without human intervention. A future step is to evaluate the interface within the business environment, where recommendations are generated and presented in an IDE used by practicing software developers as part of their normal workday.

Modeling context-aware command recommendation and acceptance in an IDE

For software developers to use the full range of available commands in an integrated development environment, one has to provide proactive support which can suggest unknown commands that could be useful for the task at hand. Researchers started exploring the potential of recommender systems to provide this type of help, but so far there are still very few contributions. We propose a new multi-criteria context-aware rating prediction model that can be used to predict the user choice of either to accept or reject an IDE command recommendation. Individual command recommendation evaluation criteria are: performance expectancy, effort expectancy, and social influence, besides, the overall evaluation/rating is the intention to use a command. We have identified four types of contexts, namely, current practice, environment, interaction, and recommendation presentation context. The model is aimed at improving recommendation quality and enabling more effective recommendation presentations.

How software developers use work breakdown relationships in issue repositories

Software developers use issues as a means to describe a range of activities to be undertaken on a software system, including features to be added and defects that require fixing. When creating issues, software developers expend manual effort to specify relationships between issues, such as one issue blocking another or one issue being a sub-task of another. In particular, developers use a variety of relationships to express how work is to be broken down on a project. To better understand how software developers use work breakdown relationships between issues, we manually coded a sample of work breakdown relationships from three open source systems. We report on our findings and describe how the recognition of work breakdown relationships opens up new ways to improve software development techniques.

An Analysis of a Project Reuse Approach in an Industrial Setting

We performed an industrial exploratory case study to analyze the software reuse process of a medium size company which is a technology leader in a niche market. Two unstructured interviews and code duplication analyses of four SVN dumps report about a development practice that resulted in more efficient maintenance, due to archiving complete versions of every shipped software, and more efficient development, due to duplication and modification of the most similar program, instead of implementing a new program from scratch.

Context-Based IDE Command Recommender System

Software developers working process could benefit from the support of an active help system that is able to recommend applicable and useful integrated development environment (IDE) commands. While previous work focused on prediction methods that can identify what developers will eventually discover autonomously, and without taking into account the characteristics of their working tasks, we want to build a system that recommends only commands that lead to better work performance. Since we cannot expect that developers are willing to invest a significant effort to use our recommender system (RS), we are developing a context-aware multi-criteria RS based on implicit feedback. We already created and evaluated context and user models. We also acquired a data set with more than 100,000 command executions. Currently, we are developing RS algorithm for predicting the scores of performance and effort expectancy and developers intention to use a specific command. We are also developing a user interface, that has to be persuasive, effective, and efficient. To date, a user interface for IDE command RS has not been developed.