% ======================== 2016 =========================================== @inproceedings{ key = {101}, author = {Ivan Candela and Gabriele Bavota and Barbara Russo and Rocco Oliveto}, title = {Using cohesion and coupling for software remodularization: is it enough?}, booktitle = {Transactions on Software Engineering and Mehodology.}, publisher = {ACM Press.}, year = {2016}, note = {[To appear]}, abstract = {Refactoring, and in particular, remodularization operations can be performed to repair the design of a software system and remove the erosion caused by software evolution. Various approaches have been proposed to support developers during the remodularization of a software system. Most of these approaches are based on the underlying assumption that developers pursue an optimal balance between quality metrics—such as cohesion and coupling—when modularizing the classes of their systems. Thus, a remodularization recommender proposes a solution that implicitly provides a (near) optimal balance between such quality metrics. However, there is still a lack of empirical evidence that such a balance is the desideratum by developers. This paper aims at bridging this gap by analyzing both objectively and subjectively the aforementioned phenomenon. Specifically, we present the results of (i) a large study analyzing the modularization quality, in terms of package cohesion and coupling, of 100 open source systems, and (ii) a survey conducted with 34 developers aimed at understanding the driving factors they consider when performing modularization tasks. The results achieved have been used to distill a set of lessons learned that might be considered to design more effective remodularization recommenders. } } @inproceedings{ key = {100}, author = {Luca Ponzanelli and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Michele Lanza}, title = {Turning the IDE into a self-confident programming assistant}, booktitle = {Empirical Software Engineering Journal.}, publisher = {Springer Press.}, year = {2016}, note = {[To appear]}, abstract = {Developers often require knowledge beyond the one they possess, which boils down to asking co-workers for help or consulting additional sources of information, such as Application Programming Interfaces (API) documentation, forums, and Q&A websites. However, it requires time and energy to formulate one's problem, peruse and process the results. We propose a novel approach that, given a context in the Integrated Development Environment (IDE), automatically retrieves pertinent discussions from StackOverflow, evaluates their relevance using a multi-faceted ranking model, and, if a given confidence threshold is surpassed, notifies the developer. We have implemented our approach in Prompter, an Eclipse plug-in. Prompter was evaluated in two empirical studies. The first study was aimed at evaluating Prompter's ranking model and involved 33 participants. The second study was conducted with 12 participants and aimed at evaluating Prompter's usefulness when supporting developers during development and maintenance tasks. Since Prompter uses "volatile information" crawled from the web, we also replicated Study I after one year to assess the impact of such a "volatility" on recommenders like Prompter. Our results indicate that (i) Prompter recommendations were positively evaluated in 74% of the cases on average, (ii) Prompter significantly helps developers to improve the correctness of their tasks by 24% on average, but also (iii) 78% of the provided recommendations are ``volatile" and can change at one year of distance. While Prompter revealed to be effective, our studies also point out issues when building recommenders based on information available on online forums. } } @inproceedings{DBLP:conf/issta/PalombaPZOL16, key = {99}, author = {Fabio Palomba and Annibale Panichella and Andy Zaidman and Rocco Oliveto and Andrea De Lucia}, title = {Automatic test case generation: what if test code quality matters?}, booktitle = {Proceedings of the 25th International Symposium on Software Testing and Analysis, {ISSTA} 2016, Saarbr{\"{u}}cken, Germany, July 18-20, 2016}, pages = {130--141}, year = {2016}, crossref = {DBLP:conf/issta/2016}, url = {http://doi.acm.org/10.1145/2931037.2931057}, doi = {10.1145/2931037.2931057}, timestamp = {Thu, 14 Jul 2016 15:39:00 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/issta/PalombaPZOL16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Test case generation tools that optimize code coverage have been extensively investigated. Recently, researchers have suggested to add other non-coverage criteria, such as memory consumption or readability, to increase the practical usefulness of generated tests. In this paper, we observe that test code quality metrics, and test cohesion and coupling in particular, are valuable candidates as additional criteria. Indeed, tests with low cohesion and/or high coupling have been shown to have a negative impact on future maintenance activities. In an exploratory investigation we show that most generated tests are indeed affected by poor test code quality. For this reason, we incorporate cohesion and coupling metrics into the main loop of search-based algorithm for test case generation. Through an empirical study we show that our approach is not only able to generate tests that are more cohesive and less coupled, but can (i) increase branch coverage up to 10% when enough time is given to the search and (ii) result in statistically shorter tests.} } @inproceedings{DBLP:conf/iwpc/ScalabrinoVPO16, key = {98}, author = {Simone Scalabrino and Mario Linares V{\'{a}}squez and Denys Poshyvanyk and Rocco Oliveto}, title = {Improving code readability models with textual features}, booktitle = {24th {IEEE} International Conference on Program Comprehension, {ICPC} 2016, Austin, TX, USA, May 16-17, 2016}, pages = {1--10}, year = {2016}, crossref = {DBLP:conf/iwpc/2016}, url = {http://dx.doi.org/10.1109/ICPC.2016.7503707}, doi = {10.1109/ICPC.2016.7503707}, timestamp = {Thu, 21 Jul 2016 14:57:20 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/iwpc/ScalabrinoVPO16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Code reading is one of the most frequent activities in software maintenance; before implementing changes, it is necessary to fully understand source code often written by other developers. Thus, readability is a crucial aspect of source code that might significantly influence program comprehension effort. In general, models used to estimate software readability take into account only structural aspects of source code, e.g., line length and a number of comments. However, code is a particular form of text; therefore, a code readability model should not ignore the textual aspects of source code encapsulated in identifiers and comments. In this paper, we propose a set of textual features that could be used to measure code readability. We evaluated the proposed textual features on 600 code snippets manually evaluated (in terms of readability) by 5K+ people. The results show that the proposed features complement classic structural features when predicting readability judgments. Consequently, a code readability model based on a richer set of features, including the ones proposed in this paper, achieves a significantly better accuracy as compared to all the state-of-the-art readability models.} } @inproceedings{DBLP:conf/iwpc/PalombaPLOZ16, key = {97}, author = {Fabio Palomba and Annibale Panichella and Andrea De Lucia and Rocco Oliveto and Andy Zaidman}, title = {A textual-based technique for Smell Detection}, booktitle = {24th {IEEE} International Conference on Program Comprehension, {ICPC} 2016, Austin, TX, USA, May 16-17, 2016}, pages = {1--10}, year = {2016}, crossref = {DBLP:conf/iwpc/2016}, url = {http://dx.doi.org/10.1109/ICPC.2016.7503704}, doi = {10.1109/ICPC.2016.7503704}, timestamp = {Thu, 21 Jul 2016 14:57:20 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/iwpc/PalombaPLOZ16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {In this paper, we present TACO (Textual Analysis for Code Smell Detection), a technique that exploits textual analysis to detect a family of smells of different nature and different levels of granularity. We run TACO on 10 open source projects, comparing its performance with existing smell detectors purely based on structural information extracted from code components. The analysis of the results indicates that TACO’s precision ranges between 67% and 77%, while its recall ranges between 72% and 84%. Also, TACO often outperforms alternative structural approaches confirming, once again, the usefulness of information that can be derived from the textual part of code components.} } @inproceedings{DBLP:conf/icse/PalombaNPOL16, key = {96}, author = {Fabio Palomba and Dario Di Nucci and Annibale Panichella and Rocco Oliveto and Andrea De Lucia}, title = {On the diffusion of test smells in automatically generated test code: an empirical study}, booktitle = {Proceedings of the 9th International Workshop on Search-Based Software Testing, SBST@ICSE 2016, Austin, Texas, USA, May 14-22, 2016}, pages = {5--14}, year = {2016}, crossref = {DBLP:conf/icse/2016sbst}, url = {http://doi.acm.org/10.1145/2897010.2897016}, doi = {10.1145/2897010.2897016}, timestamp = {Wed, 20 Jul 2016 09:47:06 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/PalombaNPOL16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The role of software testing in the software development process is widely recognized as a key activity for successful projects. This is the reason why in the last decade several automatic unit test generation tools have been proposed, focusing particularly on high code coverage. Despite the effort spent by the research community, there is still a lack of empirical investigation aimed at analyzing the characteristics of the produced test code. Indeed, while some studies inspected the effectiveness and the usability of these tools in practice, it is still unknown whether test code is maintainable. In this paper, we conducted a large scale empirical study in order to analyze the diffusion of bad design solutions, namely test smells, in automatically generated unit test classes. Results of the study show the high diffusion of test smells as well as the frequent co-occurrence of different types of design problems. Finally we found that all test smells have strong positive correlation with structural characteristics of the systems such as size or number of classes.} } @inproceedings{DBLP:conf/icse/PonzanelliBMPOH16, key = {95}, author = {Luca Ponzanelli and Gabriele Bavota and Andrea Mocci and Massimiliano Di Penta and Rocco Oliveto and Mir Anamul Hasan and Barbara Russo and Sonia Haiduc and Michele Lanza}, title = {Too long; didn't watch!: extracting relevant fragments from software development video tutorials}, booktitle = {Proceedings of the 38th International Conference on Software Engineering, {ICSE} 2016, Austin, TX, USA, May 14-22, 2016}, pages = {261--272}, year = {2016}, crossref = {DBLP:conf/icse/2016}, url = {http://doi.acm.org/10.1145/2884781.2884824}, doi = {10.1145/2884781.2884824}, timestamp = {Mon, 16 May 2016 10:25:36 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/PonzanelliBMPOH16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {When facing difficulties solving a task at hand, and knowledgeable colleagues are not available, developers resort to offline and online resources, e.g. official documentation, third-party tutorials, mailing lists, and Q&A websites. These, however, need to be found, read, and understood, which takes its toll in terms of time and mental energy. A more immediate and accessible resource are video tutorials found on the web, which in recent years have seen a steep increase in popularity. Nonetheless, videos are an intrinsically noisy data source, and finding the right piece of information might be even more cumbersome than using the previously mentioned resources. We present CodeTube, an approach which mines video tutorials found on the web, and enables developers to query their contents. The video tutorials are processed and split into coherent fragments, to return only fragments related to the query. As an added benefit, the relevant video fragments are complemented with information from additional sources, such as Stack Overflow discussions. The results of two studies to assess CodeTube indicate that video tutorials - if appropriately processed - represent a useful, yet still under-utilized source of information for software development.} } @inproceedings{DBLP:conf/icse/VillarroelBROP16, key = {94}, author = {Lorenzo Villarroel and Gabriele Bavota and Barbara Russo and Rocco Oliveto and Massimiliano Di Penta}, title = {Release planning of mobile apps based on user reviews}, booktitle = {Proceedings of the 38th International Conference on Software Engineering, {ICSE} 2016, Austin, TX, USA, May 14-22, 2016}, pages = {14--24}, year = {2016}, crossref = {DBLP:conf/icse/2016}, url = {http://doi.acm.org/10.1145/2884781.2884818}, doi = {10.1145/2884781.2884818}, timestamp = {Sun, 15 May 2016 11:55:22 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/VillarroelBROP16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Developers have to to constantly improve their apps by fixing critical bugs and implementing the most desired features in order to gain shares in the continuously increasing and competitive market of mobile apps. A precious source of information to plan such activities is represented by reviews left by users on the app store. However, in order to exploit such information developers need to manually analyze such reviews. This is something not doable if, as frequently happens, the app receives hundreds of reviews per day. In this paper we introduce CLAP (Crowd Listener for releAse Planning), a thorough solution to (i) categorize user reviews based on the information they carry out (e.g., bug reporting), (ii) cluster together related reviews (e.g., all reviews reporting the same bug), and (iii) automatically prioritize the clusters of reviews to be implemented when planning the subsequent app release. We evaluated all the steps behind CLAP, showing its high accuracy in categorizing and clustering reviews and the meaningfulness of the recommended prioritizations. Also, given the availability of CLAP as a working tool, we assessed its practical applicability in industrial environments.} } @inproceedings{DBLP:conf/icse/PonzanelliBMPOR16, key = {93}, author = {Luca Ponzanelli and Gabriele Bavota and Andrea Mocci and Massimiliano Di Penta and Rocco Oliveto and Barbara Russo and Sonia Haiduc and Michele Lanza}, title = {CodeTube: extracting relevant fragments from software development video tutorials}, booktitle = {Proceedings of the 38th International Conference on Software Engineering, {ICSE} 2016, Austin, TX, USA, May 14-22, 2016 - Companion Volume}, pages = {645--648}, year = {2016}, crossref = {DBLP:conf/icse/2016c}, url = {http://doi.acm.org/10.1145/2889160.2889172}, doi = {10.1145/2889160.2889172}, timestamp = {Sun, 15 May 2016 12:23:10 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/PonzanelliBMPOR16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Nowadays developers heavily rely on sources of informal documentation, including Q&A forums, slides, or video tutorials, the latter being particularly useful to provide introductory notions for a piece of technology. The current practice is that developers have to browse sources individually, which in the case of video tutorials is cumbersome, as they are lengthy and cannot be searched based on their contents. We present CodeTube, a Web-based recommender system that analyzes the contents of video tutorials and is able to provide, given a query, cohesive and self-contained video fragments, along with links to relevant Stack Overflow discussions. CodeTube relies on a combination of textual analysis and image processing applied on video tutorial frames and speech transcripts to split videos into cohesive fragments, index them and identify related Stack Overflow discussions.} } @inproceedings{DBLP:conf/kbse/TufanoPBPOLP16, key = {92}, author = {Michele Tufano and Fabio Palomba and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Andrea De Lucia and Denys Poshyvanyk}, title = {An empirical investigation into the nature of test smells}, booktitle = {Proceedings of the 31st {IEEE/ACM} International Conference on Automated Software Engineering, {ASE} 2016, Singapore, September 3-7, 2016}, pages = {4--15}, year = {2016}, crossref = {DBLP:conf/kbse/2016}, url = {http://doi.acm.org/10.1145/2970276.2970340}, doi = {10.1145/2970276.2970340}, timestamp = {Mon, 29 Aug 2016 15:09:35 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/kbse/TufanoPBPOLP16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Test smells have been defined as poorly designed tests and, as reported by recent empirical studies, their presence may negatively affect comprehension and maintenance of test suites. Despite this, there are no available automated tools to support identification and repair of test smells. In this paper, we firstly investigate developers' perception of test smells in a study with 19 participants. The results show that developers generally do not recognize (potentially harmful) test smells, highlighting that automated tools for identifying such smells are much needed. However, to build effective tools, deeper insights into the test smells phenomenon are required. To this aim, we conducted a large-scale empirical investigation aimed at analyzing (i) when test smells occur in source code, (ii) what their survivability is, and (iii) whether their presence is associated with the presence of design problems in production code (code smells). The results indicate that test smells are usually introduced when the corresponding test code is committed in the repository for the first time, and they tend to remain in a system for a long time. Moreover, we found various unexpected relationships between test and code smells. Finally, we show how the results of this study can be used to build effective automated tools for test smell detection and refactoring.} } @inproceedings{DBLP:conf/ssbse/ScalabrinoGNOL16, key = {91}, author = {Simone Scalabrino and Giovanni Grano and Dario Di Nucci and Rocco Oliveto and Andrea De Lucia}, title = {Search-Based Testing of Procedural Programs: Iterative Single-Target or Multi-target Approach?}, booktitle = {Search Based Software Engineering - 8th International Symposium, {SSBSE} 2016, Raleigh, NC, USA, October 8-10, 2016, Proceedings}, pages = {64--79}, year = {2016}, crossref = {DBLP:conf/ssbse/2016}, url = {http://dx.doi.org/10.1007/978-3-319-47106-8_5}, doi = {10.1007/978-3-319-47106-8_5}, timestamp = {Mon, 26 Sep 2016 12:54:39 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/ssbse/ScalabrinoGNOL16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {In the context of testing of Object-Oriented (OO) software systems, researchers have recently proposed search based approaches to automatically generate whole test suites by considering simultaneously all targets (e.g., branches) defined by the coverage criterion (multi-target approach). The goal of whole suite approaches is to overcome the problem of wasting search budget that iterative single-target approaches (which iteratively generate test cases for each target) can encounter in case of infeasible targets. However, whole suite approaches have not been implemented and experimented in the context of procedural programs. In this paper we present OCELOT (Optimal Coverage sEarch-based tooL for sOftware Testing), a test data generation tool for C programs which implements both a state-of-the-art whole suite approach and an iterative single-target approach designed for a parsimonious use of the search budget. We also present an empirical study conducted on 35 open-source C programs to compare the two approaches implemented in OCELOT. The results indicate that the iterative single-target approach provides a higher efficiency while achieving the same or an even higher level of coverage than the whole suite approach.} } @inproceedings{DBLP:conf/wcre/PanichellaDOPPL16, key = {90}, author = {Annibale Panichella and Bogdan Dit and Rocco Oliveto and Massimiliano Di Penta and Denys Poshyvanyk and Andrea De Lucia}, title = {Parameterizing and Assembling IR-Based Solutions for {SE} Tasks Using Genetic Algorithms}, booktitle = {{IEEE} 23rd International Conference on Software Analysis, Evolution, and Reengineering, {SANER} 2016, Suita, Osaka, Japan, March 14-18, 2016}, pages = {314--325}, year = {2016}, crossref = {DBLP:conf/wcre/2016}, url = {http://dx.doi.org/10.1109/SANER.2016.97}, doi = {10.1109/SANER.2016.97}, timestamp = {Fri, 17 Jun 2016 12:44:36 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/wcre/PanichellaDOPPL16}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Information Retrieval (IR) approaches are nowadays used to support various software engineering tasks, such as feature location, traceability link recovery, clone detection, or refactoring. However, previous studies showed that inadequate instantiation of an IR technique and underlying process could significantly affect the performance of such approaches in terms of precision and recall. This paper proposes the use of Genetic Algorithms (GAs) to automatically configure and assemble an IR process for software engineering tasks. The approach (named GA-IR) determines the (near) optimal solution to be used for each stage of the IR process, i.e., term extraction, stop word removal, stemming, indexing and an IR algebraic method calibration. We applied GA-IR on two different software engineering tasks, namely traceability link recovery and identification of duplicate bug reports. The results of the study indicate that GA-IR outperforms approaches previously published in the literature, and that it does not significantly differ from an ideal upper bound that could be achieved by a supervised and combinatorial approach.} } @inproceedings{ key = {89}, author = {Fiammetta Marulli and Remo Pareschi and Daniele Baldacci}, title = {The Internet of Speaking Things and Its Applications to Cultural Heritage}, booktitle = {International Conference on Internet of Things and Big Data, Rome, April 2016}, year = {2016}, crossref = {DBLP:conf/wcre/2016}, url = {http://dx.doi.org/10.5220/0005877701070117}, doi = {10.5220/0005877701070117}, abstract = {The initial driver for the development of an Internet of Things (IoT) was to provide an infrastructure capable of turning anything into a sensor that acquires and pours data into the cloud, where they can be aggregated with other data and analysed to extract decision-supportive information. The validity of this initial motivation still stands. However, going in the opposite direction is at least as useful and exciting, by exploiting Internet to make things communicate and speak, thus complementing their capability to sense and listen. In this work we present applications of IoT aimed to support the Cultural Heritage environments, but also suitable for Tourism and Smart Urban environments, that advance the available user-experience based on smart devices via the interaction with speaking things. In the first place we describe a system architecture for speaking things, comprehensive of the basic communication protocols for carrying information to the user as well as of higher-level functionalities for content generation and dialogue management. We then show how this architecture is applied to make artworks speak to people. Finally, we introduce speaking holograms as a yet more advanced and interactive application.} } % ======================== 2015 =========================================== @article{DBLP:journals/ac/PalombaLBO15, key = {88}, author = {Fabio Palomba and Andrea De Lucia and Gabriele Bavota and Rocco Oliveto}, title = {Anti-Pattern Detection: Methods, Challenges, and Open Issues}, journal = {Advances in Computers}, volume = {95}, pages = {201--238}, year = {2015}, url = {http://dx.doi.org/10.1016/B978-0-12-800160-8.00004-8}, doi = {10.1016/B978-0-12-800160-8.00004-8}, timestamp = {Tue, 30 Sep 2014 09:22:25 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/ac/PalombaLBO15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Anti-patterns are poor solutions to recurring design problems. They occur in object-oriented systems when developers unwillingly introduce them while designing and implementing the classes of their systems. Several empirical studies have highlighted that anti-patterns have a negative impact on the comprehension and maintainability of a software systems. Consequently, their identification has received recently more attention from both researchers and practitioners who have proposed various approaches to detect them. This chapter discusses on the approaches proposed in the literature. In addition, from the analysis of the state-of-the-art, we will (i) derive a set of guidelines for building and evaluating recommendation systems supporting the detection of anti-patterns; and (ii) discuss some problems that are still open, to trace future research directions in the field. For this reason, the chapter provides a support to both researchers, who are interested in comprehending the results achieved so far in the identification of anti-patterns, and practitioner, who are interested in adopting a tool to identify anti-patterns in their software systems.} } @article{DBLP:journals/ese/BavotaQOLB15, key = {87}, author = {Gabriele Bavota and Abdallah Qusef and Rocco Oliveto and Andrea De Lucia and Dave Binkley}, title = {Are test smells really harmful? An empirical study}, journal = {Empirical Software Engineering}, volume = {20}, number = {4}, pages = {1052--1094}, year = {2015}, url = {http://dx.doi.org/10.1007/s10664-014-9313-0}, doi = {10.1007/s10664-014-9313-0}, timestamp = {Mon, 08 Jun 2015 14:37:26 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/ese/BavotaQOLB15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Bad code smells have been defined as indicators of potential problems in source code. Techniques to identify and mitigate bad code smells have been proposed and studied. Recently bad test code smells (test smells for short) have been put forward as a kind of bad code smell specific to tests such a unit tests. What has been missing is empirical investigation into the prevalence and impact of bad test code smells. Two studies aimed at providing this missing empirical data are presented. The first study finds that there is a high diffusion of test smells in both open source and industrial software systems with 86 % of JUnit tests exhibiting at least one test smell and six tests having six distinct test smells. The second study provides evidence that test smells have a strong negative impact on program comprehension and maintenance. Highlights from this second study include the finding that comprehension is 30 % better in the absence of test smells.} } @article{DBLP:journals/ese/BavotaCPOP15, key = {86}, author = {Gabriele Bavota and Gerardo Canfora and Massimiliano Di Penta and Rocco Oliveto and Sebastiano Panichella}, title = {How the Apache community upgrades dependencies: an evolutionary study}, journal = {Empirical Software Engineering}, volume = {20}, number = {5}, pages = {1275--1317}, year = {2015}, url = {http://dx.doi.org/10.1007/s10664-014-9325-9}, doi = {10.1007/s10664-014-9325-9}, timestamp = {Thu, 03 Sep 2015 10:46:11 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/ese/BavotaCPOP15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Software ecosystems consist of multiple software projects, often interrelated by means of dependency relations. When one project undergoes changes, other projects may decide to upgrade their dependency. For example, a project could use a new version of a component from another project because the latter has been enhanced or subject to some bug-fixing activities. In this paper we study the evolution of dependencies between projects in the Java subset of the Apache ecosystem, consisting of 147 projects, for a period of 14 years, resulting in 1,964 releases. Specifically, we investigate (i) how dependencies between projects evolve over time when the ecosystem grows, (ii) what are the product and process factors that can likely trigger dependency upgrades, (iii) how developers discuss the needs and risks of such upgrades, and (iv) what is the likely impact of upgrades on client projects. The study results—qualitatively confirmed by observations made by analyzing the developers’ discussion—indicate that when a new release of a project is issued, it triggers an upgrade when the new release includes major changes (e.g., new features/services) as well as large amount of bug fixes. Instead, developers are reluctant to perform an upgrade when some APIs are removed. The impact of upgrades is generally low, unless it is related to frameworks/libraries used in crosscutting concerns. Results of this study can support the understanding of the of library/component upgrade phenomenon, and provide the basis for a new family of recommenders aimed at supporting developers in the complex (and risky) activity of managing library/component upgrade within their software projects.} } @article{DBLP:journals/jss/BavotaLPOP15, key = {85}, author = {Gabriele Bavota and Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Fabio Palomba}, title = {An experimental investigation on the innate relationship between quality and refactoring}, journal = {Journal of Systems and Software}, volume = {107}, pages = {1--14}, year = {2015}, url = {http://dx.doi.org/10.1016/j.jss.2015.05.024}, doi = {10.1016/j.jss.2015.05.024}, timestamp = {Mon, 13 Jul 2015 11:00:52 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/jss/BavotaLPOP15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Previous studies have investigated the reasons behind refactoring operations performed by developers, and proposed methods and tools to recommend refactorings based on quality metric profiles, or on the presence of poor design and implementation choices, i.e., code smells. Nevertheless, the existing literature lacks observations about the relations between metrics/code smells and refactoring activities performed by developers. In other words, the characteristics of code components increasing/decreasing their chances of being object of refactoring operations are still unknown. This paper aims at bridging this gap. Specifically, we mined the evolution history of three Java open source projects to investigate whether refactoring activities occur on code components for which certain indicators—such as quality metrics or the presence of smells as detected by tools—suggest there might be need for refactoring operations. Results indicate that, more often than not, quality metrics do not show a clear relationship with refactoring. In other words, refactoring operations are generally focused on code components for which quality metrics do not suggest there might be need for refactoring operations. Finally, 42% of refactoring operations are performed on code entities affected by code smells. However, only 7% of the performed operations actually remove the code smells from the affected class.}, } @article{DBLP:journals/sosym/BavotaGOLTGC15, key = {84}, author = {Gabriele Bavota and Carmine Gravino and Rocco Oliveto and Andrea De Lucia and Genoveffa Tortora and Marcela Genero and Jos{\'{e}} A. Cruz{-}Lemus}, title = {A fine-grained analysis of the support provided by {UML} class diagrams and {ER} diagrams during data model maintenance}, journal = {Software and System Modeling}, volume = {14}, number = {1}, pages = {287--306}, year = {2015}, url = {http://dx.doi.org/10.1007/s10270-012-0312-6}, doi = {10.1007/s10270-012-0312-6}, timestamp = {Mon, 02 Feb 2015 14:55:42 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/sosym/BavotaGOLTGC15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {This paper presents the results of an empirical study aiming at comparing the support provided by ER and UML class diagrams during maintenance of data models. We performed one controlled experiment and two replications that focused on comprehension activities (the first activity in the maintenance process) and another controlled experiment on modification activities related to the implementation of given change requests. The results achieved were analyzed at a fine-grained level aiming at comparing the support given by each single building block of the two notations. Such an analysis is used to identify weaknesses (i.e., building blocks not easy to comprehend) in a notation and/or can justify the need of preferring ER or UML for data modeling. The analysis revealed that the UML class diagrams generally provided a better support for both comprehension and modification activities performed on data models as compared to ER diagrams. Nevertheless, the former has some weaknesses related to three building blocks, i.e., multi-value attribute, composite attribute, and weak entity. These findings suggest that an extension of UML class diagrams should be considered to overcome these weaknesses and improve the support provided by UML class diagrams during maintenance of data models.} } @article{DBLP:journals/stvr/CanforaLPOPP15, key = {83}, author = {Gerardo Canfora and Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Annibale Panichella and Sebastiano Panichella}, title = {Defect prediction as a multiobjective optimization problem}, journal = {Softw. Test., Verif. Reliab.}, volume = {25}, number = {4}, pages = {426--459}, year = {2015}, url = {http://dx.doi.org/10.1002/stvr.1570}, doi = {10.1002/stvr.1570}, timestamp = {Fri, 15 May 2015 08:15:11 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/stvr/CanforaLPOPP15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {In this paper, we formalize the defect-prediction problem as a multiobjective optimization problem. Specifically, we propose an approach, coined as multiobjective defect predictor (MODEP), based on multiobjective forms of machine learning techniques—logistic regression and decision trees specifically—trained using a genetic algorithm. The multiobjective approach allows software engineers to choose predictors achieving a specific compromise between the number of likely defect-prone classes or the number of defects that the analysis would likely discover (effectiveness), and lines of code to be analysed/tested (which can be considered as a proxy of the cost of code inspection). Results of an empirical evaluation on 10 datasets from the PROMISE repository indicate the quantitative superiority of MODEP with respect to single-objective predictors, and with respect to trivial baseline ranking classes by size in ascending or descending order. Also, MODEP outperforms an alternative approach for cross-project prediction, based on local prediction upon clusters of similar classes.} } @article{DBLP:journals/tse/PanichellaOPL15, key = {82}, author = {Annibale Panichella and Rocco Oliveto and Massimiliano Di Penta and Andrea De Lucia}, title = {Improving Multi-Objective Test Case Selection by Injecting Diversity in Genetic Algorithms}, journal = {{IEEE} Trans. Software Eng.}, volume = {41}, number = {4}, pages = {358--383}, year = {2015}, url = {http://dx.doi.org/10.1109/TSE.2014.2364175}, doi = {10.1109/TSE.2014.2364175}, timestamp = {Thu, 10 Dec 2015 11:33:13 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/tse/PanichellaOPL15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {A way to reduce the cost of regression testing consists of selecting or prioritizing subsets of test cases from a test suite according to some criteria. Besides greedy algorithms, cost cognizant additional greedy algorithms, multi-objective optimization algorithms, and multi-objective genetic algorithms (MOGAs), have also been proposed to tackle this problem. However, previous studies have shown that there is no clear winner between greedy and MOGAs, and that their combination does not necessarily produce better results. In this paper we show that the optimality of MOGAs can be significantly improved by diversifying the solutions (sub-sets of the test suite) generated during the search process. Specifically, we introduce a new MOGA, coined as DIversity based Genetic Algorithm (DIV-GA), based on the mechanisms of orthogonal design and orthogonal evolution that increase diversity by injecting new orthogonal individuals during the search process. Results of an empirical study conducted on eleven programs show that DIV-GA outperforms both greedy algorithms and the traditional MOGAs from the optimality point of view. Moreover, the solutions (sub-sets of the test suite) provided by DIV-GA are able to detect more faults than the other algorithms, while keeping the same test execution cost.} } @article{DBLP:journals/tse/BavotaVBPOP15, key = {81}, author = {Gabriele Bavota and Mario Linares V{\'{a}}squez and Carlos Eduardo Bernal{-}C{\'{a}}rdenas and Massimiliano Di Penta and Rocco Oliveto and Denys Poshyvanyk}, title = {The Impact of {API} Change- and Fault-Proneness on the User Ratings of Android Apps}, journal = {{IEEE} Trans. Software Eng.}, volume = {41}, number = {4}, pages = {384--407}, year = {2015}, url = {http://dx.doi.org/10.1109/TSE.2014.2367027}, doi = {10.1109/TSE.2014.2367027}, timestamp = {Thu, 10 Dec 2015 11:33:17 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/tse/BavotaVBPOP15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The mobile apps market is one of the fastest growing areas in the information technology. In digging their market share, developers must pay attention to building robust and reliable apps. In fact, users easily get frustrated by repeated failures, crashes, and other bugs; hence, they abandon some apps in favor of their competition. In this paper we investigate how the fault- and change-proneness of APIs used by Android apps relates to their success estimated as the average rating provided by the users to those apps. First, in a study conducted on 5,848 (free) apps, we analyzed how the ratings that an app had received correlated with the fault- and change-proneness of the APIs such app relied upon. After that, we surveyed 45 professional Android developers to assess (i) to what extent developers experienced problems when using APIs, and (ii) how much they felt these problems could be the cause for unfavorable user ratings. The results of our studies indicate that apps having high user ratings use APIs that are less fault- and change-prone than the APIs used by low rated apps. Also, most of the interviewed Android developers observed, in their development experience, a direct relationship between problems experienced with the adopted APIs and the users' ratings that their apps received.} } @article{DBLP:journals/tse/PalombaBPOPL15, key = {80}, author = {Fabio Palomba and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Denys Poshyvanyk and Andrea De Lucia}, title = {Mining Version Histories for Detecting Code Smells}, journal = {{IEEE} Trans. Software Eng.}, volume = {41}, number = {5}, pages = {462--489}, year = {2015}, url = {http://dx.doi.org/10.1109/TSE.2014.2372760}, doi = {10.1109/TSE.2014.2372760}, timestamp = {Thu, 10 Dec 2015 11:33:01 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/tse/PalombaBPOPL15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Code smells are symptoms of poor design and implementation choices that may hinder code comprehension, and possibly increase changeand fault-proneness. While most of the detection techniques just rely on structural information, many code smells are intrinsically characterized by how code elements change overtime. In this paper, we propose Historical Information for Smell deTection (HIST), an approach exploiting change history information to detect instances of five different code smells, namely Divergent Change, Shotgun Surgery, Parallel Inheritance, Blob, and Feature Envy. We evaluate HIST in two empirical studies. The first, conducted on 20 open source projects, aimed at assessing the accuracy of HIST in detecting instances of the code smells mentioned above. The results indicate that the precision of HIST ranges between 72 and 86 percent, and its recall ranges between 58 and 100 percent. Also, results of the first study indicate that HIST is able to identify code smells that cannot be identified by competitive approaches solely based on code analysis of a single system's snapshot. Then, we conducted a second study aimed at investigating to what extent the code smells detected by HIST (and by competitive code analysis techniques) reflect developers' perception of poor design and implementation choices. We involved 12 developers of four open source projects that recognized more than 75 percent of the code smell instances identified by HIST as actual design/implementation problems.} } @inproceedings{DBLP:conf/icse/TufanoPBOPLP15, key = {79}, author = {Michele Tufano and Fabio Palomba and Gabriele Bavota and Rocco Oliveto and Massimiliano Di Penta and Andrea De Lucia and Denys Poshyvanyk}, title = {When and Why Your Code Starts to Smell Bad}, booktitle = {37th {IEEE/ACM} International Conference on Software Engineering, {ICSE} 2015, Florence, Italy, May 16-24, 2015, Volume 1}, pages = {403--414}, year = {2015}, crossref = {DBLP:conf/icse/2015-1}, url = {http://dx.doi.org/10.1109/ICSE.2015.59}, doi = {10.1109/ICSE.2015.59}, timestamp = {Tue, 03 May 2016 15:49:23 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/TufanoPBOPLP15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {In past and recent years, the issues related to managing technical debt received significant attention by researchers from both industry and academia. There are several factors that contribute to technical debt. One of these is represented by code bad smells, i.e., Symptoms of poor design and implementation choices. While the repercussions of smells on code quality have been empirically assessed, there is still only anecdotal evidence on when and why bad smells are introduced. To fill this gap, we conducted a large empirical study over the change history of 200 open source projects from different software ecosystems and investigated when bad smells are introduced by developers, and the circumstances and reasons behind their introduction. Our study required the development of a strategy to identify smell-introducing commits, the mining of over 0.5M commits, and the manual analysis of 9,164 of them (i.e., Those identified as smell-introducing). Our findings mostly contradict common wisdom stating that smells are being introduced during evolutionary tasks. In the light of our results, we also call for the need to develop a new generation of recommendation systems aimed at properly planning smell refactoring activities.} } @inproceedings{DBLP:conf/icse/PalombaTBOMPL15, key = {78}, author = {Fabio Palomba and Michele Tufano and Gabriele Bavota and Rocco Oliveto and Andrian Marcus and Denys Poshyvanyk and Andrea De Lucia}, title = {Extract Package Refactoring in {ARIES}}, booktitle = {37th {IEEE/ACM} International Conference on Software Engineering, {ICSE} 2015, Florence, Italy, May 16-24, 2015, Volume 2}, pages = {669--672}, year = {2015}, crossref = {DBLP:conf/icse/2015-2}, url = {http://dx.doi.org/10.1109/ICSE.2015.219}, doi = {10.1109/ICSE.2015.219}, timestamp = {Tue, 03 May 2016 15:49:53 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/PalombaTBOMPL15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Software evolution often leads to the degradation of software design quality. In Object-Oriented (OO) systems, this often results in packages that are hard to understand and maintain, as they group together heterogeneous classes with unrelated responsibilities. In such cases, state-of-the-art re-modularization tools solve the problem by proposing a new organization of the existing classes into packages. However, as indicated by recent empirical studies, such approaches require changing thousands of lines of code to implement the new recommended modularization. In this demo, we present the implementation of an Extract Package refactoring approach in ARIES (Automated Refactoring In EclipSe), a tool supporting refactoring operations in Eclipse. Unlike state-of-the-art approaches, ARIES automatically identifies and removes single low-cohesive packages from software systems, which represent localized design flaws in the package organization, with the aim to incrementally improve the overall quality of the software modularisation.} } @inproceedings{DBLP:conf/icse/MorenoBPOM15, key = {77}, author = {Laura Moreno and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Andrian Marcus}, title = {How Can {I} Use This Method?}, booktitle = {37th {IEEE/ACM} International Conference on Software Engineering, {ICSE} 2015, Florence, Italy, May 16-24, 2015, Volume 1}, pages = {880--890}, year = {2015}, crossref = {DBLP:conf/icse/2015-1}, url = {http://dx.doi.org/10.1109/ICSE.2015.98}, doi = {10.1109/ICSE.2015.98}, timestamp = {Tue, 03 May 2016 15:49:23 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/MorenoBPOM15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Code examples are small source code fragments whose purpose is to illustrate how a programming language construct, an API, or a specific function/method works. Since code examples are not always available in the software documentation, researchers have proposed techniques to automatically extract them from existing software or to mine them from developer discussions. In this paper we propose MUSE (Method USage Examples), an approach for mining and ranking actual code examples that show how to use a specific method. MUSE combines static slicing (to simplify examples) with clone detection (to group similar examples), and uses heuristics to select and rank the best examples in terms of reusability, understandability, and popularity. MUSE has been empirically evaluated using examples mined from six libraries, by performing three studies involving a total of 140 developers to: (i) evaluate the selection and ranking heuristics, (ii) provide their perception on the usefulness of the selected examples, and (iii) perform specific programming tasks using the MUSE examples. The results indicate that MUSE selects and ranks examples close to how humans do, most of the code examples (82%) are perceived as useful, and they actually help when performing programming tasks.} } @inproceedings{DBLP:conf/icsm/NucciPSBOL15, key = {76}, author = {Dario Di Nucci and Fabio Palomba and Sandro Siravo and Gabriele Bavota and Rocco Oliveto and Andrea De Lucia}, title = {On the role of developer's scattered changes in bug prediction}, booktitle = {2015 {IEEE} International Conference on Software Maintenance and Evolution, {ICSME} 2015, Bremen, Germany, September 29 - October 1, 2015}, pages = {241--250}, year = {2015}, crossref = {DBLP:conf/icsm/2015}, url = {http://dx.doi.org/10.1109/ICSM.2015.7332470}, doi = {10.1109/ICSM.2015.7332470}, timestamp = {Wed, 04 May 2016 11:21:25 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/NucciPSBOL15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The importance of human-related factors in the introduction of bugs has recently been the subject of a number of empirical studies. However, such factors have not been captured yet in bug prediction models which simply exploit product metrics or process metrics based on the number and type of changes or on the number of developers working on a software component. Previous studies have demonstrated that focused developers are less prone to introduce defects than non focused developers. According to this observation, software components changed by focused developers should also be less error prone than software components changed by less focused developers. In this paper we capture this observation by measuring the structural and semantic scattering of changes performed by the developers working on a software component and use these two measures to build a bug prediction model. Such a model has been evaluated on five open source systems and compared with two competitive prediction models: the first exploits the number of developers working on a code component in a given time period as predictor, while the second is based on the concept of code change entropy. The achieved results show the superiority of our model with respect to the two competitive approaches, and the complementarity of the defined scattering measures with respect to standard predictors commonly used in the literature.} } @inproceedings{DBLP:conf/icsm/PalombaVBOPPL15, key = {75}, author = {Fabio Palomba and Mario Linares V{\'{a}}squez and Gabriele Bavota and Rocco Oliveto and Massimiliano Di Penta and Denys Poshyvanyk and Andrea De Lucia}, title = {User reviews matter! Tracking crowdsourced reviews to support evolution of successful apps}, booktitle = {2015 {IEEE} International Conference on Software Maintenance and Evolution, {ICSME} 2015, Bremen, Germany, September 29 - October 1, 2015}, pages = {291--300}, year = {2015}, crossref = {DBLP:conf/icsm/2015}, url = {http://dx.doi.org/10.1109/ICSM.2015.7332475}, doi = {10.1109/ICSM.2015.7332475}, timestamp = {Wed, 04 May 2016 11:21:25 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/PalombaVBOPPL15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Nowadays software applications, and especially mobile apps, undergo frequent release updates through app stores. After installing/updating apps, users can post reviews and provide ratings, expressing their level of satisfaction with apps, and possibly pointing out bugs or desired features. In this paper we show-by performing a study on 100 Android apps-how developers addressing user reviews increase their app's success in terms of ratings. Specifically, we devise an approach, named CRISTAL, for tracing informative crowd reviews onto source code changes, and for monitoring the extent to which developers accommodate crowd requests and follow-up user reactions as reflected in their ratings. The results indicate that developers implementing user reviews are rewarded in terms of ratings. This poses the need for specialized recommendation systems aimed at analyzing informative crowd reviews and prioritizing feedback to be satisfied in order to increase the apps success.} } @inproceedings{DBLP:conf/msr/PalombaNTBOPL15, key = {74}, author = {Fabio Palomba and Dario Di Nucci and Michele Tufano and Gabriele Bavota and Rocco Oliveto and Denys Poshyvanyk and Andrea De Lucia}, title = {Landfill: An Open Dataset of Code Smells with Public Evaluation}, booktitle = {12th {IEEE/ACM} Working Conference on Mining Software Repositories, {MSR} 2015, Florence, Italy, May 16-17, 2015}, pages = {482--485}, year = {2015}, crossref = {DBLP:conf/msr/2015}, url = {http://dx.doi.org/10.1109/MSR.2015.69}, doi = {10.1109/MSR.2015.69}, timestamp = {Fri, 15 Jan 2016 09:05:52 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/msr/PalombaNTBOPL15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Code smells are symptoms of poor design and implementation choices that may hinder code comprehension and possibly increase change- and fault-proneness of source code. Several techniques have been proposed in the literature for detecting code smells. These techniques are generally evaluated by comparing their accuracy on a set of detected candidate code smells against a manually-produced oracle. Unfortunately, such comprehensive sets of annotated code smells are not available in the literature with only few exceptions. In this paper we contribute (i) a dataset of 243 instances of five types of code smells identified from 20 open source software projects, (ii) a systematic procedure for validating code smell datasets, (iii) LANDFILL, a Web-based platform for sharing code smell datasets, and (iv) a set of APIs for programmatically accessing LANDFILL's contents. Anyone can contribute to Landfill by (i) improving existing datasets (e.g., Adding missing instances of code smells, flagging possibly incorrectly classified instances), and (ii) sharing and posting new datasets. Landfill is available at www.sesa.unisa.it/landfill/, while the video demonstrating its features in action is available at http://www.sesa.unisa.it/tools/landfill.jsp.} } @inproceedings{DBLP:conf/sigsoft/VasquezBBOPP15, key = {73}, author = {Mario Linares V{\'{a}}squez and Gabriele Bavota and Carlos Eduardo Bernal{-}C{\'{a}}rdenas and Rocco Oliveto and Massimiliano Di Penta and Denys Poshyvanyk}, title = {Optimizing energy consumption of GUIs in Android apps: a multi-objective approach}, booktitle = {Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, {ESEC/FSE} 2015, Bergamo, Italy, August 30 - September 4, 2015}, pages = {143--154}, year = {2015}, crossref = {DBLP:conf/sigsoft/2015}, url = {http://doi.acm.org/10.1145/2786805.2786847}, doi = {10.1145/2786805.2786847}, timestamp = {Thu, 10 Sep 2015 16:05:11 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/sigsoft/VasquezBBOPP15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The wide diffusion of mobile devices has motivated research towards optimizing energy consumption of software systems— including apps—targeting such devices. Besides efforts aimed at dealing with various kinds of energy bugs, the adoption of Organic Light-Emitting Diode (OLED) screens has motivated research towards reducing energy consumption by choosing an appropriate color palette. Whilst past research in this area aimed at optimizing energy while keeping an acceptable level of contrast, this paper proposes an approach, named GEMMA (Gui Energy Multi-objective optiMization for Android apps), for generating color palettes using a multi- objective optimization technique, which produces color solutions optimizing energy consumption and contrast while using consistent colors with respect to the original color palette. An empirical evaluation that we performed on 25 Android apps demonstrates not only significant improvements in terms of the three different objectives, but also confirmed that in most cases users still perceived the choices of colors as attractive. Finally, for several apps we interviewed the original developers, who in some cases expressed the intent to adopt the proposed choice of color palette, whereas in other cases pointed out directions for future improvements. } } @inproceedings{DBLP:conf/sigsoft/MorenoBHPORM15, key = {72}, author = {Laura Moreno and Gabriele Bavota and Sonia Haiduc and Massimiliano Di Penta and Rocco Oliveto and Barbara Russo and Andrian Marcus}, title = {Query-based configuration of text retrieval solutions for software engineering tasks}, booktitle = {Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, {ESEC/FSE} 2015, Bergamo, Italy, August 30 - September 4, 2015}, pages = {567--578}, year = {2015}, crossref = {DBLP:conf/sigsoft/2015}, url = {http://doi.acm.org/10.1145/2786805.2786859}, doi = {10.1145/2786805.2786859}, timestamp = {Thu, 10 Sep 2015 16:05:11 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/sigsoft/MorenoBHPORM15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Text Retrieval (TR) approaches have been used to leverage the textual information contained in software artifacts to address a multitude of software engineering (SE) tasks. However, TR approaches need to be configured properly in order to lead to good results. Current approaches for automatic TR configuration in SE configure a single TR approach and then use it for all possible queries. In this paper, we show that such a configuration strategy leads to suboptimal results, and propose QUEST, the first approach bringing TR configuration selection to the query level. QUEST recommends the best TR configuration for a given query, based on a supervised learning approach that determines the TR configuration that performs the best for each query according to its properties. We evaluated QUEST in the context of feature and bug localization, using a data set with more than 1,000 queries. We found that QUEST is able to recommend one of the top three TR configurations for a query with a 69% accuracy, on average. We compared the results obtained with the configurations recommended by QUEST for every query with those obtained using a single TR configuration for all queries in a system and in the entire data set. We found that using QUEST we obtain better results than with any of the considered TR configurations. } } @inproceedings{DBLP:conf/icse/2015sst, key = {71}, author = {Patrick M{\"{a}}der and Rocco Oliveto}, title = {8th {IEEE/ACM} International Symposium on Software and Systems Traceability, {SST} 2015, Florence, Italy, May 17, 2015}, publisher = {{IEEE} Computer Society}, year = {2015}, url = {http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=7180554}, isbn = {978-0-7695-5593-5}, timestamp = {Wed, 04 May 2016 09:42:14 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/2015sst}, bibsource = {dblp computer science bibliography, http://dblp.org} } @inproceedings{DBLP:conf/iwpc/2015, key = {70}, author = {Andrea De Lucia and Christian Bird and Rocco Oliveto}, title = {Proceedings of the 2015 {IEEE} 23rd International Conference on Program Comprehension, {ICPC} 2015, Florence/Firenze, Italy, May 16-24, 2015}, publisher = {{IEEE} Computer Society}, year = {2015}, url = {http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=7180533}, timestamp = {Fri, 06 May 2016 09:29:25 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/iwpc/2015}, bibsource = {dblp computer science bibliography, http://dblp.org} } @inproceedings{DBLP:conf/fabulous/PareschiS15, key = {69}, author = {Remo Pareschi and Maria Felicia Santilli}, title = {From Global Bellies to Global Minds: The Bread Platform for Geo-Cultural Integration}, booktitle = {Future Access Enablers for Ubiquitous and Intelligent Infrastructures - First International Conference, {FABULOUS} 2015, Ohrid, Republic of Macedonia, September 23-25, 2015. Revised Selected Papers}, pages = {263--269}, year = {2015}, crossref = {DBLP:conf/fabulous/2015}, url = {http://dx.doi.org/10.1007/978-3-319-27072-2_34}, doi = {10.1007/978-3-319-27072-2_34}, timestamp = {Mon, 11 Jan 2016 14:23:07 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/fabulous/PareschiS15}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {As demonstrated by numerous ethno-anthropological studies, food can be a powerful basis for the integration of different ethnic groups and populations. The Bread project uses this integration capability, rooted in the convivial atmosphere of the experience of eating together, to address the pressing issue of the integration of migrant communities and host communities in the face of the recent migration flows that cross the world and that in Mediterranean Europe find one of their focal hubs. As part of the Bread philosophy, food is the Trojan horse for full-spectrum cultural integration, so we can actually say that the goal is to go from “global bellies” to “global minds”. To this end, a platform was developed that merge this ancestral capacity of food with the potential offered by the Internet, Web 2.0 and technologies and advanced solutions for social networking and for the dynamic acquisition and sharing of content. But Bread is a concept replicable on a global scale as well as adaptable to local needs and features, and the implementation referred to here is indeed adapted to the specific context of the city of Rome. } } @inproceedings{ key = {68}, author = {Remo Pareschi and Francesca Arcelli Fontana}, title = {Information-driven network analysis: evolving the “complex networks” paradigm}, booktitle = {Mind & Society, July 2015}, year = {2015}, url = {http://dx.doi.org/10.1007/s11299-015-0172-1}, doi = {10.1007/s11299-015-0172-1}, abstract = {Network analysis views complex systems as networks with well-defined structural properties that account for their complexity. These characteristics, which include scale-free behavior, small worlds and communities, are not to be found in networks such as random graphs and lattices that do not correspond to complex systems. They provide therefore a robust ground for claiming the existence of “complex networks” as a non-trivial subset of networks. The theory of complex networks has thus been successful in making systematically explicit relevant marks of complexity in the form of structural properties, and this success is at the root of its current popularity. Much less systematic has been, on the other hand, the definition of the properties of the building components of complex networks. The obvious assumption is that these components must be nodes and links. Generally, however, the internal structure of nodes is not taken into account, and links are serendipitously identified by the perspective with which one looks at the network to be analyzed. For instance, if the nodes are Web pages that contain information about scientific papers, one point of view will match the relevant links with hyperlinks to similar Web pages, and another with citations of other articles. We intend to contribute here a systematic approach to the identification of the components of a complex network that is based on information theory. The approach hinges on some recent results arising from the convergence between the theory of complex networks and probabilistic techniques for content mining. At its core there is the idea that nodes in a complex network correspond to basic information units from which links are extracted via methods of machine learning. Hence the links themselves are viewed as emergent properties, similarly to the broader structural properties mentioned above. Indeed, beside rounding up the theory, this approach based on learning has clear practical benefits, in that it makes networks emerge from arbitrary information domains. We provide examples and applications in a variety of contexts, starting from an information-theoretic reconstruction of the well-known distinction between “strong links” and “weak links” and then delving into specific applications such as business process management and analysis of policy making.} } % ======================== 2014 =========================================== @article{DBLP:journals/ese/LuciaPOPP14, key = {67}, author = {Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Annibale Panichella and Sebastiano Panichella}, title = {Labeling source code with information retrieval methods: an empirical study}, journal = {Empirical Software Engineering}, volume = {19}, number = {5}, pages = {1383--1420}, year = {2014}, url = {http://dx.doi.org/10.1007/s10664-013-9285-5}, doi = {10.1007/s10664-013-9285-5}, timestamp = {Sat, 27 Sep 2014 19:03:01 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/ese/LuciaPOPP14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {To support program comprehension, software artifacts can be labeled—for example within software visualization tools—with a set of representative words, hereby referred to as labels. Such labels can be obtained using various approaches, including Information Retrieval (IR) methods or other simple heuristics. They provide a bird-eye’s view of the source code, allowing developers to look over software components fast and make more informed decisions on which parts of the source code they need to analyze in detail. However, few empirical studies have been conducted to verify whether the extracted labels make sense to software developers. This paper investigates (i) to what extent various IR techniques and other simple heuristics overlap with (and differ from) labeling performed by humans; (ii) what kinds of source code terms do humans use when labeling software artifacts; and (iii) what factors—in particular what characteristics of the artifacts to be labeled—influence the performance of automatic labeling techniques. We conducted two experiments in which we asked a group of students (38 in total) to label 20 classes from two Java software systems, JHotDraw and eXVantage. Then, we analyzed to what extent the words identified with an automated technique—including Vector Space Models, Latent Semantic Indexing (LSI), latent Dirichlet allocation (LDA), as well as customized heuristics extracting words from specific source code elements—overlap with those identified by humans. Results indicate that, in most cases, simpler automatic labeling techniques—based on the use of words extracted from class and method names as well as from class comments—better reflect human-based labeling. Indeed, clustering-based approaches (LSI and LDA) are more worthwhile to be used for source code artifacts having a high verbosity, as well as for artifacts requiring more effort to be manually labeled. The obtained results help to define guidelines on how to build effective automatic labeling techniques, and provide some insights on the actual usefulness of automatic labeling techniques during program comprehension tasks.} } @article{DBLP:journals/ese/BavotaLMO14, key = {66}, author = {Gabriele Bavota and Andrea De Lucia and Andrian Marcus and Rocco Oliveto}, title = {Automating extract class refactoring: an improved method and its evaluation}, journal = {Empirical Software Engineering}, volume = {19}, number = {6}, pages = {1617--1664}, year = {2014}, url = {http://dx.doi.org/10.1007/s10664-013-9256-x}, doi = {10.1007/s10664-013-9256-x}, timestamp = {Thu, 16 Oct 2014 12:14:09 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/ese/BavotaLMO14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {During software evolution the internal structure of the system undergoes continuous modifications. These continuous changes push away the source code from its original design, often reducing its quality, including class cohesion. In this paper we propose a method for automating the Extract Class refactoring. The proposed approach analyzes (structural and semantic) relationships between the methods in a class to identify chains of strongly related methods. The identified method chains are used to define new classes with higher cohesion than the original class, while preserving the overall coupling between the new classes and the classes interacting with the original class. The proposed approach has been first assessed in an artificial scenario in order to calibrate the parameters of the approach. The data was also used to compare the new approach with previous work. Then it has been empirically evaluated on real Blobs from existing open source systems in order to assess how good and useful the proposed refactoring solutions are considered by software engineers and how well the proposed refactorings approximate refactorings done by the original developers. We found that the new approach outperforms a previously proposed approach and that developers find the proposed solutions useful in guiding refactorings.} } @article{DBLP:journals/infsof/BavotaLOT14, key = {65}, author = {Gabriele Bavota and Andrea De Lucia and Rocco Oliveto and Genoveffa Tortora}, title = {Enhancing software artefact traceability recovery processes with link count information}, journal = {Information {\&} Software Technology}, volume = {56}, number = {2}, pages = {163--182}, year = {2014}, url = {http://dx.doi.org/10.1016/j.infsof.2013.08.004}, doi = {10.1016/j.infsof.2013.08.004}, timestamp = {Fri, 06 Dec 2013 15:07:11 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/infsof/BavotaLOT14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The intensive human effort needed to manually manage traceability information has increased the interest in using semi-automated traceability recovery techniques. In particular, Information Retrieval (IR) techniques have been largely employed in the last ten years to partially automate the traceability recovery process. Previous studies mainly focused on the analysis of the performances of IR-based traceability recovery methods and several enhancing strategies have been proposed to improve their accuracy. Very few papers investigate how developers (i) use IR-based traceability recovery tools and (ii) analyse the list of suggested links to validate correct links or discard false positives. We focus on this issue and suggest exploiting link count information in IR-based traceability recovery tools to improve the performances of the developers during a traceability recovery process. Two empirical studies have been conducted to evaluate the usefulness of link count information. The two studies involved 135 University students that had to perform (with and without link count information) traceability recovery tasks on two software project repositories. Then, we evaluated the quality of the recovered traceability links in terms of links correctly and erroneously traced by the students. The results achieved indicate that the use of link count information significantly increases the number of correct links identified by the participants. The results can be used to derive guidelines on how to effectively use traceability recovery approaches and tools proposed in the literature.} } @article{DBLP:journals/jss/QusefBOLB14, key = {64}, author = {Abdallah Qusef and Gabriele Bavota and Rocco Oliveto and Andrea De Lucia and Dave Binkley}, title = {Recovering test-to-code traceability using slicing and textual analysis}, journal = {Journal of Systems and Software}, volume = {88}, pages = {147--168}, year = {2014}, url = {http://dx.doi.org/10.1016/j.jss.2013.10.019}, doi = {10.1016/j.jss.2013.10.019}, timestamp = {Wed, 19 Feb 2014 20:55:54 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/jss/QusefBOLB14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Test suites are a valuable source of up-to-date documentation as developers continuously modify them to reflect changes in the production code and preserve an effective regression suite. While maintaining traceability links between unit test and the classes under test can be useful to selectively retest code after a change, the value of having traceability links goes far beyond this potential savings. One key use is to help developers better comprehend the dependencies between tests and classes and help maintain consistency during refactoring. Despite its importance, test-to-code traceability is not common in software development and, when needed, traceability information has to be recovered during software development and evolution. We propose an advanced approach, named SCOTCH+ (Source code and COncept based Test to Code traceability Hunter), to support the developer during the identification of links between unit tests and tested classes. Given a test class, represented by a JUnit class, the approach first exploits dynamic slicing to identify a set of candidate tested classes. Then, external and internal textual information associated with the classes retrieved by slicing is analyzed to refine this set of classes and identify the final set of candidate tested classes. The external information is derived from the analysis of the class name, while internal information is derived from identifiers and comments. The approach is evaluated on five software systems. The results indicate that the accuracy of the proposed approach far exceeds the leading techniques found in the literature.} } @article{DBLP:journals/smr/OlivetoP14, key = {63}, author = {Rocco Oliveto and Denys Poshyvanyk}, title = {A selection of distinguished papers from the 19th Working Conference on Reverse Engineering 2012}, journal = {Journal of Software: Evolution and Process}, volume = {26}, number = {11}, pages = {929--930}, year = {2014}, url = {http://dx.doi.org/10.1002/smr.1696}, doi = {10.1002/smr.1696}, timestamp = {Mon, 12 Jan 2015 11:08:28 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/smr/OlivetoP14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {This special issue contains a selection of distinguished papers from the 19th Working Conference on Reverse Engineering, held in Kingston, Ontario, Canada on October 15th–18th, 2012. The papers address a variety of topics related to reverse engineering, namely the analysis of execution traces, development of fast and efficient forward static slicing techniques, and mining of software repositories aiming at deriving novel patterns related to reverse engineering activities, such as the migration in Java libraries and the analysis of effects of file editing patterns on source code quality. Copyright © 2014 John Wiley & Sons, Ltd} } @article{DBLP:journals/tosem/BavotaGOPL14, key = {62}, author = {Gabriele Bavota and Malcom Gethers and Rocco Oliveto and Denys Poshyvanyk and Andrea De Lucia}, title = {Improving software modularization via automated analysis of latent topics and dependencies}, journal = {{ACM} Trans. Softw. Eng. Methodol.}, volume = {23}, number = {1}, pages = {4:1--4:33}, year = {2014}, url = {http://doi.acm.org/10.1145/2559935}, doi = {10.1145/2559935}, timestamp = {Mon, 20 Apr 2015 18:26:50 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/tosem/BavotaGOPL14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Oftentimes, during software maintenance the original program modularization decays, thus reducing its quality. One of the main reasons for such architectural erosion is suboptimal placement of source-code classes in software packages. To alleviate this issue, we propose an automated approach to help developers improve the quality of software modularization. Our approach analyzes underlying latent topics in source code as well as structural dependencies to recommend (and explain) refactoring operations aiming at moving a class to a more suitable package. The topics are acquired via Relational Topic Models (RTM), a probabilistic topic modeling technique. The resulting tool, coined as R3 (Rational Refactoring via RTM), has been evaluated in two empirical studies. The results of the first study conducted on nine software systems indicate that R3 provides a coupling reduction from 10% to 30% among the software modules. The second study with 62 developers confirms that R3 is able to provide meaningful recommendations (and explanations) for move class refactoring. Specifically, more than 70% of the recommendations were considered meaningful from a functional point of view.} } @article{DBLP:journals/tse/ArnaoudovaEPOAG14, key = {61}, author = {Venera Arnaoudova and Laleh Mousavi Eshkevari and Massimiliano Di Penta and Rocco Oliveto and Giuliano Antoniol and Yann{-}Ga{\"{e}}l Gu{\'{e}}h{\'{e}}neuc}, title = {{REPENT:} Analyzing the Nature of Identifier Renamings}, journal = {{IEEE} Trans. Software Eng.}, volume = {40}, number = {5}, pages = {502--532}, year = {2014}, url = {http://dx.doi.org/10.1109/TSE.2014.2312942}, doi = {10.1109/TSE.2014.2312942}, timestamp = {Thu, 10 Dec 2015 11:33:09 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/tse/ArnaoudovaEPOAG14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Source code lexicon plays a paramount role in software quality: poor lexicon can lead to poor comprehensibility and even increase software fault-proneness. For this reason, renaming a program entity, i.e., altering the entity identifier, is an important activity during software evolution. Developers rename when they feel that the name of an entity is not (anymore) consistent with its functionality, or when such a name may be misleading. A survey that we performed with 71 developers suggests that 39 percent perform renaming from a few times per week to almost every day and that 92 percent of the participants consider that renaming is not straightforward. However, despite the cost that is associated with renaming, renamings are seldom if ever documented-for example, less than 1 percent of the renamings in the five programs that we studied. This explains why participants largely agree on the usefulness of automatically documenting renamings. In this paper we propose REanaming Program ENTities (REPENT), an approach to automatically document-detect and classify-identifier renamings in source code. REPENT detects renamings based on a combination of source code differencing and data flow analyses. Using a set of natural language tools, REPENT classifies renamings into the different dimensions of a taxonomy that we defined. Using the documented renamings, developers will be able to, for example, look up methods that are part of the public API (as they impact client applications), or look for inconsistencies between the name and the implementation of an entity that underwent a high risk renaming (e.g., towards the opposite meaning). We evaluate the accuracy and completeness of REPENT on the evolution history of five open-source Java programs. The study indicates a precision of 88 percent and a recall of 92 percent. In addition, we report an exploratory study investigating and discussing how identifiers are renamed in the five programs, according to our taxonomy.} } @article{DBLP:journals/tse/BavotaOGPL14, key = {60}, author = {Gabriele Bavota and Rocco Oliveto and Malcom Gethers and Denys Poshyvanyk and Andrea De Lucia}, title = {Methodbook: Recommending Move Method Refactorings via Relational Topic Models}, journal = {{IEEE} Trans. Software Eng.}, volume = {40}, number = {7}, pages = {671--694}, year = {2014}, url = {http://dx.doi.org/10.1109/TSE.2013.60}, doi = {10.1109/TSE.2013.60}, timestamp = {Thu, 10 Dec 2015 11:33:06 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/tse/BavotaOGPL14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {During software maintenance and evolution the internal structure of the software system undergoes continuous changes. These modifications drift the source code away from its original design, thus deteriorating its quality, including cohesion and coupling of classes. Several refactoring methods have been proposed to overcome this problem. In this paper we propose a novel technique to identify Move Method refactoring opportunities and remove the Feature Envy bad smell from source code. Our approach, coined as Methodbook, is based on relational topic models (RTM), a probabilistic technique for representing and modeling topics, documents (in our case methods) and known relationships among these. Methodbook uses RTM to analyze both structural and textual information gleaned from software to better support move method refactoring. We evaluated Methodbook in two case studies. The first study has been executed on six software systems to analyze if the move method operations suggested by Methodbook help to improve the design quality of the systems as captured by quality metrics. The second study has been conducted with eighty developers that evaluated the refactoring recommendations produced by Methodbook. The achieved results indicate that Methodbook provides accurate and meaningful recommendations for move method refactoring operations.} } @inproceedings{DBLP:conf/csmr/PanichellaOL14, key = {59}, author = {Annibale Panichella and Rocco Oliveto and Andrea De Lucia}, title = {Cross-project defect prediction models: L'Union fait la force}, booktitle = {2014 Software Evolution Week - {IEEE} Conference on Software Maintenance, Reengineering, and Reverse Engineering, {CSMR-WCRE} 2014, Antwerp, Belgium, February 3-6, 2014}, pages = {164--173}, year = {2014}, crossref = {DBLP:conf/csmr/2014}, url = {http://dx.doi.org/10.1109/CSMR-WCRE.2014.6747166}, doi = {10.1109/CSMR-WCRE.2014.6747166}, timestamp = {Wed, 15 Apr 2015 09:20:30 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/csmr/PanichellaOL14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Existing defect prediction models use product or process metrics and machine learning methods to identify defect-prone source code entities. Different classifiers (e.g., linear regression, logistic regression, or classification trees) have been investigated in the last decade. The results achieved so far are sometimes contrasting and do not show a clear winner. In this paper we present an empirical study aiming at statistically analyzing the equivalence of different defect predictors. We also propose a combined approach, coined as CODEP (COmbined DEfect Predictor), that employs the classification provided by different machine learning techniques to improve the detection of defect-prone entities. The study was conducted on 10 open source software systems and in the context of cross-project defect prediction, that represents one of the main challenges in the defect prediction field. The statistical analysis of the results indicates that the investigated classifiers are not equivalent and they can complement each other. This is also confirmed by the superior prediction accuracy achieved by CODEP when compared to stand-alone defect predictors.} } @inproceedings{DBLP:conf/csmr/BavotaOLMGA14, key = {58}, author = {Gabriele Bavota and Rocco Oliveto and Andrea De Lucia and Andrian Marcus and Yann{-}Ga{\"{e}}l Gu{\'{e}}h{\'{e}}neuc and Giuliano Antoniol}, title = {In medio stat virtus: Extract class refactoring through nash equilibria}, booktitle = {2014 Software Evolution Week - {IEEE} Conference on Software Maintenance, Reengineering, and Reverse Engineering, {CSMR-WCRE} 2014, Antwerp, Belgium, February 3-6, 2014}, pages = {214--223}, year = {2014}, crossref = {DBLP:conf/csmr/2014}, url = {http://dx.doi.org/10.1109/CSMR-WCRE.2014.6747173}, doi = {10.1109/CSMR-WCRE.2014.6747173}, timestamp = {Wed, 15 Apr 2015 09:20:30 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/csmr/BavotaOLMGA14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Extract Class refactoring (ECR) is used to divide large classes with low cohesion into smaller, more cohesive classes. However, splitting a class might result in increased coupling in the system due to new dependencies between the extracted classes. Thus, ECR requires that a software engineer identifies a trade off between cohesion and coupling. Such a trade off may be difficult to identify manually because of the high complexity of the class to be refactored. In this paper, we present an approach based on game theory to identify refactoring solutions that provide a compromise between the desired increment in cohesion and the undesired increment in coupling. The results of an empirical evaluation indicate that the approach identifies meaningful ECRs from a developer's point-of-view.} } @inproceedings{DBLP:conf/icsm/PalombaBPOL14, key = {57}, author = {Fabio Palomba and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Andrea De Lucia}, title = {Do They Really Smell Bad? {A} Study on Developers' Perception of Bad Code Smells}, booktitle = {30th {IEEE} International Conference on Software Maintenance and Evolution, Victoria, BC, Canada, September 29 - October 3, 2014}, pages = {101--110}, year = {2014}, crossref = {DBLP:conf/icsm/2014}, url = {http://dx.doi.org/10.1109/ICSME.2014.32}, doi = {10.1109/ICSME.2014.32}, timestamp = {Wed, 10 Jun 2015 16:53:29 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/PalombaBPOL14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {In the last decade several catalogues have been defined to characterize bad code smells, i.e., symptoms of poor design and implementation choices. On top of such catalogues, researchers have defined methods and tools to automatically detect and/or remove bad smells. Nevertheless, there is an ongoing debate regarding the extent to which developers perceive bad smells as serious design problems. Indeed, there seems to be a gap between theory and practice, i.e., what is believed to be a problem (theory) and what is actually a problem (practice). This paper presents a study aimed at providing empirical evidence on how developers perceive bad smells. In this study, we showed to developers code entities -- belonging to three systems -- affected and not by bad smells, and we asked them to indicate whether the code contains a potential design problem, and if any, the nature and severity of the problem. The study involved both original developers from the three projects and outsiders, namely industrial developers and Master's students. The results provide insights on characteristics of bad smells not yet explored sufficiently. Also, our findings could guide future research on approaches for the detection and removal of bad smells.} } @inproceedings{DBLP:conf/icsm/PonzanelliBPOL14, key = {56}, author = {Luca Ponzanelli and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Michele Lanza}, title = {Prompter: {A} Self-Confident Recommender System}, booktitle = {30th {IEEE} International Conference on Software Maintenance and Evolution, Victoria, BC, Canada, September 29 - October 3, 2014}, pages = {577--580}, year = {2014}, crossref = {DBLP:conf/icsm/2014}, url = {http://dx.doi.org/10.1109/ICSME.2014.99}, doi = {10.1109/ICSME.2014.99}, timestamp = {Wed, 10 Jun 2015 16:53:26 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/PonzanelliBPOL14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Developers often consult different sources of information like Application Programming Interfaces (API) documentation, forums, Q&A websites, etc. With the aim of gathering additional knowledge for the programming task at hand. The process of searching and identifying valuable pieces of information requires developers to spend time and energy in formulating the right queries, assessing the returned results, and integrating the obtained knowledge into the code base. All of this is often done manually. We present Prompter, a plug-in for the Eclipse IDE which automatically searches and identifies relevant Stack Overflow discussions, evaluates their relevance given the code context in the IDE, and notifies the developer if and only if a user-defined confidence threshold is surpassed.} } @inproceedings{DBLP:conf/iwpc/VasquezBPOP14, key = {55}, author = {Mario Linares V{\'{a}}squez and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Denys Poshyvanyk}, title = {How do {API} changes trigger stack overflow discussions? a study on the Android {SDK}}, booktitle = {22nd International Conference on Program Comprehension, {ICPC} 2014, Hyderabad, India, June 2-3, 2014}, pages = {83--94}, year = {2014}, crossref = {DBLP:conf/iwpc/2014}, url = {http://doi.acm.org/10.1145/2597008.2597155}, doi = {10.1145/2597008.2597155}, timestamp = {Fri, 06 May 2016 09:30:11 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/iwpc/VasquezBPOP14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The growing number of questions related to mobile development in StackOverflow highlights an increasing interest of software developers in mobile programming. For the Android platform, 213,836 questions were tagged with Android-related labels in StackOverflow between July 2008 and August 2012. This paper aims at investigating how changes occurring to Android APIs trigger questions and activity in StackOverflow, and whether this is particularly true for certain kinds of changes. Our findings suggest that Android developers usually have more questions when the behavior of APIs is modified. In addition, deleting public methods from APIs is a trigger for questions that are (i) more discussed and of major interest for the community, and (ii) posted by more experienced developers. In general, results of this paper provide important insights about the use of social media to learn about changes in software ecosystems, and establish solid foundations for building new recommenders for notifying developers/managers about important changes and recommending them relevant crowdsourced solutions. } } @inproceedings{DBLP:conf/iwpc/PanichellaCPO14, key = {54}, author = {Sebastiano Panichella and Gerardo Canfora and Massimiliano Di Penta and Rocco Oliveto}, title = {How the evolution of emerging collaborations relates to code changes: an empirical study}, booktitle = {22nd International Conference on Program Comprehension, {ICPC} 2014, Hyderabad, India, June 2-3, 2014}, pages = {177--188}, year = {2014}, crossref = {DBLP:conf/iwpc/2014}, url = {http://doi.acm.org/10.1145/2597008.2597145}, doi = {10.1145/2597008.2597145}, timestamp = {Fri, 06 May 2016 09:30:11 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/iwpc/PanichellaCPO14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Developers contributing to open source projects spontaneously group into "emerging'' teams, reflected by messages exchanged over mailing lists, issue trackers and other communication means. Previous studies suggested that such teams somewhat mirror the software modularity. This paper empirically investigates how, when a project evolves, emerging teams re-organize themselves-e.g., by splitting or merging. We relate the evolution of teams to the files they change, to investigate whether teams split to work on cohesive groups of files. Results of this study-conducted on the evolution history of four open source projects, namely Apache httpd, Eclipse JDT, Netbeans, and Samba-provide indications of what happens in the project when teams reorganize. Specifically, we found that emerging team splits imply working on more cohesive groups of files and emerging team merges imply working on groups of files that are cohesive from structural perspective. Such indications serve to better understand the evolution of software projects. More important, the observation of how emerging teams change can serve to suggest software remodularization actions.} } @inproceedings{DBLP:conf/kbse/BavotaPTPOC14, key = {53}, author = {Gabriele Bavota and Sebastiano Panichella and Nikolaos Tsantalis and Massimiliano Di Penta and Rocco Oliveto and Gerardo Canfora}, title = {Recommending refactorings based on team co-maintenance patterns}, booktitle = {{ACM/IEEE} International Conference on Automated Software Engineering, {ASE} '14, Vasteras, Sweden - September 15 - 19, 2014}, pages = {337--342}, year = {2014}, crossref = {DBLP:conf/kbse/2014}, url = {http://doi.acm.org/10.1145/2642937.2642948}, doi = {10.1145/2642937.2642948}, timestamp = {Wed, 17 Sep 2014 09:31:02 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/kbse/BavotaPTPOC14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Refactoring aims at restructuring existing source code when undisciplined development activities have deteriorated its comprehensibility and maintainability. There exist various approaches for suggesting refactoring opportunities, based on different sources of information, e.g., structural, semantic, and historical. In this paper we claim that an additional source of information for identifying refactoring opportunities, sometimes orthogonal to the ones mentioned above, is team development activity. When the activity of a team working on common modules is not aligned with the current design structure of a system, it would be possible to recommend appropriate refactoring operations---e.g., extract class/method/package---to adjust the design according to the teams' activity patterns. Results of a preliminary study---conducted in the context of extract class refactoring---show the feasibility of the approach, and also suggest that this new refactoring dimension can be complemented with others to build better refactoring recommendation tools.} } @inproceedings{DBLP:conf/msr/VasquezBBOPP14, key = {52}, author = {Mario Linares V{\'{a}}squez and Gabriele Bavota and Carlos Bernal{-}C{\'{a}}rdenas and Rocco Oliveto and Massimiliano Di Penta and Denys Poshyvanyk}, title = {Mining energy-greedy {API} usage patterns in Android apps: an empirical study}, booktitle = {11th Working Conference on Mining Software Repositories, {MSR} 2014, Proceedings, May 31 - June 1, 2014, Hyderabad, India}, pages = {2--11}, year = {2014}, crossref = {DBLP:conf/msr/2014}, url = {http://doi.acm.org/10.1145/2597073.2597085}, doi = {10.1145/2597073.2597085}, timestamp = {Sun, 18 May 2014 15:57:59 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/msr/VasquezBBOPP14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Energy consumption of mobile applications is nowadays a hot topic, given the widespread use of mobile devices. The high demand for features and improved user experience, given the available powerful hardware, tend to increase the apps' energy consumption. However, excessive energy consumption in mobile apps could also be a consequence of energy greedy hardware, bad programming practices, or particular API usage patterns. We present the largest to date quantitative and qualitative empirical investigation into the categories of API calls and usage patterns that in the context of the Android development framework exhibit particularly high energy consumption profiles. By using a hardware power monitor, we measure energy consumption of method calls when executing typical usage scenarios in 55 mobile apps from different domains. Based on the collected data, we mine and analyze energy-greedy APIs and usage patterns. We zoom in and discuss the cases where either the anomalous energy consumption is unavoidable or where it is due to suboptimal usage or choice of APIs. Finally, we synthesize our findings into actionable knowledge and recipes for developers on how to reduce energy consumption while using certain categories of Android APIs and patterns.} } @inproceedings{DBLP:conf/msr/PonzanelliBPOL14, key = {51}, author = {Luca Ponzanelli and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Michele Lanza}, title = {Mining StackOverflow to turn the {IDE} into a self-confident programming prompter}, booktitle = {11th Working Conference on Mining Software Repositories, {MSR} 2014, Proceedings, May 31 - June 1, 2014, Hyderabad, India}, pages = {102--111}, year = {2014}, crossref = {DBLP:conf/msr/2014}, url = {http://doi.acm.org/10.1145/2597073.2597077}, doi = {10.1145/2597073.2597077}, timestamp = {Sun, 18 May 2014 15:57:59 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/msr/PonzanelliBPOL14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Developers often require knowledge beyond the one they possess, which often boils down to consulting sources of information like Application Programming Interfaces (API) documentation, forums, Q&A websites, etc. Knowing what to search for and how is non- trivial, and developers spend time and energy to formulate their problems as queries and to peruse and process the results. We propose a novel approach that, given a context in the IDE, automatically retrieves pertinent discussions from Stack Overflow, evaluates their relevance, and, if a given confidence threshold is surpassed, notifies the developer about the available help. We have implemented our approach in Prompter, an Eclipse plug-in. Prompter has been evaluated through two studies. The first was aimed at evaluating the devised ranking model, while the second was conducted to evaluate the usefulness of Prompter.} } @inproceedings{DBLP:conf/sigsoft/MorenoBPOMC14, key = {50}, author = {Laura Moreno and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Andrian Marcus and Gerardo Canfora}, title = {Automatic generation of release notes}, booktitle = {Proceedings of the 22nd {ACM} {SIGSOFT} International Symposium on Foundations of Software Engineering, (FSE-22), Hong Kong, China, November 16 - 22, 2014}, pages = {484--495}, year = {2014}, crossref = {DBLP:conf/sigsoft/2014}, url = {http://doi.acm.org/10.1145/2635868.2635870}, doi = {10.1145/2635868.2635870}, timestamp = {Fri, 07 Nov 2014 13:02:02 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/sigsoft/MorenoBPOMC14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {This paper introduces ARENA (Automatic RElease Notes generAtor), an approach for the automatic generation of release notes. ARENA extracts changes from the source code, summarizes them, and integrates them with information from versioning systems and issue trackers. It was designed based on the manual analysis of 1,000 existing release notes. To evaluate the quality of the ARENA release notes, we performed three empirical studies involving a total of 53 participants (45 professional developers and 8 students). The results indicate that the ARENA release notes are very good approximations of those produced by developers and often include important information that is missing in the manually produced release notes.} } @incollection{DBLP:books/sp/ess14/BavotaPO14, key = {49}, author = {Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto}, title = {Search Based Software Maintenance: Methods and Tools}, booktitle = {Evolving Software Systems}, pages = {103--137}, year = {2014}, crossref = {DBLP:books/sp/ess2014}, url = {http://dx.doi.org/10.1007/978-3-642-45398-4_4}, doi = {10.1007/978-3-642-45398-4_4}, timestamp = {Thu, 16 Apr 2015 19:09:16 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/books/sp/ess14/BavotaPO14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Software evolution is an effort-prone activity, and requires developers to make complex and difficult decisions. This entails the development of automated approaches to support various software evolution-related tasks, for example aimed at suggesting refactoring or remodularization actions. Finding a solution to these problems is intrinsically NP-hard, and exhaustive approaches are not viable due to the size and complexity of many software projects. Therefore, during recent years, several software-evolution problems have been formulated as optimization problems, and resolved with meta-heuristics. This chapter overviews how search-based optimization techniques can support software engineers in a number of software evolution tasks. For each task, we illustrate how the problem can be encoded as a search-based optimization problem, and how meta-heuristics can be used to solve it. Where possible, we refer to some tools that can be used to deal with such tasks.} } @incollection{DBLP:books/sp/rsse14/BavotaLMO14, key = {48}, author = {Gabriele Bavota and Andrea De Lucia and Andrian Marcus and Rocco Oliveto}, title = {Recommending Refactoring Operations in Large Software Systems}, booktitle = {Recommendation Systems in Software Engineering}, pages = {387--419}, year = {2014}, crossref = {DBLP:books/sp/rsse2014}, url = {http://dx.doi.org/10.1007/978-3-642-45135-5_15}, doi = {10.1007/978-3-642-45135-5_15}, timestamp = {Wed, 03 Feb 2016 18:18:52 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/books/sp/rsse14/BavotaLMO14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {During its lifecycle, the internal structure of a software system undergoes continuous modifications. These changes push away the source code from its original design, often reducing its quality. In such cases, refactoring techniques can be applied to improve the readability and reducing the complexity of source code, to improve the architecture and provide for better software extensibility. Despite its advantages, performing refactoring in large and nontrivial software systems might be very challenging. Thus, a lot of effort has been devoted to the definition of automatic or semi-automatic approaches to support developer during software refactoring. Many of the proposed techniques are for recommending refactoring operations. In this chapter, we present guidelines on how to build such recommendation systems and how to evaluate them. We also highlight some of the challenges that exist in the field, pointing toward future research directions.} } @article{DBLP:journals/ngc/RossettiPSF14, key = {47}, author = {Marco Rossetti and Remo Pareschi and Fabio Stella and Francesca Arcelli Fontana}, title = {Integrating Concepts and Knowledge in Large Content Networks}, journal = {New Generation Comput.}, volume = {32}, number = {3-4}, pages = {309--330}, year = {2014}, url = {http://dx.doi.org/10.1007/s00354-014-0407-4}, doi = {10.1007/s00354-014-0407-4}, timestamp = {Wed, 03 Sep 2014 11:15:23 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/ngc/RossettiPSF14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Large content networks like the World Wide Web contain huge amounts of information that have the potential of being integrated because their components fit within common concepts and/or are connected through hidden, implicit relationships. One attempt at such an integration is the program called the “Web of Data,” which is an evolution of the Semantic Web. It targets semi-structured information sources such as Wikipedia and turns them into fully structured ones in the form of Web-based databases like DBpedia and then integrates them with other public databases such as Geonames. On the other hand, the vast majority of the information residing on the Web is still totally unstructured, which is the starting point for our approach that aims to integrate unstructured information sources. For this purpose, we exploit techniques from Probabilistic Topic Modeling, in order to cluster Web pages into concepts (topics), which are then related through higher-level concept networks; we also make implicit semantic relationships emerge between single Web pages. The approach has been tested through a number of case studies that are here described. While the applicative focus of the research reported here is on knowledge integration on the specific and relevant case of the WWW, the wider aim is to provide a framework for integration generally applicable to all complex content networks where information propagates from multiple sources.} } @inproceedings{DBLP:conf/simpda/PareschiRS14, key = {46}, author = {Remo Pareschi and Marco Rossetti and Fabio Stella}, title = {Tracking Hot Topics for the Monitoring of Open-World Processes}, booktitle = {Proceedings of the 4th International Symposium on Data-driven Process Discovery and Analysis {(SIMPDA} 2014), Milan, Italy, November 19-21, 2014.}, pages = {138--149}, year = {2014}, crossref = {DBLP:conf/simpda/2014}, url = {http://ceur-ws.org/Vol-1293/paper10.pdf}, timestamp = {Mon, 30 May 2016 16:28:38 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/simpda/PareschiRS14}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {We introduce the notion of open-world process to refer to processes that generally require flexible execution and are influenced by external factors. Among such processes we focus on those that fit also with the notion of “business process”. We then introduce “hot topics” to capture contextual information flows that, by flowing into the context of execution of open-world business processes, may affect their definitions. Hot topics are discovered using unsupervised learning techniques based on Probabilistic Topic Modeling and by tracking variations of the information flows into topics over time. We illustrate an application of this methodology to the tracking of recent innovations in labor laws that affect a variety of open-world business processes, from labor sourcing to merge-and-acquisition. Finally, we define a number of future directions for research. } } % ======================== 2013 =========================================== @article{DBLP:journals/ese/BavotaLMO13, key = {45}, author = {Gabriele Bavota and Andrea De Lucia and Andrian Marcus and Rocco Oliveto}, title = {Using structural and semantic measures to improve software modularization}, journal = {Empirical Software Engineering}, volume = {18}, number = {5}, pages = {901--932}, year = {2013}, url = {http://dx.doi.org/10.1007/s10664-012-9226-8}, doi = {10.1007/s10664-012-9226-8}, timestamp = {Wed, 28 Aug 2013 17:10:04 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/ese/BavotaLMO13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Changes during software evolution and poor design decisions often lead to packages that are hard to understand and maintain, because they usually group together classes with unrelated responsibilities. One way to improve such packages is to decompose them into smaller, more cohesive packages. The difficulty lies in the fact that most definitions and interpretations of cohesion are rather vague and the multitude of measures proposed by researchers usually capture only one aspect of cohesion. We propose a new technique for automatic re-modularization of packages, which uses structural and semantic measures to decompose a package into smaller, more cohesive ones. The paper presents the new approach as well as an empirical study, which evaluates the decompositions proposed by the new technique. The results of the evaluation indicate that the decomposed packages have better cohesion without a deterioration of coupling and the re-modularizations proposed by the tool are also meaningful from a functional point of view.} } @article{DBLP:journals/infsof/LuciaPOPP13, key = {44}, author = {Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Annibale Panichella and Sebastiano Panichella}, title = {Applying a smoothing filter to improve IR-based traceability recovery processes: An empirical investigation}, journal = {Information {\&} Software Technology}, volume = {55}, number = {4}, pages = {741--754}, year = {2013}, url = {http://dx.doi.org/10.1016/j.infsof.2012.08.002}, doi = {10.1016/j.infsof.2012.08.002}, timestamp = {Tue, 16 Apr 2013 13:17:24 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/infsof/LuciaPOPP13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Traceability relations among software artifacts often tend to be missing, outdated, or lost. For this reason, various traceability recovery approaches—based on Information Retrieval (IR) techniques—have been proposed. The performances of such approaches are often influenced by “noise” contained in software artifacts (e.g., recurring words in document templates or other words that do not contribute to the retrieval itself). As a complement and alternative to stop word removal approaches, this paper proposes the use of a smoothing filter to remove “noise” from the textual corpus of artifacts to be traced. We evaluate the effect of a smoothing filter in traceability recovery tasks involving different kinds of artifacts from five software projects, and applying three different IR methods, namely Vector Space Models, Latent Semantic Indexing, and Jensen–Shannon similarity model. Our study indicates that, with the exception of some specific kinds of artifacts (i.e., tracing test cases to source code) the proposed approach is able to significantly improve the performances of traceability recovery, and to remove “noise” that simple stop word filters cannot remove. The obtained results not only help to develop traceability recovery approaches able to work in presence of noisy artifacts, but also suggest that smoothing filters can be used to improve performances of other software engineering approaches based on textual analysis.} } @article{DBLP:journals/smr/CapobiancoLOPP13, key = {43}, author = {Giovanni Capobianco and Andrea De Lucia and Rocco Oliveto and Annibale Panichella and Sebastiano Panichella}, title = {Improving IR-based traceability recovery via noun-based indexing of software artifacts}, journal = {Journal of Software: Evolution and Process}, volume = {25}, number = {7}, pages = {743--762}, year = {2013}, url = {http://dx.doi.org/10.1002/smr.1564}, doi = {10.1002/smr.1564}, timestamp = {Mon, 22 Jul 2013 15:41:50 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/smr/CapobiancoLOPP13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {One of the most successful applications of textual analysis in software engineering is the use of information retrieval (IR) methods to reconstruct traceability links between software artifacts. Unfortunately, because of the limitations of both the humans developing artifacts and the IR techniques any IR-based traceability recovery method fails to retrieve some of the correct links, while on the other hand it also retrieves links that are not correct. This limitation has posed challenges for researchers that have proposed several methods to improve the accuracy of IR-based traceability recovery methods by removing the ‘noise’ in the textual content of software artifacts (e.g., by removing common words or increasing the importance of critical terms). In this paper, we propose a heuristic to remove the ‘noise’ taking into account the linguistic nature of words in the software artifacts. In particular, the language used in software documents can be classified as a technical language, where the words that provide more indication on the semantics of a document are the nouns. The results of a case study conducted on five software artifact repositories indicate that characterizing the context of software artifacts considering only nouns significantly improves the accuracy of IR-based traceability recovery methods. Copyright © 2012 John Wiley & Sons, Ltd.} } @article{DBLP:journals/smr/QusefBOLB13, key = {42}, author = {Abdallah Qusef and Gabriele Bavota and Rocco Oliveto and Andrea De Lucia and David Binkley}, title = {Evaluating test-to-code traceability recovery methods through controlled experiments}, journal = {Journal of Software: Evolution and Process}, volume = {25}, number = {11}, pages = {1167--1191}, year = {2013}, url = {http://dx.doi.org/10.1002/smr.1573}, doi = {10.1002/smr.1573}, timestamp = {Fri, 13 Dec 2013 15:28:31 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/smr/QusefBOLB13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Recently, different methods and tools have been proposed to automate or semi-automate test-to-code traceability recovery. Among these, Slicing and Coupling based Test to Code trace Hunter (SCOTCH) exploits slicing and conceptual coupling to identify the classes tested by a JUnit test. However, until now the evaluation of test-to-code traceability recovery methods has been limited to experiments assessing their tracing accuracy rather than the actual support these methods provide to a software engineer during traceability recovery tasks. Indeed, a research method or tool has a better chance of being transferred to practitioners if it is supported by empirical evidence. In this paper, we present the results of two controlled experiments carried out to evaluate the support given by SCOTCH during traceability recovery, when compared with other traceability recovery methods. The results show that SCOTCH is able to suggest a higher number of correct links with higher accuracy, thus sensibly improving the performances of software engineers during test-to-code traceability recovery tasks. Copyright © 2012 John Wiley & Sons, Ltd.} } @inproceedings{DBLP:conf/csmr/PanichellaMMPOPL13, key = {41}, author = {Annibale Panichella and Collin McMillan and Evan Moritz and Davide Palmieri and Rocco Oliveto and Denys Poshyvanyk and Andrea De Lucia}, title = {When and How Using Structural Information to Improve IR-Based Traceability Recovery}, booktitle = {17th European Conference on Software Maintenance and Reengineering, {CSMR} 2013, Genova, Italy, March 5-8, 2013}, pages = {199--208}, year = {2013}, crossref = {DBLP:conf/csmr/2013}, url = {http://dx.doi.org/10.1109/CSMR.2013.29}, doi = {10.1109/CSMR.2013.29}, timestamp = {Tue, 25 Nov 2014 17:05:17 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/csmr/PanichellaMMPOPL13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Information Retrieval (IR) has been widely accepted as a method for automated traceability recovery based on the textual similarity among the software artifacts. However, a notorious difficulty for IR-based methods is that artifacts may be related even if they are not textually similar. A growing body of work addresses this challenge by combining IR-based methods with structural information from source code. Unfortunately, the accuracy of such methods is highly dependent on the IR methods. If the IR methods perform poorly, the combined approaches may perform even worse. In this paper, we propose to use the feedback provided by the software engineer when classifying candidate links to regulate the effect of using structural information. Specifically, our approach only considers structural information when the traceability links from the IR methods are verified by the software engineer and classified as correct links. An empirical evaluation conducted on three systems suggests that our approach outperforms both a pure IR-based method and a simple approach for combining textual and structural information.} } @inproceedings{DBLP:conf/icse/BavotaLOPRT13, key = {40}, author = {Gabriele Bavota and Andrea De Lucia and Rocco Oliveto and Annibale Panichella and Fabio Ricci and Genoveffa Tortora}, title = {The role of artefact corpus in LSI-based traceability recovery}, booktitle = {7th International Workshop on Traceability in Emerging Forms of Software Engineering, {TEFSE} 2013, 19 May, 2013, San Francisco, CA, {USA}}, pages = {83--89}, year = {2013}, crossref = {DBLP:conf/icse/2013tefse}, url = {http://dx.doi.org/10.1109/TEFSE.2013.6620160}, doi = {10.1109/TEFSE.2013.6620160}, timestamp = {Wed, 04 May 2016 10:05:14 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/BavotaLOPRT13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Latent Semantic Indexing (LSI) is an advanced method widely and successfully employed in Information Retrieval (IR). It is an extension of Vector Space Model (VSM) and it is able to overcome VSM in canonical IR scenarios where it is used on very large document repositories. LSI has also been used to semi-automatically generate traceability links between software artefacts. However, in such a scenario LSI is not able to overcome VSM. This contradicting result is probably due to the different characteristics of software artefact repositories as compared to document repositories. In this paper we present a preliminary empirical study to analyze how the size and the vocabulary of the repository-in terms of number of documents and terms (i.e., the vocabulary)-affects the retrieval accuracy. Even if replications are needed to generalize our findings, the study presented in this paper provides some insights that might be used as guidelines for selecting the more adequate methods to be used for traceability recovery depending on the particular application context.} } @inproceedings{DBLP:conf/icse/DitPMOPPL13, key = {39}, author = {Bogdan Dit and Annibale Panichella and Evan Moritz and Rocco Oliveto and Massimiliano Di Penta and Denys Poshyvanyk and Andrea De Lucia}, title = {Configuring topic models for software engineering tasks in TraceLab}, booktitle = {7th International Workshop on Traceability in Emerging Forms of Software Engineering, {TEFSE} 2013, 19 May, 2013, San Francisco, CA, {USA}}, pages = {105--109}, year = {2013}, crossref = {DBLP:conf/icse/2013tefse}, url = {http://dx.doi.org/10.1109/TEFSE.2013.6620164}, doi = {10.1109/TEFSE.2013.6620164}, timestamp = {Wed, 04 May 2016 10:05:14 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/DitPMOPPL13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {A number of approaches in traceability link recovery and other software engineering tasks incorporate topic models, such as Latent Dirichlet Allocation (LDA). Although in theory these topic models can produce very good results if they are configured properly, in reality their potential may be undermined by improper calibration of their parameters (e.g., number of topics, hyper-parameters), which could potentially lead to sub-optimal results. In our previous work we addressed this issue and proposed LDA-GA, an approach that uses Genetic Algorithms (GA) to find a near-optimal configuration of parameters for LDA, which was shown to produce superior results for traceability link recovery and other tasks than reported ad-hoc configurations. LDA-GA works by optimizing the coherence of topics produced by LDA for a given dataset. In this paper, we instantiate LDA-GA as a TraceLab experiment, making publicly available all the implemented components, the datasets and the results from our previous work. In addition, we provide guidelines on how to extend our LDA-GA approach to other IR techniques and other software engineering tasks using existing TraceLab components.} } @inproceedings{DBLP:conf/icse/PanichellaDOPPL13, key = {38}, author = {Annibale Panichella and Bogdan Dit and Rocco Oliveto and Massimiliano Di Penta and Denys Poshyvanyk and Andrea De Lucia}, title = {How to effectively use topic models for software engineering tasks? an approach based on genetic algorithms}, booktitle = {35th International Conference on Software Engineering, {ICSE} '13, San Francisco, CA, USA, May 18-26, 2013}, pages = {522--531}, year = {2013}, crossref = {DBLP:conf/icse/2013}, url = {http://dx.doi.org/10.1109/ICSE.2013.6606598}, doi = {10.1109/ICSE.2013.6606598}, timestamp = {Tue, 03 May 2016 16:26:31 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/PanichellaDOPPL13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Information Retrieval (IR) methods, and in particular topic models, have recently been used to support essential software engineering (SE) tasks, by enabling software textual retrieval and analysis. In all these approaches, topic models have been used on software artifacts in a similar manner as they were used on natural language documents (e.g., using the same settings and parameters) because the underlying assumption was that source code and natural language documents are similar. However, applying topic models on software data using the same settings as for natural language text did not always produce the expected results. Recent research investigated this assumption and showed that source code is much more repetitive and predictable as compared to the natural language text. Our paper builds on this new fundamental finding and proposes a novel solution to adapt, configure and effectively use a topic modeling technique, namely Latent Dirichlet Allocation (LDA), to achieve better (acceptable) performance across various SE tasks. Our paper introduces a novel solution called LDA-GA, which uses Genetic Algorithms (GA) to determine a near-optimal configuration for LDA in the context of three different SE tasks: (1) traceability link recovery, (2) feature location, and (3) software artifact labeling. The results of our empirical studies demonstrate that LDA-GA is able to identify robust LDA configurations, which lead to a higher accuracy on all the datasets for these SE tasks as compared to previously published results, heuristics, and the results of a combinatorial search.} } @inproceedings{DBLP:conf/icse/BavotaDOPPL13, key = {37}, author = {Gabriele Bavota and Bogdan Dit and Rocco Oliveto and Massimiliano Di Penta and Denys Poshyvanyk and Andrea De Lucia}, title = {An empirical study on the developers' perception of software coupling}, booktitle = {35th International Conference on Software Engineering, {ICSE} '13, San Francisco, CA, USA, May 18-26, 2013}, pages = {692--701}, year = {2013}, crossref = {DBLP:conf/icse/2013}, url = {http://dx.doi.org/10.1109/ICSE.2013.6606615}, doi = {10.1109/ICSE.2013.6606615}, timestamp = {Tue, 03 May 2016 16:26:31 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/BavotaDOPPL13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Coupling is a fundamental property of software systems, and numerous coupling measures have been proposed to support various development and maintenance activities. However, little is known about how developers actually perceive coupling, what mechanisms constitute coupling, and if existing measures align with this perception. In this paper we bridge this gap, by empirically investigating how class coupling - as captured by structural, dynamic, semantic, and logical coupling measures - aligns with developers' perception of coupling. The study has been conducted on three Java open-source systems - namely ArgoUML, JHotDraw and jEdit - and involved 64 students, academics, and industrial practitioners from around the world, as well as 12 active developers of these three systems. We asked participants to assess the coupling between the given pairs of classes and provide their ratings and some rationale. The results indicate that the peculiarity of the semantic coupling measure allows it to better estimate the mental model of developers than the other coupling measures. This is because, in several cases, the interactions between classes are encapsulated in the source code vocabulary, and cannot be easily derived by only looking at structural relationships, such as method calls.} } @inproceedings{DBLP:conf/icse/HaiducBMOLM13, key = {36}, author = {Sonia Haiduc and Gabriele Bavota and Andrian Marcus and Rocco Oliveto and Andrea De Lucia and Tim Menzies}, title = {Automatic query reformulations for text retrieval in software engineering}, booktitle = {35th International Conference on Software Engineering, {ICSE} '13, San Francisco, CA, USA, May 18-26, 2013}, pages = {842--851}, year = {2013}, crossref = {DBLP:conf/icse/2013}, url = {http://dx.doi.org/10.1109/ICSE.2013.6606630}, doi = {10.1109/ICSE.2013.6606630}, timestamp = {Tue, 03 May 2016 16:26:31 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/HaiducBMOLM13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {There are more than twenty distinct software engineering tasks addressed with text retrieval (TR) techniques, such as, traceability link recovery, feature location, refactoring, reuse, etc. A common issue with all TR applications is that the results of the retrieval depend largely on the quality of the query. When a query performs poorly, it has to be reformulated and this is a difficult task for someone who had trouble writing a good query in the first place. We propose a recommender (called Refoqus) based on machine learning, which is trained with a sample of queries and relevant results. Then, for a given query, it automatically recommends a reformulation strategy that should improve its performance, based on the properties of the query. We evaluated Refoqus empirically against four baseline approaches that are used in natural language document retrieval. The data used for the evaluation corresponds to changes from five open source systems in Java and C++ and it is used in the context of TR-based concept location in source code. Refoqus outperformed the baselines and its recommendations lead to query performance improvement or preservation in 84% of the cases (in average).} } @inproceedings{DBLP:conf/icse/HaiducRBOLM04, key = {35}, author = {Sonia Haiduc and Giuseppe De Rosa and Gabriele Bavota and Rocco Oliveto and Andrea De Lucia and Andrian Marcus}, title = {Query quality prediction and reformulation for source code search: the refoqus tool}, booktitle = {35th International Conference on Software Engineering, {ICSE} '13, San Francisco, CA, USA, May 18-26, 2013}, pages = {1307--1310}, year = {2013}, crossref = {DBLP:conf/icse/2013}, url = {http://dx.doi.org/10.1109/ICSE.2013.6606704}, doi = {10.1109/ICSE.2013.6606704}, timestamp = {Wed, 04 May 2016 09:04:15 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/HaiducRBOLM04}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Developers search source code frequently during their daily tasks, to find pieces of code to reuse, to find where to implement changes, etc. Code search based on text retrieval (TR) techniques has been widely used in the software engineering community during the past decade. The accuracy of the TR-based search results depends largely on the quality of the query used. We introduce Refoqus, an Eclipse plugin which is able to automatically detect the quality of a text retrieval query and to propose reformulations for it, when needed, in order to improve the results of TR-based code search. A video of Refoqus is found online at http://www.youtube.com/watch?v=UQlWGiauyk4.} } @inproceedings{DBLP:conf/icse/CanforaPGOP04, key = {34}, author = {Gerardo Canfora and Massimiliano Di Penta and Stefano Giannantonio and Rocco Oliveto and Sebastiano Panichella}, title = {{YODA:} young and newcomer developer assistant}, booktitle = {35th International Conference on Software Engineering, {ICSE} '13, San Francisco, CA, USA, May 18-26, 2013}, pages = {1331--1334}, year = {2013}, crossref = {DBLP:conf/icse/2013}, url = {http://dx.doi.org/10.1109/ICSE.2013.6606710}, doi = {10.1109/ICSE.2013.6606710}, timestamp = {Wed, 04 May 2016 09:04:15 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/CanforaPGOP04}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Mentoring project newcomers is a crucial activity in software projects, and requires to identify people having good communication and teaching skills, other than high expertise on specific technical topics. In this demo we present Yoda (Young and newcOmer Developer Assistant), an Eclipse plugin that identifies and recommends mentors for newcomers joining a software project. Yoda mines developers' communication (e.g., mailing lists) and project versioning systems to identify mentors using an approach inspired to what ArnetMiner does when mining advisor/student relations. Then, it recommends appropriate mentors based on the specific expertise required by the newcomer. The demo shows Yoda in action, illustrating how the tool is able to identify and visualize mentoring relations in a project, and suggest appropriate mentors for a developer who is going to work on certain source code files, or on a given topic. Demo URL: http://youtu.be/4yrbYT-LAXA.} } @inproceedings{DBLP:conf/icse/PollockBLHOBB04, key = {33}, author = {Lori L. Pollock and David Binkley and Dawn Lawrie and Emily Hill and Rocco Oliveto and Gabriele Bavota and Alberto Bacchelli}, title = {1st international workshop on natural language analysis in software engineering (NaturaLiSE 2013)}, booktitle = {35th International Conference on Software Engineering, {ICSE} '13, San Francisco, CA, USA, May 18-26, 2013}, pages = {1537--1538}, year = {2013}, crossref = {DBLP:conf/icse/2013}, url = {http://dx.doi.org/10.1109/ICSE.2013.6606775}, doi = {10.1109/ICSE.2013.6606775}, timestamp = {Wed, 04 May 2016 09:04:15 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/PollockBLHOBB04}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Software engineers produce code that has formal syntax and semantics, which establishes its formal meaning. However, the code also includes significant natural language found primarily in identifier names and comments. Furthermore, the code is surrounded by non-source artifacts, predominantly written in natural language. The NaturaLiSE workshop focuses on natural language analysis of software. The workshop brings together researchers and practitioners interested in exploiting natural language information to create improved software engineering tools. Participants will explore natural language analysis applied to software artifacts, combining natural language and traditional program analysis, integration of natural language analyses into client tools, mining natural language data, and empirical studies focused on evaluating the usefulness of natural language analysis.} } @inproceedings{DBLP:conf/icsm/BavotaCPOP13, key = {32}, author = {Gabriele Bavota and Gerardo Canfora and Massimiliano Di Penta and Rocco Oliveto and Sebastiano Panichella}, title = {An Empirical Investigation on Documentation Usage Patterns in Maintenance Tasks}, booktitle = {2013 {IEEE} International Conference on Software Maintenance, Eindhoven, The Netherlands, September 22-28, 2013}, pages = {210--219}, year = {2013}, crossref = {DBLP:conf/icsm/2013}, url = {http://dx.doi.org/10.1109/ICSM.2013.32}, doi = {10.1109/ICSM.2013.32}, timestamp = {Wed, 10 Jun 2015 16:53:30 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/BavotaCPOP13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {When developers perform a software maintenance task, they need to identify artifacts-e.g., classes or more specifically methods-that need to be modified. To this aim, they can browse various kind of artifacts, for example use case descriptions, UML diagrams, or source code. This paper reports the results of a study-conducted with 33 participants- aimed at investigating (i) to what extent developers use different kinds of documentation when identifying artifacts to be changed, and (ii) whether they follow specific navigation patterns among different kinds of artifacts. Results indicate that, although participants spent a conspicuous proportion of the available time by focusing on source code, they browse back and forth between source code and either static (class) or dynamic (sequence) diagrams. Less frequently, participants-especially more experienced ones-follow an "integrated" approach by using different kinds of artifacts.} } @inproceedings{DBLP:conf/icsm/BavotaCPOP13a, key = {31}, author = {Gabriele Bavota and Gerardo Canfora and Massimiliano Di Penta and Rocco Oliveto and Sebastiano Panichella}, title = {The Evolution of Project Inter-dependencies in a Software Ecosystem: The Case of Apache}, booktitle = {2013 {IEEE} International Conference on Software Maintenance, Eindhoven, The Netherlands, September 22-28, 2013}, pages = {280--289}, year = {2013}, crossref = {DBLP:conf/icsm/2013}, url = {http://dx.doi.org/10.1109/ICSM.2013.39}, doi = {10.1109/ICSM.2013.39}, timestamp = {Wed, 10 Jun 2015 16:53:30 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/BavotaCPOP13a}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Software ecosystems consist of multiple software projects, often interrelated each other by means of dependency relations. When one project undergoes changes, other projects may decide to upgrade the dependency. For example, a project could use a new version of another project because the latter has been enhanced or subject to some bug-fixing activities. This paper reports an exploratory study aimed at observing the evolution of the Java subset of the Apache ecosystem, consisting of 147 projects, for a period of 14 years, and resulting in 1,964 releases. Specifically, we analyze (i) how dependencies change over time, (ii) whether a dependency upgrade is due to different kinds of factors, such as different kinds of API changes or licensing issues, and (iii) how an upgrade impacts on a related project. Results of this study help to comprehend the phenomenon of library/component upgrade, and provides the basis for a new family of recommenders aimed at supporting developers in the complex (and risky) activity of managing library/component upgrade within their software projects.} } @inproceedings{DBLP:conf/icsm/HillBBDLO13, key = {30}, author = {Emily Hill and Alberto Bacchelli and Dave Binkley and Bogdan Dit and Dawn Lawrie and Rocco Oliveto}, title = {Which Feature Location Technique is Better?}, booktitle = {2013 {IEEE} International Conference on Software Maintenance, Eindhoven, The Netherlands, September 22-28, 2013}, pages = {408--411}, year = {2013}, crossref = {DBLP:conf/icsm/2013}, url = {http://dx.doi.org/10.1109/ICSM.2013.59}, doi = {10.1109/ICSM.2013.59}, timestamp = {Wed, 10 Jun 2015 16:53:30 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/HillBBDLO13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Feature location is a fundamental step in software evolution tasks such as debugging, understanding, and reuse. Numerous automated and semi-automated feature location techniques (FLTs) have been proposed, but the question remains: How do we objectively determine which FLT is most effective? Existing evaluations frequently use bug fix data, which includes the location of the fix, but not what other code needs to be understood to make the fix. Existing evaluation measures such as precision, recall, effectiveness, mean average precision (MAP), and mean reciprocal rank (MRR) will not differentiate between a FLT that ranks higher these related elements over completely irrelevant ones. We propose an alternative measure of relevance based on the likelihood of a developer finding the bug fix locations from a ranked list of results. Our initial evaluation shows that by modeling user behavior, our proposed evaluation methodology can compare and evaluate FLTs fairly.} } @inproceedings{DBLP:conf/icst/CanforaLPOPP13, key = {29}, author = {Gerardo Canfora and Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Annibale Panichella and Sebastiano Panichella}, title = {Multi-objective Cross-Project Defect Prediction}, booktitle = {Sixth {IEEE} International Conference on Software Testing, Verification and Validation, {ICST} 2013, Luxembourg, Luxembourg, March 18-22, 2013}, pages = {252--261}, year = {2013}, crossref = {DBLP:conf/icst/2013}, url = {http://dx.doi.org/10.1109/ICST.2013.38}, doi = {10.1109/ICST.2013.38}, timestamp = {Mon, 11 May 2015 16:37:25 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icst/CanforaLPOPP13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Cross-project defect prediction is very appealing because (i) it allows predicting defects in projects for which the availability of data is limited, and (ii) it allows producing generalizable prediction models. However, existing research suggests that cross-project prediction is particularly challenging and, due to heterogeneity of projects, prediction accuracy is not always very good. This paper proposes a novel, multi-objective approach for cross-project defect prediction, based on a multi-objective logistic regression model built using a genetic algorithm. Instead of providing the software engineer with a single predictive model, the multi-objective approach allows software engineers to choose predictors achieving a compromise between number of likely defect-prone artifacts (effectiveness) and LOC to be analyzed/tested (which can be considered as a proxy of the cost of code inspection). Results of an empirical evaluation on 10 datasets from the Promise repository indicate the superiority and the usefulness of the multi-objective approach with respect to single-objective predictors. Also, the proposed approach outperforms an alternative approach for cross-project prediction, based on local prediction upon clusters of similar classes.} } @inproceedings{DBLP:conf/issta/KifetewPLOT13, key = {28}, author = {Fitsum Meshesha Kifetew and Annibale Panichella and Andrea De Lucia and Rocco Oliveto and Paolo Tonella}, title = {Orthogonal exploration of the search space in evolutionary test case generation}, booktitle = {International Symposium on Software Testing and Analysis, {ISSTA} '13, Lugano, Switzerland, July 15-20, 2013}, pages = {257--267}, year = {2013}, crossref = {DBLP:conf/issta/2013}, url = {http://doi.acm.org/10.1145/2483760.2483789}, doi = {10.1145/2483760.2483789}, timestamp = {Mon, 15 Jul 2013 10:26:47 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/issta/KifetewPLOT13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The effectiveness of evolutionary test case generation based on Genetic Algorithms (GAs) can be seriously impacted by genetic drift, a phenomenon that inhibits the ability of such algorithms to effectively diversify the search and look for alternative potential solutions. In such cases, the search becomes dominated by a small set of similar individuals that lead GAs to converge to a sub-optimal solution and to stagnate, without reaching the desired objective. This problem is particularly common for hard-to-cover program branches, associated with an extremely large solution space. In this paper, we propose an approach to solve this problem by integrating a mechanism for orthogonal exploration of the search space into standard GA. The diversity in the population is enriched by adding individuals in orthogonal directions, hence providing a more effective exploration of the solution space. To the best of our knowledge, no prior work has addressed explicitly the issue of evolution direction based diversification in the context of evolutionary testing. Results achieved on 17 Java classes indicate that the proposed enhancements make GA much more effective and efficient in automating the testing process. In particular, effectiveness (coverage) was significantly improved in 47% of the subjects and efficiency (search budget consumed) was improved in 85% of the subjects on which effectiveness remains the same. } } @inproceedings{DBLP:conf/iwpc/DiazBMOTL13, key = {27}, author = {Diana Diaz and Gabriele Bavota and Andrian Marcus and Rocco Oliveto and Silvia Takahashi and Andrea De Lucia}, title = {Using code ownership to improve IR-based Traceability Link Recovery}, booktitle = {{IEEE} 21st International Conference on Program Comprehension, {ICPC} 2013, San Francisco, CA, USA, 20-21 May, 2013}, pages = {123--132}, year = {2013}, crossref = {DBLP:conf/iwpc/2013}, url = {http://dx.doi.org/10.1109/ICPC.2013.6613840}, doi = {10.1109/ICPC.2013.6613840}, timestamp = {Fri, 06 May 2016 09:51:52 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/iwpc/DiazBMOTL13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Information Retrieval (IR) techniques have gained wide-spread acceptance as a method for automating traceability recovery. These techniques recover links between software artifacts based on their textual similarity, i.e., the higher the similarity, the higher the likelihood that there is a link between the two artifacts. A common problem with all IR-based techniques is filtering out noise from the list of candidate links, in order to improve the recovery accuracy. Indeed, software artifacts may be related in many ways and the textual information captures only one aspect of their relationships. In this paper we propose to leverage code ownership information to capture relationships between source code artifacts for improving the recovery of traceability links between documentation and source code. Specifically, we extract the author of each source code component and for each author we identify the “context” she worked on. Thus, for a given query from the external documentation we compute the similarity between it and the context of the authors. When retrieving classes that relate to a specific query using a standard IR-based approach we reward all the classes developed by the authors having their context most similar to the query, by boosting their similarity to the query. The proposed approach, named TYRION (TraceabilitY link Recovery using Information retrieval and code OwNership), has been instantiated for the recovery of traceability links between use cases and Java classes of two software systems. The results indicate that code ownership information can be used to improve the accuracy of an IR-based traceability link recovery technique.} } @inproceedings{DBLP:conf/kbse/PalombaBPOLP13, key = {26}, author = {Fabio Palomba and Gabriele Bavota and Massimiliano Di Penta and Rocco Oliveto and Andrea De Lucia and Denys Poshyvanyk}, title = {Detecting bad smells in source code using change history information}, booktitle = {2013 28th {IEEE/ACM} International Conference on Automated Software Engineering, {ASE} 2013, Silicon Valley, CA, USA, November 11-15, 2013}, pages = {268--278}, year = {2013}, crossref = {DBLP:conf/kbse/2013}, url = {http://dx.doi.org/10.1109/ASE.2013.6693086}, doi = {10.1109/ASE.2013.6693086}, timestamp = {Mon, 21 Jul 2014 07:41:41 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/kbse/PalombaBPOLP13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Code smells represent symptoms of poor implementation choices. Previous studies found that these smells make source code more difficult to maintain, possibly also increasing its fault-proneness. There are several approaches that identify smells based on code analysis techniques. However, we observe that many code smells are intrinsically characterized by how code elements change over time. Thus, relying solely on structural information may not be sufficient to detect all the smells accurately. We propose an approach to detect five different code smells, namely Divergent Change, Shotgun Surgery, Parallel Inheritance, Blob, and Feature Envy, by exploiting change history information mined from versioning systems. We applied approach, coined as HIST (Historical Information for Smell deTection), to eight software projects written in Java, and wherever possible compared with existing state-of-the-art smell detectors based on source code analysis. The results indicate that HIST's precision ranges between 61% and 80%, and its recall ranges between 61% and 100%. More importantly, the results confirm that HIST is able to identify code smells that cannot be identified through approaches solely based on code analysis.} } @inproceedings{DBLP:conf/sigsoft/VasquezBBPOP13, key = {25}, author = {Mario Linares V{\'{a}}squez and Gabriele Bavota and Carlos Bernal{-}C{\'{a}}rdenas and Massimiliano Di Penta and Rocco Oliveto and Denys Poshyvanyk}, title = {{API} change and fault proneness: a threat to the success of Android apps}, booktitle = {Joint Meeting of the European Software Engineering Conference and the {ACM} {SIGSOFT} Symposium on the Foundations of Software Engineering, ESEC/FSE'13, Saint Petersburg, Russian Federation, August 18-26, 2013}, pages = {477--487}, year = {2013}, crossref = {DBLP:conf/sigsoft/2013}, url = {http://doi.acm.org/10.1145/2491411.2491428}, doi = {10.1145/2491411.2491428}, timestamp = {Sat, 31 Aug 2013 17:43:06 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/sigsoft/VasquezBBPOP13}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {During the recent years, the market of mobile software applications (apps) has maintained an impressive upward trajectory. Many small and large software development companies invest considerable resources to target available opportunities. As of today, the markets for such devices feature over 850K+ apps for Android and 900K+ for iOS. Availability, cost, functionality, and usability are just some factors that determine the success or lack of success for a given app. Among the other factors, reliability is an important criteria: users easily get frustrated by repeated failures, crashes, and other bugs; hence, abandoning some apps in favor of others. This paper reports a study analyzing how the fault- and change-proneness of APIs used by 7,097 (free) Android apps relates to applications' lack of success, estimated from user ratings. Results of this study provide important insights into a crucial issue: making heavy use of fault- and change-prone APIs can negatively impact the success of these apps.} } @inproceedings{DBLP:conf/wcre/2013, key = {24}, author = {Ralf L{\"{a}}mmel and Rocco Oliveto and Romain Robbes}, title = {20th Working Conference on Reverse Engineering, {WCRE} 2013, Koblenz, Germany, October 14-17, 2013}, booktitle = {{IEEE} Computer Society}, year = {2013}, url = {http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=6656028}, isbn = {978-1-4799-2931-3}, timestamp = {Tue, 14 Apr 2015 18:52:47 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/wcre/2013}, bibsource = {dblp computer science bibliography, http://dblp.org} } % ======================== 2012 =========================================== @inproceedings{DBLP:conf/gecco/LuciaPOP12, key = {23}, author = {Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Annibale Panichella}, title = {Estimating the evolution direction of populations to improve genetic algorithms}, booktitle = {Genetic and Evolutionary Computation Conference, {GECCO} '12, Philadelphia, PA, USA, July 7-11, 2012}, pages = {617--624}, year = {2012}, crossref = {DBLP:conf/gecco/2012}, url = {http://doi.acm.org/10.1145/2330163.2330251}, doi = {10.1145/2330163.2330251}, timestamp = {Wed, 11 Jul 2012 15:00:56 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/gecco/LuciaPOP12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Meta-heuristics have been successfully used to solve a wide variety of problems. However, one issue many techniques have is their risk of being trapped into local optima, or to create a limited variety of solutions (problem known as "population drift"). During recent and past years, different kinds of techniques have been proposed to deal with population drift, for example hybridizing genetic algorithms with local search techniques or using niche techniques. This paper proposes a technique, based on Singular Value Decomposition (SVD), to enhance Genetic Algorithms (GAs) population diversity. SVD helps to estimate the evolution direction and drive next generations towards orthogonal dimensions. The proposed SVD-based GA has been evaluated on 11 benchmark problems and compared with a simple GA and a GA with a distance-crowding schema. Results indicate that SVD-based GA achieves significantly better solutions and exhibits a quicker convergence than the alternative techniques.} } @inproceedings{DBLP:conf/icse/LuciaPOP12, key = {22}, author = {Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Annibale Panichella}, title = {On the role of diversity measures for multi-objective test case selection}, booktitle = {7th International Workshop on Automation of Software Test, {AST} 2012, Zurich, Switzerland, June 2-3, 2012}, pages = {145--151}, year = {2012}, crossref = {DBLP:conf/icse/2012ast}, url = {http://dx.doi.org/10.1109/IWAST.2012.6228983}, doi = {10.1109/IWAST.2012.6228983}, timestamp = {Tue, 03 May 2016 15:54:00 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/LuciaPOP12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Test case selection has been recently formulated as multi-objective optimization problem trying to satisfy conflicting goals, such as code coverage and computational cost. This paper introduces the concept of asymmetric distance preserving, useful to improve the diversity of non-dominated solutions produced by multi-objective Pareto efficient genetic algorithms, and proposes two techniques to achieve this objective. Results of an empirical study conducted over four programs from the SIR benchmark show how the proposed technique (i) obtains non-dominated solutions having a higher diversity than the previously proposed multi-objective Pareto genetic algorithms; and (ii) improves the convergence speed of the genetic algorithms.} } @inproceedings{DBLP:conf/icse/BavotaLFOZ12, key = {21}, author = {Gabriele Bavota and Andrea De Lucia and Fausto Fasano and Rocco Oliveto and Carlo Zottoli}, title = {Teaching software engineering and software project management: An integrated and practical approach}, booktitle = {34th International Conference on Software Engineering, {ICSE} 2012, June 2-9, 2012, Zurich, Switzerland}, pages = {1155--1164}, year = {2012}, crossref = {DBLP:conf/icse/2012}, url = {http://dx.doi.org/10.1109/ICSE.2012.6227027}, doi = {10.1109/ICSE.2012.6227027}, timestamp = {Tue, 03 May 2016 16:08:27 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/BavotaLFOZ12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {We present a practical approach for teaching two different courses of Software Engineering (SE) and Software Project Management (SPM) in an integrated way. The two courses are taught in the same semester, thus allowing to build mixed project teams composed of five-eight Bachelor's students (with development roles) and one or two Master's students (with management roles). The main goal of our approach is to simulate a real-life development scenario giving to the students the possibility to deal with issues arising from typical project situations, such as working in a team, organising the division of work, and coping with time pressure and strict deadlines.} } @inproceedings{DBLP:conf/icse/HaiducBOML12, key = {20}, author = {Sonia Haiduc and Gabriele Bavota and Rocco Oliveto and Andrian Marcus and Andrea De Lucia}, title = {Evaluating the specificity of text retrieval queries to support software engineering tasks}, booktitle = {34th International Conference on Software Engineering, {ICSE} 2012, June 2-9, 2012, Zurich, Switzerland}, pages = {1273--1276}, year = {2012}, crossref = {DBLP:conf/icse/2012}, url = {http://dx.doi.org/10.1109/ICSE.2012.6227101}, doi = {10.1109/ICSE.2012.6227101}, timestamp = {Tue, 03 May 2016 16:08:27 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/HaiducBOML12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Text retrieval approaches have been used to address many software engineering tasks. In most cases, their use involves issuing a textual query to retrieve a set of relevant software artifacts from the system. The performance of all these approaches depends on the quality of the given query (i.e., its ability to describe the information need in such a way that the relevant software artifacts are retrieved during the search). Currently, the only way to tell that a query failed to lead to the expected software artifacts is by investing time and effort in analyzing the search results. In addition, it is often very difficult to ascertain what part of the query leads to poor results. We propose a novel pre-retrieval metric, which reflects the quality of a query by measuring the specificity of its terms. We exemplify the use of the new specificity metric on the task of concept location in source code. A preliminary empirical study shows that our metric is a good effort predictor for text retrieval-based concept location, outperforming existing techniques from the field of natural language document retrieval.} } @inproceedings{DBLP:conf/icse/BavotaLMOP12, key = {19}, author = {Gabriele Bavota and Andrea De Lucia and Andrian Marcus and Rocco Oliveto and Fabio Palomba}, title = {Supporting extract class refactoring in Eclipse: The {ARIES} project}, booktitle = {34th International Conference on Software Engineering, {ICSE} 2012, June 2-9, 2012, Zurich, Switzerland}, pages = {1419--1422}, year = {2012}, crossref = {DBLP:conf/icse/2012}, url = {http://dx.doi.org/10.1109/ICSE.2012.6227233}, doi = {10.1109/ICSE.2012.6227233}, timestamp = {Tue, 03 May 2016 16:08:27 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/BavotaLMOP12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {During software evolution changes are inevitable. These changes may lead to design erosion and the introduction of inadequate design solutions, such as design antipatterns. Several empirical studies provide evidence that the presence of antipatterns is generally associated with lower productivity, greater rework, and more significant design efforts for developers. In order to improve the quality and remove antipatterns, refactoring operations are needed. In this demo, we present the Extract class features of ARIES (Automated Refactoring In EclipSe), an Eclipse plug-in that supports the software engineer in removing the “Blob” antipattern.} } @inproceedings{DBLP:conf/icsm/BavotaQOLB12, key = {18}, author = {Gabriele Bavota and Abdallah Qusef and Rocco Oliveto and Andrea De Lucia and David Binkley}, title = {An empirical analysis of the distribution of unit test smells and their impact on software maintenance}, booktitle = {28th {IEEE} International Conference on Software Maintenance, {ICSM} 2012, Trento, Italy, September 23-28, 2012}, pages = {56--65}, year = {2012}, crossref = {DBLP:conf/icsm/2012}, url = {http://dx.doi.org/10.1109/ICSM.2012.6405253}, doi = {10.1109/ICSM.2012.6405253}, timestamp = {Wed, 10 Jun 2015 16:53:30 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/BavotaQOLB12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Unit testing represents a key activity in software development and maintenance. Test suites with high internal quality facilitate maintenance activities, such as code comprehension and regression testing. Several guidelines have been proposed to help developers write good test suites. Unfortunately, such rules are not always followed resulting in the presence of bad test code smells (or simply test smells). Test smells have been defined as poorly designed tests and their presence may negatively affect the maintainability of test suites and production code. Despite the many studies that address code smells in general, until now there has been no empirical evidence regarding test smells (i) distribution in software systems nor (ii) their impact on the maintainability of software systems. This paper fills this gap by presenting two empirical studies. The first study is an exploratory analysis of 18 software systems (two industrial and 16 open source) aimed at analyzing the distribution of test smells in source code. The second study, a controlled experiment involving twenty master students, is aimed at analyzing whether the presence of test smells affects the comprehension of source code during software maintenance. The results show that (i) test smells are widely spread throughout the software systems studied and (ii) most of the test smells have a strong negative impact on the comprehensibility of test suites and production code.} } @inproceedings{DBLP:conf/icsm/BavotaCLFOP12, key = {17}, author = {Gabriele Bavota and Luigi Colangelo and Andrea De Lucia and Sabato Fusco and Rocco Oliveto and Annibale Panichella}, title = {TraceME: Traceability Management in Eclipse}, booktitle = {28th {IEEE} International Conference on Software Maintenance, {ICSM} 2012, Trento, Italy, September 23-28, 2012}, pages = {642--645}, year = {2012}, crossref = {DBLP:conf/icsm/2012}, url = {http://dx.doi.org/10.1109/ICSM.2012.6405343}, doi = {10.1109/ICSM.2012.6405343}, timestamp = {Wed, 10 Jun 2015 16:53:29 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/BavotaCLFOP12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {In this demo we present TraceME (Traceability Management in Eclipse), an Eclipse plug-in, that supports the software engineer in capturing and maintaining traceability links between different types of artifacts. A comparative analysis of the functionalities of the tools supporting traceability recovery highlights that TraceME is the more comprehensive tool for supporting such a critical activity during software development.} } @inproceedings{DBLP:conf/iwpc/LuciaPOPP12, key = {16}, author = {Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Annibale Panichella and Sebastiano Panichella}, title = {Using {IR} methods for labeling source code artifacts: Is it worthwhile?}, booktitle = {{IEEE} 20th International Conference on Program Comprehension, {ICPC} 2012, Passau, Germany, June 11-13, 2012}, pages = {193--202}, year = {2012}, crossref = {DBLP:conf/iwpc/2012}, url = {http://dx.doi.org/10.1109/ICPC.2012.6240488}, doi = {10.1109/ICPC.2012.6240488}, timestamp = {Fri, 06 May 2016 09:32:57 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/iwpc/LuciaPOPP12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Information Retrieval (IR) techniques have been used for various software engineering tasks, including the labeling of software artifacts by extracting “keywords” from them. Such techniques include Vector Space Models, Latent Semantic Indexing, Latent Dirichlet Allocation, as well as customized heuristics extracting words from specific source code elements. This paper investigates how source code artifact labeling performed by IR techniques would overlap (and differ) from labeling performed by humans. This has been done by asking a group of subjects to label 20 classes from two Java software systems, JHotDraw and eXVantage. Results indicate that, in most cases, automatic labeling would be more similar to human-based labeling if using simpler techniques - e.g., using words from class and method names - that better reflect how humans behave. Instead, clustering-based approaches (LSI and LDA) are much more worthwhile to be used on source code artifacts having a high verbosity, as well as for artifacts requiring more effort to be manually labeled.} } @inproceedings{DBLP:conf/kbse/HaiducBOLM12, key = {15}, author = {Sonia Haiduc and Gabriele Bavota and Rocco Oliveto and Andrea De Lucia and Andrian Marcus}, title = {Automatic query performance assessment during the retrieval of software artifacts}, booktitle = {{IEEE/ACM} International Conference on Automated Software Engineering, ASE'12, Essen, Germany, September 3-7, 2012}, pages = {90--99}, year = {2012}, crossref = {DBLP:conf/kbse/2012}, url = {http://doi.acm.org/10.1145/2351676.2351690}, doi = {10.1145/2351676.2351690}, timestamp = {Fri, 19 Oct 2012 18:37:58 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/kbse/HaiducBOLM12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Text-based search and retrieval is used by developers in the context of many SE tasks, such as, concept location, traceability link retrieval, reuse, impact analysis, etc. Solutions for software text search range from regular expression matching to complex techniques using text retrieval. In all cases, the results of a search depend on the query formulated by the developer. A developer needs to run a query and look at the results before realizing that it needs reformulating. Our aim is to automatically assess the performance of a query before it is executed. We introduce an automatic query performance assessment approach for software artifact retrieval, which uses 21 measures from the field of text retrieval. We evaluate the approach in the context of concept location in source code. The evaluation shows that our approach is able to predict the performance of queries with 79% accuracy, using very little training data. } } @inproceedings{DBLP:conf/scam/BavotaCLPOS12, key = {14}, author = {Gabriele Bavota and Bernardino De Carluccio and Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Orazio Strollo}, title = {When Does a Refactoring Induce Bugs? An Empirical Study}, booktitle = {12th {IEEE} International Working Conference on Source Code Analysis and Manipulation, {SCAM} 2012, Riva del Garda, Italy, September 23-24, 2012}, pages = {104--113}, year = {2012}, crossref = {DBLP:conf/scam/2012}, url = {http://dx.doi.org/10.1109/SCAM.2012.20}, doi = {10.1109/SCAM.2012.20}, timestamp = {Wed, 15 Apr 2015 18:38:13 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/scam/BavotaCLPOS12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Refactorings are - as defined by Fowler - behavior preserving source code transformations. Their main purpose is to improve maintainability or comprehensibility, or also reduce the code footprint if needed. In principle, refactorings are defined as simple operations so that are "unlikely to go wrong" and introduce faults. In practice, refactoring activities could have their risks, as other changes. This paper reports an empirical study carried out on three Java software systems, namely Apache Ant, Xerces, and Ar-go UML, aimed at investigating to what extent refactoring activities induce faults. Specifically, we automatically detect (and then manually validate) 15,008 refactoring operations (of 52 different kinds) using an existing tool (Ref-Finder). Then, we use the SZZ algorithm to determine whether it is likely that refactorings induced a fault. Results indicate that, while some kinds of refactorings are unlikely to be harmful, others, such as refactorings involving hierarchies (e.g., pull up method), tend to induce faults very frequently. This suggests more accurate code inspection or testing activities when such specific refactorings are performed.} } @inproceedings{DBLP:conf/sigsoft/CanforaPOP12, key = {13}, author = {Gerardo Canfora and Massimiliano Di Penta and Rocco Oliveto and Sebastiano Panichella}, title = {Who is going to mentor newcomers in open source projects?}, booktitle = {20th {ACM} {SIGSOFT} Symposium on the Foundations of Software Engineering (FSE-20), SIGSOFT/FSE'12, Cary, NC, {USA} - November 11 - 16, 2012}, pages = {44}, year = {2012}, crossref = {DBLP:conf/sigsoft/2012}, url = {http://doi.acm.org/10.1145/2393596.2393647}, doi = {10.1145/2393596.2393647}, timestamp = {Mon, 15 Jun 2015 19:00:08 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/sigsoft/CanforaPOP12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {When newcomers join a software project, they need to be properly trained to understand the technical and organizational aspects of the project. Inadequate training could likely lead to project delay or failure. In this paper we propose an approach, named Yoda (Young and newcOmer Developer Assistant) aimed at identifying and recommending mentors in software projects by mining data from mailing lists and versioning systems. Candidate mentors are identified among experienced developers who actively interact with newcomers. Then, when a newcomer joins the project, Yoda recommends her a mentor that, among the available ones, has already discussed topics relevant for the newcomer. Yoda has been evaluated on software repositories of five open source projects. We have also surveyed some developers of these projects to understand whether mentoring was actually performed in their projects, and asked them to evaluate the mentoring relations Yoda identified. Results indicate that top committers are not always the most appropriate mentors, and show the potential usefulness of Yoda as a recommendation system to aid project managers in supporting newcomers joining a software project.} } @inproceedings{DBLP:conf/ssbse/BavotaCLPO12, key = {12}, author = {Gabriele Bavota and Filomena Carnevale and Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto}, title = {Putting the Developer in-the-Loop: An Interactive {GA} for Software Re-modularization}, booktitle = {Search Based Software Engineering - 4th International Symposium, {SSBSE} 2012, Riva del Garda, Italy, September 28-30, 2012. Proceedings}, pages = {75--89}, year = {2012}, crossref = {DBLP:conf/ssbse/2012}, url = {http://dx.doi.org/10.1007/978-3-642-33119-0_7}, doi = {10.1007/978-3-642-33119-0_7}, timestamp = {Fri, 14 Sep 2012 10:36:35 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/ssbse/BavotaCLPO12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {This paper proposes the use of Interactive Genetic Algorithms (IGAs) to integrate developer’s knowledge in a re-modularization task. Specifically, the proposed algorithm uses a fitness composed of automatically-evaluated factors—accounting for the modularization quality achieved by the solution—and a human-evaluated factor, penalizing cases where the way re-modularization places components into modules is considered meaningless by the developer. The proposed approach has been evaluated to re-modularize two software systems, SMOS and GESA. The obtained results indicate that IGA is able to produce solutions that, from a developer’s perspective, are more meaningful than those generated using the full-automated GA. While keeping feedback into account, the approach does not sacrifice the modularization quality, and may work requiring a very limited set of feedback only, thus allowing its application also for large systems without requiring a substantial human effort.} } @incollection{DBLP:books/daglib/p/LuciaMOP12, key = {11}, author = {Andrea De Lucia and Andrian Marcus and Rocco Oliveto and Denys Poshyvanyk}, title = {Information Retrieval Methods for Automated Traceability Recovery}, booktitle = {Software and Systems Traceability.}, pages = {71--98}, year = {2012}, crossref = {DBLP:books/daglib/0028967}, url = {http://dx.doi.org/10.1007/978-1-4471-2239-5_4}, doi = {10.1007/978-1-4471-2239-5_4}, timestamp = {Wed, 04 Sep 2013 09:40:17 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/books/daglib/p/LuciaMOP12}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The potential benefits of traceability are well known and documented, as well as the impracticability of recovering and maintaining traceability links manually. Indeed, the manual management of traceability information is an error prone and time consuming task. Consequently, despite the advantages that can be gained, explicit traceability is rarely established unless there is a regulatory reason for doing so. Extensive efforts have been brought forth to improve the explicit connection of software artifacts in the software engineering community (both research and commercial). Promising results have been achieved using Information Retrieval (IR) techniques for traceability recovery. IR-based traceability recovery methods propose a list of candidate traceability links based on the similarity between the text contained in the software artifacts. Software artifacts have different structures and the common element among many of them is the textual data, which most often captures the informal semantics of artifacts. For example, source code includes large volume of textual data in the form of comments and identifiers. In consequence, IR-based approaches are very well suited to address the traceability recovery problem. The conjecture is that artifacts with high textual similarity are good candidates to be traced to each other since they share several concepts. In this chapter we overview a general process of using IR-based methods for traceability link recovery and overview some of them in a greater detail: probabilistic, vector space, and Latent Semantic Indexing models. Finally, we discuss common approaches to measuring the performance of IR-based traceability recovery methods and the latest advances in techniques for the analysis of candidate links.} } % ======================== 2011 =========================================== @article{DBLP:journals/jss/BavotaLO11, key = {10}, author = {Gabriele Bavota and Andrea De Lucia and Rocco Oliveto}, title = {Identifying Extract Class refactoring opportunities using structural and semantic cohesion measures}, journal = {Journal of Systems and Software}, volume = {84}, number = {3}, pages = {397--414}, year = {2011}, url = {http://dx.doi.org/10.1016/j.jss.2010.11.918}, doi = {10.1016/j.jss.2010.11.918}, timestamp = {Mon, 04 Apr 2011 09:37:59 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/jss/BavotaLO11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Approaches for improving class cohesion identify refactoring opportunities using metrics that capture structural relationships between the methods of a class, e.g., attribute references. Semantic metrics, e.g., C3 metric, have also been proposed to measure class cohesion, as they seem to complement structural metrics. However, until now semantic relationships between methods have not been used to identify refactoring opportunities. In this paper we propose an Extract Class refactoring method based on graph theory that exploits structural and semantic relationships between methods. The empirical evaluation of the proposed approach highlighted the benefits provided by the combination of semantic and structural measures and the potential usefulness of the proposed method as a feature for software development environments.} } @article{DBLP:journals/tse/LuciaPO11, key = {9}, author = {Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto}, title = {Improving Source Code Lexicon via Traceability and Information Retrieval}, journal = {{IEEE} Trans. Software Eng.}, volume = {37}, number = {2}, pages = {205--227}, year = {2011}, url = {http://dx.doi.org/10.1109/TSE.2010.89}, doi = {10.1109/TSE.2010.89}, timestamp = {Thu, 10 Dec 2015 11:33:12 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/tse/LuciaPO11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {The paper presents an approach helping developers to maintain source code identifiers and comments consistent with high-level artifacts. Specifically, the approach computes and shows the textual similarity between source code and related high-level artifacts. Our conjecture is that developers are induced to improve the source code lexicon, i.e., terms used in identifiers or comments, if the software development environment provides information about the textual similarity between the source code under development and the related high-level artifacts. The proposed approach also recommends candidate identifiers built from high-level artifacts related to the source code under development and has been implemented as an Eclipse plug-in, called COde Comprehension Nurturant Using Traceability (COCONUT). The paper also reports on two controlled experiments performed with master's and bachelor's students. The goal of the experiments is to evaluate the quality of identifiers and comments (in terms of their consistency with high-level artifacts) in the source code produced when using or not using COCONUT. The achieved results confirm our conjecture that providing the developers with similarity between code and high-level artifacts helps to improve the quality of source code lexicon. This indicates the potential usefulness of COCONUT as a feature for software development environments.} } @inproceedings{DBLP:conf/icse/OlivetoGBPL11, key = {8}, author = {Rocco Oliveto and Malcom Gethers and Gabriele Bavota and Denys Poshyvanyk and Andrea De Lucia}, title = {Identifying method friendships to remove the feature envy bad smell}, booktitle = {Proceedings of the 33rd International Conference on Software Engineering, {ICSE} 2011, Waikiki, Honolulu , HI, USA, May 21-28, 2011}, pages = {820--823}, year = {2011}, crossref = {DBLP:conf/icse/2011}, url = {http://doi.acm.org/10.1145/1985793.1985913}, doi = {10.1145/1985793.1985913}, timestamp = {Wed, 01 Apr 2015 20:06:21 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/OlivetoGBPL11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {We propose a novel approach to identify Move Method refactoring opportunities and remove the Feature Envy bad smell from source code. The proposed approach analyzes both structural and conceptual relationships between methods and uses Relational Topic Models to identify sets of methods that share several responsabilities, i.e., 'friend methods'. The analysis of method friendships of a given method can be used to pinpoint the target class (envied class) where the method should be moved in. The results of a preliminary empirical evaluation indicate that the proposed approach provides meaningful refactoring opportunities.} } @inproceedings{DBLP:conf/icse/GethersSPOPL11, key = {7}, author = {Malcom Gethers and Trevor Savage and Massimiliano Di Penta and Rocco Oliveto and Denys Poshyvanyk and Andrea De Lucia}, title = {CodeTopics: which topic am {I} coding now?}, booktitle = {Proceedings of the 33rd International Conference on Software Engineering, {ICSE} 2011, Waikiki, Honolulu , HI, USA, May 21-28, 2011}, pages = {1034--1036}, year = {2011}, crossref = {DBLP:conf/icse/2011}, url = {http://doi.acm.org/10.1145/1985793.1985988}, doi = {10.1145/1985793.1985988}, timestamp = {Wed, 01 Apr 2015 20:06:21 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icse/GethersSPOPL11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Recent studies indicated that showing the similarity between the source code being developed and related high-level artifacts (HLAs), such as requirements, helps developers improve the quality of source code identifiers. In this paper, we present CodeTopics, an Eclipse plug-in that in addition to showing the similarity between source code and HLAs also highlights to what extent the code under development covers topics described in HLAs. Such views complement information derived by showing only the similarity between source code and HLAs helping (i) developers to identify functionality that are not implemented yet or (ii) newcomers to comprehend source code artifacts by showing them the topics that these artifacts relate to.} } @inproceedings{DBLP:conf/icsm/QusefBOLB11, key = {6}, author = {Abdallah Qusef and Gabriele Bavota and Rocco Oliveto and Andrea De Lucia and David Binkley}, title = {{SCOTCH:} Test-to-code traceability using slicing and conceptual coupling}, booktitle = {{IEEE} 27th International Conference on Software Maintenance, {ICSM} 2011, Williamsburg, VA, USA, September 25-30, 2011}, pages = {63--72}, year = {2011}, crossref = {DBLP:conf/icsm/2011}, url = {http://dx.doi.org/10.1109/ICSM.2011.6080773}, doi = {10.1109/ICSM.2011.6080773}, timestamp = {Wed, 10 Jun 2015 16:53:30 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/QusefBOLB11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Maintaining traceability links between unit tests and tested classes is an important factor for effectively managing the development and evolution of software systems. Exploiting traceability links helps in program comprehension and maintenance by ensuring consistency between unit tests and tested classes during maintenance activities. Unfortunately, it is often the case that such links are not explicitly maintained and thus they have to be recovered manually during software evolution. A novel automated solution to this problem, based on dynamic slicing and conceptual coupling, is presented. The resulting tool, SCOTCH (Slicing and Coupling based Test to Code trace Hunter), is empirically evaluated on three systems: an open source system and two industrial systems. The results indicate that SCOTCH identifies traceability links between unit test classes and tested classes with a high accuracy and greater stability than existing techniques, highlighting its potential usefulness as a feature within a software development environment.} } @inproceedings{DBLP:conf/icsm/GethersOPL11, key = {5}, author = {Malcom Gethers and Rocco Oliveto and Denys Poshyvanyk and Andrea De Lucia}, title = {On integrating orthogonal information retrieval methods to improve traceability recovery}, booktitle = {{IEEE} 27th International Conference on Software Maintenance, {ICSM} 2011, Williamsburg, VA, USA, September 25-30, 2011}, pages = {133--142}, year = {2011}, crossref = {DBLP:conf/icsm/2011}, url = {http://dx.doi.org/10.1109/ICSM.2011.6080780}, doi = {10.1109/ICSM.2011.6080780}, timestamp = {Wed, 10 Jun 2015 16:53:30 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/icsm/GethersOPL11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Different Information Retrieval (IR) methods have been proposed to recover traceability links among software artifacts. Until now there is no single method that sensibly outperforms the others, however, it has been empirically shown that some methods recover different, yet complementary traceability links. In this paper, we exploit this empirical finding and propose an integrated approach to combine orthogonal IR techniques, which have been statistically shown to produce dissimilar results. Our approach combines the following IR-based methods: Vector Space Model (VSM), probabilistic Jensen and Shannon (JS) model, and Relational Topic Modeling (RTM), which has not been used in the context of traceability link recovery before. The empirical case study conducted on six software systems indicates that the integrated method outperforms stand-alone IR methods as well as any other combination of non-orthogonal methods with a statistically significant margin.} } @inproceedings{DBLP:conf/iwpc/LuciaPOPP11, key = {4}, author = {Andrea De Lucia and Massimiliano Di Penta and Rocco Oliveto and Annibale Panichella and Sebastiano Panichella}, title = {Improving IR-based Traceability Recovery Using Smoothing Filters}, booktitle = {The 19th {IEEE} International Conference on Program Comprehension, {ICPC} 2011, Kingston, ON, Canada, June 22-24, 2011}, pages = {21--30}, year = {2011}, crossref = {DBLP:conf/iwpc/2011}, url = {http://dx.doi.org/10.1109/ICPC.2011.34}, doi = {10.1109/ICPC.2011.34}, timestamp = {Fri, 06 May 2016 09:33:40 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/iwpc/LuciaPOPP11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Information Retrieval methods have been largely adopted to identify traceability links based on the textual similarity of software artifacts. However, noise due to word usage in software artifacts might negatively affect the recovery accuracy. We propose the use of smoothing filters to reduce the effect of noise in software artifacts and improve the performances of traceability recovery methods. An empirical evaluation performed on two repositories indicates that the usage of a smoothing filter is able to significantly improve the performances of Vector Space Model and Latent Semantic Indexing. Such a result suggests that other than being used for traceability recovery the proposed filter can be used to improve performances of various other software engineering approaches based on textual analysis.} } @inproceedings{DBLP:conf/models/BavotaGOLTGC11, key = {3}, author = {Gabriele Bavota and Carmine Gravino and Rocco Oliveto and Andrea De Lucia and Genoveffa Tortora and Marcela Genero and Jos{\'{e}} A. Cruz{-}Lemus}, title = {Identifying the Weaknesses of {UML} Class Diagrams during Data Model Comprehension}, booktitle = {Model Driven Engineering Languages and Systems, 14th International Conference, {MODELS} 2011, Wellington, New Zealand, October 16-21, 2011. Proceedings}, pages = {168--182}, year = {2011}, crossref = {DBLP:conf/models/2011}, url = {http://dx.doi.org/10.1007/978-3-642-24485-8_13}, doi = {10.1007/978-3-642-24485-8_13}, timestamp = {Fri, 14 Oct 2011 19:04:17 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/models/BavotaGOLTGC11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {In this paper we present an experiment and two replications aimed at comparing the support provided by ER and UML class diagrams during comprehension activities by focusing on the single building blocks of the two notations. This kind of analysis can be used to identify weakness in a notation and/or justify the need of preferring ER or UML for data modeling. The results reveal that UML class diagrams are generally more comprehensible than ER diagrams, even if the former has some weaknesses related to three building blocks, i.e., multi-value attribute, composite attribute, and weak entity. These findings suggest that a UML class diagram extension should be considered to overcome these weaknesses and improve the comprehensibility of the notation.} } @inproceedings{DBLP:conf/msr/EshkevariAPOGA11, key = {2}, author = {Laleh Mousavi Eshkevari and Venera Arnaoudova and Massimiliano Di Penta and Rocco Oliveto and Yann{-}Ga{\"{e}}l Gu{\'{e}}h{\'{e}}neuc and Giuliano Antoniol}, title = {An exploratory study of identifier renamings}, booktitle = {Proceedings of the 8th International Working Conference on Mining Software Repositories, {MSR} 2011 (Co-located with ICSE), Waikiki, Honolulu, HI, USA, May 21-28, 2011, Proceedings}, pages = {33--42}, year = {2011}, crossref = {DBLP:conf/msr/2011}, url = {http://doi.acm.org/10.1145/1985441.1985449}, doi = {10.1145/1985441.1985449}, timestamp = {Wed, 03 Feb 2016 18:18:52 +0100}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/msr/EshkevariAPOGA11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {Identifiers play an important role in source code understandability, maintainability, and fault-proneness. This paper reports a study of identifier renamings in software systems, studying how terms (identifier atomic components) change in source code identifiers. Specifically, the paper (i) proposes a term renaming taxonomy, (ii) presents an approximate lightweight code analysis approach to detect and classify term renamings automatically into the taxonomy dimensions, and (iii) reports an exploratory study of term renamings in two open-source systems, Eclipse-JDT and Tomcat. We thus report evidence that not only synonyms are involved in renamings but also (in a small fraction) more unexpected changes occur: surprisingly, we detected hypernym (a more abstract term, e.g., size vs. length) and hyponym (a more concrete term, e.g., restriction vs. rule) renamings, and antonym renamings (a term replaced with one having the opposite meaning, e.g., closing vs. opening). Despite being only a fraction of all renamings, synonym, hyponym, hypernym, and antonym renamings may hint at some program understanding issues and, thus, could be used in a renamingrecommendation system to improve code quality.} } @inproceedings{DBLP:conf/wcre/QusefBOLB11, key = {1}, author = {Abdallah Qusef and Gabriele Bavota and Rocco Oliveto and Andrea De Lucia and David Binkley}, title = {{SCOTCH:} Slicing and Coupling Based Test to Code Trace Hunter}, booktitle = {18th Working Conference on Reverse Engineering, {WCRE} 2011, Limerick, Ireland, October 17-20, 2011}, pages = {443--444}, year = {2011}, crossref = {DBLP:conf/wcre/2011}, url = {http://dx.doi.org/10.1109/WCRE.2011.68}, doi = {10.1109/WCRE.2011.68}, timestamp = {Tue, 14 Apr 2015 18:52:47 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/conf/wcre/QusefBOLB11}, bibsource = {dblp computer science bibliography, http://dblp.org}, abstract = {In this demonstration we present an Eclipse plug-in, called SCOTCH (Slicing and Coupling based Test to Code trace Hunter), that uses dynamic slicing and conceptual coupling to recover the trace ability links between unit tests and tested classes. Empirical evaluation shows that SCOTCH identifies trace ability links between unit tests and tested classes with a high accuracy.} }