All Publications 

2017
  1. Le An, Foutse Khomh, and Yann-Gaël Guéhéneuc. An Empirical Study of Crash-inducing Commits in Mozilla Firefox. Software Quality Journal (SQJ), pp 1–-32, March 2017. Note: 33 pages. [Text ] Keyword(s): Code and design smells, SQJ.
    Abstract:
    Software crashes are dreaded by both software organisations and end-users. Many software organisations have automatic crash reporting tools embedded in their software systems to help quality-assurance teams track and fix crash-related bugs. Previous approaches, which focused on the triaging of crash-types and crash-related bugs, can help software organisations increase their debugging efficiency of crashes. However, these approaches can only be applied after the software systems have been crashing for a certain period of time. To help software organisations detect and fix crash-prone code earlier, we examine the characteristics of commits that lead to crashes, which we call crash-inducing commits, in Mozilla Firefox. We observe that crash-inducing commits are often submitted by developers with less experience and that developers perform more addition and deletion of lines of code in crash-inducing commits but also that they need less effort to fix the bugs caused by these commits. We also characterise commits that would lead to frequent crashes, which impact a large user base, which we call highly impactful crash-inducing commits. Compared to other crash-related bugs, we observe that bugs due to highly impactful crash-inducing commits were less reopened by developers and tend to be fixed by a single commit. We build predictive models to help software organisations detect and fix crash-prone bugs early, when their developers commit code. Our predictive models achieve a precision of 61.2\% and a recall of 94.5\% to predict crash-inducing commits and a precision of 60.9\% and a recall of 91.1\% to predict highly impactful crash-inducing commits. Software organisations could use our models and approach to track and fix crash-prone commits early, before they negatively impact users, thus increasing bug fixing efficiency and user-perceived quality.
    [bibtex-key = An17-SQJ-CrashInducingCommits]

  2. Latifa Guerrouj, Zeinab Kermansaravi, Venera Arnaoudova, Benjamin C. M. Fung, Foutse Khomh, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Investigating the Relation between Lexical Smells and Change- and Fault-proneness: An Empirical Study. Software Quality Journal (SQJ), 25(3):641–-670, September 2017. Note: 30 pages. [Text ] Keyword(s): Code and design smells, SQJ.
    Abstract:
    Past and recent studies have shown that design smells which are poor solutions to recurrent design problems make object-oriented systems difficult to maintain, and that they negatively impact the class change- and fault-proneness. More recently, lexical smells have been introduced to capture recurring poor practices in the naming, documentation, and choice of identifiers during the implementation of an entity. Although recent studies show that developers perceive lexical smells as impairing program understanding, no study has actually evaluated the relationship between lexical smells and software quality as well as their interaction with design smells. In this paper, we detect 29 smells consisting of 13 design smells and 16 lexical smells in 30 releases of three projects: ANT, ArgoUML, and Hibernate. We analyze to what extent classes containing lexical smells have higher (or lower) odds to change or to be subject to fault fixing than other classes containing design smells. Our results show and bring empirical evidence on the fact that lexical smells can make, in some cases, classes with design smells more fault-prone. In addition, we empirically demonstrate that classes containing design smells only are more change- and fault-prone than classes with lexical smells only.
    [bibtex-key = Guerrouj17-SQJ-LexicalSmells]

  3. Fehmi Jaafar, Angela Lozano, Yann-Gaël Guéhéneuc, and Kim Mens. Analyzing Software Evolution and Quality by Extracting Asynchrony Change Patterns. Journal of Systems and Software (JSS), 131:311–-322, September 2017. Note: 12 pages. [Text ] Keyword(s): Evolution patterns, JSS.
    Abstract:
    Change patterns describe two or more files were often changed together during the development or the maintenance of software systems. Several studies have been presented to detect change patterns and to analyze their types and their impact on software quality. In this context, we introduced the Asynchrony change pattern to describes a set of files that always change together in the same change periods, regardless developers who maintained them. In this paper, we investigate the impact of Asynchrony change pattern on design and code smells such as anti-patterns and code clones. Concretely, we conduct an empirical study by detecting Asynchrony change patterns, anti-patterns and code clones occurrences on 22 versions of four software systems and analyzing their fault-proneness. Results show that cloned files that follow the same Asynchrony change patterns have significantly increased fault-proneness with respect to other clones, and that anti-patterns following the same Asynchrony change pattern can be up to five times more risky in terms of fault-proneness as compared to other anti-patterns. Asynchrony change patterns thus seem to be strong indicators of fault-proneness for clones and anti-patterns.
    [bibtex-key = Jaafar17-JSS-AsynchronyChangePatterns]

  4. Francis Palma, Javier Gonzalez-Huerta, Mohamed Founi, Naouel Moha, Guy Tremblay, and Yann-Gaël Guéhéneuc. Semantic Analysis of RESTful APIs for the Detection of Linguistic Patterns and Antipatterns. International Journal of Cooperative Information Systems (IJCIS), 26(2):1–-37, June 2017. Note: 38 pages. [Text ] Keyword(s): Code and design smells, IJCIS.
    Abstract:
    Identifier lexicon may have a direct impact on software understandability and reusability and, thus, on the quality of the final software product. Understandability and reusability are two important characteristics of software quality. REpresentational State Transfer (REST) style is becoming a de facto standard adopted by software organizations to build their Web applications. Understandable and reusable Uniform Resource Identifers (URIs) are important to attract client developers of RESTful APIs because good URIs support the client developers to understand and reuse the APIs. Consequently, the use of proper lexicon in RESTful APIs has also a direct impact on the quality of Web applications that integrate these APIs. Linguistic antipatterns represent poor practices in the naming, documentation, and choice of identifiers in the APIs as opposed to linguistic patterns that represent the corresponding best practices. In this paper, we present the Semantic Analysis of RESTful APIs (SARA) approach that employs both syntactic and semantic analyses for the detection of linguistic patterns and antipatterns in RESTful APIs. We provide detailed definitions of 12 linguistic patterns and antipatterns and define and apply their detection algorithms on 18 widely-used RESTful APIs, including Facebook, Twitter, and Dropbox. Our detection results show that linguistic patterns and antipatterns do occur in major RESTful APIs in particular in the form of poor documentation practices. Those results also show that SARA can detect linguistic patterns and antipatterns with higher accuracy compared to its state-of-the-art approach---DOLAR.
    [bibtex-key = Palma17-IJCIS-LexicalSmells]

  5. Aminata Sabané, Yann-Gaël Guéhéneuc, Venera Arnaoudova, and Giuliano Antoniol. Fragile Base-class Problem, Problem?. Journal of Empirical Software Engineering (EMSE), 22(5):2612–-2657, October 2017. Note: 46 pages. [Text ] Keyword(s): Code and design smells, EMSE.
    Abstract:
    The fragile base-class problem (FBCP) has been described in the literature as a consequence of “misusing” inheritance and composition in object-oriented programming when (re)using frameworks. Many research works have focused on preventing the FBCP by proposing alternative mechanisms for reuse, but, to the best of our knowledge, there is no previous research work studying the prevalence and impact of the FBCP in real-world software systems. The goal of our work is thus twofold: (1) assess, in different systems, the prevalence of micro-architectures, called FBCS, that could lead to two aspects of the FBCP, (2) investigate the relation between the detected occurrences and the quality of the systems in terms of change and fault proneness, and (3) assess whether there exist bugs in these systems that are related to the FBCP. We therefore perform a quantitative and a qualitative study. Quantitatively, we analyse multiple versions of seven different open-source systems that use 58 different frameworks, resulting in 301 configurations. We detect in these systems 112,263 FBCS occurrences and we analyse whether classes playing the role of sub-classes in FBCS occurrences are more change and–or fault prone than other classes. Results show that classes participating in the analysed FBCS are neither more likely to change nor more likely to have faults. Qualitatively, we conduct a survey to confirm/infirm that some bugs are related to the FBCP. The survey involves 41 participants that analyse a total of 104 bugs of three open-source systems. Results indicate that none of the analysed bugs is related to the FBCP. Thus, despite large, rigorous quantitative and qualitative studies, we must conclude that the two aspects of the FBCP that we analyse may not be as problematic in terms of change and fault-proneness as previously thought in the literature. We propose reasons why the FBCP may not be so prevalent in the analysed systems and in other systems in general.
    [bibtex-key = Sabane17-EMSE-FBCS]

  6. Zéphyrin Soh, Foutse Khomh, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Noise in Mylyn Interaction Traces and Its Impact on Developers and Recommendation Systems. Journal of Empirical Software Engineering (EMSE), pp 1--48, June 2017. Note: 49 pages. [Text ] Keyword(s): Understanding program comprehension, EMSE.
    Abstract:
    Interaction traces (ITs) are developers’ logs collected while developers maintain or evolve software systems. Researchers use ITs to study developers’ editing styles and recommend relevant program entities when developers perform changes on source code. However, when using ITs, they make assumptions that may not necessarily be true. This article assesses the extent to which researchers’ assumptions are true and examines noise in ITs. It also investigates the impact of noise on previous studies. This article describes a quasi-experiment collecting both Mylyn ITs and video-screen captures while 15 participants performed four realistic software maintenance tasks. It assesses the noise in ITs by comparing Mylyn ITs and the ITs obtained from the video captures. It proposes an approach to correct noise and uses this approach to revisit previous studies. The collected data show that Mylyn ITs can miss, on average, about 6\% of the time spent by participants performing tasks and can contain, on average, about 85\% of false edit events, which are not real changes to the source code. The approach to correct noise reveals about 45\% of misclassification of ITs. It can improve the precision and recall of recommendation systems from the literature by up to 56\% and 62\%, respectively. Mylyn ITs include noise that biases subsequent studies and, thus, can prevent researchers from assisting developers effectively. They must be cleaned before use in studies and recommendation systems. The results on Mylyn ITs open new perspectives for the investigation of noise in ITs generated by other monitoring tools such as DFlow, FeedBag, and Mimec, and for future studies based on ITs.
    [bibtex-key = Soh17-EMSE-MylynNoise]

  7. José Côté, Sylvie Cossette, Pilar Ramirez-Garcia, Geneviève Rouleau, Patricia Auger, François Boudreau, Marie-Pierre Gagnon, and Yann-Gaël Guéhéneuc. A Web-based Nursing Tailored Intervention to Support Health Behaviour Change among People Living with HIV: Development and Demonstration of TAVIE en santé. In Susan Michie and Anne Blandford, editors, Proceedings of the 3rd UCL Centre for Behaviour Change Digital Health Conference (DHC), February 2017. University College London Press. Note: Poster. 1 pages. [Slides ] Keyword(s): VIHTAVIE, DHC. [bibtex-key = Cote17-DHC-TAVIE]

  8. Fehmi Jaafar, Angela Lozano, Yann-Gaël Guéhéneuc, and Kim Mens. On the Analysis of Co-Occurrence of Anti-Patterns and Clones. In Manuel Nuñez, Tadashi Dohi, and Xiaoying Bai, editors, Proceedings of the 3rd International Conference on Software Quality, Reliability, and Security (QRS), pages 274--284, July 2017. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, QRS.
    Abstract:
    One of the most important tasks in software maintenance is debugging. Developers perform debugging to fix faults and implement new features. Usually they use interactive development environments to perform their debugging sessions. To start an interactive debugging session, developers must set breakpoints. Choosing where to set breakpoints is a non-trivial task, yet few studies have investigated how developers set breakpoints during interactive debugging sessions. To understand how developers set breakpoints, we analysed more than 10 hours of 45 video-recorded debugging sessions, where a total of 307 breakpoints were set. We used the videos from two independent studies involving three software systems. We could observe that: (1) considerable time is spent by developers until they are able to set the first breakpoint; (2) when developers toggle breakpoints carefully, they complete tasks faster than developers who set (potential useless) breakpoints quickly; and (3) different developers set breakpoints in similar locations while working (independently) on the same tasks or different tasks. We discuss some implications of our observations for debugging activities.
    [bibtex-key = Jaafar17-QRS-CloneAntipatterns]

  9. Fabio Petrillo, Hyan Mandian, Aiko Yamashita, Foutse Khomh, and Yann-Gaël Guéhéneuc. How Do Developers Toggle Breakpoints? Observational Studies. In Manuel Nuñez, Tadashi Dohi, and Xiaoying Bai, editors, Proceedings of the 3rd International Conference on Software Quality, Reliability, and Security (QRS), pages 285--295, July 2017. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, QRS.
    Abstract:
    In software engineering, a smell is a part of a software system’s source code with a poor quality and that may indicate a deeper problem. Although many kinds of smells have been studied to analyze their causes, their behavior, and their impact on software quality, those smells typically are studied independently from each other. However, if two smells coincide inside a class, this could increases their negative effect (e.g., spaghetti code that is being cloned across the system). In this paper we report results from an empirical study conducted to examine the relationship between two specific kinds of smells: code clones and antipatterns. We conducted our study on three open-source software systems: Azureus, Eclipse, and JHotDraw. Results show that between 32\% and 63\% of classes in the analysed systems present co-occurrence of smells, and that such classes are more risky in term of fault-proneness.
    [bibtex-key = Petrillo17-QRS-BreakpointToggling]

  10. Fábio Petrillo, Philippe Merle, Naouel Moha, and Yann-Gaël Guéhéneuc. Towards a REST Cloud Computing Lexicon. In Donald Ferguson, Vìctor Méndez Muñoz, and Jorge Cardoso, editors, Proceedings of the 7th International Conference on Cloud Computing and Services Science (CLOSER), pages 348--355, April 2017. SciTePress. Note: 8 pages. [Text ] [Slides ] Keyword(s): Code and design smells, CLOSER.
    Abstract:
    Cloud computing is a popular Internet-based computing paradigm that provides on-demand computational services and resources, generally offered by cloud providers' REpresentational State Transfer (REST) APIs. To the best of our knowledge, there has been no study on the analysis of the lexicon adopted by cloud providers, despite its importance for developers. In this paper, we studied three different and well-known REST APIs (Google Cloud Platform, OpenStack, and Open Cloud Computing Interface) to investigate and organise their lexicons. This study presents three main contributions: 1) a tooled approach, called CLOUDLEX, for extracting and analysing REST cloud computing lexicons, 2) a dataset of services, resources, and terms used in the three studied REST APIs, 3) our analysis of this dataset, which represents a first attempt to provide a common REST cloud computing lexicon. After analysing our dataset, we observe that although the three studied REST APIs to describe the same domain (cloud computing), contrary to what one might expect, they do not share a large number of common terms, and only 5\% of terms (17/352) are shared by two providers. Thus, the three APIs are lexically heterogeneous, and there is not a consensus on which terms to use on cloud computing systems. We discuss new avenues for cloud computing API designers and researchers.
    [bibtex-key = Petrillo17-ICPC-CloudLexicon]

  11. Rubén Saborido, Foutse Khomh, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Comprehension of Ads-supported and Paid Android Applications: Are They Different?. In David Lo and Alexander Serebrenik, editors, Proceedings of the 25th International Conference on Program Comprehension (ICPC), pages 143--153, May 2017. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, ICPC.
    Abstract:
    The Android market is a place where developers offer paid and-or free apps to users. Free apps are interesting to users because they can try them immediately without incurring a monetary cost. However, free apps often have limited features and-or contain ads when compared to their paid counterparts. Thus, users may eventually need to pay to get additional features and-or remove ads. While paid apps have clear market values, their ads-supported versions are not entirely free because ads have an impact on performance. In this paper, first, we perform an exploratory study about ads-supported and paid apps to understand their differences in terms of implementation and development process. We analyze 40 Android apps and we observe that (i) ads-supported apps are preferred by users although paid apps have a better rating, (ii) developers do not usually offer a paid app without a corresponding free version, (iii) ads-supported apps usually have more releases and are released more often than their corresponding paid versions, (iv) there is no a clear strategy about the way developers set prices of paid apps, (v) paid apps do not usually include more functionalities than their corresponding ads-supported versions, (vi) developers do not always remove ad networks in paid versions of their ads-supported apps, and (vii) paid apps require less permissions than ads-supported apps. Second, we carry out an experimental study to compare the performance of ads-supported and paid apps and we propose four equations to estimate the cost of ads-supported apps. We obtain that (i) ads-supported apps use more resources than their corresponding paid versions with statistically significant differences and (ii) paid apps could be considered a most cost-effective choice for users because their cost can be amortized in a short period of time, depending on their usage.
    [bibtex-key = Saborido17-ICPC-AndroidAds]

  12. Anas Shatnawi, Hafedh Mili, Ghizlane El-Boussaidi, Anis Boubaker, Yann-Gaël Guéhéneuc, Naouel Moha, Jean Privat, and Manel Abdellatif. Analyzing Program Dependencies in Java EE Applications. In Lin Tan and Abram Hindle, editors, Proceedings of the 14th International Conference on Mining Software Repositories (MSR), pages 64--74, May 2017. ACM Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, MSR.
    Abstract:
    Program dependency artifacts such as call graphs help support a number of software engineering tasks such as software mining, program understanding, debugging, feature location, software maintenance and evolution. Java Enterprise Edition (JEE) applications represent a significant part of the recent legacy applications, and we are interested in modernizing them. This modernization involves, among other things, analyzing dependencies between their various components/tiers. JEE applications tend to be multilanguage, rely on JEE container services, and make extensive use of late binding techniques-all of which makes finding such dependencies difficult. In this paper, we describe some of these difficulties and how we addressed them to build a dependency call graph. We developed our tool called DeJEE (Dependencies in JEE) as an Eclipse plug-in. We applied DeJEE on two open-source JEE applications: Java PetStore and JSP Blog. The results show that DeJEE is able to identify different types of JEE dependencies.
    [bibtex-key = Shatnawi17-MSR-JEEDependencies]

  13. Aiko Yamashita, S. Amirhossein Abtahizadeh, Foutse Khomh, and Yann-Gaël Guéhéneuc. Software Evolution and Quality Data from Controlled, Multiple, Industrial Case Studies. In Lin Tan and Abram Hindle, editors, Proceedings of the 14th International Conference on Mining Software Repositories (MSR), pages 507--510, May 2017. ACM Press. Note: Short paper. 4 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, MSR.
    Abstract:
    A main difficulty to study the evolution and quality of real-life software systems is the effect of moderator factors, such as: programming skill, type of maintenance task, and learning effect. Experimenters must account for moderator factors to identify the relationships between the variables of interest. In practice, controlling for moderator factors in realistic (industrial) settings is expensive and rather difficult. The data presented in this paper has two particularities: First, it involves six professional developers and four real-life, industrial systems. Second, it was obtained from controlled, multiple case studies where the moderator variables: programming skill, maintenance task, and learning effect were controlled for. This data set is relevant to experimenters studying evolution and quality of real-life systems, in particular those interested in studying industrial systems and replicating empirical studies.
    [bibtex-key = Yamashota17-MSR-P-Seodin]

  14. Mahdis Zolfagharinia, Bram Adams, and Yann-Gaël Guéhéneuc. Do Not Trust Build Results at Face Value: An Empirical Study of 30 Million CPAN Builds. In Lin Tan and Abram Hindle, editors, Proceedings of the 14th International Conference on Mining Software Repositories (MSR), pages 312--322, May 2017. ACM Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, MSR.
    Abstract:
    Continuous Integration (CI) is a cornerstone of modern quality assurance, providing on-demand builds (compilation and tests) of code changes or software releases. Despite the myriad of CI tools and frameworks, the basic activity of interpreting build results is not straightforward, due to not only the number of builds being performed but also, and especially, due to the phenomenon of build inflation, according to which one code change can be built on dozens of different operating systems, run-time environments and hardware architectures. As existing work mostly ignored this inflation, this paper performs a large-scale empirical study of the impact of OS and run-time environment on build failures on 30 million builds of the CPAN ecosystem's CI environment. We observe the evolution of build failures over time, and investigate the impact of OSes and environments on build failures. We show that distributions may fail differently on different OSes and environments and, thus, that the results of CI require careful filtering and selection to identify reliable failure data.
    [bibtex-key = Zolfagharinia17-MSR-CPANBuilds]

  15. Abdelilah Sakti, Gilles Pesant, and Yann-Gaël Guéhéneuc. JTExpert at the Fifth Unit Testing Tool Competition, May 2017. Note: Tool demo at the 10th International Workshop on Search-Based Software Testing. 4 pages. [Text ] [Slides ] Keyword(s): Test case generation, SBST.
    Abstract:
    JTeXpert is a software testing tool that automatically generates a whole test suite to satisfy the branch-coverage criterion. It takes as inputs a Java source code and its dependencies and automatically produces a test-case suite in JUnit format. In this paper, we summarize our results for the Unit Testing Tool Competition held at the fifth SBST Contest, where JTeXpert received 849 points and was ranked second. We also analyze our tool's performance.
    [bibtex-key = Sakti17-Demo-SBST]


2016
  1. Yann-Gaël Guéhéneuc, Gi-hwon Kwon, and Pornsiri Muenchaisri. Guest Editorial: Special Section with the extensions to the best papers from APSEC'13 and APSEC'14, volume 74, chapter 1, pages 181--182. Elsevier, June 2016. Note: 2 pages. [Text ] Keyword(s): Evolution patterns, IST. [bibtex-key = Gueheneuc16-ISTGuestIntroductionForAPSEC14]

  2. Jane Huffman Hayes, Alexander Dekhtyar, Jody Larsen, and Yann-Gaël Guéhéneuc. Effective Use of Analysts' Effort in Automated Tracing. Requirements Engineering (REEN), pp 1--25, October 2016. Note: 26 pages. [Text ] Keyword(s): Requirement traceability, REEN.
    Abstract:
    Because of the large amount of effort it takes to manually trace requirements, automated traceability methods for mapping textual software engineering artifacts to each other and generating candidate links have received increased attention over the past 15 years. Automatically generated links, however, are viewed as candidates until human analysts confirm/reject them for the final requirements traceability matrix. Studies have shown that analysts are a fallible, but necessary, participant in the tracing process. There are two key measures guiding analyst work on the evaluation of candidate links: accuracy of analyst decision and efficiency of their work. Intuitively, it is expected that the more effort the analyst spends on candidate link validation, the more accurate the final traceability matrix is likely to be, although the exact nature of this relationship may be difficult to gauge outright. To assist analysts in making the best use of their time when reviewing candidate links, prior work simulated four possible behaviors and showed that more structured approaches save the analysts’ time/effort required to achieve certain levels of accuracy. However, these behavioral simulations are complex to run and their results difficult to interpret and use in practice. In this paper, we present a mathematical model for evaluating analyst effort during requirements tracing tasks. We apply this model to a simulation study of 12 candidate link validation approaches. The simulation study is conducted on a number of different datasets. In each study, we assume perfect analyst behavior (i.e., analyst always being correct when making a determination about a link). Under this assumption, we evaluate the estimated effort for the analyst and plot it against the accuracy of the recovered traceability matrix. The effort estimation model is guided by a parameter specifying the relationship between the time it takes an analyst to evaluate a presented link and the time it takes an analyst to discover a link not presented to her. We construct a series of effort estimations based on different values of the model parameter. We found that the analysts’ approach to candidate link validation—essentially the order in which the analyst examines presented candidate links—does impact the effort. We also found that the lowest ratio of the cost of finding a correct link from scratch over the cost of recognizing a correct link yields the lowest effort for all datasets, but that the lowest effort does not always yield the highest quality matrix. We finally observed that effort varies by dataset. We conclude that the link evaluation approach we call “Top 1 Not Yet Examined Feedback Pruning” was the overall winner in terms of effort and highest quality and, thus, should be followed by human analysts if possible.
    [bibtex-key = Hayes16-REEN-AnalystEffort]

  3. Fehmi Jaafar, Yann-Gaël Guéhéneuc, Sylvie Hamel, Foutse Khomh, and Mohammad Zulkernine. Evaluating the Impact of Design Pattern and Anti-pattern Dependencies on Changes and Faults. Journal of Empirical Software Engineering (EMSE), 21(3):896--931, February 2016. Note: 35 pages. [Text ] Keyword(s): Code and design smells, Design patterns, EMSE.
    Abstract:
    On the one hand, design patterns are solutions to recurring design problems, aimed at increasing reuse, flexibility, and maintainability. However, numerous previous work found that some patterns, such as the Observer and Singleton, are correlated with large code structures and argued that they are likely to be more fault prone. On the other hand, anti-patterns describe poor solutions to design and implementation problems that highlight weaknesses in the design of software systems and that may slow down maintenance and increase the risk of faults. They have been found to negatively impact change and fault-proneness. Classes participating in design patterns and anti-patterns have dependencies with other classes, \eg{} static and co-change dependencies, that may propagate problems to other classes. We investigate the impact of such dependencies in object-oriented systems by studying the relations between the presence of static and co-change dependencies and (1) the fault-proneness, (2) the types of changes, and (3) the types of faults that these classes undergo. We analyze six design patterns and 10 anti-patterns in 39 releases of ArgoUML, JFreeChart, and XercesJ, and investigate to what extent classes having dependencies with design patterns or anti-patterns have higher odds to faults than other classes. We show that in almost all releases of the three systems, classes having dependencies with anti-patterns are more fault-prone than others while it is not always true for classes with dependencies with design patterns. We also observe that structural changes are the most common changes impacting classes having dependencies with anti-patterns. Software developers could use this knowledge about the impact of design pattern and anti-pattern dependencies to better focus their testing and reviewing activities towards the most risky classes and to propagate changes adequately.
    [bibtex-key = Jaafar14-EMSE-PatternDependencies]

  4. Wenbin Li, Jane Huffman Hayes, Giulio Antoniol, Yann-Gaël Guéhéneuc, and Bram Adams. Error Leakage and Wasted Time: Sensitivity and Effort Analysis of a Requirements Consistency Checking Process. Journal of Software: Evolution and Process (JSEP), 28(12):1061–-1080, October 2016. Note: 20 pages. [Text ] Keyword(s): Requirement traceability, JSEP.
    Abstract:
    Several techniques are used by requirements engineering practitioners to address difficult problems such as specifying precise requirements while using inherently ambiguous natural language text and ensuring the consistency of requirements. Often, these problems are addressed by building processes/tools that combine multiple techniques where the output from 1 technique becomes the input to the next. While powerful, these techniques are not without problems. Inherent errors in each technique may leak into the subsequent step of the process. We model and study 1 such process, for checking the consistency of temporal requirements, and assess error leakage and wasted time. We perform an analysis of the input factors of our model to determine the effect that sources of uncertainty may have on the final accuracy of the consistency checking process. Convinced that error leakage exists and negatively impacts the results of the overall consistency checking process, we perform a second simulation to assess its impact on the analysts' efforts to check requirements consistency. We show that analyst's effort varies depending on the precision and recall of the subprocesses and that the number and capability of analysts affect their effort. We share insights gained and discuss applicability to other processes built of piped techniques.
    [bibtex-key = Li16-JSEP-ErrorLeakage]

  5. Wei Wu, Foutse Khomh, and Bram Adams, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Exploratory Study of API Changes and Usages based on Apache and Eclipse Ecosystems. Journal of Empirical Software Engineering (EMSE), 21(6):2366–2412, December 2016. Note: 47 pages. [Text ] Keyword(s): Understanding program comprehension, EMSE.
    Abstract:
    Frameworks are widely used in modern software development to reduce development costs. They are accessed through their Application Programming Interfaces (APIs), which specify the contracts with client programs. When frameworks evolve, API backwardcompatibility cannot always be guaranteed and client programs must upgrade to use the new releases. Because framework upgrades are not cost-free, observing API changes and usages together at fine-grained levels is necessary to help developers understand, assess, and forecast the cost of each framework upgrade. Whereas previous work studied API changes in frameworks and API usages in client programs separately, we analyse and classify API changes and usages together in 22 framework releases from the Apache and Eclipse ecosystems and their client programs. We find that (1) missing classes and methods happen more often in frameworks and affect client programs more often than the other API change types do, (2) missing interfaces occur rarely in frameworks but affect client programs often, (3) framework APIs are used on average in 35\% of client classes and interfaces, (4) most of such usages could be encapsulated locally and reduced in number, and (5) about 11\% of APIs usages could cause ripple effects in client programs when these APIs change. Based on these findings, we provide suggestions for developers and researchers to reduce the impact of API evolution through language mechanisms and design strategies.
    [bibtex-key = Wu15-EMSE-APIChangeEcosystems]

  6. Béchir Bani, Foutse Khomh, and Yann-Gaël Guéhéneuc. A Study of the Energy Consumption of Databases and Cloud Patterns. In Michael Sheng, Eleni Stroulia, and Samir Tata, editors, Proceedings of the 14th International Conference on Service Oriented Computing (ICSOC), pages 606--614, October 2016. Springer. Note: Short paper. 8 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, ICSOC.
    Abstract:
    Nowadays databases have become the backbone of cloud-based applications. Cloud-based applications are used in about every industry today. Despite their popularity and wide adoption, little is still known about the energy footprint of these applications and, in particular, of their databases. Yet, reducing the energy consumption of applications is a major objective for society and will continue to be so in the near to far future. In this paper, we study the energy consumption of three databases used by cloud-based applications: MySQL, PostgreSQL, and MongoDB, through a series of experiments with three cloud-based applications (a RESTful multi-threaded application, DVD Store, and JPetStore). We also study the impact of cloud patterns on the energy consumption because databases in cloud-based applications are often implemented in conjunction with patterns. We measure the energy consumption using the Power-API tool to keep track of the energy consumed at the process-level by the variants of the cloud-based applications. We report that the choice of the databases can reduce the energy consumption of a cloud-based application regardless of the cloud patterns that are implemented.
    [bibtex-key = Bani16-ICSOC-CloudPatternEnergy]

  7. José Côté, Pilar Ramirez-Garcia, Gaston Godin, Yann-Gaël Guéhéneuc, Annick Hernandez, and les concepteurs des interventions TAVIE. Concept et plateforme informatique TAVIE : déploiement d’une pratique infirmière virtuelle au service de la gestion des maladies chroniques. In Actes du 1er Forum Franco--Québécois d'Innovation en Santé (FFQIS), octobre 2016. Aviesan. Keyword(s): VIHTAVIE, FFQIS. [bibtex-key = Cote16-Sante-TAVIE]

  8. Bilal Karasneh, Michel R.V. Chaudron, Foutse Khomh, and Yann-Gaël Guéhéneuc. Studying the Relation between Anti-patterns in Models and in Source Code. In Michele Lanza and Yasutaka Kamei, editors, Proceedings of the 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER), pages 36--45, March 2016. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, SANER.
    Abstract:
    There exists a large body of work on the specification and detection of anti-patterns in the source code of software systems. However, there are very few studies on the origins of the occurrences of anti-patterns in the source code: do the very design of the systems lead to the occurrences of anti-patterns or are anti-patterns introduced during implementation? Knowing when anti-patterns are introduced could help software designers and developers improve the quality of the source code, for example by eliminating fault-prone anti-patterns early during the design of the systems, even before their implementation. Therefore, we detect occurrences of anti-patterns in design models and in the source code of some systems, trace these occurrences between design and implementation, and study their relation and impact on the source code. First, we analyze both the UML design models and the source code of 10 open-source systems and show that antipatterns exist in design models. We observe that, on average, 37\% of the classes in the design models that belong to anti-patterns also exist in the source code and also play roles in the same anti-patterns. Second, we investigate two open-source systems to assess the impact of the anti-patterns in their design models on the source code in terms of changes and faults. We show that classes that have anti-patterns in the design models have more changes and faults in the source code. Our results suggest that the design of the systems lead to anti-patterns and that the antipatterns impact negatively the change- and fault-proneness of the classes in the source code. Thus, designers should be wary of anti-patterns in their design models and could benefit from tools that detect and trace these anti-patterns into the source code.
    [bibtex-key = Karasneh16-SANER-ModelsCodeAPs]

  9. Hassna Louadah, Roger Champagne, Yvan Labiche, and Yann-Gaël Guéhéneuc. A Data Extraction Process for Avionics Systems' Interface Specifications. In Bran Selic and Philippe Desfray, editors, Proceedings of the 4th International Conference on Model-Driven Engineering and Software Development (MODELSWARD), pages 544--554, February 2016. SCITEPRESS Press. Note: 11 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, MODELSWARD.
    Abstract:
    Avionics systems, along with their internal hardware and software components interfaces, must be well defined and specified (e.g., unambiguous, complete, verifiable, consistent, and traceable specification). Such a specification is usually written in the form of an Interface Control Document (ICD), and represents the cornerstone of the avionics system integration activities. However, there is no commonly accepted language to define and use these ICDs and no common definition of what an ICD is or should contain. Indeed, avionics companies define their own, proprietary ICDs and processes. In this paper, we first identify the pieces of information that an ICD should contain for both federated and IMA open systems. Then, we propose a data extraction process that enables better understanding and more efficient extraction of open avionics systems interface specifications, and provides a clearer vision on the information needed to build a model driven solution for modeling avionics system interfaces, our long-term goal. We validate this process by applying it on a set of open avionics sub-system standards and the results have shown its feasibility.
    [bibtex-key = Louadah16-MODELSWARD-ICD]

  10. Fábio Petrillo, Philippe Merle, Naouel Moha, and Yann-Gaël Guéhéneuc. Are REST APIs for Cloud Computing Well-Designed? An Exploratory Study. In Michael Sheng, Eleni Stroulia, and Samir Tata, editors, Proceedings of the 14th International Conference on Service Oriented Computing (ICSOC), pages 157--170, October 2016. Springer. Note: 13 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ICSOC.
    Abstract:
    Cloud computing is currently the most popular model to offer and access computational resources and services. Many cloud providers use the REST architectural style (Representational State Transfer) for offering such computational resources. However, these cloud providers face challenges when designing and exposing REST APIs that are easy to handle by end-users and/or developers. Yet, they benefit from best practices to help them design understandable and reusable REST APIs. However, these best practices are scattered in the literature and they have not be studied systematically on real-world APIs. Consequently, we propose two contributions. In our first contribution, we survey the literature and compile a catalog of 73 best practices in the design of REST APIs making APIs more understandable and reusable. In our second contribution, we perform a study of three different and well-known REST APIs from three cloud providers to investigate how their APIs are offered and accessed. These cloud providers are Google Cloud Platform, OpenStack, and Open Cloud Computing Interface (OCCI). In particular, we evaluate the coverage of the features provided by the REST APIs of these cloud providers and their conformance with the best practices for REST APIs design. Our results show that Google Cloud follows 66\% (48/73), OpenStack follows 62\% (45/73), and OCCI 1.2 follows 56\% (41/73) of the best practices. Second, although these numbers are not necessarily high, partly because of the strict and precise specification of best practices, we showed that cloud APIs reach an acceptable level of maturity.
    [bibtex-key = Petrillo16-ICSOC-CloudRestAPIs]

  11. Fábio Petrillo, Zéphyrin Soh, Foutse Khomh, Marcelo Soares Pimenta, Carla Maria Dal Sasso, and Yann-Gaël Guéhéneuc. Towards Understanding Interactive Debugging. In Yves Le Traon and Zhenyu Chen, editors, Proceedings of the 24th International Conference on Software Quality, Reliability, and Security (QRS), pages 152--163, August 2016. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, QRS.
    Abstract:
    Debugging is a laborious activity in which developers spend lot of time navigating through code, looking for starting points, and stepping through statements. Yet, although debuggers exist for 40 years now, there have been few research studies to understand this important and laborious activity. Indeed, to perform such a study, researchers need detailed information about the different steps of the interactive debugging process. In this paper, to help research studies on debugging and, thus, help improving our understanding of how developers debug systems using debuggers, we present the Swarm Debug Infrastructure (SDI), with which practitioners and researchers can collect and share data about developers' interactive debugging activities. We assess the effectiveness of the SDI through an experiment that aims to understand how developers apply interactive debugging on five true faults found in JabRef, toggling breakpoints and stepping code. Our study involved five freelancers and two student developers performing 19 bug location sessions. We collect videos recording and data about 6 hours of effective debugging activities. The data includes 110 breakpoints and near 7,000 invocations. We process the collected videos and data to answer five research questions showing that (1) there is no correlation between the number of invocations (respectively the number of breakpoints toggled) during a debugging session and the time spent on the debugging task, p = -0.039 (respectively 0.093). We also observed that (2) developers follow different debugging patterns and (3) there is no relation between numbers of breakpoints and expertise. However, (4) there is a strong negative correlation between time of the first breakpoint (p = -0.637), and the time spent on the task, suggesting that when developers toggle breakpoints carefully, they complete tasks faster than developers who toggle breakpoints too quickly. We conclude that the SDI allows collecting and sharing debugging data that can provide interesting insights about interactive debugging activities. We discuss some implications for tool developers and future debuggers.
    [bibtex-key = Petrillo16-QRS-InteractiveDebugging]

  12. Fábio Petrillo, Zéphyrin Soh, Foutse Khomh, Marcelo Soares Pimenta, Carla Maria Dal Sasso, and Yann-Gaël Guéhéneuc. Understanding Interactive Debugging with Swarm Debug Infrastructure. In Jonathan I. Maletic and Gabriele Bavota, editors, Proceedings of the 24th International Conference on Program Comprehension (ICPC), pages 1--4, May 2016. IEEE CS Press. Note: Short Paper. 4 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, ICPC.
    Abstract:
    Debugging is a laborious activity in which developers spend lot of time navigating through code, looking for starting points, and stepping through statements. In this paper, we present the Swarm Debug Infrastructure (SDI) with which researchers can collect and share data about developers' interactive debugging activities. SDI allows collecting and sharing debugging data that are useful to answer research questions about interactive debugging activities. We assess the effectiveness of the SDI through an experiment to understand how developers apply interactive debugging
    [bibtex-key = Petrillo16-ICPC-SwarmDebugging]

  13. Cristiano Politowski, Lisandra Fontoura, Fábio Petrillo, and Yann-Gaël Guéhéneuc. Are the Old Days Gone? A Survey on Actual Software Engineering Processes in Video Game Industry. In Kendra Cooper, editor, Proceedings of the 5th ICSE International Workshop on Games and Software Engineering (GAS), pages 22--28, May 2016. ACM Press. Note: 7 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, GAS.
    Abstract:
    In the past 10 years, several researches studied video game development process who proposed approaches to improve the way how games are developed. These approaches usually adopt agile methodologies because of claims that traditional practices and the waterfall process are gone. However, are the ``old days" really gone in the game industry? In this paper, we present a survey of software engineering processes in video game industry from postmortem project analyses. We analyzed 20 postmortems from Gamasutra Portal. We extracted their processes and modelled them through using the Business Process Model and Notation (BPMN). This work presents three main contributions. First, a postmortem analysis methodology to identify and extract project processes. Second, the study main result: the ``old days" are gone, but not completely. Iterative practices are increasing and are applied to at least 65\% of projects in which 45\% of this projects explicitly adopted Agile practices. However, waterfall process is still applied at least 30\% of projects. Finally, we discuss some implications, directions and opportunities for video game development community.
    [bibtex-key = Politowski16-GAS-SEProcessesGame]

  14. Zéphyrin Soh, Aiko Yamashita, Foutse Khomh, and Yann-Gaël Guéhéneuc. Do Code Smells Impact the Effort of Different Maintenance Programming Activities?. In Michele Lanza and Yasutaka Kamei, editors, Proceedings of the 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER), pages 393--402, March 2016. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, SANER.
    Abstract:
    Empirical studies have shown insofar that code smells have relatively low impact over maintenance effort at file level. We surmise that previous studies have found low effects of code smells because the effort considered is a ``sheer-effort'' that does not distinguish between the types of activities. In our study, we investigate the effects of code smells at different level: at activity level. Examples of activities are: reading, editing, searching, and navigating, which are performed independently over different files during maintenance. We conjecture that structural attributes represented in the form of different code smells do indeed have an effect on the effort for performing certain kinds of activities. To verify this conjecture, we revisit a previous study about the impact of code smell on maintenance effort, using the same dataset, but considering activity effort. Results show that different code smells affect differently activity effort. Yet, the size of the changes preformed to solve the task impacts the effort of all activities more than code smells and file size. While code smells impact the editing and navigating effort more than file size, the file size impacts the reading and searching activities more than code smells. One major implication of these results is that if code smells indeed affect the effort of certain kinds of activities, it means that their effects are contingent on the type of maintenance task at hand, where some types of activities will become more predominant than others.
    [bibtex-key = Soh16-SANER-Noises]

  15. Hironori Washizaki, Yann-Gaël Guéhéneuc, and Foutse Khomh. A Taxonomy for Program Metamodels in Program Reverse Engineering. In Bram Adams and Denys Poshyvanyk, editors, Proceedings of the 32nd International Conference on Software Maintenance and Evolution (ICSME), pages 44--55, October 2016. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Design patterns, ICSM, ICSME.
    Abstract:
    To support program comprehension, maintenance, and evolution, metamodels are frequently used during program reverse engineering activities to describe and analyze constituents of a program and their relations. Reverse engineering tools often define their own metamodels according to the intended purposes and features. Although each metamodel has its own advantages, its limitations may be addressed by other metamodels. Existing works have evaluated and compared metamodels and tools, but none have considered all the possible characteristics and limitations to provide a comprehensive guideline for classifying, comparing, reusing, and extending program metamodels. To aid practitioners and researchers in classifying, comparing, reusing, and extending program metamodels and their corresponding reverse engineering tools according to the intended goals, we establish a conceptual framework with definitions of program metamodels and related concepts. Then this framework is used to provide a comprehensive taxonomy, named Program Metamodel TAxonomy (ProMeTA), which incorporates newly identified characteristics into those stated in previous works, which were identified via a systematic literature survey on program metamodels, while keeping the orthogonality of the entire taxonomy. Additionally, we validate the taxonomy in terms of its orthogonality and usefulness through the classification of popular metamodels.
    [bibtex-key = Washizaki16-ICSME-Metamodels]

  16. Yann-Gaël Guéhéneuc. Bidouille : fabriquer un boîtier Boing Ball pour AmigaOne XE (Traduction), juin 2016. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Voici l'histoire du bo{\^\i}tier "Boing Ball" que j'ai construit pour mon AmigaOne XE. Cela commen{\c{c}}a comme une blague qui se changea en un projet s{\'e}rieux qui est maintenant devenu r{\'e}alit{\'e}.
    [bibtex-key = Gueheneuc16-WebZine-BoingBall]

  17. Yann-Gaël Guéhéneuc. Reportage : Australian Roadshow (Traduction), septembre 2016. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Voici un reportage sur l'Australian Roadshow, une s{\'e}rie de rassemblements sur le th{\`e}me d'AmigaOS 4, qui s'est tenu {\`a} partie du 18 octobre 2003 {\`a} Sydney, Brisbane et Canberra.
    [bibtex-key = Gueheneuc16-WebZine-AustralianRoadshow]

  18. Abdelilah Sakti, Gilles Pesant, and Yann-Gaël Guéhéneuc. JTExpert at the Fourth Unit Testing Tool Competition, May 2016. Note: Tool demo at the 9th ICSE International Workshop on Search-Based Software Testing. 4 pages. [Text ] [Slides ] Keyword(s): Test case generation, SBST.
    Abstract:
    JTExpert is a software testing tool that automatically generates a whole test suite to satisfy the branch-coverage criterion. It takes as inputs a Java source code and its dependencies and automatically produces a test-case suite in JUnit format. In this paper, we summarize our results for the Unit Testing Tool Competition held at the fourth SBST Contest, where JTExpert received 931 points and was ranked third. We also analyze our tool's performance.
    [bibtex-key = Sakti16-Demo-SBST]


2015
  1. Yann-Gaël Guéhéneuc and Tom Mens. Guest Editorial: Introduction to the Special Issue on Software Maintenance and Evolution Research, volume 20, chapter 1, pages 1193--1197. Springer, February 2015. Note: 4 pages. [Text ] Keyword(s): Evolution patterns, EMSE.
    Abstract:
    The past decade has seen tremendous changes in the landscape of software engineering activities in industry and of software engineering research topics in academia. Software engineering activities used to be mostly “hidden” behind the closed doors of software industries. In the 1990’s, the emergence of the open-source development model and movement revolutionized software development but also software engineering research. Nowadays, open-source software (OSS) development has become a major source of new libraries and programs, and more and more industries either use OSS or even release OSS themselves. Even large corporations, in which trade secrets were the norm, now consider releasing their source code as open-source, for example Microsoft with its Windows operating system.
    [bibtex-key = Gueheneuc15-EMSEGuestIntroductionForICSM13]

  2. Nasir Ali, Zohreh Sharafi, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Empirical Study on the Importance of Source Code Entities for Requirements Traceability. Empirical Software Engineering (EMSE), 20(2):442--478, April 2015. Note: 37 pages. [Text ] Keyword(s): Features and requirements, Understanding program comprehension, EMSE.
    Abstract:
    Requirements Traceability (RT) links help developers during program comprehension and maintenance tasks. However, creating RT links is a laborious and resource-consuming task. Information Retrieval (IR) techniques are useful to automatically create traceability links. However, IR-based techniques typically have low accuracy (precision, recall, or both) and thus, creating RT links remains a human intensive process. We conjecture that understanding how developers verify RT links could help improve the accuracy of IR-based RT techniques to create RT links. Consequently, we perform an empirical study consisting of four case studies. First, we use an eye-tracking system to capture developers' eye movements while they verify RT links. We analyse the obtained data to identify and rank developers' preferred types of Source Code Entities (SCEs), \eg{} domain vs.\ implementation-level source code terms and class names vs.\ method names. Second, we perform another eye-tracking case study to confirm that it is the semantic content of the developers' preferred types of SCEs and not their locations that attract developers' attention and help them in their task to verify RT links. Third, we propose an improved term weighting scheme, \ie{} Developers Preferred Term Frequency/Inverse Document Frequency ($DPTF/IDF$), that uses the knowledge of the developers' preferred types of SCEs to give more importance to these SCEs into the term weighting scheme. We integrate this weighting scheme with an IR technique, \ie{} Latent Semantic Indexing (LSI), to create a new technique to RT link recovery. Using three systems (iTrust, Lucene, and Pooka), we show that the proposed technique statistically improves the accuracy of the recovered RT links over a technique based on LSI and the usual Term Frequency/Inverse Document Frequency ($TF/IDF$) weighting scheme. Finally, we compare the newly proposed $DPTF/IDF$ with our original Domain Or Implementation/Inverse Document Frequency ($DOI/IDF$) weighting scheme.
    [bibtex-key = Ali14-EMSE-EyeTrackingTraceability]

  3. José Côté, Sylvie Cossette, Pilar Ramirez-Garcia, Alexandra De Pokomandy, Catherine Worthington, Marie-Pierre Gagnon, Patricia Auger, François Boudreau, Joyal Miranda, Yann-Gaël Guéhéneuc, and Cécile Tremblay. Evaluation of a Web-based Tailored Intervention (TAVIE en santé) to Support People Living with HIV in the Adoption of Health Promoting Behaviours: an Online Randomized Controlled Trial Protocol. BMC Public Health (BMC), 15, October 2015. [Text ] Keyword(s): VIHTAVIE, BMC Public Health.
    Abstract:
    extit{Background.} Long-term use of antiretroviral therapy, normal aging, and presence of certain risk factors are associated with metabolic disorders that predispose persons living with HIV to diabetes and cardiovascular diseases. The emergence and progression of these disorders can be prevented by adopting healthy behaviours. Based on the theory of planned behaviour, the Web-based tailored intervention TAVIE en sant{\'e} was developed. The aim of this study is to evaluate the effectiveness of TAVIE en sant{\'e} in order to support people living with HIV in the adoption of health promoting behaviours. extit{Method/Design.} An online randomized controlled trial with parallel-groups will be conducted across Canada. To participate in this study, people living with HIV must be: $\geq$ 18 years, able to read/understand French or English, have access to the Internet. A convenience sample of 750 participants will be randomly assigned either to an experimental group (TAVIE en sant{\'e}, n = 375) or to a control group (websites, n = 375) (1:1 allocation ratio). The TAVIE en sant{\'e} intervention is composed of seven interactive computer sessions, lasting between 5 and 10 min. The sessions, hosted by a virtual nurse, aim to develop and strengthen skills required for behaviour change. The control group will receive a validated list of five predetermined conventional health-related Websites. The adoption of health behaviour (smoking cessation or physical activity or healthy eating) is the principal outcome. Cognitions (intention, attitude, perceived behavioral control) are the secondary outcomes. Health indicators will also be assessed. All outcomes will be measured with a self-administered online questionnaire and collected three times: at baseline, 3 and 6 months after. The principal analyses will focus on differences between the two trial groups using Intention-to-Treat analysis. extit{Discussion.} This study will yield new results about the efficacy of Web-based tailored health behaviours change interventions in the context of chronic disease. The TAVIE en sant{\'e} intervention could constitute an accessible complementary service in support of existing specialized services to support people living with HIV adopt health behaviors.
    [bibtex-key = Cote15-BMC-RandomizedTrial]

  4. José Côté, Gaston Godin, Pilar Ramirez-Garcia, Geneviève Rouleau, Anne Bourbonnais, Yann-Gaël Guéhéneuc, Cécile Tremblay, and Joanne Otis. Virtual Intervention to Support Self-Management of Antiretroviral Therapy Among People Living With HIV. Journal of Medical Internet Research (JMIR), 17(1):e6, January 2015. [Text ] Keyword(s): VIHTAVIE, JMIR.
    Abstract:
    extbf{Background:} Living with human immunodeficiency virus (HIV) necessitates long-term health care follow-up, particularly with respect to antiretroviral therapy (ART) management. Taking advantage of the enormous possibilities afforded by information and communication technologies (ICT), we developed a virtual nursing intervention (VIH-TAVIE) intended to empower HIV patients to manage their ART and their symptoms optimally. ICT interventions hold great promise across the entire continuum of HIV patient care but further research is needed to properly evaluate their effectiveness. extbf{Objective:} The objective of the study was to compare the effectiveness of two types of follow-up—traditional and virtual—in terms of promoting ART adherence among HIV patients. extbf{Methods:} A quasi-experimental study was conducted. Participants were 179 HIV patients on ART for at least 6 months, of which 99 were recruited at a site offering virtual follow-up and 80 at another site offering only traditional follow-up. The primary outcome was medication adherence and the secondary outcomes were the following cognitive and affective variables: self-efficacy, attitude toward medication intake, symptom-related discomfort, stress, and social support. These were evaluated by self-administered questionnaire at baseline (T0), and 3 (T3) and 6 months (T6) later. extbf{Results:} On average, participants had been living with HIV for 14 years and had been on ART for 11 years. The groups were highly heterogeneous, differing on a number of sociodemographic dimensions: education, income, marital status, employment status, and living arrangements. Adherence at baseline was high, reaching 80\% (59/74) in the traditional follow-up group and 84\% (81/97) in the virtual follow-up group. A generalized estimating equations (GEE) analysis was run, controlling for sociodemographic characteristics at baseline. A time effect was detected indicating that both groups improved in adherence over time but did not differ in this regard. Improvement at 6 months was significantly greater than at 3 months in both groups. Analysis of variance revealed no significant group-by-time interaction effect on any of the secondary outcomes. A time effect was observed for the two kinds of follow-ups; both groups improved on symptom-related discomfort and social support. extbf{Conclusions:} Results showed that both interventions improved adherence to ART. Thus, the two kinds of follow-up can be used to promote treatment adherence among HIV patients on ART.
    [bibtex-key = Cote15-JMIR-VirtualIntervention]

  5. Zohreh Sharafi, Zéphyrin Soh, and Yann-Gaël Guéhéneuc. A Systematic Literature Review on the Usage of Eye-tracking in Software Engineering. Journal of Information and Software Technology (IST), 67:79--107, November 2015. Note: 28 pages. [Text ] Keyword(s): Understanding program comprehension, IST.
    Abstract:
    extit{Context.} Eye-tracking is a mean to collect evidence regarding some participants' cognitive processes. Eye-trackers monitor participants' visual attention by collecting eye-movement data. These data are useful to get insights into participants' cognitive processes during reasoning tasks. extit{Objective.} The Evidence-based Software Engineering (EBSE) paradigm has been proposed in 2004 and, since then, has been used to provide detailed insights regarding different topics in software engineering research and practice. Systematic Literature Reviews (SLR) are also useful in the context of EBSE by bringing together all existing evidence of research and results about a particular topic. This SLR evaluates the current state of the art of using eye-trackers in software engineering and provides evidence on the uses and contributions of eye-trackers to empirical studies in software engineering. extit{Method.} We perform a SLR covering eye-tracking studies in software engineering published from 1990 up to the end of 2014. To search all recognised resources, instead of applying manual search, we perform an extensive automated search using Engineering Village. We identify 36 relevant publications, including nine journal papers, two workshop papers, and 25 conference papers. extit{Results.} The software engineering community started using eye-trackers in the 1990s and they have become increasingly recognised as useful tools to conduct empirical studies from 2006. We observe that researchers use eye-trackers to study model comprehension, code comprehension, debugging, collaborative interaction, and traceability. Moreover, we find that studies use different metrics based on eye-movement data to obtain quantitative measures. We also report the limitations of current eye-tracking technology, which threaten the validity of previous studies, along with suggestions to mitigate these limitations. extit{Conclusion.} However, not withstanding these limitations and threats, we conclude that the advent of new eye-trackers makes the use of these tools easier and less obtrusive and that the software engineering community could benefit more from this technology.
    [bibtex-key = Sharafi15-IST-SLREyeTracking]

  6. Wei Wu, Adrien Serveaux, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. The Impact of Imperfect Change Rules on Framework API Evolution Identification: An Empirical Study. Empirical Software Engineering (EMSE), 20(4):1126--1158, August 2015. Note: 32 pages. [Text ] Keyword(s): Evolution patterns, EMSE.
    Abstract:
    Software frameworks keep evolving. It is often time-consuming for developers to keep their client code up-to-date. Not all frameworks have documentation about the upgrading process. Many approaches have been proposed to ease the impact of non-documented framework evolution on developers by identifying change rules between two releases of a framework, but these change rules are imperfect, extit{i.e.}, not 100\% correct. To the best of our knowledge, there is no empirical study to show the usefulness of these imperfect change rules. Therefore, we design and conduct an experiment to evaluate their impact. In the experiment, the subjects must find the replacements of 21 missing methods in the new releases of three open-source frameworks with the help of (1) all-correct, (2) imperfect, and (3) no change rules. The statistical analysis results show that the precision of the replacements found by the subjects with the three sets of change rules are significantly different. The precision with all-correct change rules is the highest while that with no change rules is the lowest, while imperfect change rules give a precision in between. The effect size of the difference between the subjects with no and imperfect change rules is large and that between the subjects with imperfect and correct change rules is moderate. The results of this study show that the change rules generated by framework API evolution approaches do help developers, even they are not always correct. The imperfect change rules can be used by developers upgrading their code when documentation is not available or as a complement to partial documentation. The moderate difference between results from subjects with imperfect and all-correct change rules also suggests that improving precision of change rules will still help developers.
    [bibtex-key = Wu14-EMSE-EyeTrackingTraceability]

  7. S. Amirhossein Abtahizadeh, Foutse Khomh, and Yann-Gaël Guéhéneuc. How Green Are Cloud Patterns? A Case Study of Energy Consumption. In Kui Ren and Tommaso Melodia, editors, Proceedings of the 34th International Performance Computing and Communications Conference (IPCCC), pages 1--8, December 2015. IEEE CS Press. Note: 8 pages. [Text ] [Slides ] Keyword(s): Code and design smells, Quality models, IPCCC.
    Abstract:
    Cloud Patterns are abstract solutions to recurrent design problems in the cloud. Previous work has shown that these patterns can improve the Quality of Service (QoS) of cloud applications but their impact on energy consumption is still unknown. Yet, energy consumption is the biggest challenge that cloud computing systems (the backbone of today’s high-tech economy) face today. In fact, 10\% of the world’s electricity is now being consumed by servers, laptops, tablets and smartphones. Energy consumption has complex dependencies on the hardware platform, and the multiple software layers. The hardware, its firmware, the operating system, and the various software components used by a cloud application, all contribute to determining the energy footprint. Hence, even though increasing a data center efficiency will eventually improve energy efficiency, the internal design of cloud-based applications can be improved to lower energy consumption. In this paper, we conduct an empirical study on a RESTful multi-threaded application deployed in the cloud, to investigate the individual and the combined impact of three cloud patterns (e.g., Local Database proxy, Local Sharding Based Router and Priority Queue) on the energy consumption of cloud based applications. We measure the energy consumption using Power-API; an application programming interface (API) written in Java to monitor the energy consumed at the processlevel. Results show that cloud patterns can effectively reduce the energy consumption of a cloud application, but not in all cases. In general, there appear to be a trade-off between an improved response time of the application and the energy consumption. Developers and software architects can make use of these results to guide their design decisions.
    [bibtex-key = Abtahizadeh15-IPCCC-GreenPatterns]

  8. José Côté, Gaston Godin, Pilar Ramirez-Garcia, Geneviève Rouleau, Anne Bourbonnais, Yann-Gaël Guéhéneuc, Cécile Tremblay, and Joanne Otis. Virtual Intervention to Support Self-Management of Antiretroviral Therapy Among People Living With HIV. In Proceedings of the 5th World Congress on Social Media, Mobile Apps, and Internet/Web 2.0 in Health, Medicine and Biomedical Research (Medicine 2.0), October 2015. Medicine 2.0. [Slides ] Keyword(s): VIHTAVIE, Medicine 2.0.
    Abstract:
    extit{Background.} Living with HIV necessitates long-term healthcare follow-up particularly with respect to management of antiretroviral therapy (ART). With the enormous possibilities afforded by information and communication technologies (ICT), we developed a virtual nursing intervention (VIH-TAVIE) to empower persons living with HIV (PLHIV) to manage their ART and their symptoms optimally. ICT interventions hold great promise across the entire continuum of PLHIV care but further research is needed to properly evaluate their effectiveness. extit{Objective.} The objective of the study was to compare the effectiveness of two types of follow-up–traditional and virtual–in terms of promoting adherence to ART among PLHIV. extit{Methods.} A quasi-experimental study was conducted. A sample of 179 PLHIV on ART for at least six months was recruited, of which 99 at a site offering the virtual follow-up and 80 at another site offering more traditional follow-ups. Adherence, the primary outcome, and cognitive and affective variables (self-efficacy, attitude towards medication intake, symptom-related discomfort, stress or social support) were evaluated by self-administered questionnaire at three measurement times: baseline (T0), and three months (T3) and six months (T6) later. extit{Results.} On average, participants had been living with HIV for 14 years and had been on treatment for 11 years. The groups were highly heterogeneous, but differed on a number of sociodemographic dimensions: education, income, marital status, employment status, and living arrangements. Adherence at baseline was high, reaching 79.7\% for the traditional follow-up group and 83.5\% for the virtual follow-up group. A generalized estimating equations (GEE) analysis was run, controlling for sociodemographic characteristics at baseline. A time effect was detected, indicating that the two groups improved on adherence over time but did not differ. Improvement at six months was significantly greater than at three months for both groups. Analysis of variance revealed no significant group-by-time interaction on self-efficacy, attitude towards medication intake, symptom-related discomfort, stress or social support. A time effect was observed for both types of follow-up on symptom-related discomfort and social support. Both groups improved over time with respect to these variables. extit{Conclusions.} Results showed that the two groups improved their adherence at six months but did not differ in this regard. Hence, neither type of follow-up proved better than the other in terms of treatment adherence promotion.
    [bibtex-key = Cote15-Medicine20-VirtualIntervention]

  9. Jane Huffman Hayes, Giuliano Antoniol, Bram Adams, and Yann-Gaël Guéhéneuc. Inherent Characteristics of Traceability Artifacts: Less Is More. In Didar Zowghi and Vincenzo Gervasi, editors, Proceedings of the 23rd International Requirements Engineering Conference (RE), pages 196--201, August 2015. IEEE CS Press. Note: RE Next! 6 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, RE.
    Abstract:
    This paper describes ongoing work to characterize the inherent ease or ``traceability'' with which a textual artifact can be traced using an automated technique. Software traceability approaches use varied measures to build models that automatically recover links between pairs of natural language documents. Thus far, most of the approaches use a single-step model, such as logistic regression, to identify new trace links. However, such approaches require a large enough training set of both true and false trace links. Yet, the former are by far in the minority, which reduces the performance of such models. Therefore, this paper formulates the problem of identifying trace links as the problem of finding, for a given logistic regression model, the subsets of links in the training set giving the best accuracy (in terms of G-metric) on a test set. Using hill climbing with random restart for subset selection, we found that, for the ChangeStyle dataset, we can classify links with a precision of up to 40\% and a recall of up to 66\% using a training set as small as one true candidate link (out of 33) and 41 false links. To get better performance and learn the best possible logistic regression classifier, we must ``discard'' links in the trace dataset that increase noise to avoid learning with links that are not representative. This preliminary work is promising because it shows that few correct examples may perform better than several poor ones. It also shows which inherent characteristics of the artifacts make them good candidates to learn efficient traceability models automatically, i.e., it reveals their traceability.
    [bibtex-key = Hayes15-RENext-InherentCharacteristics]

  10. Jane Huffman Hayes, Yann-Gaël Guéhéneuc, Giuliano Antoniol, Wenbin Li, and Mirek Truszczynski. Error Leakage and Wasted Time: Sensitivity Analysis of a Requirements Consistency Checking Process. In Marouane Kessentini, editor, Proceedings of the 1st North American Search Based Software Engineering Symposium (NasBASE), pages 1061--1080, February 2015. Elsevier. Note: 15 pages. [Text ] [Slides ] Keyword(s): Requirement traceability, NasBASE.
    Abstract:
    A myriad of techniques are used by requirements engineering researchers and practitioners to address difficult problems, such as consistency checking of temporal requirements. Often, complex problems are addressed by building processes/tools that combine multiple techniques where the output from one technique becomes the input to the next technique, e.g., feature location that uses information retrieval and dynamic analysis techniques in sequence to perform the three step process of preparing a corpus, generating queries, and retrieving results. While powerful, these techniques are not without flaw. Inherent errors in each technique may leak into the subsequent step of the process. Errors then can be viewed as variations in the overall process. Errors of omission, or failure to retrieve elements, are viewed as error leakage because the "lost" elements will not be processed in subsequent steps. Errors of commission, or retrieval of irrelevant elements, amount to wasted time as human analysts will review/analyze these extraneous elements. As software quality professionals, developers, and researchers depend on these processes to verify and validate software and attendant artifacts, it is important to understand the impact of these errors on the quality of the output of the final step of the processes, e.g., the accuracy of the list of features retrieved using feature location. Therefore, we model and study one such process, for checking the consistency of temporal requirements. We study the process and assess error leakage and wasted time considering this process as fully automated. We perform an exploratory sensitivity analysis using Monte Carlo simulations of the input factors of our model to determine the effect that these sources of uncertainty, i.e., the errors of omission and commission, may have on the final accuracy of the consistency checking process. The sensitivity analysis uses published data on accuracy of previous techniques and data collected by applying the process on a real-world system. We share insights gained and discuss its applicability to other processes built of piped techniques.
    [bibtex-key = Hayes15-NasBASE-ErrorLeakageTraceability]

  11. Francis Palma, Javier Gonzalez-Huerta, Naouel Moha, Yann-Gaël Guéhéneuc, and Guy Tremblay. Are RESTful APIs Well-designed? Detection of Their Linguistic (Anti)Patterns. In Alistair Barros, Daniela Grigori, and N.C. Narendra, editors, Proceedings of the 13th International Conference on Service Oriented Computing (ICSOC), pages 171--187, November 2015. Springer. Note: 16 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ICSOC.
    Abstract:
    Identifier lexicon has a direct impact on software understandability and reusability and, thus, on the quality of the final software product. Understandability and reusability are two important characteristics of software quality. REST (REpresentational State Transfer) style is becoming a de facto standard adopted by many software organisations. The use of proper lexicon in RESTful APIs might make them easier to understand and reuse by client developers, and thus, would ease their adoption. Linguistic antipatterns represent poor practices in the naming, documentation, and choice of identifiers in the APIs as opposed to linguistic patterns that represent best practices. We present the DOLAR approach (Detection Of Linguistic Antipatterns in REST), which applies syntactic and semantic analyses for the detection of linguistic (anti)patterns in RESTful APIs. We provide detailed definitions of ten (anti)patterns and define and apply their detection algorithms on 15 widely-used RESTful APIs, including Facebook, Twitter, and YouTube. The results show that DOLAR can indeed detect linguistic (anti)patterns with high accuracy and that they do occur in major RESTful APIs.
    [bibtex-key = Palma15-ICSOC-RESTLinguisticAPs]

  12. Francis Palma, Naouel Moha, and Yann-Gaël Guéhéneuc. Specification and Detection of Business Process Antipatterns. In Morad Benyoucef and Michael Weiss, editors, Proceedings of the 6th International Conference on eTechnologies (MCETECH), pages 37--52, May 2015. Springer. Note: 15 pages. [Text ] [Slides ] Keyword(s): Code and design smells, MCETECH.
    Abstract:
    Structured business processes (SBPs) are now in enterprises the prominent solution to software development problems through orchestrating Web services. By their very nature, SBPs evolve through adding new or modifying existing functionalities. Those changes may deteriorate the process design and introduce process antipatterns---poor but recurring solutions that may degrade processes design quality and hinder their maintenance and evolution. However, to date, few solutions exist to detect such antipatterns to facilitate the maintenance and evolution and improve the quality of process design. We propose SODA-BP (Service Oriented Detection for Antipatterns in Business Processes), supported by a framework for specifying and detecting process antipatterns. To validate SODA-BP, we specify eight antipatterns and perform their detection on a set of randomly selected 35 SBPs form a corpus of more than 150 collected processes from an open-source search engine. Some of the SBPs were modified by adding, removing, or modifying process elements to introduce noise in them. Results shows that SODA-BP has an average detection precision of more than 75\% and recall of 100\%.
    [bibtex-key = Palma15-MCETech-AntiBusinessProcess]

  13. Geneviève Rouleau, José Côté, Pilar Ramirez-Garcia, Annick Hernandez, and Yann-Gaël Guéhéneuc. VIH-TAVIE et TAVIE en santé : interventions infirmières en cybersanté pour soutenir la prise des antirétroviraux et l'adoption de comportements de santé auprès d'une clientèle VIH. In Céline Audet and Claude La Charité, editors, actes du 83e congrès de l'ACFAS, mai 2015. ACFAS. Keyword(s): VIHTAVIE, ACFAS.
    Abstract:
    Il devient imp{\'e}ratif d’innover dans de nouvelles modalit{\'e}s de soins pour relever les d{\'e}fis reli{\'e}s {\`a} l’accroissement des probl{\`e}mes chroniques de sant{\'e} et aux soins complexes qui en d{\'e}coulent. Les interventions en cybersant{\'e} repr{\'e}sentent une solution prometteuse. Objectifs : Un concept d’intervention infirmi{\`e}re virtuelle appel{\'e} TAVIE (Traitement, Assistance, virtuelle, infirmi{\`e}re et Enseignement) a {\'e}t{\'e} d{\'e}velopp{\'e} pour soutenir de mani{\`e}re personnalis{\'e}e les personnes vivant avec un probl{\`e}me de sant{\'e} chronique, comme les personnes vivant avec le VIH (PVVIH), dans la gestion des d{\'e}fis inh{\'e}rents {\`a} leur condition de sant{\'e}. Deux interventions seront pr{\'e}sent{\'e}es : VIH-TAVIE, con{\c{c}}ue pour soutenir la prise des antir{\'e}troviraux; et TAVIE en sant{\'e}, d{\'e}velopp{\'e}e pour motiver l’adoption de comportements de sant{\'e}. M{\'e}thode : Le d{\'e}veloppement des interventions est issu d’un croisement des savoirs clinique, empirique, th{\'e}orique et d’un travail avec les experts des arts multim{\'e}dia et de l’informatique. L’efficacit{\'e} de VIH-TAVIE a {\'e}t{\'e} {\'e}valu{\'e}e en milieu clinique {\`a} l’aide d’un devis quasi-exp{\'e}rimental et qualitatif. R{\'e}sultats: Les PVVIH ont trouv{\'e} que l’infirmi{\`e}re virtuelle humanisait leur exp{\'e}rience de participer {\`a} VIH-TAVIE et ont retir{\'e} des b{\'e}n{\'e}fices de l’intervention. Conclusion : VIH-TAVIE et TAVIE en sant{\'e} sont pr{\'e}sentement {\'e}valu{\'e}es via un essai randomis{\'e} en ligne. L’{\'e}valuation de ces interventions ouvre une voie vers des changements dans les modes traditionnels de prestation des soins.
    [bibtex-key = Rouleau15-ACFAS-VIHTAVIE]

  14. Zohreh Sharafi, Timothy Shaffer, Bonita Sharif, and Yann-Gaël Guéhéneuc. Eye-tracking Metrics in Software Engineering. In Jing Sun and Y. Raghu Reddy, editors, Proceedings of the 22nd Asia-Pacific Software Engineering Conference (APSEC), pages 96--103, December 2015. IEEE CS Press. Note: 8 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, APSEC.
    Abstract:
    Eye-tracking studies are getting more prevalent in software engineering. Researchers often use different metrics when publishing their results in eye-tracking studies. Even when the same metrics are used, they are given different names, causing difficulties in comparing studies. To encourage replications and facilitate advancing the state of the art, it is important that the metrics used by researchers be clearly and consistently defined in the literature. There is therefore a need for a survey of eyetracking metrics to support the (future) goal of standardizing eyetracking metrics. This paper seeks to bring awareness to the use of different metrics along with practical suggestions on using them. It compares and contrasts various eye-tracking metrics used in software engineering. It also provides definitions for common metrics and discusses some metrics that the software engineering community might borrow from other fields.
    [bibtex-key = Sharafi15-APSEC-EyeTrackingMetrics]

  15. Zéphyrin Soh, Thomas Drioul, Pierre-Antoine Rappe, Foutse Khomh, Yann-Gaël Guéhéneuc, and Naji Habra. Noises in Interaction Traces Data and their Impact on Previous Research Studies. In Jeff Carver and Oscar Dieste, editors, Proceedings of the 9th International Symposium of Empirical Software Engineering and Measurement (ESEM), pages 1--10, October 2015. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, ESEM.
    Abstract:
    Context: Developers' interaction traces (ITs) are commonly used in software engineering to understand how developers maintain and evolve software systems. Researchers make several assumptions when mining ITs, e.g., edit events are considered to be change activities and the time mined from ITs is considered to be the time spent by the developers performing the maintenance task. Goal: We investigate the extent to which these assumptions are correct. We examine noises in developers'''' ITs data and the impact of these noises on previous results derived from these traces. Approach: We perform an experiment with 15 participants, whom we asked to perform bug-fixing activities and collect Mylyn ITs and VLC video captures. We then investigate noises between the two data sets and propose an approach to correct noises in ITs. Results: We find that Mylyn ITs can miss on average about 6\% of the time spent performing a task and contain on average about 28\% of false edit-events. We report that these noises may have led researchers to mislabel some participants'''' editing styles in about 34\% of the cases and that the numbers of edit-events performed by developers and the times that they spent on tasks are correlated, when they were considered not to be. Conclusion: We show that ITs must be carefully cleaned before being used in research studies.
    [bibtex-key = Soh15-ESEM-Noises]

  16. Yann-Gaël Guéhéneuc. Entrevue avec Fleecy Moss (Traduction), mai 2015. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Qu'est-ce qui arrive {\`a} l'Amiga ? Est-ce que l'arr{\^e}t de la publication de CU Amiga signifie la fin de l'Amiga ? La r{\'e}ponse courte est "non". Vous ne nous croyez pas ? Dans un dernier effort pour r{\'e}pondre {\`a} cela, nous avons demand{\'e} {\`a} Amiga Inc. de tout d{\'e}baller. Fleecy Moss - l'homme que Petro appelle "Flossy" (en fran{\c{c}}ais : "ultra-chic") a beaucoup de choses {\`a} dire.
    [bibtex-key = Gueheneuc15-WebZine-InterviewFleecyMoss]

  17. Yann-Gaël Guéhéneuc. Entrevue avec Gary Peake (Traduction), mars 2015. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Gary Peake a {\'e}t{\'e} un pilier de l'Amiga depuis toujours.
    [bibtex-key = Gueheneuc15-WebZine-GaryPeake]

  18. Yann-Gaël Guéhéneuc. L'Amiga mène le bal dans les présentations multimédias interactives (Traduction), june 2015. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Vous serez peut-{\^e}tre surpris d'apprendre que des Amiga sont pr{\'e}sents un peu partout pour faire des pr{\'e}sentations multim{\'e}dias interactives. Allons voir ce qui se trame derri{\`e}re ces pr{\'e}sentations pour comprendre comment cela est possible.
    [bibtex-key = Gueheneuc15-WebZine-Multimedia]

  19. Yann-Gaël Guéhéneuc. Reportage : DevCon Commodore 1992 au Royaume-Uni (Traduction), janvier 2015. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Chaque ann{\'e}e durant ces trois derni{\`e}res ann{\'e}es, Commodore UK a organis{\'e} une conf{\'e}rence d{\'e}di{\'e}e aux d{\'e}veloppeurs pour donner {\`a} ces derniers r{\'e}sidant au Royaume-Uni la possibilit{\'e} de voir les nouvelles technologies, d'{\^e}tre inform{\'e}s sur divers probl{\`e}mes de programmation, de montrer leurs derni{\`e}res astuces et, plus g{\'e}n{\'e}ralement, de se m{\^e}ler {\`a} d'autres gens qui ont les m{\^e}mes int{\'e}r{\^e}ts.
    [bibtex-key = Gueheneuc15-WebZine-DevCon92]

  20. Yann-Gaël Guéhéneuc. Reportage : Loren Eyrich voyage avec un Amiga (Traduction), février 2015. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Loren Eyrich pr{\'e}f{\`e}re les routes "moins fr{\'e}quent{\'e}es" au sens propre comme au figur{\'e}.
    [bibtex-key = Gueheneuc15-WebZine-LorenEyrich]

  21. Yann-Gaël Guéhéneuc. Reportage : l'Amiga dans les écoles nord-américaines (Traduction), mars 2015. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Nous sommes tous au courant du r{\^o}le de l'Amiga dans les cours de graphismes et de vid{\'e}o au lyc{\'e}e dans tout le pays [NDLT : au Canada et aux {\'E}tats-Unis]. Mais l'Amiga est aussi pr{\'e}sent dans des endroits moins courants : depuis l'{\'e}cole primaire jusqu'aux facult{\'e}s de m{\'e}decine.
    [bibtex-key = Gueheneuc15-WebZine-AmigaInNASchools]

  22. Yann-Gaël Guéhéneuc. Test de Flight Of The Amazon Queen, mars 2015. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Flight of the Amazon Queen, ou FOTAQ pour ses amis, est un jeu d’aventure « pointe et clique » con{\c{c}}u pour l’Amiga et le MS-DOS d{\'e}velopp{\'e} par Interactive Binary Illusions et publi{\'e} en 1995 par Warner Interactive et MojoTouch. Ce jeu rappel un peu les aventures de Indiana Jones, les Nazis d{\'e}moniaques en moins mais avec un m{\'e}chant m{\'e}galomaniaque, des dinosaures, des Amazones et des lederhosen !
    [bibtex-key = Gueheneuc15-WebZine-FOTAQ]

  23. Abdelilah Sakti, Gilles Pesant, and Yann-Gaël Guéhéneuc. JTExpert at the Third Unit Testing Tool Competition, May 2015. Note: Tool demo at the 8th International Workshop on Search-Based Software Testing. 4 pages. [Text ] [Slides ] Keyword(s): Test case generation, SBST.
    Abstract:
    JTExpert is a software testing tool that automatically generates a whole test suite to satisfy the branch-coverage criterion on a given Java source code. It takes as inputs a Java source code and its dependencies and automatically produces a test-case suite in JUnit format. In this paper, we summarize our results for the Unit Testing Tool Competition held at the third SBST Contest, where JTExpert got a score of 159.16 and was ranked sixth of seven participating tools. Thus, we discuss the internal and external reasons that were behind the relatively poor score and ranking.
    [bibtex-key = Sakti15-Demo-SBST]


2014
  1. Yann-Gaël Guéhéneuc and Gi-hwon Kwon, editors. Proceedings of the 21th Asia-Pacific Software Engineering Conference, December 2014. IEEE CS Press. [bibtex-key = APSEC14]

  2. Foutse Khomh, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Massimiliano Di Penta. Modèles de qualité et conception des programmes, chapter 3, pages 85--116. Éditions Lavoisier, avril 2014. Note: Hermes Science. Traité IC2, série Informatique et Systèmes d'Information. 32 pages. [Text ] Keyword(s): Quality models, Design patterns, EMSL.
    Abstract:
    \paragraph{Contexte} La qualit{\'e} des programmes par objets se d{\'e}compose en de nombreuses dimensions, qui requi{\`e}rent des mod{\`e}les pour les {\'e}valuer. Ces mod{\`e}les d{\'e}crivent des relations entre des dimensions de qualit{\'e} (aussi appel{\'e}es caract{\'e}ristiques de qualit{\'e}) d'une part et des attributs internes des classes des programmes d'autre part. Par exemple, le mod{\`e}le \QM{} de Bansiya et Davis mesure six caract{\'e}ristiques de qualit{\'e} ; celui de Zimmermann \ygg@latin{et al.} mesure la propension aux fautes des classes. Les mod{\`e}les de qualit{\'e} utilisent des m{\'e}triques de classes (\eg{} nombres de m{\'e}thodes) ou de relations entre classes (\eg{} couplage) pour mesurer les attributs internes des classes et en d{\'e}river des valeurs pour les caract{\'e}ristiques de qualit{\'e} externes des programmes. \paragraph{Probl{\`e}me} La qualit{\'e} des programmes par objets, \ie{} d{\'e}velopp{\'e}s avec une m{\'e}thodologie objet, ne d{\'e}pend pas uniquement de la structure de leurs classes, que mesurent les m{\'e}triques, mais aussi de la fa{\c{c}}on dont celles-ci sont organis{\'e}es ; \ie{} leur conception qui se manifeste concr{\`e}tement au travers de styles de conception, \eg{} des occurrences de patrons et d'anti-patrons de conception. \paragraph{Objectif} L'objectif de ce chapitre est de pr{\'e}senter l'{\'e}tat de l'art sur les mod{\`e}les de qualit{\'e} et d'introduire notre m{\'e}thode \DQLT{} et son instantiation, \PQM{}, pour la mesure de la propension aux changements et aux fautes des classes en prenant en compte la conception des programmes par objets. \paragraph{M{\'e}thode} Nous introduisons la m{\'e}thode \DQLT{} pour construire syst{\'e}matiquement des mod{\`e}les de qualit{\'e} pour les programmes par objets qui prennent en compte les attributs internes des classes (au travers de m{\'e}triques) et leurs conceptions (au travers des occurrences de patrons et d'anti-patrons de conception). \paragraph{R{\'e}sultats} En utilisant \DQLT{} et nos r{\'e}cents r{\'e}sultats sur les propensions aux changements et aux fautes des classes qui jouent des r{\^o}les dans des anti-patrons ou patrons de conception, nous construisons le mod{\`e}le de qualit{\'e} \PQM{}. Ce mod{\`e}le prend en compte la conception des programmes par objets dans son {\'e}valuation de leurs propensions aux changements et aux fautes. Nous validons \PQM{} sur trois programmes dont le code source est libre. Nous montrons ainsi les bonnes performances de \PQM{}, en particulier dans le cas inter-projets : celui o{\`u} le mod{\`e}le est entra{\^\i}n{\'e} sur les donn{\'e}es d'un programme et appliqu{\'e} sur un autre programme. Nous comparons aussi \PQM{} avec deux mod{\`e}les pr{\'e}c{\'e}dents et montrons ainsi que \PQM{} mesure avec une meilleure pr{\'e}cision et un meilleur rappel les propensions aux changements et aux fautes des classes que les autres mod{\`e}les. \paragraph{Conclusion} Notre m{\'e}thode \DQLT{} permet de construire syst{\'e}matiquement des mod{\`e}les de qualit{\'e} pour les programmes par objets en prenant en compte leur conception. Une instantiation de notre m{\'e}thode, le mod{\`e}le \PQM{}, montre de meilleurs pr{\'e}cisions et rappels dans l'{\'e}valuation des propensions aux changements et aux fautes des classes des programmes par objets que les pr{\'e}c{\'e}dents mod{\`e}les.
    [bibtex-key = Khomh14-EMSL-PQMOD]

  3. Venera Arnaoudova, Laleh Eshkevari, Massimiliano Di Penta, Rocco Oliveto, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. REPENT: Analyzing the Nature of Identifier Renamings. Transactions on Software Engineering (TSE), 40(5):502--532, May 2014. Note: 30 pages. [Text ] Keyword(s): Linguistic smells, TSE.
    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, \ie{} 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\% perform renaming from a few times per week to almost every day and that 92\% 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\% 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 {\sc REPENT} ({\sc REanaming Program ENTities}), 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 (\eg{} 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\% and a recall of 92\%. In addition, we report an exploratory study investigating and discussing how identifiers are renamed in the five programs, according to our taxonomy.
    [bibtex-key = Arnaoudova14-TSE-REPENT]

  4. Fehmi Jaafar, Yann-Gaël Guéhéneuc, Guiliano Antoniol, and Sylvie Hamel. Detecting Asynchrony and Dephase Change Patterns by Mining Software Repositories. Journal of Software Maintenance and Evolution: Research and Practice (JSME), 26(1):77--106, January 2014. Note: Under publication. [Text ] Keyword(s): Evolution patterns, JSME-JSEP. [bibtex-key = Jaafar13-JSME-MacroCoChanges]

  5. Fehmi Jaafar, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Foutse Khomh. Analysing Anti-patterns Static Relationships with Design Patterns. Electronic Communications of the EASST (ECEASST), 59, August 2014. Note: 26 pages. [Text ] Keyword(s): Code and design smells, ECEASST.
    Abstract:
    Anti-patterns are motifs that are usually thought to be good solutions to some design or implementation problems, but back-fires badly when applied. Previous studies have reported that anti-patterns make object oriented systems hard to maintain. Anti-patterns motifs usually have dependencies with other classes in the system. In this paper, we propose to analyse these dependencies (with in particular design patterns) in order to understand how developers can maintain programs containing anti-patterns. To the best of our knowledge, no substantial investigation of anti-pattern dependencies with design patterns has been done before. This paper presents the results of a study that we performed on three different systems, ArgoUML, JFreeChart, and XercesJ, written in Java, and of size ranges from 1,191 to 3,325 classes, to analyse the static relationships between anti-patterns and design patterns. We found that these relationships (1) exist, but (2) are temporary and (3) classes participating in such relationships are more change-prone but less fault-prone than other anti-pattern classes.
    [bibtex-key = Jaafar14-ECEASST-AntipatternRelationships]

  6. Soumaya Medini, Venera Arnaoudova, Massimiliano Di Penta, Giulian Antoniol, Yann-Gaël Guéhéneuc, and Paolo Tonella. SCAN: An Approach to Label and Relate Execution Trace Segments. Journal of Software: Evolution and Process (JSEP), 26(11):962--995, November 2014. Note: 33 pages. [Text ] Keyword(s): Features and requirements, JSME-JSEP.
    Abstract:
    Program comprehension is a prerequisite to any maintenance and evolution task. In particular, when performing feature location, developers perform program comprehension by abstracting software features and identifying the links between high-level abstractions (features) and program elements. We present Segment Concept AssigNer (SCAN), an approach to support developers in feature location. SCAN uses a search-based approach to split execution traces into cohesive segments. Then, it labels the segments with relevant keywords and, finally, uses formal concept analysis to identify relations among segments. In a first study, we evaluate the performances of SCAN on six Java programs by 31 participants. We report an average precision of 69\% and a recall of 63\% when comparing the manual and automatic labels and a precision of 63\% regarding the relations among segments identified by SCAN. After that, we evaluate the usefulness of SCAN for the purpose of feature location on two Java programs. We provide evidence that SCAN (i) identifies 69\% of the gold set methods and (ii) is effective in reducing the quantity of information that developers must process to locate features—reducing the number of methods to understand by an average of 43\% compared to the entire execution traces.
    [bibtex-key = Medini14-JSEP-SCAN]

  7. Francis Palma, Mathieu Nayrolles, Naouel Moha, Yann-Gaël Guéhéneuc, Benoit Baudry, and Jean-Marc Jézéquel. SOA Antipatterns: An Approach for their Specification and Detection. International Journal of Cooperative Information Systems (IJCIS), 23(1), March 2014. Note: 31 pages. [Text ] Keyword(s): Code and design smells, IJCIS.
    Abstract:
    \def\SBS{SBSs}\def\SOA{SOA}\def\SODA{SODA} Like any other large and complex software systems, Service Based Systems (\SBS{}) must evolve to fit new user requirements and execution contexts. The changes resulting from the evolution of \SBS{} may degrade their design and quality of service (QoS) and may often cause the appearance of common poor solutions in their architecture, called \emph{antipatterns}, in opposition to \emph{design patterns}, which are good solutions to recurring problems. Antipatterns resulting from these changes may hinder the future maintenance and evolution of \SBS{}. The detection of antipatterns is thus crucial to assess the design and QoS of \SBS{} and facilitate their maintenance and evolution. However, methods and techniques for the detection of antipatterns in \SBS{} are still in their infancy despite their importance. In this paper, we introduce a novel and innovative approach supported by a framework for specifying and detecting antipatterns in \SBS{}. Using our approach, we specify ten well-known and common antipatterns, including extit{Multi Service} and extit{Tiny Service}, and automatically generate their detection algorithms. We apply and validate the detection algorithms in terms of precision and recall on two systems developed independently, (1) extit{Home-Automation}, an SBS with 13 services, and (2) extit{FraSCAti}, an open-source implementation of the Service Component Architecture (SCA) standard with more than 100 services. This validation demonstrates that our approach enables the specification and detection of SOA antipatterns with an average precision of 90\% and recall of 97.5\%.
    [bibtex-key = Palma14-IJCIS-SOAAntipatternsDetection]

  8. Abdelilah Sakti, Gilles Pesant, and Yann-Gaël Guéhéneuc. Instance Generator and Problem Representation to Improve Object Oriented Code Coverage. Transactions on Software Engineering (TSE), 40(99):1--22, October 2014. Note: 22 pages. [Text ] Keyword(s): Test case generation, TSE.
    Abstract:
    Search-based approaches have been extensively applied to solve the problem of software test-data generation. Yet, testdata generation for object-oriented programming (OOP) is challenging due to the features of OOP, e.g., abstraction, encapsulation, and visibility that prevent direct access to some parts of the source code. To address this problem we present a new automated search-based software test-data generation approach that achieves high code coverage for unit-class testing. We first describe how we structure the test-data generation problem for unit-class testing to generate relevant sequences of method calls. Through a static analysis, we consider only methods or constructors changing the state of the class-under-test or that may reach a test target. Then we introduce a generator of instances of classes that is based on a family of means-of-instantiation including subclasses and external factory methods. It also uses a seeding strategy and a diversification strategy to increase the likelihood to reach a test target. Using a search heuristic to reach all test targets at the same time, we implement our approach in a tool, JTExpert, that we evaluate on more than a hundred Java classes from different open-source libraries. JTExpert gives better results in terms of search time and code coverage than the state of the art, EvoSuite, which uses traditional techniques.
    [bibtex-key = Sakti14-TSE-JTExpert]

  9. Gabriele Bavota, Rocco Oliveto, Andrea Di Lucia, Andrian Marcus, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. In Medio Stat Virtus: Extract Class Refactoring through Nash Equilibria. In Dave Binkley and Filippo Ricca, editors, Proceedings of the 1st CSMR-WCRE Software Evolution Week (CSMR-WCRE), pages 214--223, February 2014. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, CSMR-WCRE, CSMR, WCRE.
    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.
    [bibtex-key = Bavota14-CSMR-WCRE-ClassRefactoringNashEquilibria]

  10. Fehmi Jaafar, Foutse Khomh, Yann-Gaël Guéhéneuc, and Mohammad Zulkernine. Anti-pattern Mutations and Fault-proneness. In Bruce McMillin, editor, Proceedings of the 14th International Conference on Quality Software (QSIC), pages 246--255, October 2014. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, QSIC.
    Abstract:
    Software evolution and development are continuous activities that have a never-ending cycle. While developers commit changes on a software system to fix bugs or to implement new requirements, they sometimes introduce anti-patterns, which are bad solutions to recurring design problems in the system. Many previous studies have shown that these anti-patterns have negative effects on code quality, in particular fault-proneness. However, it is not clear if and how anti-patterns evolve and which evolutionary behaviours are more fault-prone. This paper presents results from an empirical study aimed at understanding the evolution of anti-patterns in 27 releases of three open-source software systems: ArgoUML, Mylyn, and Rhino. Specifically, the study analyzes the mutations of anti-patterns, the changes that they undergo, and the relation between anti-pattern evolution behaviours and fault-proneness. Results show that (1) anti-patterns mutate from one type of anti-patterns to another, (2) structural changes are behind these mutations, and (3) some mutations are more risky in terms of fault-proneness.
    [bibtex-key = Jaafar14-QSIC-AntiPatternMutations]

  11. Mario Linares-Vásquez, Sam Klock, Collin McMillan, Aminata Sabané, Denys Poshyvanyk, and Yann-Gaël Guéhéneuc. Domain Matters: Bringing Further Evidence of the Relationships among Anti-patterns, Application Domains, and Quality-related Metrics in Java Mobile Apps. In Andrew Begel and Leon Moonen, editors, Proceedings of the 22nd International Conference on Program Comprehension (ICPC), pages 232--243, June 2014. ACM Press. Note: 11 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ICPC.
    Abstract:
    Some previous work began studying the relationship between application domains and quality, in particular through the prevalence of code and design smells (e.g., anti-patterns). Indeed, it is generally believed that the presence of these smells degrades quality but also that their prevalence varies across domains. Though anecdotal experiences and empirical evidence gathered from developers and researchers support this belief, there is still a need to further deepen our understanding of the relationship between application domains and quality. Consequently, we present a large-scale study that investigated the systematic relationships between the presence of smells and quality-related metrics computed over the bytecode of 1,343 Java Mobile Edition applications in 13 different application domains. Although, we did not find evidence of a correlation between smells and quality-related metrics, we found (1) that larger differences exist between metric values of classes exhibiting smells and classes without smells and (2) that some smells are commonly present in all the domains while others are most prevalent in certain domains.
    [bibtex-key = Linares-Vasquez14-ICPC-DomainMatters]

  12. Angela Lozano, Fehmi Jaafar, Kim Mens, and Yann-Gaël Guéhéneuc. Clones and Macro Co-changes. In Nils Göde and Yoshiki Higo, editors, Proceedings of the 8th International Workshop on Software Clones (IWSC), February 2014. Electronic Communications of the EASST. Note: 15 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, IWSC.
    Abstract:
    Ideally, any change that modifies the similar parts of a cloned code snippet should be propagated to all its duplicates. In practice however, consistent propagation of changes in clones does not always happen. Current evidence indicates that clone families have a 50\% chance of having consistent changes. This paper measures cloning and co-changes at file level as a proxy to assess the frequency of consistent changes. Given that changes to a clone group are not necessarily propagated in the same commit transaction (i.e., late propagations), our analysis uses macro co-changes instead of the traditional definition of co-changes. Macro changes group bursts of changes that are closer among themselves than to other changes, regardless of author or message. Then, macro co-changes are sets of files that change in the same macro changes. Each cloned file is tagged depending on whether any of the files with which it macro co-changes is cloned with it (during the macro change) or not. Contrary to previous results, we discovered that most of the cloned files macro co-change \emph{only} with files with which they share clones. Thus providing evidence that macro changes are appropriate to study the conjecture of clones requiring co-changes, and indicating that consistent changes might be the norm in cloned code.
    [bibtex-key = Lozano14-IWSC-ClonesMacroCochanges]

  13. Francis Palma, Johann Dubois, Naouel Moha, and Yann-Gaël Guéhéneuc. Detection of REST Patterns and Antipatterns: A Heuristics-based Approach. In Xavier Franch, Aditya Ghose, and Grace Lewis, editors, Proceedings of the 12th International Conference on Service Oriented Computing (ICSOC), pages 230--244, November 2014. Springer. Note: 15 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ICSOC.
    Abstract:
    exttt{REST} (REpresentational State Transfer), relying on extit{resources} as its architectural unit, is currently a popular architectural choice for building Web-based applications. It is shown that extit{design patterns}---good solutions to recurring design problems---improve the design quality and facilitate maintenance and evolution of software systems. extit{Antipatterns}, on the other hand, are poor and counter-productive solutions. Therefore, the detection of exttt{REST} (anti)patterns is essential for improving the maintenance and evolution of exttt{RESTful} systems. Until now, however, no approach has been proposed. In this paper, we propose exttt{SODA-R} (Service Oriented Detection for Antipatterns in exttt{REST}), a heuristics-based approach to detect (anti)patterns in exttt{RESTful} systems. We define detection heuristics for eight exttt{REST} antipatterns and five patterns, and perform their detection on a set of 12 widely-used exttt{REST} exttt{APIs} including BestBuy, Facebook, and DropBox. The results show that exttt{SODA-R} can perform the detection of exttt{REST} (anti)patterns with high accuracy. We also found that Twitter, DropBox, and Alchemy are not well-designed, \emph{i.e.}, contain more antipatterns. In contrast, Facebook, BestBuy, and YouTube are well-designed, \emph{i.e.}, contain more patterns and less antipatterns.
    [bibtex-key = Palma14-ICSOC-SOAAntiPatternsWebServices]

  14. Francis Palma, An Le, Foutse Khomh, Naouel Moha, and Yann-Gaël Guéhéneuc. Investigating the Change-Proneness of Service Patterns and Antipatterns. In Christian Huemer, editor, Proceedings of the 7th International Conference on Service-Oriented Computing and Applications (SOCA), pages 1--8, November 2014. IEEE CS Press. Note: 8 pages. [Text ] [Slides ] Keyword(s): Code and design smells, SOCA.
    Abstract:
    Like any other software systems, service-based systems (SBSs) evolve frequently to accommodate new user requirements. This evolution may degrade their design and implementation and may cause the introduction of common bad practice solutions -- antipatterns -- in opposition to patterns which are good solutions to common recurring design problems. We believe that the degradation of the design of SBSs does not only affect the clients of the SBSs but also the maintenance and evolution of the SBSs themselves. This paper presents the results of an empirical study that aimed to quantify the impact of service (anti)patterns on the maintenance and evolution of SBSs. We measure the maintenance effort of a service implementation in terms of the number of changes and the size of changes (i.e., Code churns) performed by developers to maintain and evolve the service, two effort metrics that have been widely used in software engineering studies. Using data collected from the evolutionary history of the SBS FraSCAti, we investigate if (1) services involved in patterns require less maintenance effort, (2) services detected as antipatterns require more maintenance effort than other services, and (3) if some particular service antipatterns are more change-prone than others. Results show that (1) services involved in patterns require less maintenance effort, but not at statistically significant level, (2) services detected as antipatterns require significantly more maintenance effort than non-antipattern services, and (3) services detected as God Component, Multi Service, and Service Chain antipatterns are more change-prone (i.e., Require more maintenance effort) than the services involved in other antipatterns. We also analysed the relation between object-oriented code smells and service patterns/antipatterns and found a significant difference in the proportion of code smells contained in the implementations of service (anti)patterns.
    [bibtex-key = Palma14-SOCA-ServiceAntiPatternChangeProneness]

  15. Francis Palma, Naouel Moha, Guy Tremblay, and Yann-Gaël Guéhéneuc. Specification and Detection of SOA Antipatterns in Web Services. In Paris Avgeriou, editor, Proceedings of the 8th European Conference on Software Architecture (ECSA), pages 58--73, August 2014. Springer. Note: 15 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ECSA.
    Abstract:
    Service Based Systems, composed of Web Services (WSs), offer promising solutions to software development problems for companies. Like other software artefacts, WSs evolve due to the changed user requirements and execution contexts, which may introduce poor solutions-Antipatterns-may cause (1) degradation of design and quality of service (QoS) and (2) difficult maintenance and evolution. Thus, the automatic detection of antipatterns in WSs, which aims at evaluating their design and QoS requires attention. We propose SODA-W (Service Oriented Detection for Antipatterns in Web services), an approach supported by a framework for specifying and detecting antipatterns in WSs. Using SODA-W, we specify ten antipatterns, including God Object Web Service and Fine Grained Web Service, and perform their detection in two different corpora: (1) 13 weather-related and (2) 109 financial-related WSs. SODA-W can specify and detect antipatterns in WSs with an average precision of more than 75\% and a recall of 100\%.
    [bibtex-key = Palma14-ECSA-SOAAntiPatternsWebServices]

  16. Yann-Gaël Guéhéneuc. En pratique : Art Effect 4 - retoucher une image (trottoir) (Traduction), février 2014. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Dans ce tutoriel, vous allez retoucher un trottoir en face d'un bar et le remplacer par une plage de galets.
    [bibtex-key = Gueheneuc14-WebZine-ArtEffectTouchingUp]

  17. Yann-Gaël Guéhéneuc. Entrevue avec Andrew Morris (Traduction), décembre 2014. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    {\`A} la suite de notre entretien avec David Makin, qui programma Crystal Dragon et Super Scramble Simulator, nous avons maintenant le plaisir de recevoir Andrew Morris, qui r{\'e}alisa les graphismes pour Super Scramble Simulator et ceux de grands jeux de Gremlin/Magnetic Fields, comme Super Cars et la s{\'e}rie des Lotus.
    [bibtex-key = Gueheneuc14-WebZine-AndrewMorris]

  18. Yann-Gaël Guéhéneuc. Entrevue avec Bill McEwen et Dick Van Dyke (Traduction), janvier 2014. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Steve Young de CNN Financial Network a rencontr{\'e} Bill McEwen, nouveau pr{\'e}sident d'Amiga Inc. et Dick Van Dyke, une c{\'e}l{\'e}brit{\'e} du cin{\'e}ma.
    [bibtex-key = Gueheneuc13-WebZine-AustralianRoadshow]

  19. Yann-Gaël Guéhéneuc. Entrevue avec Randy Platt (Traduction), octobre 2014. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Voici une entrevue avec Randy Platt, programmeur de jeux vid{\'e}o chez Cinemaware (1987-1991).
    [bibtex-key = Gueheneuc14-WebZine-InterviewPlatt]

  20. Yann-Gaël Guéhéneuc. Entrevue avec Robert J. Mical (Traduction), juillet 2014. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Publication d'une entrevue avec Robert J. Mical, un des d{\'e}veloppeurs de l'AmigaOS d'origine. Il s'agit de sa premi{\`e}re entrevue, datant de 1987, o{\`u} il raconte les d{\'e}veloppements en cours de l'{\'e}poque mais aussi quelques faits historiques.
    [bibtex-key = Gueheneuc14-WebZine-InterviewMical]

  21. Yann-Gaël Guéhéneuc. Reportage : Consumer Electronic Show Summer 1986 (Traduction), avril 2014. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Retour sur le Consumer Electronic Show Summer 1986, un salon informatique qui s'est tenu en juin 1986.
    [bibtex-key = Gueheneuc14-WebZine-CES86]

  22. Wei Wu, Bram Adams, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. ACUA: API Change and Usage Auditor, September 2014. Note: Tool demo at the 14th International Working Conference on Source Code Analysis and Manipulation. 6 pages. [Text ] Keyword(s): Code and design smells, SCAM.
    Abstract:
    Modern software uses frameworks through their Application Programming Interfaces (APIs). Framework APIs may change while frameworks evolve. Client programs have to upgrade to new releases of frameworks if security vulnerabilities are discovered in the used releases. Patching security vulnerabilities can be delayed by non-security-related API changes when the frameworks used by client programs are not up to date. Keeping frameworks updated can reduce the reaction time to patch security leaks. Client program upgrades are not cost free, developers need to understand the API usages in client programs and API changes between framework releases before conduct upgrading tasks. In this paper, we propose a tool ACUA to generate reports containing detailed API change and usage information by analyzing the binary code of both frameworks and clients programs written in Java. Developers can use the API change and usage reports generated by ACUA to estimate the work load and decide when to starting upgrading client programs based on the estimation.
    [bibtex-key = Wu14-Demo-SCAM-ACUA]


2013
  1. Yann-Gaël Guéhéneuc and Tom Mens, editors. Proceedings of the 29th International Conference on Software Maintenance, September 2013. IEEE CS Press. [bibtex-key = ICSM13]

  2. Nasir Ali, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Trustrace: Mining Software Repositories to Improve the Accuracy of Requirement Traceability Links. Transactions on Software Engineering (TSE), 39(5):725--741, May 2013. Note: 20 pages. [Text ] Keyword(s): Features and requirements, TSE.
    Abstract:
    Traceability is the only means to ensure that the source code of a system is consistent with its requirements and that all and only the specified requirements have been implemented by developers. During software maintenance and evolution, requirement traceability links become obsolete because developers do not/cannot devote effort to update them. Yet, recovering these traceability links later is a daunting and costly task for developers. Consequently, the literature proposed methods, techniques, and tools to recover these traceability links semi-automatically or automatically. Among the proposed techniques, the literature showed that information retrieval (IR) techniques can automatically recover traceability links between free-text requirements and source code. However, IR techniques lack accuracy (precision and recall). In this paper, we show that mining software repositories and combining mined results with IR techniques can improve the accuracy (precision and recall) of IR techniques and we propose Trustrace, a trust-based traceability recovery approach. We apply Trustrace on four medium-size open-source systems to compare the accuracy of its traceability links with those recovered using state-of-the-art IR techniques from the literature, based on the Vector Space Model and Jensen--Shannon model. The results of Trustrace are up to 22.7\% more precise and have 7.66\% better recall values than those of the other techniques, on average. We thus show that mining software repositories and combining the mined data with existing results from IR techniques improves the precision and recall of requirement traceability links.
    [bibtex-key = Ali13-TSE-Trustrace]

  3. Latifa Guerrouj, Massimiliano Di Penta, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Experimental Investigation on the Effects of Context on Source Code Identifiers Splitting and Expansion. Empirical Software Engineering (EMSE), pp 1--48, July 2013. Note: 45 pages. [Text ] Keyword(s): Identifier analysis, EMSE.
    Abstract:
    Recent and past studies indicate that source code lexicon plays an important role in program comprehension. Developers often compose source code identifiers with abbreviated words and acronyms, and do not always use consistent mechanisms and explicit separators when creating identifiers. Such choices and inconsistencies impede the work of developers that must understand identifiers by decomposing them into their component terms, and mapping them onto dictionary, application or domain words. When software documentation is scarce, outdated or simply not available, developers must therefore use the available contextual information to understand the source code. This paper aims at investigating how developers split and expand source code identifiers, and, specifically, the extent to which different kinds of contextual information could support such a task. In particular, we consider (i) an internal context consisting of the content of functions and source code files in which the identifiers are located, and (ii) an external context involving external documentation. We conducted a family of two experiments with 63 participants, including bachelor, master, Ph.D. students, and post-docs. We randomly sampled a set of 50 identifiers from a corpus of open source C programs and we asked participants to split and expand them with the availability (or not) of internal and external contexts. We report evidence on the usefulness of contextual information for identifier splitting and acronym/abbreviation expansion. We observe that the source code files are more helpful than just looking at function source code, and that the application-level contextual information does not help any further. The availability of external sources of information only helps in some circumstances. Also, in some cases, we observe that participants better expanded acronyms than abbreviations, although in most cases both exhibit the same level of accuracy. Finally, results indicated that the knowledge of English plays a significant effect in identifier splitting/expansion. The obtained results confirm the conjecture that contextual information is useful in program comprehension, including when developers split and expand identifiers to understand them. We hypothesize that the integration of identifier splitting and expansion tools with IDE could help to improve developers' productivity.
    [bibtex-key = Guerrouj13-EMSE-TIDIER]

  4. Ségla Kpodjedo, Filippo Ricca, Philippe Galinier, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. MADMatch: Many-to-many Approximate Diagram Matching for Design Comparison. Transactions on Software Engineering (TSE), 39(8):1090--1111, Feburary 2013. Note: 23 pages. [Text ] Keyword(s): Evolution patterns, TSE.
    Abstract:
    Matching algorithms play a fundamental role in many important but difficult software engineering activities, especially design evolution analysis and model comparison. We present MADMatch, a fast and scalable Many-to-many Approximate Diagram Matching approach based on an Error-Tolerant Graph matching (ETGM) formulation. Diagrams are represented as graphs, costs are assigned to possible differences between two given graphs, and the goal is to retrieve the cheapest matching. We address the resulting optimisation problem with a tabu search enhanced by the novel use of lexical and structural information. Through several case studies with different types of diagrams and tasks, we show that our generic approach obtains better results than dedicated state-of-the-art algorithms, such as AURA, PLTSDiff or UMLDiff, on the exact same datasets used to introduce (and evaluate) these algorithms.
    [bibtex-key = Kpodjedo13-TSE-MADMatch]

  5. Ségla Kpodjedo, Filippo Ricca, Philippe Galinier, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Studying Software Evolution of Large Object-oriented Software Systems using an ETGM Algorithm. Journal of Software Maintenance and Evolution: Research and Practice (JSME), 25(2):139--163, September 2013. Note: 28 pages. [Text ] Keyword(s): Evolution patterns, JSME-JSEP.
    Abstract:
    Analyzing and understanding the evolution of large object-oriented software systems is an important but difficult task, in which matching algorithms play a fundamental role. An error-tolerant graph matching (ETGM) algorithm is able to identify evolving classes that maintain a stable structure of relations (associations, inheritances, and aggregations) with other classes and that, thus, likely constitute the backbone of the system. Therefore, we first develop a novel ETGM algorithm to study the evolution of class diagrams. This algorithm improves the performance of our previous algorithm. Second, we describe the process of building an oracle to test and study our algorithm. Third, we report for the new algorithm the impact of the algorithm parameters on the F-measure summarizing precision and recall. Finally, with tuned algorithm parameters, we carry out and report an extensive empirical evaluation of our algorithm. Overall we show that: this novel algorithm is scalable, stable and has better time performance. In our empirical evaluation, we use small, \ie{} Rhino, medium, \ie{} Azureus and ArgoUML, and large systems, \ie{} Mozilla and Eclipse.
    [bibtex-key = Kpodjedo13-JSME-ETGMEvolution]

  6. Joyal Miranda, José Côté, Gaston Godin, Martin Blais, Joanne Otis, Yann-Gaël Guéhéneuc, Ghayas Fadel, Luisa Barton, and Shawn Fowler. An Internet-Based Intervention Condom-Him to Increase Condom Use Among Human Immunodeficiency Virus-Positive Men Who Have Sex With Men: Protocol for a Randomized Controlled Trial. JMIR Research Protocols, 2(2):e39, October 2013. Note: 8 pages. [Text ] Keyword(s): VIHTAVIE, JMIRResProtoc.
    Abstract:
    Background: In the recent years, the Internet has been used as a medium to find sexual partners and engage in risky sexual behavior. This has changed the way in which men having have sex with men (MSM) seek sexual partners and has increased the number of high-risk sexual encounters. Therefore, developers of human immunodeficiency virus (HIV)-prevention interventions have also started using the Internet as a viable medium to promote safe sexual behaviors. However, much of the efforts thus far have been aimed at HIV-negative rather than HIV-positive MSM. HIV-positive individuals continue to engage in risky sexual behaviors and thus constitute an important group in which HIV prevention strategies need to be addressed. Therefore, HIV prevention in HIV-positive MSM is a critical issue. Objective: Condom-Him, an Internet-based intervention tailored to increase condom use among HIV-positive MSM, was developed with the aim of improving condom use, self-efficacy, and intentions to use condoms among these individuals. The acceptability and feasibility of this Internet-based intervention will be examined in a pilot study. Methods: We will perform a randomized controlled parallel-group superiority trial. HIV-positive MSM who currently engage in unprotected anal sex will be recruited for the study. Participants will be randomly assigned using a one-to-one allocation ratio generated by the computer program. The researchers will be blinded to participant's group assignment. Participants will be assigned either to use the Condom-Him intervention (experimental arm) or to view a list of websites containing HIV/AIDS related information (control arm). Self-administered questionnaires will be provided online before randomization (baseline) and two weeks after intervention (post-test). Results: The study will include a total of 60 participants with 30 in each group. The results from this pilot study will provide further evidence for a larger study to examine the effectiveness of this intervention and will provide a cost-effective and widely accessible approach to HIV prevention for HIV-positive MSM. Conclusions: Internet-based interventions for HIV-positive MSM, a population that has been under-represented in the efforts for positive prevention of HIV within Canada, have the potential to provide a cost-effective strategy, which influences the way in which information is accessed and provided to high-risk individuals. The advantages of an Internet-based intervention include the potential to provide consistency in the delivery of an intervention and the ability to disseminate the intervention to a wider population. Internet-based interventions are perceived as vital tools in combating HIV infection within the realm of social media. Therefore, it is important to determine the feasibility and acceptability of these interventions before implementing them.
    [bibtex-key = Joyal13-JMIRResProtoc]

  7. Venera Arnaoudova, Massimiliano Di Penta, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. A New Family of Software Anti-Patterns: Linguistic Anti-Patterns. In Anthony Cleve and Filippo Ricca, editors, Proceedings of the 17th European Conference on Software Maintenance and Reengineering (CSMR), pages 187--196, March 2013. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Linguistic smells, CSMR.
    Abstract:
    Recent and past studies have shown that poor source code lexicon negatively affects software understandability, maintainabi\-lity, and, overall, quality. Besides a poor usage of lexicon and documentation, sometimes a software artifact description is misleading with respect to its implementation. Consequently, developers will spend more time and effort when understanding these software artifacts, or even make wrong assumptions when they use them. This paper introduces the definition of software linguistic antipatterns, and defines a family of them, \ie those related to inconsistencies (i) between method signatures, documentation, and behavior and (ii) between attribute names, types, and comments. Whereas ``design'' antipatterns represent recurring, poor design choices, linguistic antipatterns represent recurring, poor naming and commenting choices. The paper provides a first catalogue of one family of linguistic antipatterns, showing real examples of such antipatterns and explaining what kind of misunderstanding they can cause. Also, the paper proposes a dectector prototype for Java programs called LAPD (Linguistic Anti-Pattern Detector), and reports a study investigating the presence of linguistic antipatterns in four Java software projects.
    [bibtex-key = Arnaoudova13-CSMR-LinguisticAntipatterns]

  8. Luis Sergio Da Silva, Yann-Gaël Guéhéneuc, and John Mullins. An Approach to Formalise Security Patterns. In Surafel Lemma Abebe, Venera Arnaoudova, Laleh Eshkevari, Aminata Sabané, and Wei Wu, editors, Proceedings of the 1st International Workshop on Patterns Promotion and Anti-patterns Prevention (PPAP), pages N/A, March 2013. ÉPM. Note: 6 pages. [Text ] [Slides ] Keyword(s): Code and design smells, PPAP.
    Abstract:
    The software engineering literature proposes many methods, techniques and tools to ease software development, among which design patterns. The main goal of design patterns is to ease software development through the reuse of good practices in software design and implementation. Design patterns pertain to various domains, including security. In the context of security, security patterns describe design and implementation solutions intended to protect data from a set of possible threats or at least to reduce the risk of their occurrences. Previous works on security patterns defined these patterns and proposed strategies to find occurrences of these patterns using techniques that detect the relationships between software components. However, to the best of our knowledge, these approaches did not describe the behavioural aspects of the components, such as the internal implementation of methods. Behavioural aspects are necessary to investigate and validate the following characteristics: constraints and scope. It is important to guide developers to the correct use of security patterns and preventing wrong implementation and security holes. This article proposes an approach, using Coloured Petri Nets and a set of API already available in the Ptidej reverse- engineering tool suite, to formalise and analyse the structural and behavioural aspects of security patterns and identify their occurrences in different kinds of software systems.
    [bibtex-key = DaSilvaJr13-PPAP-SecurityPatterns]

  9. Étienne Duclos, Sébastien Le Digabel, Yann-Gaël Guéhéneuc, and Bram Adams. ACRE: An Automated Aspect Creator for Testing C++ Applications. In Anthony Cleve and Filippo Ricca, editors, Proceedings of the 17th European Conference on Software Maintenance and Reengineering (CSMR), pages 121--130, March 2013. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Test-case generation, CSMR.
    Abstract:
    We present ACRE, an automated aspect creator, to use aspect-oriented programming (AOP) to perform memory, invariant and interferences testing for software programs written in C++. ACRE allows developers without knowledge in AOP to use aspects to test their programs without modifying the behavior of their source code. ACRE uses a domain-specific language (DSL), which statements testers insert into the source code like comments to describe the aspects to be used. The presence of DSL statements in the code does not modify the program's compilation and behavior. ACRE parses the DSL statements and automatically generates appropriate aspects that are then weaved into the source code to identify bugs due to memory leaks, incorrect algorithm implementation, or interference among threads. Thanks to the use of aspects and ACRE, testers can add or remove tests easily. Using an aspect generated by ACRE, we find a memory leak in a complex C++ software program, NOMAD, used in both industry and research. We also verify a crucial mathematical point of the algorithm behind NOMAD and collect data to find possible interference bugs, in NOMAD.
    [bibtex-key = Duclos13-CSMR-ACRE]

  10. Fehmi Jaafar, Yann-Gaël Guéhéneuc, and Sylvie Hamel. Analysing Anti-patterns Static Relationships with Design Patterns. In Surafel Lemma Abebe, Venera Arnaoudova, Laleh Eshkevari, Aminata Sabané, and Wei Wu, editors, Proceedings of the 1st International Workshop on Patterns Promotion and Anti-patterns Prevention (PPAP), March 2013. ÉPM. Note: 6 pages. [Text ] [Slides ] Keyword(s): Code and design smells, Design patterns, PPAP.
    Abstract:
    Anti-patterns are motifs that are commonly used by developers but they are ineffective and counterproductive in program development and–or maintenance. These motifs evolve and they may have dependencies with non-anti-pattern classes. We propose to analyse these dependencies (in particular with design patterns) in order to understand how developers can maintain programs containing anti-patterns. To the best of our knowledge, no substantial investigation of anti-pattern dependencies with design patterns was presented. This paper presents the results of a study that we performed on three different Java systems (ArgoUML, JFreeChart, and XercesJ) to analyse the static relationships between anti-patterns and design patterns. We detect such static relationships to better understand software systems and to explain the co-existence of these motifs. Our finding provides evidence that developers encapsulate anti-patterns using design patterns to facilitate maintenance tasks and reduce comprehension effort.
    [bibtex-key = Jaafar13-PPAP-AntipatternDependencies]

  11. Fehmi Jaafar, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Foutse Khomh. Mining the Relationship Between Anti-patterns Dependencies and Fault-proneness. In Rocco Oliveto and Romain Robbes, editors, Proceedings of the 20th Working Conference on Reverse Engineering (WCRE), October 2013. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, WCRE.
    Abstract:
    Anti-patterns describe poor solutions to design and implementation problems which are claimed to make object oriented systems hard to maintain. Anti-patterns indicate weaknesses in design that may slow down development or increase the risk of faults or failures in the future. Classes in anti-patterns have some dependencies, such as static relationships, that may propagate potential problems to other classes. To the best of our knowledge, the relationship between anti-patterns dependencies (with non anti-patterns classes) and faults has yet to be studied in details. This paper presents the results of an empirical study aimed at analysing anti-patterns dependencies in three open source software systems, namely ArgoUML, JFreeChart, and XerecesJ. We show that, in almost all releases of the three systems, classes having dependencies with anti-patterns are more fault-prone than others. We also report other observations about these dependencies such as their impact on fault prediction. Software organizations could make use of these knowledge about anti-patterns dependencies to better focus their testing and reviews activities toward the most risky classes, \eg{} classes with fault-prone dependencies with anti-patterns.
    [bibtex-key = Jaafar13-WCRE-AntipatternsFaults]

  12. Fehmi Jaafar, Salima Hassaine, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Bram Adams. On the Relationship Between Program Evolution and Fault-proneness: An Empirical Study. In Anthony Cleve and Filippo Ricca, editors, Proceedings of the 17th European Conference on Software Maintenance and Reengineering (CSMR), pages 15--24, March 2013. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, CSMR.
    Abstract:
    Over the years, many researchers have studied the evolution and maintenance of object-oriented source code in order to understand the possibly costly erosion of the software. However, many studies thus far did not link the evolution of classes to faults. Since (1) some classes evolve independently, other classes have to do it together with others (co-evolution); and (2) not all classes are meant to last forever, but some are meant for experimentation or to try out an idea that was then dropped or modified. In this paper, we group classes based on their evolution to infer their lifetime models and co-evolution trends. Then, we link each group's evolution to faults. We create phylogenetic trees showing the evolutionary history of programs and we use such trees to facilitate spotting the program code decay. We perform an empirical study, on three open-source programs: ArgoUML, JFreechart, and XercesJ, to examine the relation between the evolution of object-oriented source code at class level and fault-proneness. Our results indicate that (1) classes having a specific lifetime model are significantly less fault-prone than other classes and (2) faults fixed by maintaining co-evolved classes are significantly more frequent than faults fixed using not co-evolved classes.
    [bibtex-key = Jaafar13-CSMR-MacroCoChangeBugProneness]

  13. Francis Palma, Naouel Moha, and Yann-Gaël Guéhéneuc. Detection of Process Antipatterns: A BPEL Perspective. In Hafedh Mili, Yasmine Charif, and Emily Liu, editors, Proceedings of the 1st Workshop on Methodologies for Robustness Injection into Business Processes (MRI-BP), pages N/A, September 2013. IEEE CS Press. Note: 5 pages. [Text ] [Slides ] Keyword(s): Code and design smells, MRI-BP.
    Abstract:
    With the increasing significance of the service-oriented paradigm for implementing business solutions, assessing and analyzing such solutions also becomes an essential task to ensure and improve their quality of design. One way to develop such solutions, a.k.a., Service-Based systems (SBSs) is to generate BPEL (Business Process Execution Language) processes via orchestrating Web services. Development of large business processes (BPs) involves design decisions. Improper and wrong design decisions in software engineering are commonly known as \emph{antipatterns}, \emph{i.e.}, poor solutions that might affect the quality of design. The detection of antipatterns is thus important to ensure and improve the quality of business processes. However, although BP antipatterns have been defined in the literature, no effort was given to detect such antipatterns within BPEL processes. With the aim of improving the design and quality of BPEL processes, we propose the first rule-based approach to specify and detect BP antipatterns. We specify 7 BP antipatterns from the literature and perform the detection for 4 of them in an initial experiment with 3 example BPEL processes.
    [bibtex-key = Palma13-MRIBP-BPELAntipatterns]

  14. Aminata Sabané, Massimiliano Di Penta, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. A Study on the Relation Between Antipatterns and the Cost of Class Unit Testing. In Anthony Cleve and Filippo Ricca, editors, Proceedings of the 17th European Conference on Software Maintenance and Reengineering (CSMR), pages 167--176, March 2013. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Test-case generation, CSMR.
    Abstract:
    Antipatterns are known as recurring, poor design choices; recent and past studies indicated that they negatively affect software systems in terms of understandability and maintainability, also increasing change-and defect-proneness. For this reason, refactoring actions are often suggested. In this paper, we investigate a different side-effect of antipatterns, which is their effect on testability and on testing cost in particular. We consider as (upper bound) indicator of testing cost the number of test cases that satisfy the minimal data member usage matrix (MaDUM) criterion proposed by Bashir and Goel. A study---carried out on four Java programs, Ant 1.8.3, ArgoUML 0.20, CheckStyle 4.0, and JFreeChart 1.0.13---supports the evidence that, on the one hand, antipatterns unit testing requires, on average, a number of test cases substantially higher than unit testing for non-antipattern classes. On the other hand, antipattern classes must be carefully tested because they are more defect-prone than other classes. Finally, we illustrate how specific refactoring actions---applied to classes participating in antipatterns---could reduce testing cost.
    [bibtex-key = Sabane13-CSMR-CostUnitTestAntipatterns]

  15. Abdelilah Sakti, Yann-Gaël Guéhéneuc, and Gilles Pesant. Constraint-based Fitness Function for Search-Based Software Testing. In Carla Gomes and Meinolf Sellmann, editors, Proceedings of the 10th International Conference on Integration of Artificial Intelligence and Operations Research in Constraint Programming (CPAIOR), pages 378--385, May 2013. Springer. Note: Short paper. 4 pages. [Text ] [Slides ] Keyword(s): Test case generation, CPAIOR.
    Abstract:
    Evolutionary testing approach is a powerful automated technique for generating test inputs. Its goal is to reach a branch or a statement in a program under test. One major limit of this approach is its fitness function that does not offer enough information to orient the search to reach a test target with the existence of nested predicates. To address the problem, we propose a new fitness function based on constraint programming. The level of difficulty to satisfy a constraint is the main factor for ranking test candidates: We modulate predicates as a constraint satisfaction problem, then the difficulty-level of a constraint is determined according to the its impact on the search space. Difficulty level is a novel fitness function have been designed to deal with nested predicates and its usefulness have been improved based on benchmarks from the literature.
    [bibtex-key = Sakti13-CPAIOR-ConstraintFitness]

  16. Zohreh Sharafi, Alessandro Marchetto, Angelo Susi, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. An Empirical Study on the Efficiency of Graphical vs. Textual Representations in Requirements Comprehension. In Denys Poshyvanyk and Massimiliano Di Penta, editors, Proceedings of the 21st International Conference on Program Comprehension (ICPC), May 2013. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, ICPC.
    Abstract:
    Graphical representations are used to visualise, specify, and document software artifacts in all stages of software development process. In contrast with text, graphical representations are presented in two-dimensional form, which seems easy to process. However, few empirical studies investigated the efficiency of graphical representations vs.\ textual ones in modelling and presenting software requirements. Therefore, in this paper, we report the results of an eye-tracking experiment involving 28 participants to study the impact of structured textual vs.\ graphical representations on subjects' efficiency while performing requirement comprehension tasks. We measure subjects' efficiency in terms of the percentage of correct answers (accuracy) and of the time and effort spend to perform the tasks. We observe no statistically-significant difference in term of accuracy. However, our subjects spent more time and effort while working with the graphical representation although this extra time and effort does not affect accuracy. Our findings challenge the general assumption that graphical representations are more efficient than the textual ones at least in the case of developers not familiar with the graphical representation. Indeed, our results emphasise that training can significantly improve the efficiency of our subjects working with graphical representations. Moreover, by comparing the visual paths of our subjects, we observe that the spatial structure of the graphical representation leads our subjects to follow two different strategies (top-down vs.\ bottomup) and subsequently this hierarchical structure helps developers to ease the difficulty of model comprehension tasks.
    [bibtex-key = Sharafi13-ICPC-EfficiencyTextvsGraph]

  17. Zéphyrin Soh, Foutse Khomh, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Towards Understanding How Developers Spend Their Effort During Maintenance Activities. In Rocco Oliveto and Romain Robbes, editors, Proceedings of the 20th Working Conference on Reverse Engineering (WCRE), pages 152--161, October 2013. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, WCRE.
    Abstract:
    For many years, researchers and practitioners have strived to assess and improve the productivity of software development teams. One key step toward achieving this goal is the understanding of factors affecting the efficiency of developers performing development and maintenance activities. In this paper, we aim to understand how developers' spend their effort during maintenance activities and study the factors affecting developers' effort. By knowing how developers' spend their effort and which factors affect their effort, software organisations will be able to take the necessary steps to improve the efficiency of their developers, for example, by providing them with adequate program comprehension tools. For this preliminary study, we mine 2,408 developers' interaction histories and 3,395 patches from four open-source software projects (ECF, Mylyn, PDE, Eclipse Platform). We observe that usually, the complexity of the implementation required for a task does not reflect the effort spent by developers on the task. Most of the effort appears to be spent during the exploration of the program. In average, 62\% of files explored during the implementation of a task are not significantly relevant to the final implementation of the task. Developers who explore a large number of files that are not significantly relevant to the solution to their task take a longer time to perform the task. We expect that the results of this study will pave the way for better program comprehension tools to guide developers during their explorations of software systems.
    [bibtex-key = Soh13-WCRE-MatchingEffortTasks]

  18. Zéphyrin Soh, Foutse Khomh, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Bram Adams. On the Effect of Program Exploration on Maintenance Tasks. In Rocco Oliveto and Romain Robbes, editors, Proceedings of the 20th Working Conference on Reverse Engineering (WCRE), pages 391--400, October 2013. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, WCRE.
    Abstract:
    When developers perform a maintenance task, they follow an exploration strategy (ES) that is characterised by how they navigate through the program entities. Studying ES can help to assess how developers understand a program and perform a change task. Various factors could influence how developers explore a program and the way in which they explore a program may affect their performance for a certain task. In this paper, we investigate the ES followed by developers during maintenance tasks and assess the impact of these ES on the duration and effort spent by developers on the tasks. We want to know if developers frequently revisit one (or a set) of program entities (referenced exploration), or if they visit program entities with almost the same frequency (unreferenced exploration) when performing a maintenance task. We mine 1,705 Mylyn interaction histories (IH) from four open-source projects (ECF, Mylyn, PDE, and Eclipse Platform) and perform a user study to verify if both reference exploration (RE) and unreference exploration (UE) were followed by some developers. Using the Gini inequality index on the number of revisits of program entities, we automatically classify interaction histories as RE and UE and perform an empirical study to measure the effect of program exploration on the task duration and effort. We report that, although a UE may require more exploration effort than a RE, a UE is on average 12.30\% less time consuming than a RE.
    [bibtex-key = Soh13-WCRE-ProgramExploration]

  19. Zéphyrin Soh and Yann-Gaël Guéhéneuc. Towards the exploration strategies by mining Mylyn's interaction histories. Technical report EPM-RT-2013-01, École Polytechnique de Montréal, February 2013. Note: 24 pages. [Text ] Keyword(s): Understanding program comprehension.
    Abstract:
    When developers perform a maintenance task, they always explore the program, \ie{} move from one program entity to another. However, even though maintenance is a crucial task, the exploration strategies (ES) used by developers to navigate through the program entities remain unstudied. This lack of study prevents us from understanding how developers explore a program and perform a change task, from recommending strategies to developers, and (ultimately) from critically evaluating a developer's exploration performance. As a first step towards understanding ES, we mined interaction histories (IH) gathered using the Eclipse Mylyn plugin from developers performing a change task on four open-source projects (ECF, Mylyn, PDE, and Eclipse Platform). An ES is defined and characterized by the way (how) the developers navigate through the program entities. Using the Gini inequality index on the number of revisits of program entities, we observe that ES can be either centralized (CES) or extended (EES). We automatically classified interaction histories as CES or EES and performed an empirical study to ascertain the effect of the ES on the task duration and effort. We found that, although an EES requires more exploration effort than a CES, an EES is less time consuming than a CES. Extensive work (number of days spent performing a task) typically imply a CES. Our results show that developers who follow an EES have a methodical investigation of source code while developers who follow a CES have an opportunistic exploration of source code.
    [bibtex-key = Soh13-TR-MylynInteractionHistories]

  20. Wei Wu, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Miryung Kim. Halo: A Multi-feature Two-pass Analysis to Identify Framework API Evolution. Technical report EPM-RT-2013-05, École Polytechnique de Montréal, June 2013. Note: 24 pages. [Text ] Keyword(s): Evolution patterns.
    Abstract:
    Software frameworks and libraries are indispensable to today's software systems. Because of the fast development of open-source software in recent years, frameworks and libraries have became much versatile as any open-source system or part thereof can be used as a framework (or a library). Developer can reuse frameworks in innovative ways that are not expected by the providers of frameworks. Many frameworks are not well documented and very few owners provide specific documents to describe the changes between different releases of their frameworks. When they evolve, it is often time-consuming for developers to keep their dependent code up-to-date. Approaches have been proposed to lessen the impact of framework evolution on developers by identifying API evolution or change rules between two releases of a framework. However, the precision and recall of the change rules generated by these approaches depend on the features that they use, such as call-dependency relations or text similarity. If these features do not provide enough information, the approaches can miss correct change rules and compromise the precision and recall. For example, if a method in the old release of a framework is not called by other methods, we cannot find its change rule using call-dependency relations alone. Considering more features can overcome this limitation. Yet, because many features may also give contradictory information, integrating them is not straightforward. We thus introduce Halo, a novel hybrid approach that uses multiple features, including call dependency relations, method documentations, inheritance relations, and text similarity. Halo implements a two-pass analysis inspired by pattern classification problem. We implement Halo in Java and compare it with four state-of-the-art approaches. The comparison shows that, on average, the recall and the precision of Halo are 43\% and 5\% higher than that of other approaches.
    [bibtex-key = Wu13-TR-HALO]

  21. Yann-Gaël Guéhéneuc. Comparatifs : quelques correctifs AmigaOS 68k (processeur et opérations sur disque), Mai 2013. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Voici donc un petit r{\'e}sum{\'e} de quelques correctifs appliqu{\'e}s sur mon Amiga 1200/040 avec AmigaOS 3.x : BlizKick, SetPatch, RalLibPatch, PoolMem, CopyMem040.safe, FBlit, SystemPatch et PFS3.
    [bibtex-key = Gueheneuc13-WebZine-Comparatifs]

  22. Yann-Gaël Guéhéneuc. En pratique : Art Effect 4 - réaliser des filigranes (Traduction), août 2013. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Dans ce tutoriel, vous allez apprendre comment faire des filigranes.
    [bibtex-key = Gueheneuc13-WebZine-ArtEffectWatermarks]

  23. Yann-Gaël Guéhéneuc. Installation de Geek Gadgets sur AmigaOS 3.x, janvier 2013. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Les Geek Gadgets ont pour objectif d'offrir un environnement UN*X complet sur l'Amiga. Ils se d{\'e}composent essentiellement en trois choses : d'abord, d'une biblioth{\`e}que {\'e}mulant des fonctions UN*X pour rendre la vie facile aux d{\'e}veloppeurs, il s'agit de ixemul.library. Ensuite, les Geek Gadgets incluent de nombreux outils UN*X port{\'e}s sur Amiga, gr{\^a}ce {\`a} IXEmul. Enfin, il s'agit d'un environnement de compilation permettant de recompiler des outils UN*X sur Amiga en faisant appel {\`a} IXEmul.
    [bibtex-key = Gueheneuc13-WebZine-GeekGadgetsInstallation]

  24. Yann-Gaël Guéhéneuc. Test de Lure Of The Temptress, juillet 2013. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Lure Of The Temptress est un jeu informatique con{\c{c}}u pour l'Amiga, l'Atari ST et le DOS, d{\'e}velopp{\'e} par Revolution Software et distribu{\'e} par Virgin Interactive Entertainment, en 1992. Il s'agit d'un jeu d'aventure "pointe et clique". Lure Of The Temptress a une histoire de fond int{\'e}ressante, une intrigue prenante, de beaux graphismes, une belle trame sonore et fait bien rire avec ses dialogues assez spirituels...
    [bibtex-key = Gueheneuc13-WebZine-LureOfTheTemptress]

  25. Wei Wu, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. MOFAE: Multi-objective Optimization Approach to Framework API Evolution, June 2013. Note: Poster at the 2013 Spring Meeting of the Consortium for Software Engineering Research. 24 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, CSER.
    Abstract:
    Observation: APIs change between two versions of a framework. Problem: No documents about how to replace the missing APIs; Manually searching for the replacements is time consuming. Solution: Multi-objective optimization.
    [bibtex-key = Wu13-CSER-MOFAE]


2012
  1. Nasir Ali, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Factors Impacting the Inputs of Traceability Recovery Approaches, chapter 7, pages 99--127. Springer, September 2012. Note: 28 pages. [Text ] Keyword(s): Features and requirements, SST.
    Abstract:
    In requirement engineering, researchers have proposed various tractability recovery approaches. To the best of our knowledge, all traceability recovery approaches have low precision and recall. Our main claim in this chapter is that there exist factors that impact the traceability approaches' inputs, in particular \emph{source document}, \emph{target document}, and \emph{experts' opinion}, that cause low precision and recall. In this chapter, we pursue four objectives: first, to identify and document factors that impact traceability recovery approaches' inputs; second, to identify metrics/tools to measure/improve the quality of the inputs with respect to the identified factors, third, to provide precautions to control these factors, and, fourth, to empirically prove and quantify the effect of one of these factors---expert's programming knowledge---on the traceability recovery approaches' inputs. To achieve the first two objectives, we perform an incremental literature review of traceability recovery approaches and identify and document three key inputs and the seven factors impacting these inputs, out of 12 identified factors. We analyse the reported results in literature for the identified factors to address our third objective. We conduct an empirical study to assess the impact of expert's programming knowledge, to address our fourth objective. We use the effort, number of correct answers, and time to measure the effect of expert's programming knowledge on traceability recovery. We conclude that, in the literature, seven factors impacting the inputs of traceability recovery approaches have been identified, documented, and reported along with related metrics/tools and precautions. We suggest that practitioners should be wary of these seven factors and researchers should focus on the five others to improve traceability recovery approaches.
    [bibtex-key = Ali11-SST-FactorImpactingTraceability]

  2. José Coté, Gaston Godin, Yann-Gaël Guéhéneuc, Geneviève Rouleau, Pilar Ramirez-Garcia, Joanne Otis, Cécile Tremblay, and Ghayas Fadel. Evaluation of a Real-time Virtual Intervention to Empower Persons Living with HIV for Therapy Self-management: Study Protocol for an Online Randomized Controlled Trial. Trials Journal (Trials), 13(1), December 2012. Note: 27 pages. [Text ] Keyword(s): VIHTAVIE, Trials.
    Abstract:
    Morbidity and mortality among people infected with the human immunodeficiency virus (HIV) has declined dramatically since 1996 with the advent of a powerful antiretroviral therapy (ART) and the use of appropriate prophylaxis against opportunistic infections. Formerly considered a terminal illness, HIV infection is now categorized as a chronic disease. Though they cannot eradicate HIV, existing viral therapies suppress its replication and thus make it possible to maintain and improve the immune function of infected persons. However, therapy interruption, even if just temporary, allows the virus to multiply and then develop a resistance to medication. This is why it is imperative for therapy adherence to be optimal. Resistance reduces treatment response and allows the disease to progress. This resistance can be transmitted, thus becoming a public health issue. Developing interventions to boost and sustain antiretroviral therapy (ART) adherence has become a critical objective in the field of HIV and its treatment.
    [bibtex-key = Cote12-TRIALS-EvaluationHIV]

  3. José Côté, Geneviève Rouleau, Gaston Godin, Pilar Ramirez-Garcia, Yann-Gaël Guéhéneuc, Georgette Nahas, Cécile Tremblay, Joanne Otis, and Annick Hernandez. Acceptability and Feasibility Study of a Virtual Intervention to Help Persons Living with HIV Manage their Daily Therapies. Journal of Telemedecine and Telecare (JTT), 18(7):409--421, October 2012. Note: 12 pages. [Text ] Keyword(s): VIHTAVIE, JTT.
    Abstract:
    Objective. The VIH-TAVIE virtual intervention was developed to empower persons living with HIV to manage their daily antiretroviral therapies. VIH-TAVIE consists of four interactive computer sessions with a virtual nurse who serves as a guide through a learning process aimed at enhancing treatment management capacities. The information furnished and the strategies proposed by the nurse are adapted specifically on the basis of responses provided by the user. ewline Methods. A study was conducted to document the acceptability and feasibility of the web application. VIH-TAVIE was evaluated in a hospital setting as an adjunct intervention to regular care. Participants (N=88) were mostly men (n=73) and had a mean age of 47 years (SD=7). They had been diagnosed with HIV some 15 years earlier and had been on antiretroviral medication for a mean period of 12 years. Data were collected by different means: acceptability questionnaires, field notes and observations. ewline Results. For the majority of the PLHIV, VIH-TAVIE was easy to use. They learned tips for taking their medication, diminishing adverse side-effects and maintaining a positive attitude towards treatment. A large portion of the participants deemed their VIH-TAVIE experience highly satisfactory and felt the intervention met their needs with respect to strategies and proficiencies even though they had been taking medication for at least 12 years on average. ewline Conclusion. Still only at an experimental stage, the VIH-TAVIE approach is intended to be complementary to clinical follow-up.
    [bibtex-key = Cote12-Telemedecie-AcceptabilityFeasabilityStudy]

  4. Foutse Khomh, Massimiliano Di Penta, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Exploratory Study of the Impact of Antipatterns on Class Change- and Fault-Proneness. Empirical Software Engineering (EMSE), 17(3):243--275, June 2012. Note: 27 pages. [Text ] Keyword(s): Code and design smells, EMSE.
    Abstract:
    {\bf Context: } Antipatterns are poor design choices that are conjectured to make object-orien\-ted systems harder to maintain. ewline oindent {\bf Aim: } We investigate the impact of antipatterns on classes in object-oriented systems by studying the relation between the presence of antipatterns and the change- and fault-proneness of the classes. ewline oindent {\bf Method: } We detect umberofap{} antipatterns in umberofver{} releases of ArgoUML, Eclipse, Mylyn, and Rhino, and analyse (1) to what extent classes participating in antipatterns have higher odds to change or to be subject to fault-fixing than other classes, (2) to what extent these odds (if higher) are due to the sizes of the classes or to the presence of antipatterns, and (3) what kinds of changes affect classes participating in antipatterns. ewline oindent {\bf Results:} We show that, in almost all releases of the four systems, classes participating in antipatterns are more change- and fault-prone than others. We also show that size alone cannot explain the higher odds of classes with antipatterns to underwent a (fault-fixing) change than other classes. Finally, we show that structural changes affect more classes with antipatterns than others. We provide qualitative explanations of the increase of change- and fault-proneness in classes participating in antipatterns using release notes and bug reports. ewline oindent {\bf Conclusions: } The obtained results justify \emph{a posteriori} previous work on the specification and detection of antipatterns and could help to better focus quality assurance and testing activities.
    [bibtex-key = Khomh11-EMSE-AntiPatternsImpact]

  5. Benoît de Smet, Lorent Lempereur, Zohreh Sharafi, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Naji Habra. Taupe: Visualising and Analysing Eye-tracking Data. Science of Computer Programming (SCP), 79:260--278, February 2012. Note: 2nd special issue on Experimental Software and Toolkits. 20 pages. [Text ] Keyword(s): Understanding program comprehension, SCP.
    Abstract:
    Program comprehension is an essential part of any maintenance activity. It allows developers to build mental models of the program before undertaking any change. It has been studied by the research community for many years to devise models and tools to understand and ease this activity. Recently, researchers introduced the use of eye-tracking devices to gather and analyse data about the developers' cognitive processes during program comprehension. However, eye-tracking devices are not completely reliable and, thus, recorded data sometimes must be processed, filtered, or corrected. Moreover, the analysis software tools packaged with eye-tracking devices are not open-source and do not always provide extension points to seamlessly integrate new sophisticated analyses. Consequently, we develop the aupe{} software system to help researchers visualise, analyse and edit the data recorded by eye-tracking devices. The two main objectives of aupe{} are neutrality and extensibility so that researchers can easily (1) apply the system on any eye-tracking data and (2) extend the system with their own analyses. To meet our objectives, we base the development of the aupe{}: (1) on well-known good practices, such as design patterns and a plug-in architecture using reflection, (2) on a thorough documentation, validation and verification process, and (3) on lessons learned from existing analysis software systems. This paper describes the context of development of the aupe{}, the architectural and design choices made during its development, and its documentation, validation and verification process. It also illustrates the application of aupe{} in three experiments on the use of design patterns by developers during program comprehension.
    [bibtex-key = DeSmet11-SCP-Taupe]

  6. Surafel Lemma Abebe, Paolo Tonella, Venera Arnaoudova, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Can Lexicon Bad Smells Improve Fault Prediction?. In Rocco Oliveto and Denys Poshyvanyk, editors, Proceedings of the 19th Working Conference on Reverse Engineering (WCRE), pages 235--244, October 2012. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, WCRE.
    Abstract:
    In software development, early identification of fault-prone classes can save a considerable amount of resources. In the literature, source code structural metrics have been widely investigated as one of the factors that can be used to identify faulty classes. Structural metrics measure code complexity, one aspect of the source code quality. Complexity might affect program understanding and hence increase the likelihood of inserting errors in a class. Besides the structural metrics, we believe that the quality of the identifiers used in the code may also affect program understanding and thus increase the likelihood of error insertion. In this study, we measure the quality of identifiers using the number of Lexicon Bad Smells (LBS) they contain. We investigate whether using LBS in addition to structural metrics improves fault prediction. To conduct the investigation, we asses s the prediction capability of a model while using i) only structural metrics, and ii) structural metrics and LBS. The results on three open source systems, ArgoUML, Rhino, and Eclipse, indicate that there is an improvement in the majority of the cases.
    [bibtex-key = Abebe12-WCRE-LBS]

  7. Nasir Ali, Aminata Sabané, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Improving Bug Location Using Binary Class Relationships. In Mariano Ceccato and Zheng Li, editors, Proceedings of the 12th International Working Conference on Source Code Analysis and Manipulation (SCAM), pages 174--183, September 2012. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Binary class relations, Features and requirements, SCAM.
    Abstract:
    Bug location assists developers in locating culprit source code that must be modified to fix a bug. Done manually, it requires intensive search activities with unpredictable costs of effort and time. Information retrieval (IR) techniques have been proven useful to speedup bug location in object-oriented programs. IR techniques compute the textual similarities between a bug report and the source code to provide a list of potential culprit classes to developers. They rank the list of classes in descending order of the likelihood of the classes to be related to the bug report. However, due to the low textual similarity between source code and bug reports, IR techniques may put a culprit class at the end of a ranked list, which forces developers to manually verify all non-culprit classes before finding the actual culprit class. Thus, even with IR techniques, developers are not saved from manual effort. In this paper, we conjecture that binary class relationships (BCRs) could improve the rankings by IR techniques of classes and, thus, help reducing developers' manual effort. We present an approach, LIBCROOS, that combines the results of any IR technique with BCRs gathered through source code analyses. We perform an empirical study on four systems---Jabref, Lucene, muCommander, and Rhino---to compare the accuracy, in terms of rankings, of LIBCROOS with two IR techniques: latent semantic indexing (LSI) and vector space model (VSM). The results of this empirical study show that LIBCROOS improves the rankings of both IR technique statistically when compared to LSI and VSM alone and, thus, may reduce the developers' effort.
    [bibtex-key = Ali12-SCAM-ImprovingBugLocationBCR]

  8. Nasir Ali, Zohreh Sharafi, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Empirical Study on Requirements Traceability Using Eye-Tracking. In Massimiliano Di Penta and Jonathan I. Maletic, editors, Proceedings of the 28th International Conference on Source Maintenance (ICSM), pages 191--200, September 2012. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Requirement traceability, Understanding program comprehension, ICSM.
    Abstract:
    Requirements traceability (RT) links help developers understand programs and ensure that their source code is consistent with its documentation. Creating RT links is a laborious and resource-consuming task. Information Retrieval (IR) techniques are useful to recover automatically traceability links but IR-based approaches typically have low accuracy (precision and recall) and, thus, creating RT links remains a human intensive process. We conjecture that understanding how developers create RT links could help improving the accuracy of IR-based approaches to recover RT links. Consequently, we perform an empirical study consisting of two controlled experiments. First, we use an eye-tracking system to capture developers' eye movements while they verify RT links. We analyse the obtained data to identify and rank developers' preferred source code entities (SCEs), \eg{} class names, method names, used by these developers. Second, we use the ranked SCEs to propose two new weighting schemes called $SCE/IDF$ and $DOI/IDF$ to recover RT links combined with an IR technique. $SEC/IDF$ is based on the developers preferred SCEs to create RT links. $DOI/IDF$ is an extension of $SEC/IDF$ distinguishing domain and implementation concepts. We use LSI combined with $SEC/IDF$, $DOI/IDF$, and $TF/IDF$ to show, using two systems, iTrust and Pooka, that $LSI_{DOI/IDF}$ statistically improves the accuracy of the recovered RT links over $LSI_{TF/IDF}$.
    [bibtex-key = Ali12-ICSM-RequirementsEyetracking]

  9. Neelesh Bhattacharya, Olfat El-Mahi, Etienne Duclos, Giovanni Beltrame, Giuliano Antoniol, Sébastien Le Digabel, and Yann-Gaël Guéhéneuc. Optimizing Threads Schedule Alignments to Expose the Interference Bug Pattern. In Gordon Fraser and Jerffeson Teixeira de Souza, editors, Proceedings of the 4th Symposium on Search Based Software Engineering (SSBSE), pages 90--104, September 2012. IEEE CS Press. Note: 15 pages. [Text ] [Slides ] Keyword(s): Test case generation, SSBSE.
    Abstract:
    Managing and controlling interference conditions in multi-threaded programs has been an issue of worry for application developers for a long time. Typically, when write events from two concurrent threads to the same shared variable are not properly protected, an occurrence of the interference bug pattern could be exposed. We propose a mathematical formulation and its resolution to maximize the possibility of exposing occurrences of the interference bug pattern. We formulate and solve the issue as an optimization problem that gives us (1) the optimal position to inject a delay in the execution flow of a thread and (2) the optimal duration for this delay to align at least two different write events in a multi-threaded program. To run the injected threads and calculate the thread execution times for validating the results, we use a virtual platform modelling a perfectly parallel system. All the effects due to the operating system's scheduler or the latencies of hardware components are reduced to zero, exposing only the interactions between threads. To the best of our knowledge, no previous work has formalized the alignment of memory access events to expose occurrences of the interference bug pattern. We use three different algorithms (random, stochastic hill climbing, and simulated annealing) to solve the optimization problem and compare their performance. We carry out experiments on four small synthetic programs and three real-world applications with varying numbers of threads and read/write executions. Our results show that the possibility of exposing interference bug pattern can be significantly enhanced, and that metaheuristics (hill climbing and simulated annealing) provide much better results than a random algorithm.
    [bibtex-key = Bhattacharya12-SSBSE-ThreadAlignment]

  10. José Côté, Geneviève Rouleau, Yann-Gaël Guéhéneuc, Gaston Godin, Pilar Ramirez-garcia, Annick Hernandez, Géraldine Martorella, and Sylvie Cossette. Virtual Nursing Interventions: Tailored Real-Time Support for People Living with a Chronic Health Problem. In Proceedings of the 5th World Congress on Social Media, Mobile Apps, and Internet/Web 2.0 in Health, Medicine and Biomedical Research (Medicine 2.0), September 2012. Medicine 2.0. [Text ] Keyword(s): VIHTAVIE, Medicine 2.0.
    Abstract:
    Introduction: Health professionals are called upon to contribute to finding novel and practical solutions for meeting the challenges of health services and care. The increase in chronic health problems and the emergence of new needs in the population pose significant challenges for research. New avenues for solutions must be considered and the development and evaluation of innovative interventions paves the way for changes in the traditional modes of care delivery. Objectives: A virtual nursing intervention concept called TAVIE (French acronym for Traitement Assistance Virtuelle Infirmi{\`e}re et Enseignement or Treatment Virtual Nurse Assistance and Teaching) has been developed to provide tailored, real-time support to people living with a chronic health problem who must manage the challenges inherent to their health condition. Method: The web-based interventions developed to date on this basis are the fruit of the integration of clinical, empirical and theoretical knowledge and collaboration with experts in media arts and computer sciences. Results: Based on a philosophy of empowerment, these tailored virtual interventions are intended to boost people's ability to take charge of their health conditions. Specifically, the web applications involve a virtual nurse who guides the user through the process of learning the requisite skills to self-manage his or her health condition. The user plays an active role in the matter: he or she is seen as someone who has strengths and the potential to change and who is expected to put the recommended strategies and skills into practice. In addition to delivering teaching that is tailored or adapted to the needs of the user, the virtual nurse provides feedback and positive reinforcement on progress made and skills acquired. Thus, the virtual nurse becomes a guide, a care partner and a mentor who empowers the user to take charge of his or her situation. A computer platform endowed with a content management system and a database, among other things, was created to act as an umbrella support for different applications (VIH-TAVIE, SOULAGE-TAVIE, TRANSPLANT-TAVIE, CARDIO-TAVIE) enabling a variety of clients to cope with or meet their health challenges. VIH-TAVIE is intended to support people living with HIV in adhering to their antiretroviral therapy. SOULAGE-TAVIE offers support for managing postoperative pain. TRANSPLANT-TAVIE is meant to help transplant recipients manage their immunosuppressive drug intake. CARDIO-TAVIE provides support for managing heart medication intake. Conclusion: Still at an experimental stage, this virtual intervention approach is being developed at a time of service reorganization and resource shortages. This web-based support cannot substitute for the quality and intensity of the relationship between health professional and patient; it is meant to be complementary to conventional follow-up. Indeed, it fits into the continuum or trajectory of care and services intended to ensure quality follow-up.
    [bibtex-key = Cote12-Medicine20-VIHTAVIEVirtualNursing]

  11. José Côté, Geneviève Rouleau, Yann-Gaël Guéhéneuc, Pilar Ramirez-Garcia, Gaston Godin, Joanne Otis, Riyas Fadel, and Cécile Tremblay. HIV-MEDIC Online: Evaluation of a Web-based Intervention to Better Support People Living with HIV (PLHIV) for Taking Their Antiretroviral Therapy. In Pierre Côté and Jean-Pierre Routy, editors, Proceedings of the 21th Canadian Conference on HIV/Aids Research (CAHR), April 2012. Pulsus Group. [Text ] Keyword(s): VIHTAVIE, CAHR.
    Abstract:
    Introduction. HIV-MEDIC online is a randomized controlled trial available in French and English on a secure Web site, which aims to assess the efficacy of virtual support interventions in the management of antiretroviral therapy to PLHIV. Objective. The objectives of this communication are: 1) to present HIV-MEDIC online, 2) to show the experience of the site's first users, and 3) to reveal the challenges encountered in a study done entirely through the Web. Method. Usability tests to potential users, i.e., to PLHIV on antiretroviral therapy, were a prerequisite to launching the study online. Observation and structured interviews were undertaken to determine the usability (ease of use, efficiency, errors, and user satisfaction) of the user interface and the content of the entire process of the randomized controlled trial online. Results. Usability tests among the users allowed the improvement of the virtual research process. HIV-MEDIC online was developed thanks to the pooling of diversified expertise: a clinical team, community workers, researchers, web design, multimedia team, and computer programmers. Evaluation of an intervention through a randomized controlled trial online presents particular challenges especially in terms of recruitment, ethics, data collection, long-term follow-up, and data security. Conclusion. Accessibility to Web-based interventions provides the possibility for capability and empowerment. From their home or any other place chosen by the individuals accessing the Internet, PLHIV can benefit from this new intervention modality and from the results of this research.
    [bibtex-key = Cote12-WebSupportVIH]

  12. José Côté, Geneviève Rouleau, Pilar Ramirez-garcia, Yann-Gaël Guéhéneuc, Gaston Godin, and Annick Hernandez. VIH-TAVIE: Tailored Virtual Support for Better Self-Management of Antiretroviral Therapy. In Proceedings of the 5th World Congress on Social Media, Mobile Apps, and Internet/Web 2.0 in Health, Medicine and Biomedical Research (Medicine 2.0), September 2012. Medicine 2.0. [Text ] Keyword(s): VIHTAVIE, Medicine 2.0.
    Abstract:
    Background: The VIH-TAVIE (VIH – Traitement Assistance Virtuelle Infirmi{\`e}re et Enseignement or HIV – Treatment Virtual Nurse Assistance and Teaching) intervention is an innovative healthcare application that employs information technology as a means of access and learning to help people living with HIV (PLHIV) adhere more effectively to their daily antiretroviral treatment. Objective: The presentation will serve to describe the VIH-TAVIE application and demonstrate how it works. Method: With the help of experts in the fields of media arts (e.g., media consultant, graphic designer) and computer sciences, a group of health professionals (nurses, pharmacists, nutritionists, doctors) created the TAVIE computing platform, which supports the VIH-TAVIE application and allows developing other tailored virtual interventions quickly and efficiently. Results: The VIH-TAVIE application is composed of four computer sessions each 20-30 minutes long, in which the user interacts with an animated ``virtual'' nurse. The nurse guides the individual through a process of learning about the aptitudes required to optimize treatment adherence. The aim of VIH-TAVIE is to allow PLHIV to consolidate their self-motivation, self-observation, problem-solving, emotional-control and social-interaction capacities. Together, these enable PLHIV to incorporate the therapeutic regimen into their daily routine, to cope with side-effects from the medication, to handle situations or circumstances that could interfere with medication intake, to interact with health professionals, and to mobilize social support. The virtual nurse also provides personalized teaching, such as by giving examples of other PLHIV who managed to handle situations similar to those faced by the user, as well as feedback and positive reinforcement on progress made and skills acquired. Overall, VIH-TAVIE comprises about 130 pages, 140 short video clips, 40 animated features and 55 PDF files (e.g., summaries of different skills, answers to frequently asked questions, advice on coping with side-effects). It also provides the user with consolidation tools (e.g., a logbook for recording adverse side-effects). The TAVIE platform is endowed with a Content Management System with some 20 algorithms set up to ``tailor'' responses according to user profile and information submitted by the user at each session. The relation and interaction between user and virtual nurse makes for a more dynamic experience than is the case with ordinary general information websites insensitive to user profile. The database included in the platform allows keeping track of how resources are used (e.g., PDF files downloaded, video clips and web pages viewed, time spent on each page), which facilitates evaluating the intervention's effectiveness with respect to the target group and makes it easier to adjust and update content accordingly. Conclusion: The ultimate aim of the VIH-TAVIE project is to make support available to PLHIV at all times and at their convenience so that they may develop the skills needed to meet the challenges inherent to their health condition.
    [bibtex-key = Cote12-Medicine20-VIHTAVIESelfManagement]

  13. Massimiliano Di Penta, Giuliano Antoniol, Daniel M. German, Yann-Gaël Guéhéneuc, and Bram Adams. Five Days of Empirical Software Engineering: the PASED Experience. In Jochen Ludewig and Hausi A. Müller, editors, Proceedings of the 34th International Conference on Software Engineering (ICSE), pages 1255--1258, June 2012. ACM Press. Note: Software Engineering Education Track. 4 pages. [Text ] [Slides ] Keyword(s): ICSE.
    Abstract:
    Acquiring the skills to plan and conduct different kinds of empirical studies is a mandatory requirement for graduate students working in the field of software engineering. These skills typically can only be developed based on the teaching and experience of the students' supervisor, because of the lack of specific, practical courses providing these skills. To fill this gap, we organized the first Canadian Summer School on Practical Analyses of Software Engineering Data (PASED). The aim of PASED is to provide---using a ``learning by doing'' model of teaching---a solid foundation to software engineering graduate students on conducting empirical studies. This paper describes our experience in organizing the PASED school, i.e., what challenges we encountered, how we designed the lectures and laboratories, and what could be improved in the future based on the participants' feedback.
    [bibtex-key = DiPenta12-SEE-PASED]

  14. Latifa Guerrouj, Philippe Galinier, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Massimiliano Di Penta. TRIS: a Fast and Accurate Identifiers Splitting and Expansion Algorithm. In Rocco Oliveto and Denys Poshyvanyk, editors, Proceedings of the 19th Working Conference on Reverse Engineering (WCRE), pages 103--112, October 2012. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Identifier analysis, WCRE.
    Abstract:
    In the quest of supporting various software engineering tasks such as program comprehension, reverse engineering, or program redocumentation researchers have proposed several identifier splitting and expansion approaches such as Samurai, TIDIER and more recently GenTest. The ultimate goal of such approaches is to help disambiguating conceptual information encoded in compound (or abbreviated) identifiers. This paper presents TRIS, TRee-based Identifier Splitter, a two-phases approach to split and expand program identifiers. TRIS takes as input a dictionary of words, the identifiers to split and the identifiers source code application. First, TRIS pre-compiles transformed dictionary words into a tree representation, associating a cost to each transformation. In a second phase, it maps the identifier splitting problem into a minimization problem, \ie{} the search of the shortest path (optimal split/expansion) in a weighted graph. We apply TRIS on a sample of 974 identifiers extracted from JHotDraw (Java), 3,085 Lynx identifiers (C), and on a sample of 489 C identifiers extracted from 340 C programs. Finally, we compared TRIS with GenTest on a set of 2,663 mixed Java, C and C++ identifiers. We report evidence that TRIS split (and expansion) is more accurate than state of the art approaches and that it is also efficient in terms of computation time.
    [bibtex-key = Guerrouj12-WCRE-TRIS]

  15. Salima Hassaine, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Giuliano Antoniol. ADvISE: Architectural Decay In Software Evolution. In Rudolf Ferenc Tom Mens, Anthony Cleve, editor, Proceedings of the 16th European Conference on Software Maintenance and Reengineering (CSMR), pages 267--276, March 2012. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, CSMR.
    Abstract:
    Software systems evolve continuously, requiring continuous maintenance and development. Consequently, their architecture tends to degrade with time as it becomes less relevant to new, emerging requirements. Therefore, stability or resilience is a primary criterion for evaluating an architecture. In this paper, we propose a quantitative approach to study the evolution of the architecture of object oriented systems over time. In particular, we represent an architecture as a set of triplets $(S,R,T)$, where $S$ and $T$ represent two classes and $R$ is a relationship linking them. We use these triplets as basic unit to measure the stability of an architecture. We show the applicability and usefulness of our approach by studying the evolution of three open source systems: JFreeChart and Xerces-J and Rhino.
    [bibtex-key = Hassaine12-CSMR-ADvISE]

  16. Abdou Maiga, Nasir Ali, Neelesh Bhattacharya, Aminata Sabané, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Esma Aimeur. SMURF: A SVM-based Incremental Anti-pattern Detection Approach. In Rocco Oliveto and Denys Poshyvanyk, editors, Proceedings of the 19th Working Conference on Reverse Engineering (WCRE), pages 466--475, October 2012. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, WCRE.
    Abstract:
    In current, typical software development projects, hundreds of developers work asynchronously in space and time and may introduce anti-patterns in their software systems because of time pressure, lack of understanding, communication, and--or skills. Anti-patterns impede development and maintenance activities by making the source code more difficult to understand. Detecting anti-patterns incrementally and on subsets of a system could reduce costs, effort, and resources by allowing practitioners to identify and take into account occurrences of anti-patterns as they find them during their development and maintenance activities. Researchers have proposed approaches to detect occurrences of anti-patterns but these approaches have currently four limitations: (1) they require extensive knowledge of anti-patterns, (2) they have limited precision and recall, (3) they are not incremental, and (4) they cannot be applied on subsets of systems. To overcome these limitations, we introduce SMURF, a novel approach to detect anti-patterns, based on a machine learning technique---support vector machines---and taking into account practitioners' feedback. Indeed, through an empirical study involving three systems and four anti-patterns, we showed that the accuracy of SMURF is greater than that of DETEX and BDTEX when detecting anti-patterns occurrences. We also showed that SMURF can be applied in both intra-system and inter-system configurations. Finally, we reported that SMURF accuracy improves when using practitioners' feedback.
    [bibtex-key = Maiga12-WCRE-SMURF]

  17. Abddou Maiga, Nasir Ali, Neelesh Bhattacharya, Aminata Sabané, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Esma Aimeur. Support Vector Machines for Anti-pattern Detection. In Tim Menzies and Motoshi Saeki, editors, Proceedings of the 27th Conference on Automated Software Engineering (ASE), pages 278--281, September 2012. ACM Press. Note: Short paper. 4 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ASE.
    Abstract:
    Developers may introduce anti-patterns in their software systems because of time pressure, lack of understanding, communication, and--or skills. Anti-patterns impede development and maintenance activities by making the source code more difficult to understand. Detecting anti-patterns in a whole software system may be infeasible because of the required parsing time and of the subsequent needed manual validation. Detecting anti-patterns on subsets of a system could reduce costs, effort, and resources. Researchers have proposed approaches to detect occurrences of anti-patterns but these approaches have currently some limitations: they require extensive knowledge of anti-patterns, they have limited precision and recall, and they cannot be applied on subsets of systems. To overcome these limitations, we introduce SVMDetect, a novel approach to detect anti-patterns, based on a machine learning technique---support vector machines. Indeed, through an empirical study involving three subject systems and four anti-patterns, we showed that the accuracy of SVMDetect is greater than of DETEX when detecting anti-patterns occurrences on a set of classes. Concerning, the whole system, SVMDetect is able to find more anti-patterns occurrences than DETEX.
    [bibtex-key = Maiga12-ASE-FeedbackAntipatterns]

  18. Soumaya Medini, Giuliano Antoniol, Yann-Gaël Guéhéneuc, Massimiliano Di Penta, and Paolo Tonella. SCAN: an Approach to Label and Relate Execution Trace Segments. In Rocco Oliveto and Denys Poshyvanyk, editors, Proceedings of the 19th Working Conference on Reverse Engineering (WCRE), pages 135--144, October 2012. IEEE CS Press. Note: Best paper. 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, WCRE.
    Abstract:
    Identifying concepts in execution traces is a task often necessary to support program comprehension or maintenance activities. Several approaches---static, dynamic or hybrid---have been proposed to identify cohesive, meaningful sequence of methods in execution traces. However, none of the proposed approaches is able to label such segments and to identify relations identified in other segments of the same trace This paper present SCAN (Segment Concept AssigNer) an approach to assign labels to sequences of methods in execution traces, and to identify relations between such segments. SCAN uses information retrieval methods and formal concept analysis to produce sets of words helping the developer to understand the concept implemented by a segment. Specifically, formal concept analysis allows SCAN to discover commonalities between segments in different trace areas, as well as terms more specific to a given segment and higher level relation between segments. The paper describes SCAN along with a preliminary manual validation---upon execution traces collected from usage scenarios of JHotDraw and ArgoUML---of SCAN accuracy in assigning labels representative of concepts implemented by trace segments.
    [bibtex-key = Medini12-WCRE-SCAN]

  19. Naouel Moha, Francis Palma, Mathieu Nayrolles, Benjamin Joyen Conseil, Yann-Gaël Guéhéneuc, Benoit Baudry, and Jean-Marc Jézéquel. Specification and Detection of SOA Antipatterns. In Chengfei Liu, Heiko Ludwig, and Farouk Toumani, editors, Proceedings of the 10th International Conference on Service Oriented Computing (ICSOC), pages 1--16, November 2012. Springer. Note: Runner-up best paper. 15 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ICSOC.
    Abstract:
    Like any other complex software system, Service Based Sys-tems (SBSs) must evolve to fit new user requirements and execution contexts. The changes resulted from the evolution of SBSs degrade their design and quality of service (QoS) and often cause the appearance of common bad practice solutions, called antipatterns. Antipatterns result-ing from these changes also hinder the maintenance and evolution of SBSs. The automatic detection of antipatterns is thus important to as-sess the design and QoS of SBSs and ease the maintenance and evolution. However, methods and techniques for the detection of antipatterns in SBSs are still in their infancy despite their importance. In this paper, we introduce a novel and innovative approach supported by a framework for specifying and detecting antipatterns in SBSs. Using our approach, we specify 10 well-known and common antipatterns, including Multi Service and Tiny Service, and we automatically generate their detection algo-rithms. We apply and validate the detection algorithms in terms of pre-cision and recall on Home-Automation, an SBS developed independently. This validation demonstrates that our approach enables the specification and the detection of SOA antipatterns with high precision and recall.
    [bibtex-key = Moha12-ICSOC-DetectionSOAAntipatterns]

  20. Francis Palma, Hadi Farzin, Yann-Gaël Guéhéneuc, and Naouel Moha. Recommendation System for Design Patterns in Software Development: A DPR Overview. In Walid Maalej, Martin Robillard, Robert J. Walker, and Thomas Zimmermann, editors, Proceedings of the 3rd International Workshop on Recommendation Systems for Software (RSSE), pages N/A, June 2012. ACM Press. Note: 5 pages. [Text ] [Slides ] Keyword(s): Design patterns, RSSE.
    Abstract:
    Software maintenance can become monotonous and expensive due to ignorance and misapplication of appropriate design patterns during the early phases of design and development. To have a good and reusable system, designers and developers must be aware of large information set and many quality concerns, e.g., design patterns. Systems with correct design pattern may ensure easy maintenance and evolution. However, without assistance, designing and development of software systems following certain design patterns is difficult for engineers. Recommendation systems for software engineering can assist designers and developers with a wide range of activities including suggesting design patterns. With the help of pattern recommenders, designers can come up with a reusable design. We provide a extit{Design Pattern Recommender} (DPR) process overview for software design to suggest design patterns, based on a simple Goal-Question-Metric (GQM) approach. Our prototype provides two-fold solution. In the primary-level, DPR only proposes one or more design patterns for a problem context, and in the secondary level, for a initial set of design, DPR refactors models and suggests design patterns. Our preliminary evaluation shows that DPR has a good trade-off between accuracy and procedural complexity, comparing to other state-of-the-art approaches.
    [bibtex-key = Palma12-RSSE-DPR]

  21. Abdelilah Sakti, Yann-Gaël Guéhéneuc, and Gilles Pesant. Boosting Search-Based Testing by using Constraint-based Testing. In Gordon Fraser and Jerffeson Teixeira de Souza, editors, Proceedings of the 4th Symposium on Search Based Software Engineering (SSBSE), pages 213--227, September 2012. IEEE CS Press. Note: 15 pages. [Text ] [Slides ] Keyword(s): Test case generation, SSBSE.
    Abstract:
    Search-based testing (SBT) uses an evolutionary algorithm in order to generate test cases. In general for search-based testing the initial population is generated using a random selection. Such an initial population is likely to achieve low coverage. A guided selection procedure to generate a diversified initial population may substantially increase the chance of reaching adequate coverage with less effort, therefore saving in resource expenditure. In this paper we propose an approach that models a relaxed version of the unit under test as a constraint satisfaction problem. Based on this model and the test target we generate an initial population. An evolutionary algorithm uses this population to generate test input leading to cover the test target. The approach combines constraint-based and search-based techniques and has two key advantages: It does not require any change in the underlying testing techniques and it avoids traditional problems associated either with constraint-based or search-based testing. Using eToc, an open source SBT tool, a prototype of this approach has been implemented. Empirical results on both known benchmarks and two open source programs are presented.
    [bibtex-key = Sakti12-SSBSE-BoostingSBTwithCBT]

  22. Zohreh Sharafi, Zéphyrin Soh, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Women & Men -- Different but Equal: On the Impact of Identifier Style on Source Code Reading. In Arie van Deursen and Michael W. Godfrey, editors, Proceedings of the 20th International Conference on Program Comprehension (ICPC), pages 27--36, June 2012. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, ICPC.
    Abstract:
    Program comprehension is preliminary to any program evolution task. Researchers agree that identifiers play an important role in code reading and program understanding activities. Yet, to the best of our knowledge, only one work investigated the impact of gender on the memorability of identifiers and thus, ultimately, on program comprehension. This paper reports the results of an experiment involving 15 male subjects and nine female subjects to study the impact of gender on the subjects' visual effort, required time, as well as accuracy to recall Camel Case versus Underscore identifiers in source code reading. We observe no statistically-significant difference in term of accuracy, required time, and effort. However, our data supports the conjecture that male and female subjects follow different comprehension strategies: female subjects seem to carefully weight all options and spend more time to rule out wrong answers while male subjects seem to quickly set their minds on some answers, possibly the wrong ones. Indeed, we found that the effort spent on wrong answers is significantly higher for female subjects and that there is an interaction between the effort that female subjects invested on wrong answers and their higher percentages of correct answers when compared to male subjects.
    [bibtex-key = Sharafi12-ICPC-MenWomen]

  23. Zéphyrin Soh, Zohreh Sharafi, Bertrand van den Plas, Gerardo Cepeda Porras, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Professional Status and Expertise for UML Class Diagram Comprehension: An Empirical Study. In Arie van Deursen and Michael W. Godfrey, editors, Proceedings of the 20th International Conference on Program Comprehension (ICPC), pages 163--172, June 2012. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, ICPC.
    Abstract:
    Professional experience is one of the most important criteria for almost any job offer in software engineering. Professional experience refers both to professional status (practitioner vs. student) and expertise (expert vs. novice). We perform an experiment with 21 subjects including both practitioners and students, and experts and novices. We seek to understand the relation between the speed and accuracy of the subjects and their status and expertise in performing maintenance tasks on UML class diagrams. We also study the impact of the formulation of the maintenance task. We use an eye-tracking system to gather the fixations of the subjects when performing the task. We measure the subjects' comprehension using their accuracy, the time spent, the search effort, the overall effort, and the question comprehension effort. We found that (1) practitioners are more accurate than students while students spend around 35 percent less time than practitioners, (2) experts are more accurate than novices while novices spending around 33 percent less time than experts, (3) expertise is the most important factor for accuracy and speed, (4) experienced students are more accurate and spend around 37 percent less time than experienced practitioners, and (5) when the description of the task is precise, the novice students can be accurate. We conclude that it is an illusion for project managers to focus on status only when recruiting a software engineer. Our result is the starting point to consider the differences between status and expertise when studying software engineers' productivity. Thus, it can help project managers to recruit productive engineers and motivated students to acquire the experience and ability in the projects.
    [bibtex-key = Soh12-ICPC-StatusExpertise]

  24. Etienne Duclos, Yann-Gaël Guéhéneuc, and Sébastien Le Digabel. ACRE: An Automated Aspect Creator for Testing C++ Applications. Technical report G-2012-19, Les cahiers du GERAD, June 2012. Note: 17 pages. [Text ] Keyword(s): Test-case generation, CSMR.
    Abstract:
    We present ACRE, an Automatic aspeCt cREator, to use aspect-oriented programming to test multiplatform software programs written in C++. ACRE allows developers without knowledge of aspect programming to use aspects for testing purposes and to test their programs without modifying their source code. ACRE uses a nonintrusive domain-specific language (DSL) which statements testers insert into the source code to describe the aspect to be used. The presence of DSL statements in the code does not modify the program's compilation and behavior. ACRE parses the DSL and automatically generates appropriate aspects that are then woven into the source code to identify bugs such as memory leaks or incorrect implementation. Testers can also add or remove tests easily. Using an aspect generated by ACRE, we find a memory leak in a complex multi-platform C++ software program, NOMAD, used in both industry and research.
    [bibtex-key = Duclos12-TR-ACRE]

  25. Yann-Gaël Guéhéneuc. Compiler/porter THTTPd sur AmigaOS 3.x, juillet 2012. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Voici les {\'e}tapes pour recompiler/porter THTTPd v2.21b + PHP v4.2.3 sur AmigaOS 3.x. Ces {\'e}tapes ont {\'e}t{\'e} toutes valid{\'e}es : le r{\'e}sultat que vous obtiendrez {\`a} la fin est visible sur ces pages, qui sont g{\'e}r{\'e}es avec THTTPd et PHP sur Amiga. Ces {\'e}tapes font l'hypoth{\`e}se que vous avez install{\'e} GCC v3.4.0 pour faire de la compilation crois{\'e}e sur votre Windows/Cygwin et les Geek Gadgets sur votre Amiga, pour tester PHP.
    [bibtex-key = Gueheneuc12-WebZine-CompilePortTHTTPDAmiga]

  26. Yann-Gaël Guéhéneuc. Test de Tower Of Babel, décembre 2012. Note: Obligement, un magazine en ligne (webzine) dédié au monde de l'Amiga. [Text ] Keyword(s): Amiga, Obligement.
    Abstract:
    Tower Of Babel est un jeu informatique pour l'Amiga, l'Atari ST et l'Archimedes d'Acorn cr{\'e}{\'e} par Pete Cooke, d{\'e}velopp{\'e} par Rainbird Software et distribu{\'e} par MicroProse Software en 1990. C'est un jeu r{\'e}flexion (puzzle) tridimensionel qui se d{\'e}roule dans des tours en graphique vectoriel avec polygones pleins. Tower Of Babel est un jeu de r{\'e}flexion tr{\`e}s int{\'e}ressant et parfois tr{\`e}s difficile {\`a} r{\'e}soudre...
    [bibtex-key = Gueheneuc12-WebZine-TestTowerOfBabel]

  27. Mathieu Nayrolles, Francis Palma, Naouel Moha, and Yann-Gaël Guéhéneuc. Soda: A Tool Support for the Detection of SOA Antipatterns, November 2012. Note: Tool demo at the 11th International Conference on Service Oriented Computing. 4 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ICSOC.
    Abstract:
    During their evolution, Service Based Systems (SBSs) need to fit new user requirements and execution contexts. The resulting changes from the evolution of SBSs may degrade their design and Quality of Service (QoS), and thus may cause the appearance of common poor solutions, called Antipatterns. Like other complex systems, antipatterns in SBSs may hinder the future maintenance and evolution. Therefore, the automatic detection of such antipatterns is an important task for assessing the design and QoS of SBSs, to facilitate their maintenance and evolution. However, despite of their importance, no tool support exists for the detection of antipatterns in SBSs. In this paper, we introduce a prototype tool, called Soda, for detecting SOA (Service Oriented Architecture) antipatterns in SBSs. Soda also supports specification of SOA antipatterns.
    [bibtex-key = Nayrolles12-Demo-ICSOC]


2011
  1. Latifa Guerrouj, Massimiliano Di Penta, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. TIDIER: An Identifier Splitting Approach using Speech Recognition Techniques. Journal of Software Maintenance and Evolution: Research and Practice (JSME), 25(6):575-599, June 2011. Note: 24 pages. [Text ] Keyword(s): Identifier analysis, JSME-JSEP.
    Abstract:
    The software engineering literature reports empirical evidence on the relation between various characteristics of a software system and software quality. Among many factors, recent studies have shown that a proper choice of identifiers influences software understandability and maintainability. Indeed, identifiers are developers' main source of information and guide their cognitive processes during program understanding when high-level documentation is scarce or outdated and when source code is not sufficiently commented. This paper proposes a novel approach to recognize words composing source code identifiers. The approach is based on an adaptation of Dynamic Time Warping used to recognize words in continuous speech. The approach overcomes the limitations of existing identifier splitting approaches when naming conventions (\eg{} Camel Case) are not used or when identifiers contain abbreviations. The proposed approach has been applied on a sample of more than 1,000 identifiers extracted from 340 C programs and compared with a simple Camel Case splitter and with an implementation of an alternative identifier splitting approach, Samurai. Results indicate the capability of the novel approach (i) to outperform the alternative ones when a dictionary augmented with domain knowledge or a contextual dictionary are used and (ii) to expand 48\% of a set of selected abbreviations into dictionary words.
    [bibtex-key = Guerrouj11-JSME-TIDIER]

  2. Foutse Khomh, Stéphane Vaucher, Yann-Gaël Guéhéneuc, and Houari Sahraoui. A GQM-based Method and a Bayesian Approach for the Detection of Code and Design Smells. Journal of Software and Systems (JSS), 84(4):559--572, April 2011. Note: 35 pages. [Text ] Keyword(s): Code and design smells, JSS.
    Abstract:
    The presence of code and design smells can have a severe impact on the quality of a program. Consequently, their detection and correction have drawn the attention of both researchers and practitioners who have proposed various approaches to detect code and design smells in programs. However, none of these approaches handle the inherent uncertainty of the detection process. We propose a Bayesian approach to manage this uncertainty. First, we present a systematic process to convert existing state-of-the-art detection rules into a probabilistic model. We illustrate this process by generating a model to detect occurrences of the Blob antipattern. Second, we present results of the validation of the model: we built this model on two open-source programs, \product{GanttProject v1.10.2} and \product{Xerces v2.7.0}, and measured its accuracy. Third, we compare our model with another approach to show that it returns the same candidate classes while ordering them to minimise the quality analysts' effort. Finally, we show that when past detection results are available, our model can be calibrated using machine learning techniques to offer an improved, context-specific detection.
    [bibtex-key = Khomh11-JSS-GQMBayesianDesignSmells]

  3. Ségla Kpodjedo, Filippo Ricca, Philippe Galinier, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Design Evolution Metrics for Defect Prediction in Object Oriented Systems. Empirical Software Engineering (EMSE), 16(1):141--175, February 2011. Note: 34 pages. [Text ] Keyword(s): Evolution patterns, EMSE.
    Abstract:
    Testing is the most widely adopted practice to ensure software quality. However, this activity is often a compromise between the available resources and software quality. In object-oriented development, testing effort should be focused on defective classes. Unfortunately, identifying those classes is a challenging and difficult activity on which many metrics, techniques, and models have been tried. In this paper, we investigate the usefulness of elementary design evolution metrics to identify defective classes. The metrics include the numbers of added, deleted, and modified attributes, methods, and relations. The metrics are used to recommend a ranked list of classes likely to contain defects for a system. They are compared to Chidamber and Kemerer's metrics on several versions of Rhino and of ArgoUML. Further comparison is conducted with the complexity metrics computed by Zimmermann extit{et al.} on several releases of Eclipse. The comparisons are made according to three criteria: presence of defects, number of defects, and defect density in the top-ranked classes. They show that the design evolution metrics, when used in conjunction with known metrics, improve the identification of defective classes. In addition, they show that the design evolution metrics make significantly better predictions of defect density than other metrics and, thus, can help in reducing the testing effort by focusing test activity on a reduced volume of code.
    [bibtex-key = Kpodjedo11-EMSE-DesignEvolutionMetrics]

  4. Marwen Abbes, Foutse Khomh, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Empirical Study of the Impact of Two Antipatterns, Blob and Spaghetti Code, On Program Comprehension. In Yiannis Kanellopoulos and Tom Mens, editors, Proceedings of the 15th European Conference on Software Maintenance and Reengineering (CSMR), pages 181--190, March 2011. IEEE CS Press. Note: Best paper. 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, Understanding program comprehension, CSMR.
    Abstract:
    Antipatterns are ``poor'' solutions to recurring design problems which are conjectured in the literature to make object-oriented systems harder to maintain. However, little quantitative evidence exists to support this conjecture. We performed an empirical study to investigate whether the occurrence of antipatterns does indeed affect the understandability of systems by developers during comprehension and maintenance tasks. We designed and conducted three experiments, with 24 subjects each, to collect data on the performance of developers on basic tasks related to program comprehension and assessed the impact of two antipatterns and of their combinations: Blob and Spaghetti Code. We measured the developers' performance with: (1) the NASA task load index for their effort; (2) the time that they spent performing their tasks; and, (3) their percentages of correct answers. Collected data show that the occurrence of one antipattern does not significantly decrease developers' performance while the combination of two antipatterns impedes significantly developers. We conclude that developers can cope with one antipattern but that combinations of antipatterns should be avoided possibly through detection and refactorings.
    [bibtex-key = Abbes11-CSMR-AntipatternsImpactComprehension]

  5. Nasir Ali, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Requirements Traceability for Object Oriented Systems by Partitioning Source Code. In Martin Pinzger and Denys Poshyvanyk, editors, Proceedings of the 18th Working Conference on Reverse Engineering (WCRE), pages 45--54, October 2011. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Requirement traceability, WCRE.
    Abstract:
    Requirements traceability ensures that source code is consistent with documentation and that all requirements have been implemented. During software evolution, features are added, removed, or modified, the code drifts away from its original requirements. Thus traceability recovery approaches becomes necessary to re-establish the traceability relations between requirements and source code. This paper presents an approach (Coparvo) complementary to existing traceability recovery approaches for object-oriented programs. Coparvo reduces false positive links recovered by traditional traceability recovery processes thus reducing the manual validation effort. Coparvo assumes that information extracted from different entities (e.g., class names, comments, class variables, or methods signatures) are different information sources; they may have different level of reliability in requirements traceability and each information source may act as a different expert recommending traceability links. We applied Coparvo on three data sets, Pooka, SIP Communicator, and iTrust, to filter out false positive links recovered via the information retrieval approach \ie{} vector space model. The results show that Coparvo significantly improves the of the recovered links accuracy and also reduces up to $83\%$ effort required to manually remove false positive links.
    [bibtex-key = Ali11-WCRE-Partitioning]

  6. Nasir Ali, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Trust-Based Requirements Traceability. In Susan E. Sim and Filippo Ricca, editors, Proceedings of the 19th International Conference on Program Comprehension (ICPC), pages 111--120, June 2011. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Requirement traceability, ICPC.
    Abstract:
    Information retrieval (IR) approaches have proven useful in recovering traceability links between free-text documentation and source code. IR-based traceability recovery approaches produce ranked lists of traceability links between pieces of documentation and source code. These traceability links are then pruned using various strategies and, finally, validated by human experts. In this paper we propose two contributions to improve the precision and recall of traceability links and, thus, reduces the required human experts' manual validation effort. First, we propose a novel approach, Trustrace, inspired by Web trust models to improve the precision and recall of traceability links: Trustrace uses any traceability recovery approach to obtain a set of traceability links, which rankings are then re-evaluated using a set of other traceability recovery approaches. Second, we propose a novel traceability recovery approach, Histrace, to identify traceability links between requirements and source code through CVS/SVN change logs using a Vector Space Model (VSM). We combine a traditional recovery traceability approach with Histrace to build Trustrace{ ext{VSM},~ ext{Histrace}} in which we use Histrace as one expert adding knowledge to the traceability links extractted from CVS/SVN change logs. We apply Trustrace{ ext{VSM},~ ext{Histrace}} on two case studies to compare its traceability links with those recovered using only the VSM-based approach, in terms of precision and recall. We show that Trustrace{ ext{VSM},~ ext{Histrace}} improves with statistical significance the precision of the traceability links while also improving recall but without statistical significance.
    [bibtex-key = Ali11-ICPC-TrustTraceability]

  7. Nasir Ali, Wei Wu, Giuliano Antoniol, Massimiliano Di Penta, Yann-Gaël Guéhéneuc, and Jane Huffman Hayes. MoMS: Multi-objective Miniaturization of Software. In James R. Cordy and Paolo Tonella, editors, Proceedings of the 27th International Conference on Software Maintenance (ICSM), pages 153--162, September 2011. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, ICSM.
    Abstract:
    Smart phones, gaming consoles, and wireless routers are ubiquitous; the increasing diffusion of such devices with limited resources, together with society's unsatiated appetite for new applications, pushes companies to miniaturize their programs. Miniaturizing a program for a hand-held device is a time-consuming task often requiring complex decisions. Companies must accommodate conflicting constraints: customers' satisfaction with features may be in conflict with a device's limited storage, memory, or battery life. This paper proposes a process, \OdMoMS{}, for the multi-objective miniaturization of software to help developers miniaturize programs while satisfying multiple conflicting constraints. It can be used to support the reverse engineering, next release problem, and porting of both software and product lines. The process directs the elicitation of customer pre-requirements, their mapping to program features, and the selection of the features to port. We present two case studies based on Pooka, an email client, and SIP Communicator, an instant messenger, to demonstrate that \OdMoMS{} supports optimized miniaturization and helps reduce effort by 77\%, on average, over a manual approach.
    [bibtex-key = Ali11-ICSM-Miniaturisation]

  8. Ahmed Belderrar, Ségla Kpodjedo, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Philippe Galinier. Sub-graph Mining: Identifying Micro-architectures in Evolving Object-oriented Software. In Yiannis Kanellopoulos and Tom Mens, editors, Proceedings of the 15th European Conference on Software Maintenance and Reengineering (CSMR), pages 171--180, March 2011. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, CSMR.
    Abstract:
    Developers introduce novel and undocumented micro-architectures when performing evolution tasks on object-oriented applications. We are interested in understanding whether those organizations of classes and relations can bear, much like cataloged design and anti-patterns, potential harm or benefit to an object-oriented application. We present SGFinder, a sub-graph mining approach and tool based on an efficient enumeration technique to identify recurring micro-architectures in object-oriented class diagrams. Once SGFinder has detected instances of micro-architectures, we exploit these instances to identify their desirable properties, such as stability, or unwanted properties, such as change or fault proneness. We perform a feasibility study of our approach by applying SGFinder on the reverse-engineered class diagrams of several releases of two Java applications: ArgoUML and Rhino. We characterize and highlight some of the most interesting micro-architectures, \eg{} the most change and fault prone, and conclude that SGFinder opens the way to further interesting studies.
    [bibtex-key = Belderrar11-CSMR-SubgraphsEvolution]

  9. Neelesh Bhattacharya, Abdelilah Sakti, Giuliano Antoniol, Yann-Gaël Guéhéneuc, and Gilles Pesant. Divide-by-zero Exceptions Raising via Branch Coverage. In Myra Cohen and Mel Ó Cinnéide, editors, Proceedings of the 3rd International Symposium on Search-based Software Engineering (SSBSE), pages 204--218, September 2011. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Test case generation, SSBSE.
    Abstract:
    In this paper, we discuss how a search-based branch coverage approach can be used to design an effective test data generation approach, specifically targeting divide-by-zero exceptions. We first propose a novel additive fitness function combining \emph{approach level} and \emph{branch distance}. We then use different search strategies, \ie{} hill climbing, simulated annealing, and genetic algorithm, to evaluate the performance of the novel fitness function on a small synthetic example as well as on methods known to throw divide-by-zero exceptions, extracted from real world systems, namely Eclipse and Android. Finally, we also describe how the test data generation for divide-by-zero exceptions can be formulated as a constraint programming problem and compare the resolution of this problem with a genetic algorithm in terms of execution time. We thus report evidence that genetic algorithm using our novel fitness function out-performs hill climbing and simulated annealing and a previous approach (in terms of numbers of fitness evaluation) but is out-performed by constraint programming (in terms of execution time).
    [bibtex-key = Bhattacharya11-SSBSE-DivideByZero]

  10. Neelesh Bhattacharya, Abdelilah Sakti, Giuliano Antoniol, Yann-Gaël Guéhéneuc, and Gilles Pesant. Performance Analysis of Metaheuristic and Constraint Programming Approaches to Generate Structural Test Cases. In Fevzi Belli and Michael Linschulte, editors, Proceedings of the 4th International Conference on Software Testing, Verification, and Validation (ICST), pages N/A, March 2011. IEEE CS Press. Note: Poster. 2 pages. [Text ] [Slides ] Keyword(s): Test case generation, ICST.
    Abstract:
    Structural test case generation has been carried out by various approaches in software testing. Metaheuristics and constraint programming approaches are two of the more important approaches used for generating structural test cases. However, both of these approaches have limitations, which prevent them to be used in various applications, like wireless telecommunication and aeronautical engineering, because the problems in these areas involve variables with large domains and complex constraints.
    [bibtex-key = Bhattacharya11-ICST-P-CSPGAComparisonTestGeneration]

  11. José Côté, Geneviève Rouleau, Yann-Gaël Guéhéneuc, Gaston Godin, Pilar Ramirez-Garcia, Joanne Otis, and Georgette Nahas. Suitability and Feasability Study of a Virtual Nursing Intervention to Help Person Living with HIV Manage their Daily Therapies. In Actes du 1er symposium international sur la recherche en intervention en sciences infirmières : développement, évaluation et partage (ISI), avril 2011. [Text ] Keyword(s): VIHTAVIE, ISI. [bibtex-key = Cote11-ISI-SuitablityFeasabilityVirtualNursing]

  12. Laleh Eshkevari, Venera Arnaoudova, Massimiliano Di Penta, Rocco Oliveto, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Exploratory Study of Identifier Renamings. In Tao Xie and Thomas Zimmermann, editors, Proceedings of the 8th Working Conference on Mining Software Repositories (MSR), pages 33--42, May 2011. ACM Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Quality models, MSR.
    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 projects, Eclipse-JDT and Tomcat. We thus report evidence that not only synonyms are involved in renaming but also (in a small fraction) more unexpected changes occur: surprisingly, we detected hypernym (a more abstract term, \eg{} size vs.\ length) and hyponym (a more concrete term, \eg{} restriction vs.\ rule) renamings, and antonym renamings (a term replaced with one having the opposite meaning, \eg{} closing vs.\ opening). Despite being only a fraction of all renamings, synonym, hyponym, hypernym, and antonym renamings may hint to some program understanding issues and, thus, could be used in a renaming-recommendation system to improve code quality.
    [bibtex-key = Eshkevari11-MSR-IdentifierRenamingTaxonomy]

  13. Salima Hassaine, Ferdaous Boughanmi, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Giuliano Antoniol. A Seismology-inspired Approach for Change Impact Analysis. In James R. Cordy and Paolo Tonella, editors, Proceedings of the 27th International Conference on Software Maintenance (ICSM), pages 53--62, September 2011. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, ICSM.
    Abstract:
    Change impact analysis aims at identifying software artefacts that are being affected by a change. It helps developers to assess their change efforts and perform more adequate changes. Several approaches have been proposed to aid in impact analysis. However, to the best of our knowledge, none of these approaches have been used to study the scope of changes in a program. We present a metaphor inspired by seismology and propose a mapping between the concepts of seismology and change propagation, to study the scope of change propagation. We perform three case studies on Pooka, Rhino, and Xerces-J to observe change propagation. We use ANOVA and Duncan statistical tests to assess the statistically significance of our observations, which show that changes propagate to a limited scope.
    [bibtex-key = Hassaine11-ICSM-ChangeImpactSeismology]

  14. Salima Hassaine, Ferdaous Boughanmi, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Giuliano Antoniol. Change Impact Analysis: An Earthquake Metaphor. In Susan E. Sim and Filippo Ricca, editors, Proceedings of the 19th International Conference on Program Comprehension (ICPC), pages 209--210, June 2011. IEEE CS Press. Note: Poster. 2 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, ICPC.
    Abstract:
    The maintenance of large programs is a costly activity because their evolution often leads to two problems: an increase in their complexity and an erosion of their design. Impact analysis is crucial to make decisions among different alternatives to implement a change and to assess and plan maintenance activities by highlighting artefacts that should change when another artefact changes. Several approaches were proposed to identify software artefacts being affected by a change. However, to the best of our knowledge, none of these approaches have been used to study two pieces of information: (1) the scope of a change in a program and (2) the propagation of the change in time. Yet, these pieces of information are useful for developers to better understand and, thus, plan changes. In this paper, we present a metaphor inspired by seismology and propose a mapping between the concepts of seismology and software evolution. Our metaphor relate the problems of (1) change impact and earthquake's debris and (2) change propagation and damaged site predictions to observe the scopes and the evolution in time of changes. We show the applicability and usefulness of our metaphor using Rhino and Xerces-J.
    [bibtex-key = Hassaine11-ICPC-P-EarthquakeSE]

  15. Fehmi Jaafar, Yann-Gaël Guéhéneuc, Sylvie Hamel, and Giuliano Antoniol. An Exploratory Study of Macro Co-changes. In Martin Pinzger and Denys Poshyvanyk, editors, Proceedings of the 18th Working Conference on Reverse Engineering (WCRE), pages 325--334, October 2011. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, WCRE.
    Abstract:
    The literature describes several approaches to identify the artefacts of programs that change together to reveal the (hidden) dependencies among these artefacts. These approaches analyse historical data, mined from version control systems, and report co-changing artefacts, which hint at the causes, consequences, and actors of the changes. We introduce the novel concepts of \emph{macro co-changes} (MCC), \ie{} of artefacts that co-change within a large time interval, and of \emph{dephase macro co-changes} (DMCC), \ie{} macro co-changes that always happen with the same shifts in time. We describe typical scenarios of MCC and DMCC and we use the Hamming distance to detect approximate occurrences of MCC and DMCC. We present our approach, \DeMaCCC, to identify these concepts in large programs. We apply \DeMaCCC{} and compare it in terms of precision and recall with UMLDiff (file stability) and association rules (co-changing files) on four systems: ArgoUML, FreeBSD, SIP, and XalanC, developed with three different languages (C, C++, and Java) and of sizes ranging from 597 to 3,603 files and from 6,050 to 735,324 changes over periods of eight to 15 years. We also use external information to validate the (approximate) MCC and DMCC found by \DeMaCCC{}. We thus answer two research questions showing the existence and usefulness of theses concepts and explaining scenarios of hidden dependencies among artefacts.
    [bibtex-key = Jaafar11-WCRE-MacroCoChange]

  16. Soumaya Medini, Philippe Galinier, Massimiliano Di Penta, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. A Fast Algorithm to Locate Concepts in Execution Traces. In Myra Cohen and Mel Ó Cinnéide, editors, Proceedings of the 3rd International Symposium on Search-based Software Engineering (SSBSE), pages 252--266, September 2011. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, SSBSE.
    Abstract:
    The identification of cohesive segments in execution traces is a important step in concept location which, in turns, is of paramount importance for many program-comprehension activities. In this paper, we reformulate the trace segmentation problem as a dynamic programming problem. Differently to approaches based on genetic algorithms, dynamic programming can compute an exact solution with better performance than previous approaches, even on long traces. We describe the new problem formulation and the algorithmic details of our approach. We then compare the performances of dynamic programming with those of a genetic algorithm, showing that dynamic programming reduces dramatically the time required to segment traces, without sacrificing precision and recall; even slightly improving them.
    [bibtex-key = Medini11-SSBSE-FastConceptSplitting]

  17. Abdelilah Sakti, Yann-Gaël Guéhéneuc, and Gilles Pesant. CP-SST : approche bassée sur la programmation par contraintes pour le test structurel du logiciel. In Arnaud Lallouet, editor, Actes des 7e Journées Francophones de Programmation par Contraintes (JFPC), pages 289--298, juin 2011. LIRIS. Note: 10 pages. [Text ] [Slides ] Keyword(s): Test case generation, JFPC.
    Abstract:
    Le co{\^u}t du test peut facilement d{\'e}passer 50\% du co{\^u}t total d'un logiciel critique. Le test structurel est la strat{\'e}gie de choix pour tester un syst{\`e}me critique. En fonction de la criticit{\'e} du syst{\`e}me, diff{\'e}rentes applications de test structurel sont exig{\'e}es (analyse de couverture structurelle, g{\'e}n{\'e}ration des donn{\'e}es de test, preuve de la post condition). Cet article s'int{\'e}resse au probl{\`e}me de combinaison des applications de test structurel, peu touch{\'e} jusqu'{\`a} maintenant, qui peut faciliter l'automatisation du processus de test structurel et r{\'e}duire de mani{\`e}re significative le nombre de donn{\'e}es de test g{\'e}n{\'e}r{\'e}es. Pour int{\'e}grer plusieurs applications de test structurel en une seule approche, nous mod{\'e}lisons le programme sous test et son graphe de flot et de contr{\^o}le (GFC) par un probl{\`e}me de satisfaction de contraintes (PSC). Nous utilisons une nouvelle classification des sommets du GFC, la d{\'e}pendance de contr{\^o}le, les techniques statiques d'assignation unique (SSA) et l'inf{\'e}rence de la programmation par contraintes. Le mod{\`e}le PSC que nous proposons conserve toute la s{\'e}mantique structurelle du programme, cette caract{\'e}ristique le rendant utilisable pour diff{\'e}rentes applications de test structurel : analyser une couverture structurelle, g{\'e}n{\'e}rer des donn{\'e}es de test ou prouver la post condition. Nos exp{\'e}rimentations sur des benchmarks traditionnels montrent un gain de temps par rapport aux approches existantes de test structurel.
    [bibtex-key = Sakti11-JFPC-CPTestGeneration]


2010
  1. Yann-Gaël Guéhéneuc. Un cadre pour la traçabilité des motifs de conception. Éditions universitaires européennes, June 2010. Note: 360 pages. [Text ]
    Abstract:
    Les patrons de conception sont importants en g\'enie logiciel \`a objets car ils contribuent \`a la qualit\'e des programmes. Ils proposent des solutions \'el\'egantes \`a des probl\`emes r\'ecurrents de conception, des motifs utilis\'es pendant l'implantation. \`A~l'usage, ces motifs de conception sont diss\'emin\'es dans le code source et ne sont plus explicites lors de la maintenance~; pourtant, ils aideraient \`a comprendre l'implantation et la conception des programmes, assurant leur qualit\'e. Ce m\'emoire propose des mod\`eles et des algorithmes pour garantir la tra\c cabilit\'e des motifs de conception entre les phases d'implantation et de r\'etroconception des programmes par l'identification semi-automatique des micro-architectures similaires \`a ces motifs dans le code source. La m\'etamod\'elisation est utilis\'ee pour d\'ecrire les motifs de conception et les programmes Java. Elle am\`ene \`a expliciter certaines relations interclasses (association, agr\'egation et composition) offertes par les langages de conception comme UML et \`a pr\'eciser leurs propri\'et\'es (dur\'ee de vie, exclusivit\'e, multiplicit\'e et site d'invocation) pour les identifier avec des algorithmes d'analyses statiques et dynamiques. Elle conduit aussi \`a traduire les motifs en syst\`emes de contraintes et \`a identifier les micro-architectures similaires, formes compl\`etes et approch\'ees, par la r\'esolution de probl\`emes de satisfaction de contraintes. La programmation par contraintes avec explications permet de guider la r\'esolution et d'expliquer les micro-architectures identifi\'ees. La suite d'outils Ptidej est une implantation des mod\`eles et des algorithmes propos\'es. Elle est int\'egr\'ee \`a l'environnement Eclipse de d\'eveloppement en Java. Elle inclut le m\'etamod\`ele PADL, d\'eriv\'e du m\'etamod\`ele PDL ; des outils d'analyses statiques et dynamiques, Introspector et Caffeine ; et un solveur de contraintes, PtidejSolver, d\'eriv\'e du solveur de contraintes avec explications de r\'ef\'erence PaLM.
    [bibtex-key = Gueheneuc-EUE-PhDThesis]

  2. Yann-Gaël Guéhéneuc. Design Patterns: Empirical Studies on the Impact of Design Patterns on Quality, chapter 19, pages 204--219. Taylor and Francis Group, September 2010. Note: 16 pages. [Text ] Keyword(s): Design patterns, ESE.
    Abstract:
    Design patterns are a form of documentation that proposes solutions to recurring object-oriented software design problems. Design patterns became popular in software engineering thanks to the book published in 1995 by the Gand of Four: Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides. Since the publication of the book ``Design Patterns: Elements of Reusable Object-Oriented Software'', design patterns have been used to design programs and ease their maintenance, to teach object-oriented concepts and related ``good'' practices in classrooms, to assess quality and help program comprehension in research. However, design patterns may also lead to over-engineered programs and may negatively impact quality. We recall the history of design patterns and present some recent development characterising the advantages and disadvantages of design patterns.
    [bibtex-key = Gueheneuc10-ESE-DesignPatterns]

  3. Tom Mens, Yann-Gaël Guéhéneuc, Juan Fernandez-Ramil, and Maja D'Hondt. Guest Editorial: Software Evolution, volume 27, chapter 1, pages 22--25. IEEE CS Press, July--August 2010. Note: 4 pages. [Text ] Keyword(s): Evolution patterns, IEEE Software.
    Abstract:
    Modern society depends heavily on software systems. Software can enable or even accelerate human, social, economic, and technological changes. Software systems must often reflect these changes to adequately fulfill their roles and remain relevant to stakeholders, but the number of new requirements and maintenance requests often grows faster than software owners' abilities to implement them. Evolving and maintaining these systems is therefore critical and, consequently, most developers work on maintaining, incrementally enhancing, and adapting existing systems.
    [bibtex-key = Mens10-IEEESoftwareGuestIntroduction]

  4. Gerardo Cepeda Porras and Yann-Gaël Guéhéneuc. An Empirical Study on the Efficiency of Different Design Pattern Representations in UML Class Diagrams. Empirical Software Engineering (EMSE), 15(5):493--522, February 2010. Note: 29 pages. [Text ] Keyword(s): Understanding program comprehension, EMSE.
    Abstract:
    Design patterns are recognized in the software engineering community as useful solutions to recurring design problems that improve the quality of programs. They are more and more used by developers in the design and implementation of their programs. Therefore, the visualization of the design patterns used in a program could be useful to efficiently understand how it works. Currently, a common representation to visualize design patterns is the UML collaboration notation. Previous work noticed some limitations in this representation and proposed new representations to tackle these limitations. However, none of these pieces of work conducted empirical studies to compare their new representations with this common representation. We designed and conducted an empirical study to collect data on the performance of developers on basic tasks related to design pattern comprehension to evaluate the impact of three visual representations and to compare them with the common one. We used eye-trackers to measure the developers' effort during the execution of the study. Collected data show that there exists for certain tasks a representation that is more efficient than the common one. We also found tasks for which the common representation works better.
    [bibtex-key = CepedaPorras10-EMSE-UMLNotations]

  5. José Côté, Pilar Ramirez-Garcia, Geneviève Rouleau, Diane Saulnier, Yann-Gaël Guéhéneuc, Annick Hernandez, and Gaston Godin. A Nursing Virtual Intervention: Real-Time Support for Managing Antiretroviral Therapy. Computers, Informatics, Nursing (CIN), 29(1):43--51, January--February 2010. Note: 22 pages. [Text ] Keyword(s): VIHTAVIE, CIN.
    Abstract:
    Based on a philosophy of empowerment, we developed the VIHTAVIE virtual intervention (HIV-Treatment, Virtual Nursing Assistance and Education) to equip persons living with HIV for managing with their daily antiretroviral therapies. In this article we describe the VIHTAVIE project and the process of developing it, which was carried out in three phases: 1) development of the intervention's clinical content, 2) generation of a multimedia presentation and 3) implementation of our web application via computer interface. VIHTAVIE consists of four interactive sessions at the computer, animated by a virtual nurse that takes the individual through the learning process about the capabilities necessary for taking the treatment. This information and strategies provided by the virtual nurse are specifically adapted to the participant, according to the responses he or she supplies. The VIHTAVIE approach, still experimental, is intended to be complementary with the actual clinical follow-up and has been developed in the context of reorganizing services and of the scarcity of resources. While we anticipate direct positive outcomes among the HIV clientele, it is also highly probable that this virtual support application will have ramifications among different clienteles who must also contend with the daily challenges of their health conditions.
    [bibtex-key = Cote09-CIN-VirtualIntervention]

  6. Yann-Gaël Guéhéneuc, Jean-Yves Guyomarc'h, and Houari Sahraoui. Improving Design Pattern Identification: a New Approach and an Exploratory Study. Software Quality Journal (SQJ), 18(1):145--166, March 2010. Note: 21 pages. [Text ] Keyword(s): Design patterns, SQJ.
    Abstract:
    The identification of occurrences of design patterns in programs can help maintainers to understand the program design and implementation. It can also help them to make informed changes. Current identification approaches are limited to complete occurrences, are time- and resource-consuming, and lead to many false positives. We propose to combine a structural and a numerical approach to improve the identification of complete and incomplete occurrences of design patterns. We develop a structural approach using explanation-based constraint programming and we enhance this approach using experimentally-built numerical signatures. We show that the use of numerical signatures improves the identification of complete and incomplete occurrences in terms of performance and precision.
    [bibtex-key = Gueheneuc10-SQJ-MetricalPtidejSolver]

  7. Olivier Kaczor, Yann-Gaël Guéhéneuc, and Sylvie Hamel. Identification of Design Motifs with Pattern Matching Algorithms. Information and Software Technology (IST), 52(2):152--168, February 2010. Note: 16 pages. [Text ] Keyword(s): Design patterns, IST.
    Abstract:
    Design patterns are important in software maintenance because they help in understanding and re-engineering systems. They propose design motifs, solutions to recurring design problems. The identification of occurrences of design motifs in large systems consists of identifying classes whose structure and organization match exactly or approximately the structure and organization of classes as suggested by the motif. We adapt two classical approximate string matching algorithms based on automata simulation and bit-vector processing to efficiently identify exact and approximate occurrences of motifs. We then carry out two case studies to show the performance, precision, and recall of our algorithms. In the first case study, we assess the performance of our algorithms on seven medium-to-large systems. In the second case study, we compare our approach with three existing approaches (an explanation-based constraint approach, a metric-enhanced explanation-based constraint approach, and a similarity scoring approach) by applying the algorithms on three small-to-medium size systems, \JHotDraw{}, \ygg@product{Juzzle}, and \ygg@product{QuickUML}. Our studies show that approximate string matching based on bit-vector processing provides efficient algorithms to identify design motifs.
    [bibtex-key = Kaczor09-IST-EfficientDPIdentification]

  8. Naouel Moha, Yann-Gaël Guéhéneuc, Laurence Duchien, and Anne-Françoise Le Meur. DECOR: A Method for the Specification and Detection of Code and Design Smells. Transactions on Software Engineering (TSE), 36(1):20--36, January--February 2010. Note: 16 pages. [Text ] Keyword(s): Code and design smells, TSE.
    Abstract:
    Code and design smells are poor solutions to recurring implementation and design problems. They may hinder the evolution of a system by making it hard for software engineers to carry out changes. We propose three contributions to the research field related to code and design smells: (1) DECOR, a method that embodies and defines all the steps necessary for the specification and detection of code and design smells; (2) \DEX{} a detection technique that instantiates this method; and (3) an empirical validation in terms of precision and recall of \DEX. The originality of \DEX{} stems from the ability for software engineers to specify smells at a high-level of abstraction using a consistent vocabulary and domain-specific language for automatically generating detection algorithms. Using \DEX{}, we specify four well-known design smells: the antipatterns Blob, Functional Decomposition, Spaghetti Code, and Swiss Army Knife, and their 15 underlying code smells, and we automatically generate their detection algorithms. We apply and validate the detection algorithms in terms of precision and recall on \product{Xerces} v2.7.0, and discuss the precision of these algorithms on 11 open-source systems.
    [bibtex-key = Moha09-TSE-DECOR]

  9. Naouel Moha, Yann-Gaël Guéhéneuc, Anne-Françoise Le Meur, Laurence Duchien, and Alban Tiberghien. From a Domain Analysis to the Specification and Detection of Code and Design Smells. Formal Aspects of Computing (FAC), 22(3):345--368, May 2010. Note: 23 pages. [Text ] Keyword(s): Code and design smells, FAC.
    Abstract:
    Code and design smells are recurring design problems in software systems that need to be identified to avoid their possible negative consequences in development and maintenance. Consequently, several smell detection approaches and tools have been proposed in the literature. However, so far, they allow the detection of predefined smells but the detection of new smells or smells adapted to the context of the analysed systems is possible only by implementing new detection algorithms manually. Moreover, previous approaches do not explain the transition from specifications of smells to their detection. Finally, the validation of the existing detection approaches and tools has been limited on few proprietary systems and on a reduced number of smells. In this paper, we introduce an approach to automate the generation of detection algorithms from specifications written using a domain-specific language. This language is defined from a thorough domain analysis. It allows the specification of smells using high-level domain-related abstractions. It allows the adaptation of the specifications of smells to the context of the analysed systems. We specify 10 smells, generate automatically their detection algorithms using templates, and validate the algorithms in terms of precision and recall on \ygg@product{Xerces} v2.7.0 and \ygg@product{GanttProject} v1.10.2, two open-source object-oriented systems.
    [bibtex-key = Moha09-FAC-DDDomainAnalysis]

  10. Houari Sahraoui, Lionel C. Briand, Yann-Gaël Guéhéneuc, and Olivier Beaurepaire. Investigating the Impact of a Measurement Program on Software Quality. Information and Software Technology (IST), 52(9):923--933, September 2010. Note: 10 pages. [Text ] Keyword(s): Quality models, IST.
    Abstract:
    Measurement programs have been around for several decades but have been often misused or misunderstood by managers and developers. This misunderstanding prevented their adoption despite their many advantages. In this paper, we present the results of an empirical study on the impact of a measurement program, MQL, in an industrial context. We analyzed data collected on 44 systems of different sizes: 22 systems were developed using MQL while the other 22 did not use a specific measurement program (control group). We studied the impact of MQL on a set of quality indicators. Our results show that MQL had a clearly positive impact on all the studied indicators. This impact is statistically significant for all the indicators but corrective maintenance effort. We therefore bring concrete evidence that a measurement program can have a significant, positive impact on the quality of software systems if combined with appropriate decision making procedures and corrective actions.
    [bibtex-key = Sahraoui10-IST-ImpactMeasurementProgram]

  11. Venera Arnaoudova, Laleh Eshkevari, Rocco Oliveto, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Physical and Conceptual Identifier Dispersion: Measures and Relation to Fault Proneness. In Rudolf Ferenc and Denys Poshyvanyk, editors, Proceedings of the 26th International Conference on Software Maintenance (ICSM), pages 1--5, September 2010. IEEE CS Press. Note: Early Research Achievements Track. Best paper. 5 pages. [Text ] [Slides ] Keyword(s): Identifier analysis, ICSM.
    Abstract:
    Poorly-chosen identifiers have been reported in the literature as misleading and increasing the program comprehension effort. Identifiers are composed of terms, which can be dictionary words, acronyms, contractions, or simple strings. We conjecture that the use of identical terms in different contexts may increase the risk of faults. We investigate our conjecture using a measure combining term entropy and term context coverage to study whether certain terms increase the odds ratios of methods to be fault-prone. Entropy measures the \emph{physical dispersion} of terms in a program: the higher the entropy, the more scattered across the program the terms. Context coverage measures the \emph{conceptual dispersion} of terms: the higher their context coverage, the more unrelated the methods using them. We compute term entropy and context coverage of terms extracted from identifiers in Rhino 1.4R3 and ArgoUML 0.16. We show statistically that methods containing terms with high entropy and context coverage are more fault-prone than others.
    [bibtex-key = Arnaoudova10-ICSM-ERA-IdentifierEntropy]

  12. Fatemeh Asadi, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Concept Location with Genetic Algorithms: A Comparison of Four Distributed Architectures. In Lionel Briand, editor, Proceedings of the 2nd International Symposium on Search Based Software Engineering (SSBSE), pages 153--162, September 2010. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, SSBSE.
    Abstract:
    Genetic algorithms are attractive to solve many search-based software engineering problems because they allow the easy parallelization of computations, which improves scalability and reduces computation time. In this paper, we present our experience in applying different distributed architectures to parallelize a genetic algorithm used to solve the concept identification problem. We developed an approach to identify concepts in execution traces by finding cohesive and decoupled fragments of the traces. The approach relies on a genetic algorithm, on a textual analysis of source code using latent semantic indexing, and on trace compression techniques. The fitness function in our approach has a polynomial evaluation cost and is highly computationally intensive. A run of our approach on a trace of thousand methods may require several hours of computation on a standard PC. Consequently, we reduced computation time by parallelizing the genetic algorithm at the core of our approach over a standard TCP/IP network. We developed four distributed architectures and compared their performances: we observed a decrease of computation time up to 140 times. Although presented in the context of concept location, our findings could be applied to many other search-based software engineering problems.
    [bibtex-key = Asadi10-SSBSE-ComparisonDistributedArchitectures]

  13. Fatemeh Asadi, Massimiliano Di Penta, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. A Heuristic-based Approach to Identify Concepts in Execution Traces. In Rudolf Ferenc and Juan Carlos Dueñas, editors, Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR), pages 31--40, March 2010. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, CSMR.
    Abstract:
    Concept or feature identification, \ie{} the identification of the source code fragments implementing a particular feature, is a crucial task during software understanding and maintenance. This paper proposes an approach to identify concepts in execution traces by finding cohesive and decoupled fragments of the traces. The approach relies on search-based optimization techniques, textual analysis of the system source code using latent semantic indexing, and trace compression techniques. It is evaluated to identify features from execution traces of two open source systems from different domains, JHotDraw and ArgoUML. Results show that the approach is always able to identify trace segments implementing concepts with a high precision and, for highly cohesive concepts, with a high overlap with the manually-built oracle.
    [bibtex-key = Asadi10-CSMR-IdentifyConceptsTraces]

  14. Gabriele Bavota, Rocco Oliveto, Andrea De Lucia, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Playing with Refactoring: Identifying Extract Class Opportunities through Game Theory. In Rudolf Ferenc and Denys Poshyvanyk, editors, Proceedings of the 26th International Conference on Software Maintenance (ICSM), pages 1--5, September 2010. IEEE CS Press. Note: Early Research Achievements Track. 5 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ICSM.
    Abstract:
    In software engineering, developers must often find solutions to problems balancing competing goals, e.g., quality versus cost, time to market versus resources, or cohesion versus coupling. Finding a suitable balance between contrasting goals is often complex and recommendation systems are useful to support developers and managers in performing such a complex task. We believe that contrasting goals can be often dealt with game theory techniques. Indeed, game theory is successfully used in other fields, especially in economics, to mathematically propose solutions to strategic situation, in which an individual's success in making choices depends on the choices of others. To demonstrate the applicability of game theory to software engineering and to understand its pros and cons, we propose an approach based on game theory that recommend extract-class refactoring opportunities. A preliminary evaluation inspired by mutation testing demonstrates the applicability and the benefits of the proposed approach.
    [bibtex-key = Bavota10-ICSM-ERA-RefactoringGameTheory]

  15. José Côté, Geneviève Rouleau, Diane Saulnier, Cécile Tremblay, Hélène Morin, Pilar Ramirez-Garcia, Yann-Gaël Guéhéneuc, Gaston Godin, and Joanne Otis. Découvrir aujourd'hui, réinventer demain ! Le mode virtuel : une voie prometteuse pour le soutien des clientèles dans l'autogestion de leur condition de santé. In Christine Thoer and Joseph Levy, editors, actes du 78e congrès de l'ACFAS, mai 2010. ACFAS. [Text ] Keyword(s): VIHTAVIE, ACFAS.
    Abstract:
    Bas\'ee sur une philosophie d'empowerment, VIH-TAVIE (VIH - Traitement, Assistance Virtuelle Infirmi\`ere et Enseignement) vise \`a outiller la personne vivant avec le VIH (PVVIH) dans la gestion quotidienne de ses antir\'etroviraux. Le but de cette communication est de faire une d\'emonstration de VIH-TAVIE et de pr\'esenter les r\'esultats pr\'eliminaires sur l'acceptabilit\'e et la faisabilit\'e de VIH-TAVIE.
    [bibtex-key = Cote10-ACFAS-ModeVirtuel]

  16. Massimiliano Di Penta, Daniel M. German, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Exploratory Study of the Evolution of Software Licensing. In Prem Devanbu and Sebastian Uchitel, editors, Proceedings of the 32nd International Conference on Software Engineering (ICSE), pages 145--154, May 2010. ACM Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, ICSE.
    Abstract:
    ree and open source software systems (FOSS) are distributed and made available to users under different software licenses, mentioned in FOSS code by means of licensing statements. Various factors, such as changes in the legal landscape, commercial code licensed as FOSS, or code reused from other FOSS systems, lead to evolution of licensing, which may affect the way a system or part thereof can be subsequently used. Therefore, it is crucial to monitor licensing evolution. However, manually tracking the licensing evolution of thousands of files is a daunting task. After presenting several cases of the effects of licensing evolution, we argue that developers and system integrators must monitor licensing evolution and they need an automatic approach due to the sheer size of FOSS systems. We propose an approach to automatically track changes occurring in the licensing terms of a system and report an empirical study of the licensing evolution of six different FOSS systems. Results show that licensing underwent frequent and substantial changes.
    [bibtex-key = DiPenta10-ICSE-SoftwareLicensingEvolution]

  17. Salima Hassaine, Foutse Khomh, Yann-Gaël Guéhéneuc, and Sylvie Hamel. IDS: An Immune-inspired Approach for the Detection of Software Design Smells. In Mel Ó Cinnéide, editor, Proceedings of the 7th International Conference on the Quality of Information and Communications Technology (QUATIC), pages 343--348, September--October 2010. IEEE CS Press. Note: Quality in ICT Reengineering and Refactoring Track. 6 pages. [Text ] [Slides ] Keyword(s): Code and design smells, QUATIC.
    Abstract:
    We propose a parallel between object-oriented system designs and living creatures. We suggest that, like any living creature, system designs are subject to diseases, which are design smells (code smells and antipatterns). Design smells are conjectured in the literature to impact the quality and life of systems and, therefore, their detection has drawn the attention of both researchers and practitioners with various approaches. With our parallel, we propose a novel approach built on models of the immune system responses to pathogenic material. We show that our approach can detect more than one smell at a time. We build and test our approach on GanttProject v1.10.2 and Xerces v2.7.0, for which manually-validated and publicly-available smells exist. The results show a significant improvement in detection time, precision, and recall, in comparison to the state--of--the--art approaches.
    [bibtex-key = Hassaine10-QUATIC-IDS]

  18. Günter Kniesel, Alexander Binun, Péter Hegedus, Lajos Jeno Fülöp, Alexander Chatzigeorgiou, Yann-Gaël Guéhéneuc, and Nikolaos Tsantalis. DPDX -- A Common Exchange Format for Design Pattern Detection Tools. In Rudolf Ferenc and Juan Carlos Dueñas, editors, Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR), pages 232--235, March 2010. IEEE CS Press. Note: Short paper. 5 pages. [Text ] [Slides ] Keyword(s): Design patterns, CSMR.
    Abstract:
    Tools for design pattern detection (DPD) can significantly ease program comprehension, helping programmers understand the design and intention of certain parts of a system's implementation. Many tools have been proposed in the past. However, the many different output formats used by the tools make it difficult to compare their results and to improve their accuracy and performance through data fusion. In addition, all the output formats have been shown to have several limitations in both their forms and contents. Consequently, we develop DPDX, a rich common exchange format for DPD tools, to overcome previous limitations. DPDX provides the basis for an open federation of tools that perform comparison, fusion, visualisation, and--or validation of DPD results. In the process of building the format, we also clarify some central notions of design patterns that lacked a common, generally accepted definitions, and thus provide a sound common foundation and terminology for DPD.
    [bibtex-key = Kniesel10-CSMR-DPDX]

  19. Nioosha Madani, Latifa Guerrouj, Massimiliano Di Penta, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Recognizing Words from Source Code Identifiers using Speech Recognition Techniques. In Rudolf Ferenc and Juan Carlos Dueñas, editors, Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR), pages 68--77, March 2010. IEEE CS Press. Note: Best paper. 10 pages. [Text ] [Slides ] Keyword(s): Identifier analysis, CSMR.
    Abstract:
    The existing software engineering literature has empirically shown that a proper choice of identifiers influences software understandability and maintainability. Researchers have noticed that identifiers are one of the most important source of information about program entities and that the semantic of identifiers guide the cognitive process. Recognizing the words forming identifiers is not an easy task when naming conventions (\eg{} Camel Case) are not used or strictly followed and--or when these words have been abbreviated or otherwise transformed. This paper proposes a technique inspired from speech recognition, \ie{} dynamic time warping, to split identifiers into component words. The proposed technique has been applied to identifiers extracted from two different applications: JHotDraw and Lynx. Results compared to manually-built oracles and with Camel Case algorithm are encouraging. In fact, they show that the technique successfully recognize words composing identifiers (even when abbreviated) in about 90\% of cases and that it performs better than Camel Case. Furthermore, it was able to spot mistakes in the manually-built oracle.
    [bibtex-key = Madani10-CSMR-IdentifiersSpeechRecognition]

  20. Rocco Oliveto, Foutse Khomh, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Numerical Signatures of Antipatterns: An Approach based on B-Splines. In Rudolf Ferenc and Juan Carlos Dueñas, editors, Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR), pages 248--251, March 2010. IEEE CS Press. Note: Short paper. 5 pages. [Text ] [Slides ] Keyword(s): Code and design smells, CSMR.
    Abstract:
    Antipatterns are poor object-oriented solutions to recurring design problems. The identification of occurrences of antipatterns in systems has received recently some attention but current approaches have two main limitations: either (1) they classify classes strictly as being or not antipatterns, and thus cannot report accurate information for borderline classes, or (2) they return the probabilities of classes to be antipatterns but they require an expensive tuning by experts to have acceptable accuracy. To mitigate such limitations, we introduce a new identification approach, ABS (Antipattern identification using B-Splines), based on a numerical analysis technique. The results of a preliminary study show that ABS generally outperforms previous approaches in terms of accuracy when used to identify Blobs.
    [bibtex-key = Oliveto10-CSMR-BSplineSmellDetection]

  21. Wei Wu, Yann-Gaël Guéhéneuc, Giuliano Antoniol, and Miryung Kim. AURA: A Hybrid Approach to Identify Framework Evolution. In Prem Devanbu and Sebastian Uchitel, editors, Proceedings of the 32nd International Conference on Software Engineering (ICSE), pages 325--334, May 2010. ACM Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, ICSE.
    Abstract:
    Software frameworks and libraries are indispensable to today's software systems. As they evolve, it is often time-consuming for developers to keep their code up-to-date, so approaches have been proposed to facilitate this. Usually, these approaches cannot automatically identify change rules for one-replaced-by-many and many-replaced-by-one methods, and they trade off recall for higher precision using one or more experimentally-evaluated thresholds. We introduce AURA, a novel hybrid approach that combines call dependency and text similarity analyses to overcome these limitations. We implement it in a Java system and compare it on five frameworks with three previous approaches by Dagenais and Robillard, M.\ Kim \ygg@latin{et al.}, and Sch\"afer \ygg@latin{et al.} The comparison shows that, on average, the recall of AURA is 53.07\% higher while its precision is similar, \ygg@latin{e.g.}, 0.10\% lower.
    [bibtex-key = Wu10-ICSE-AURA]


2009
  1. Luc Charest, Yann-Gaël Guéhéneuc, and Yousra Tagmouti. Translating Design Pattern Concepts to Hardware Concepts, chapter 4, pages 93--118. CRC Press, September 2009. Note: 25 pages. [Text ] Keyword(s): Design patterns, NET.
    Abstract:
    For half a century, hardware systems have become increasingly complex and pervasive. They are not only found in satellite navigation systems or automated factory machinery but also in everyday cell-phone, parc-o-meter, and car control-and-command systems. This increase in the use of hardware systems led to a revolution in their design and implementation: the chips are becoming more and more powerful, their logics is implemented as software systems executed by the chips, thus helping system designers to cope with their complexity. These \emph{mixed hardware--software systems} raise the level of generality of the ``hardware part'' and the level of abstraction of the ``software part'' of the systems. Thus, they suggest that mainstream software engineering techniques and good practices, such as design patterns, could be used by system designers to design and implement their mixed hardware--software systems. This chapter presents a proof of concept on ``translating'' the solutions of design patterns into hardware concepts to alleviate the system designers' work and, thus, to accelerate the design of mixed hardware--software systems. This chapter opens the path towards a new kind of hardware synthesis.
    [bibtex-key = Charest09-NETTechnology-PatternsHardware]

  2. Yann-Gaël Guéhéneuc. A Theory of Program Comprehension---Joining Vision Science and Program Comprehension. International Journal of Software Science and Computational Intelligence (IJSSCI), 1(2):54--72, April-June 2009. Note: 18 pages. [Text ] Keyword(s): Understanding program comprehension, JSSCI.
    Abstract:
    There exists an extensive literature on vision science, on the one hand, and on program comprehension, on the other hand. However, these two domains of research have been so far rather disjoint. Indeed, several cog- nitive theories have been proposed to explain program comprehension. These theories explain the processes taking place in the software engi- neers' minds when they understand programs. They explain how software engineers process available information to perform their tasks but not how software engineers acquire this information. Vision science provides ex- planations on the processes used by people to acquire visual information from their environment. Joining vision science and program comprehen- sion provides a more comprehensive theoretical framework to explain facts on program comprehension, to predict new facts, and to frame experi- ments. We join theories in vision science and in program comprehension; the resulting theory is consistent with facts on program comprehension and helps in predicting new facts, in devising experiments, and in putting certain program comprehension concepts in perspective.
    [bibtex-key = Gueheneuc08-JSSCI-VisionTheory]

  3. Janice Ka-Yee Ng, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Identification of Behavioral and Creational Design Motifs through Dynamic Analysis. Journal of Software Maintenance and Evolution: Research and Practice (JSME), 22(8):597--627, November 2009. Note: 30 pages. [Text ] Keyword(s): Design patterns, JSME-JSEP.
    Abstract:
    Design patterns offer design motifs, solutions to object-oriented design problems. Design motifs lead to well-structured designs and thus are believed to ease software maintenance. However, after use, they are often ``lost" and are consequently of little help during program comprehension and other maintenance activities. Therefore, several works proposed design pattern identification approaches to recover occurrences of the motifs. These approaches mainly used the structure and organisation of classes as input. Consequently, they have a low precision when considering behavioural and creational motifs, which pertain to the assignment of responsibilities and the collaborations among objects at runtime. We propose MoDeC, an approach to describe behavioral and creational motifs as collaborations among objects in the form of scenario diagrams. We identify these motifs using dynamic analysis and constraint programming. Using a proof-of-concept implementation of MoDeC and different scenarios for five other Java{} programs and extsf{Builder}, extsf{Command}, and extsf{Visitor}, we show that MoDeC has a better precision than a state-of-the-art static approaches.
    [bibtex-key = KaYeeNg09-JSME-BehaviouralCreationalIdentification]

  4. Daniel M. German, Massimiliano Di Penta, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Code Siblings: Technical and Legal Implications of Copying Code between Systems. In Michael W. Godfrey and Jim Whitehead, editors, Proceedings of the 6th Working Conference on Mining Software Repositories (MSR), pages 81--90, May 2009. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, MSR.
    Abstract:
    Source code cloning does not happen within a single system only. It can also occur between one system and another. We use the term code sibling to refer to a code clone that evolves in a different system than the code from which it originates. Code siblings can only occur when the source code copyright owner allows it and when the conditions imposed by such license are not incompatible with the license of the destination system. In some situations copying of source code fragments are allowed---legally---in one direction, but not in the other. In this paper, we use clone detection, license mining and classification, and change history techniques to understand how code siblings---under different licenses---flow in one direction or the other between Linux and two BSD Unixes, FreeBSD and OpenBSD. Our results show that, in most cases, this migration appears to happen according to the terms of the license of the original code being copied, favoring always copying from less restrictive licenses towards more restrictive ones. We also discovered that sometimes code is inserted to the kernels from an outside source.
    [bibtex-key = German09-MSR-CodeSiblings]

  5. Sébastien Jeanmart, Yann-Gaël Guéhéneuc, Houari Sahraoui, and Naji Habra. Impact of the Visitor Pattern on Program Comprehension and Maintenance. In James Miller and Rick Selby, editors, Proceedings of the 3rd International Symposium on Empirical Software Engineering and Measurement (ESEM), pages 69--78, October 2009. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, ESEM.
    Abstract:
    In the software engineering literature, many works claim that the use of design patterns improves the comprehensibility of programs and, more generally, their maintainability. Yet, little work attempted to study the impact of design patterns on the developers' tasks of program comprehension and modification. We design and perform an experiment to collect data on the impact of the Visitor pattern on comprehension and modification tasks with class diagrams. We use an eye-tracker to register saccades and fixations, the latter representing the focus of the developers' attention. Collected data show that the Visitor pattern plays a role in maintenance tasks: class diagrams with its canonical representation requires less efforts from developers.
    [bibtex-key = Jeanmart09-ESEM-VisitorImpact]

  6. Foutse Khomh, Massimiliano Di Penta, and Yann-Gaël Guéhéneuc. An Exploratory Study of the Impact of Code Smells on Software Change-proneness. In Giuliano Antoniol and Andy Zaidman, editors, Proceedings of the 16th Working Conference on Reverse Engineering (WCRE), pages 75--84, October 2009. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, WCRE.
    Abstract:
    Code smells are poor implementation choices, thought to make object-orien\-ted systems hard to maintain. In this study, we investigate if classes with code smells are more change-prone than classes without smells. Specifically, we test the general hypothesis: classes with code smells are not more change prone than other classes. We detect umberofsmells{} code smells in 9 releases of Azureus and in 13 releases of Eclipse, and study the relation between classes with these code smells and class change-proneness. We show that, in almost all releases of Azureus and Eclipse, classes with code smells are more change-prone than others, and that specific smells are more correlated than others to change-proneness. These results justify \emph{a posteriori} previous work on the specification and detection of code smells and could help focusing quality assurance and testing activities.
    [bibtex-key = Khomh09-WCRE-CodeSmellsChanges]

  7. Foutse Khomh, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Playing Roles in Design Patterns: An Empirical Descriptive and Analytic Study. In Kostas Kontogiannis and Tao Xie, editors, Proceedings of the 25th International Conference on Software Maintenance (ICSM), pages 83--92, September 2009. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Design patterns, ICSM.
    Abstract:
    This work presents a descriptive and analytic study of classes playing zero, one, or two roles in six different design patterns (and combinations thereof). First, we answer three research questions showing that (1) playing roles in design patterns is not a all-or-nothing characteristic of classes and that there are significant differences among the (2) internal and (3) external characteristics of classes playing zero, one, or two roles. Second, we revisit a previous work on design patterns and changeability and show that its results were, in a great part, due to classes playing two roles. Third, we exemplify the use of the study results to provide a ranking of the occurrences of the design patterns identified in a program. The ranking allows developers to balance precision and recall as they see fit.
    [bibtex-key = Khomh09-ICSM-DPRoles]

  8. Foutse Khomh, Stéphane Vaucher, Yann-Gaël Guéhéneuc, and Houari Sahraoui. A Bayesian Approach for the Detection of Code and Design Smells. In Choi Byoung-ju, editor, Proceedings of the 9th International Conference on Quality Software (QSIC), pages 305--314, August 2009. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, QSIC.
    Abstract:
    The presence of code and design smells can have a severe impact on the quality of a program. Consequently, their detection and correction have drawn the attention of both researchers and practitioners who have proposed various approaches to detect code and design smells in programs. However, none of these approaches handle the inherent uncertainty of the detection process. We propose a Bayesian approach to manage this uncertainty. First, we present a systematic process to convert existing state-of-the-art detection rules into a probabilistic model. We illustrate this process by generating a model to detect occurrences of the Blob antipattern. Second, we present results of the validation of the model: we built this model on two open-source programs, \product{GanttProject v1.10.2} and \product{Xerces v2.7.0}, and measured its accuracy. Third, we compare our model with another approach to show that it returns the same candidate classes while ordering them to minimise the quality analysts' effort. Finally, we show that when past detection results are available, our model can be calibrated using machine learning techniques to offer an improved, context-specific detection.
    [bibtex-key = Khomh09-QSIC-BayesianDD]

  9. Stéphane Vaucher, Foutse Khomh, Naouel Moha, and Yann-Gaël Guéhéneuc. Tracking Design Smells: Lessons from a Study of God Classes. In Giuliano Antoniol and Andy Zaidman, editors, Proceedings of the 16th Working Conference on Reverse Engineering (WCRE), pages 145--154, October 2009. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, Quality models, WCRE.
    Abstract:
    ``God class'' is a term used to describe certain types of large classes which ``know too much or do too much". Often a God class(\GC{}) is created by accident as incremental functionality is added to a central class over the course of several versions. \GC{}s are generally thought to be examples of bad code that should be detected and removed to ensure software quality. However, in some cases, a \GC{} is created by design as the best solution to a particular problem because, \eg{} the problem is not easily decomposable or strong requirements on efficiency are imposed. In this paper we study, in two open-source systems, the ``life cycle" of \GC{}s: how they arise, how prevalent are they, and whether they remain or are they removed as the systems evolve over time through a number of versions. We show how to detect the degree of ``godliness" in classes automatically. Then we show that by identifying the evolution of ``godliness" we can distinguish between those that are so by design (good code) from those that occurred by accident (bad code). This methodology will allow software quality teams to implement prevention and correction mechanisms.
    [bibtex-key = Vaucher09-WCRE-CurePreventionSmells]

  10. Foutse Khomh, Massimiliano Di Penta, Yann-Gaël Guéhéneuc, and Guiliano Antoniol. An Exploratory Study of the Impact of Antipatterns on Software Changeability. Technical report EPM-RT-2009-02, École Polytechnique de Montréal, April 2009. Note: 15 pages. [Text ] Keyword(s): Code and design smells, Evolution patterns.
    Abstract:
    Antipatterns are poor design choices that make object-orien\-ted systems hard to maintain by developers. In this study, we investigate if classes that participate in antipatterns are more change-prone than classes that do not. Specifically, we test the general hypothesis: classes belonging to antipatterns are not more likely than other classes to undergo chan\-ges, to be impacted when fixing issues posted in issue-tracking systems, and in particular to unhandled excep\-tions-related issues---a crucial problem for any software system. We detect 11 antipatterns in 13 releases of Eclipse and study the relations between classes involved in these antipatterns and classes change-, issue-, and unhandled ex\-ception-proneness. We show that, in almost all releases of Eclipse, classes with antipatterns are more change-, issue-, and un\-handled-exception-prone than others. These results justify previous work on the specification and detection of antipatterns and could help focusing quality assurance and testing activities.
    [bibtex-key = Khomh09-TR-AntipatternsChangeability]

  11. Foutse Khomh, Yann-Gaël Guéhéneuc, and Guiliano Antoniol. An Empirical Descriptive and Analytic Study of Playing Roles in Design Patterns. Technical report EPM-RT-2009-03, École Polytechnique de Montréal, April 2009. Note: 15 pages. [Text ] Keyword(s): Design patterns, Evolution patterns.
    Abstract:
    This work presents a descriptive and analytic study of classes playing zero, one, or two roles in six different design patterns (and combinations thereof). First, we answer three research questions showing that (1) playing roles in design patterns is not a all-or-nothing characteristic of classes and that there are significant differences among the (2) internal and (3) external characteristics of classes playing zero, one, or two roles. Second, we revisit a previous work on design patterns and changeability and show that its results were, in a great part, due to classes playing two roles. Third, we exemplify the use of the study results to provide a ranking of the occurrences of the design patterns identified in a program. The ranking allows developers to balance precision and recall as they see fit.
    [bibtex-key = Khomh09-TR-DesignPatternsRoles]

  12. Foutse Khomh, Naouel Moha, and Yann-Gaël Guéhéneuc. DEQUALITE : méthode de construction de modèles de qualité prenant en compte la conception des systèmes. Technical report EPM-RT-2009-04, École Polytechnique de Montréal, avril 2009. Note: 31 pages. [Text ] Keyword(s): Quality models.
    Abstract:
    La plupart des mod\`eles de qualit\'e pr\'esent\'es dans la litt\'erature ou utilis\'es dans l'industrie pour \'evaluer les syst\`emes par objets utilisent des m\'etriques de classes (nombre de m\'ethodes d'une classe par exemple) ou des m\'etriques de relations entre classes (couplage entre deux classes par exemple) pour mesurer les attributs internes des syst\`emes. Cependant, la qualit\'e des syst\`emes par objets ne d\'epend pas uniquement de la structure de leurs classes mais aussi de la fa\c con dont celles-ci sont organis\'ees, c'est-\`a-dire de leur conception. Nous proposons DEQUALITE, une m\'ethode de construction de mod\`eles de qualit\'e permettant de mesurer la qualit\'e des syst\`emes par objets en prenant en compte non seulement les attributs internes du syst\`eme mais aussi sa conception. Notre m\'ethode utilise une approche par apprentissage. Elle s'appuie sur une \'etude des patrons de conception pour prendre en compte la conception des syst\`emes. Notre m\'ethode permet aussi de combiner des mod\`eles de qualit\'e afin d'augmenter la capacit\'e de pr\'ediction. Nous illustrons notre m\'ethode sur un ensemble de syst\`emes implantant des patrons de conception et sur le mod\`ele de qualit\'e QMOOD de Bansiya. Nous discutons les avantages et les inconv\'enients de cette m\'ethode et proc\'edons \`a la validation d'un mod\`ele de qualit\'e r\'esultant sur un ensemble de syst\`emes. Nous terminons par une discussion sur les avantages et limitations de l'utilisation des patrons de conception pour la construction de mod\`eles de qualit\'e.
    [bibtex-key = Khomh09-TR-DEQUALITE]


2008
  1. Khashayar Khosravi and Yann-Gaël Guéhéneuc. On Issues with Software Quality Models, chapter 11, pages 218--235. ICFAI University Press, January 2008. Note: 28 pages. [Text ] Keyword(s): Quality models, Design patterns, SQM.
    Abstract:
    Software metrics and quality models play a pivotal role in measurement of software quality. A number of well-known quality models and software metrics are used to build quality software both in industry and in academia. However, during our research on measuring software quality using design patterns, we faced many issues related to existing software metrics and quality models. In this position paper, we discuss some of these issues and present our approach to software quality assessment.
    [bibtex-key = Khosravi08-SQM-IssuesQualityModels]

  2. Yann-Gaël Guéhéneuc and Giuliano Antoniol. DeMIMA: A Multi-layered Framework for Design Pattern Identification. Transactions on Software Engineering (TSE), 34(5):667--684, September 2008. Note: 18 pages. [Text ] Keyword(s): Design patterns, TSE.
    Abstract:
    Design patterns are important in object-oriented programming because they offer design motifs, elegant solutions to recurrent design problems, which improve the quality of software systems. Design motifs facilitate system maintenance by helping to understand design and implementation. However, after implementation, design motifs are spread throughout the source code and are thus not directly available to maintainers. We present DeMIMA, an approach to identify semi-automatically micro-architectures that are similar to design motifs in source code and to ensure the traceability of these micro-architectures between implementation and design. DeMIMA consists of three layers: two layers to recover an abstract model of the source code, including binary class relationships, and a third layer to identify design patterns in the abstract model. We apply DeMIMA to five open-source systems and, on average, we observe 34\% precision for the considered 12 design motifs. Through the use of explanation-based constraint programming, DeMIMA ensures 100\% recall on the five systems. We also apply DeMIMA on 33 industrial components.
    [bibtex-key = Gueheneuc07-TSE-MultiLayeredFramework]

  3. Giuliano Antoniol, Kamel Ayari, Massimiliano Di Penta, Foutse Khomh, and Yann-Gaël Guéhéneuc. Is It a Bug or an Enhancement? A Text-based Approach to Classify Change Requests. In Mark Vigder and Marsha Chechik, editors, Proceedings of the 18th IBM Centers for Advanced Studies Conference (CASCON), pages 23-37, October 2008. ACM Press. Note: 15 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, CASCON.
    Abstract:
    Bug tracking systems are valuable assets for managing maintenance activities. They are widely used in open-source projects as well as in the software industry. They collect many different kinds of issues: requests for defect fixing, enhancements, refactoring/restructuring activities and organizational issues. These different kinds of issues are simply labeled as ``bug" for lack of a better classification support or of knowledge about the possible kinds. This paper investigates whether the text of the issues posted in bug tracking systems is enough to classify them into corrective maintenance and other kinds of activities. We show that alternating decision trees, naive Bayes classifiers, and logistic regression can be used to accurately distinguish bugs from other kinds of issues. Results from empirical studies performed on issues for Mozilla, Eclipse, and JBoss indicate that issues can be classified with between 77\% and 82\% of correct decisions.
    [bibtex-key = Antoniol08-CASCON-ClassificationofChangeReq]

  4. Giuliano Antoniol, Jane Huffman Hayes, Yann-Gaël Guéhéneuc, and Massimiliano Di Penta. Reuse or Rewrite: Combining Textual, Static, and Dynamic Analyses to Assess the Cost of Keeping a System Up-to-date. In Hong Mei and Kenny Wong, editors, Proceedings of the 24th International Conference on Software Maintenance (ICSM), pages 147--156, September--October 2008. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, ICSM.
    Abstract:
    Undocumented software systems are a common challenge for developers performing maintenance and/or reuse. The challenge is two-fold: (1) when no comments or documentation exist, it is difficult for developers to understand how a system works; (2) when no requirements exist, it is difficult to know what the system actually does. We present a method, named ReORe (Reuse or Rewrite) that assists developers in recovering requirements for a competitor system and in deciding if they should reuse parts of their existing system or rewrite it from scratch. Our method requires source code and executable for the system and assumes that requirements are preliminarily recovered. We apply ReORe to Lynx, a Web browser written in C. We provide evidence of ReORe accuracy: 56\% for validation based on textual and static analysis and 94\% for the final validation using dynamic analysis.
    [bibtex-key = Antoniol08-ICSM-ReORe]

  5. Simon Denier and Yann-Gaël Guéhéneuc. Mendel: A Model, Metrics, and Rules to Understand Class Hierarchies. In René Krikhaar and Ralf Lämmel, editors, Proceedings of the 16th International Conference on Program Comprehension (ICPC), pages 143--152, June 2008. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, ICPC.
    Abstract:
    Inheritance is an important mechanism when developing object-oriented programs with class-based programming languages: it enables subtyping, polymorphism, and code reuse. Inheritance is also known as a difficult feature to grasp and to use correctly because of its many purposes. We propose a model of inheritance to help understand class hierarchies of class-based object-oriented programs. We define metrics and rules to highlight interesting classes and behaviours with respect to inheritance. Thus, we provide the programmer with insight on how inheritance is used in a program. We illustrate our approach on \JHotDraw{} and validate it further on three other programs: ArgoUML, Azureus, and Log4J. We also show that our model can describe existing rules, such as micro patterns.
    [bibtex-key = Denier08-ICPC-Mendel]

  6. Massimiliano Di Penta, Luigi Cerulo, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. An Empirical Study of the Relationships between Design Pattern Roles and Class Change Proneness. In Hong Mei and Kenny Wong, editors, Proceedings of the 24th International Conference on Software Maintenance (ICSM), pages 217--226, September--October 2008. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Design patterns, ICSM.
    Abstract:
    Analyzing the change-proneness of design patterns and the kinds of changes occurring to classes playing role(s) in some design pattern(s) during software evolution poses the basis for guidelines to help developers who have to choose, apply or maintain design patterns. Building on previous work, this paper shifts the focus from design patterns as wholes to the finer-grain level of design pattern roles. It presents an empirical study to understand whether there are roles that are more change-prone than others and whether there are changes that are more likely to occur to certain roles. It relies on data extracted from the source code repositories of three different systems (JHotDraw, Xerces, and Eclipse-JDT) and from 12 design patterns.
    [bibtex-key = DiPenta08-ICSM-DPRoles]

  7. Marc Eaddy, Alfred V. Aho, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Cerberus: Tracing Requirements to Source Code Using Information Retrieval, Dynamic Analysis, and Program Analysis. In René Krikhaar and Ralf Lämmel, editors, Proceedings of the 16th International Conference on Program Comprehension (ICPC), pages 53--62, June 2008. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, ICPC.
    Abstract:
    The concern location problem is to identify the source code within a program related to the features, requirements, or other concerns of the program. This problem is central to program development and maintenance. We present a new technique called prune dependency analysis that can be combined with existing techniques to dramatically improve the accuracy of concern location. We developed Cerberus, a potent hybrid technique for concern location that combines information retrieval, execution tracing, and prune dependency analysis. We used Cerberus to trace the 360 requirements of RHINO, a 32,134 line Java program that implements the ECMAScript international standard. In our experiment, prune dependency analysis boosted the recall of information retrieval by 155\% and execution tracing by 104\%. Moreover, we show that our combined technique outperformed the other techniques when run individually or in pairs.
    [bibtex-key = Eaddy08-ICPC-Cerberus]

  8. Adnane Ghannem, Salima Hassaine, Yann-Gaël Guéhéneuc, and Sylvie Hamel. L'analyse de logiciels, phylogénie et histoire. In Mireille Blay-Fornarino, editor, Actes du 14e colloque Langages et Modèles à Objets (LMO), pages N/A, mars 2008. Éditions Cépaduès. Note: Poster. 2 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, LMO.
    Abstract:
    La maintenance des logiciels de grande taille est une activit\'e co\^uteuse, car leur \'evolution incontr\^ol\'ee compromet leur compr\'ehension et modification. Une \'etude de leur \'evolution pourrait r\'eduire les co\^uts. Notre travail a pour objectif de proposer des techniques d'analyse de l'\'evolution (historique et phylog\'enie), en adaptant des algorithmes de bioinformatique.
    [bibtex-key = Ghannem08-LMO-AnalyseLogiciels]

  9. Jane Huffman Hayes, Giuliano Antoniol, and Yann-Gaël Guéhéneuc. Prereqir: Recovering Pre-Requirements via Cluster Analysis. In Andy Zaidman, Massimilano Di Penta, and Ahmed Hassan, editors, Proceedings of the 15th Working Conference on Reverse Engineering (WCRE), pages 165--174, October 2008. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, WCRE.
    Abstract:
    High-level software artifacts, such as requirements, domain-specific requirements, and so on, are an important source of information that is often neglected during the reverse- and re-engineering processes. We posit that domain specific pre-requirements information (PRI) can be obtained by eliciting the stakeholders' understanding of generic systems or domains. We discuss the semi-automatic recovery of domain-specific PRI that can then be used during reverse- and re-engineering, for example, to recover traceability links or to assess the degree of obsolescence of a system with respect to competing systems and the clients' expectations. We present a method using partition around medoids and agglomerative clustering for obtaining, structuring, analyzing, and labeling textual PRI from a group of diverse stakeholders. We validate our method using PRI for the development of a generic Web browser provided by 22 different stakeholders. We show that, for a similarity threshold of about 0.36, about 55\% of the PRI were common to two or more stakeholders and 42\% were outliers. We automatically label the common and outlier PRI (82\% correctly labeled), and obtain 74\% accuracy for the similarity threshold of 0.36 (78\% for a threshold of 0.5). We assess the recall and precision of the method, and compare the labeled PRI to a generic Web browser requirements specification.
    [bibtex-key = Hayes08-WCRE-PREREQIR]

  10. Foutse Khomh and Yann-Gaël Guéhéneuc. Do Design Patterns Impact Software Quality Positively?. In Christos Tjortjis and Andreas Winter, editors, Proceedings of the 12th Conference on Software Maintenance and Reengineering (CSMR), pages 274--278, April 2008. IEEE CS Press. Note: Short Paper. 5 pages. [Text ] [Slides ] Keyword(s): Quality models, CSMR.
    Abstract:
    We present an empirical study of the impact of design patterns on quality attributes in the context of software maintenance and evolution. Our first hypothesis verifies software engineering lore: design patterns impact software quality positively. We show that, contrary to popular beliefs, design patterns \emph{in practice} impact negatively several quality attributes, thus providing concrete evidence against common lore. We then study design patterns and object-oriented best practices by formulating a second hypothesis on the impact of these principles on quality. We show that results for some design patterns cannot be explained and conclude on the need for further studies on the relation between design patterns and object-oriented best practices. Thus, we bring further evidence that design patterns should be used with caution during development because they may actually impede maintenance and evolution.
    [bibtex-key = Khomh08-CSMR-DPQuality]

  11. Naouel Moha, Yann-Gaël Guéhéneuc, Anne-Françoise Le Meur, and Laurence Duchien. A Domain Analysis to Specify Design Defects and Generate Detection Algorithms. In José Fiadeiro and Paola Inverardi, editors, Proceedings of the 11th international conference on Fundamental Approaches to Software Engineering (FASE), pages 276--291, March-April 2008. Springer-Verlag. Note: 15 pages. [Text ] [Slides ] Keyword(s): Code and design smells, FASE.
    Abstract:
    Quality experts often need to identify in software systems design defects, which are recurring design problems, that hinder the development and maintenance. Consequently, several design defect detection approaches and tools have been proposed in the literature. However, we are not aware of any approach that defines and reify the process of generating detection algorithms from the existing textual descriptions of defects. In this paper, we introduce an approach to automate the generation of detection algorithms from specifications written using a domain-specific language. The domain-specific is defined from a thorough domain analysis. We specify several design defects, generate automatically detection algorithms using templates, and validate the generated detection algorithms in terms of precision and recall on \ygg@product{Xerces} v2.7.0, an open-source object-oriented system.
    [bibtex-key = Moha08-FASE-DDDomainAnalysis]

  12. Naouel Moha, Amine Mohamed Rouane Hacene, Petko Valtchev, and Yann-Gaël Guéhéneuc. Refactorings of Design Defects using Relational Concept Analysis. In Raoul Medina and Sergei Obiedkov, editors, Proceedings of the 4th International Conference on Formal Concept Analysis (ICFCA), pages 289--304, February 2008. Springer-Verlag. Note: 18 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ICFCA.
    Abstract:
    Software engineers often need to identify and correct design defects, \ie{} recurring design problems that hinder development and maintenance by making programs harder to comprehend and--or evolve. While detection of design defects is an actively researched area, their correction---mainly a manual and time-consuming activity --- is yet to be extensively investigated for automation. In this paper, we propose an automated approach for suggesting defect-correcting refactorings using relational concept analysis (RCA). The added value of RCA consists in exploiting the links between formal objects which abound in a software re-engineering context. We validated our approach on instances of the extit{Blob} design defect taken from four different open-source programs.
    [bibtex-key = Moha08-ICFCA-RefactoringsDesignDefects]

  13. Naouel Moha, Foutse Khomh, and Yann-Gaël Guéhéneuc. Génération automatique d'algorithmes de détection des défauts de conception. In Mireille Blay-Fornarino, editor, Actes du 14e colloque Langages et Modèles à Objets (LMO), pages 93--106, mars 2008. Éditions Cépaduès. Note: 13 pages. [Text ] [Slides ] Keyword(s): Code and design smells, LMO.
    Abstract:
    Les d\'efauts de conception sont des probl\`emes r\'ecurrents de conception qui diminuent la qualit\'e des programmes et donc freinent leur d\'eveloppement et maintenance. Plusieurs approches outill\'ees de d\'etection des d\'efauts ont \'et\'e propos\'ees dans la litt\'erature mais, \`a notre connaissance, elles utilisent toutes des algorithmes de d\'etection ad hoc, ce qui rend difficile leur g\'en\'eralisation \`a d'autres d\'efauts, et elles sont bas\'ees principalement sur des m\'etriques, qui ne rendent pas compte de certaines caract\'eristiques importantes des syst\`emes analys\'es, telle leur architecture. Dans cet article, nous d\'eveloppons notre approche bas\'ee sur un m\'eta-mod\`ele des d\'efauts de conception en pr\'esentant une g\'en\'eration automatique des algorithmes de d\'etection \`a partir de gabarits. Nous pr\'esentons aussi les performances de la g\'en\'eration et \'evaluons les algorithmes g\'en\'er\'es en terme de pr\'ecision et de rappel. Nous fournissons ainsi des moyens concrets pour automatiser la g\'en\'eration des algorithmes de d\'etection et donc de d\'etecter de nouveaux d\'efauts tout en prenant en compte toutes les caract\'eristiques des syst\`emes.
    [bibtex-key = Moha08-LMO-DefautConception]

  14. Simon Denier, Foutse Khomh, and Yann-Gaël Guéhéneuc. Reverse-Engineering the Literature on Design Patterns and Reverse-Engineering. Technical report EPM-RT-2008-09, DGIGL, École Polytechnique Montréal, October 2008. Note: 18 pages. [Text ] Keyword(s): Understanding program comprehension.
    Abstract:
    Since their inception in 1994, design patterns have been the subject of many papers. In the reverse-engineering community, several authors have proposed approaches to consider design patterns during reverse- and re-engineering. However, it has been recently put forward in the community that it is difficult to compare previous approaches due to the diversity of vocabulary and the lack of a general framework to map and relate these approaches. Consequently, we study 59 papers related to design patterns in the software engineering community at large (1) to identify and define common terms related to design patterns, (2) to identify recurring themes in the papers, and (3) to further characterise approaches for design pattern detection along several categories. Recurring themes allow us to provide the portrait of the ``typical" paper on design patterns while catagories draw the portrait of the ``typical" approach in design pattern detection. We propose to the community to use a fix vocabulary, to diversify the approaches, and to build a common benchmark to assess the reverse engineering of design patterns.
    [bibtex-key = Denier08-TR-DPStateOfTheArt]

  15. Foutse Khomh and Yann-Gaël Guéhéneuc. An Empirical Study of Design Patterns and Software Quality. Technical report 1315, University of Montreal, january 2008. Note: 44 pages. [Text ] Keyword(s): Quality models, Design patterns.
    Abstract:
    We present an empirical study of the impact of design patterns on quality attributes in the context of software maintenance and evolution. Our first hypothesis verifies software engineering lore: design patterns impact software quality positively. We show that, contrary to popular beliefs, design patterns in practice impact negatively several quality attributes, thus providing concrete evidence against common lore. We then study design patterns and object-oriented best practices by formulating a second hypothesis on the impact of these principles on quality. We show that results for some design patterns cannot be explained and conclude on the need for further studies on the relation between design patterns and object-oriented best practices. Thus, we bring further evidence that design patterns should be used with caution during development because they may actually impede maintenance and evolution.
    [bibtex-key = Khomh08-TR-EmpStudyDPQuality]

  16. Naouel Moha and Yann-Gaël Guéhéneuc. Ptidej and DECOR: Identification of Design Patterns and Design Defects, February 2008. Note: SATToSE: Seminar on Advanced Tools and Techniques for Software Evolution, Waulsort, Belgium. [Text ] Keyword(s): Code and design smells, SATToSE.
    Abstract:
    Design defects come from poor design choices and have the effect of degrading the quality of object-oriented designs. Therefore, they present opportunities for improvements. However, design defects have not been precisely specified and there are few appropriate tools that allow their detection as well as their correction. Our goal is to provide a systematic method to specify systematically design defects precisely and to generate automatically detection and correction algorithms from their specifications. The detection algorithms are based not only on metrics but also on lexical and structural properties whereas the correction algorithms are based on refactorings. We apply and validate these algorithms on open-source object-oriented programs to show that our method allows a systematic specification, a precise detection, and a suitable correction of design defects.
    [bibtex-key = Moha08-Demo-SATToSE]


2007
  1. Denys Poshyvanyk, Yann-Gaël Guéhéneuc, Andrian Marcus, Giuliano Antoniol, and Václav Rajlich. Feature Location using Probabilistic Ranking of Methods based on Execution Scenarios and Information Retrieval. Transactions on Software Engineering (TSE), 33(6):420--432, June 2007. Note: 14 pages. [Text ] Keyword(s): Features and requirements, TSE.
    Abstract:
    This paper recasts the problem of feature location in source code as a decision-making problem in the presence of uncertainty. The solution to the problem is formulated as a combination of expert opinions. The experts in this case are represented by two existing techniques for feature location: Scenario-based Probabilistic Ranking of events and an Information Retrieval-based technique that uses Latent Semantic Indexing. The combination of these two methods is empirically evaluated through several case studies. The case studies use the source code of the Mozilla web browser and the Eclipse integrated development environment. The results show that the combined technique significantly improves the effectiveness of feature location when compared to each of the techniques used independently.
    [bibtex-key = Poshyvanyk07-TSE-Promesir]

  2. Giuliano Antoniol, Yann-Gaël Guéhéneuc, Ettore Merlo, and Paolo Tonella. Mining the Lexicon Used by Programmers during Software Evolution. In Ladan Tahvildari and Gerardo Canfora, editors, Proceedings of the 23rd International Conference on Software Maintenance (ICSM), pages 14--23, October 2007. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Identifier analysis, ICSM.
    Abstract:
    Identifiers represent an important source of information for programmers understanding and maintaining a system. Self-documenting identifiers reduce the time and effort necessary to obtain the level of understanding appropriate for the task at hand. While the role of the lexicon in program comprehension has long been recognized, only a few works have studied the quality and enhancement of the identifiers and no works have studied the evolution of the lexicon. In this paper, we characterize the evolution of program identifiers in terms of stability metrics and occurrences of renaming. We assess whether an evolution process similar to the one occurring for the program structure exists for identifiers. We report data and results about the evolution of three large systems, for which several releases are available. We have found evidence that the evolution of the lexicon is more limited and constrained than the evolution of the structure. We argue that the different evolution results from several factors including the lack of advanced tool support for lexicon construction, documentation, and evolution. Finally, we suggest the existence of rules on the co-evolution of structure and lexicon of software systems.
    [bibtex-key = Antoniol07-ICSM-LexiconEvolution]

  3. José Côté, Pilar Ramirez Garcia, Gaston Godin, and Yann-Gaël Guéhéneuc. Gérer sa médication antirétrovirale avec une assistance en ligne... une approche en cours d'évaluation. In Bernard Bégaud, Pavel Hamet, André Jacques, and Vittorio A. Sironi, editors, Actes du 2e Congrès international sur la chaîne des médicaments (CICM), Octobre 2007. Groupe d'étude sur l'interdisciplinarité et les représentations sociales. Keyword(s): VIHTAVIE, CICM. [bibtex-key = Cote07-CICM-GereMedicationAntiretrovirale]

  4. Yann-Gaël Guéhéneuc. PMARt: Pattern-like Micro Architecture Repository. In Michael Weiss, Aliaksandr Birukou, and Paolo Giorgini, editors, Proceedings of the 1st EuroPLoP Focus Group on Pattern Repositories (EPFPR), pages N/A, July 2007. N/A. Note: 3 pages. [Text ] Keyword(s): Design patterns, EPFPR.
    Abstract:
    We introduce PMARt{}, a repository of pattern-like micro-architetcures. The purpose of PMARt{} is to serve as baseline to assess the precision and recall of pattern identification tools. Indeed, several approaches have been proposed to identify occurrences of design patterns, yet few have been independently validated for precision and recall for lack of known occurrences. We hope that PMARt{} can be shared and enriched by researchers interested in design pattern identification.
    [bibtex-key = Gueheneuc07-EPFPR-PMARt]

  5. Yann-Gaël Guéhéneuc and Rabih Mustapha. A Simple Recommender System for Design Patterns. In Michael Weiss, Aliaksandr Birukou, and Paolo Giorgini, editors, Proceedings of the 1st EuroPLoP Focus Group on Pattern Repositories (EPFPR), pages N/A, July 2007. N/A. Note: 2 pages. [Text ] Keyword(s): Design patterns, EPFPR.
    Abstract:
    Since its introduction in computer science, the concept of pattern has flourished. Several conferences and workshops focus on writing and disseminating patterns. Consequently, a large number of patterns exist and it is sometimes difficult to find the right patterns and to choose among many candidate, when solving a given problem. In this paper, we introduce a simple recommender system to help user in choosing among the 23 design patterns from the GoF. We detail its implementation and discuss its application to other patterns.
    [bibtex-key = Gueheneuc07-EPFPR-Recommander]

  6. Foutse Khomh and Yann-Gaël Guéhéneuc. Perception and Reality: What are Design Patterns Good For?. In Fernando Brito e Abreu, Coral Calero, Yann-Gaël Guéhéneuc, Christian Lange, Michele Lanza, and Houari A. Sahraoui, editors, Proceedings of the 11th ECOOP workshop on Quantitative Approaches in Object-Oriented Software Engineering (QAOOSE), pages N/A, July--August 2007. Springer-Verlag. Note: 7 pages. [Text ] [Slides ] Keyword(s): Quality models, Design patterns, QAOOSE.
    Abstract:
    We present a study of the impact of design patterns on quality attributes. An empirical study is performed by asking respondents their evaluations of the impact of all design patterns on several quality attributes. We present detailed results for three design patterns (Abstract Factory, Composite, and Flyweight) and three quality attributes (reusability, understandability, and expendability). We perform a Null hypothesis test and we conclude that, contrary to popular beliefs, design patterns do not always improve reusability and understandability, but that they do improve expandability.
    [bibtex-key = Khomh07-QAOOSE-DPQuality]

  7. Naouel Moha, Yann-Gaël Guéhéneuc, Laurence Duchien, and Anne-Françoise Le Meur. Discussion on the Results of the Detection of Design Defects. In Serge Demeyer, Yann-Gaël Guéhéneuc, Christian Lange, Kim Mens, Roel Wuyts, and Stéphane Ducasse, editors, Proceedings of the 8th ECOOP workshop on Object-Oriented Reengineering (WOOR), pages N/A, July--August 2007. N/A. Note: 6 pages. [Text ] Keyword(s): Code and design smells, WOOR.
    Abstract:
    Software engineers often need to identify in their systems ``poor" design choices---design defects---that hinder the development and maintenance, as opportunities of improvements and as a measure of the quality of their systems. However, the detection of design defects is difficult because of the lack of specifications and tools. We propose DECOR, a method to specify design defects systematically and to generate automatically detection algorithms. With this method, software engineers analyse and specify design defects at a high-level of abstraction using a unified vocabulary and a dedicated language for generating detection algorithms. To illustrate our method, in this paper, we specify 4 well-known design defects, the antipatterns Blob, Functional Decomposition, Spaghetti Code, and Swiss Army Knife and their 15 underlying code smells and we generate automatically their detection algorithms. We apply and validate the detection algorithms in terms of precision and recall and discuss the precision of these algorithms on 11 open-source object-oriented systems.
    [bibtex-key = Moha07-WOOR-DesignDefects]

  8. Janice Ka-Yee Ng and Yann-Gaël Guéhéneuc. Identification of Behavioral and Creational Design Patterns through Dynamic Analysis. In Andy Zaidman, Abdelwahab Hamou-Lhadj, and Orla Greevy, editors, Proceedings of the 3rd International Workshop on Program Comprehension through Dynamic Analysis (PCODA), pages 34--42, October 2007. Delft University of Technology. Note: TUD-SERG-2007-022. 9 pages. [Text ] Keyword(s): Design patterns, PCODA.
    Abstract:
    Design patterns are considered to be a simple and elegant way to solve problems in object-oriented software systems, because their application leads to a well-structured object-oriented design, and hence, are considered to ease software comprehension and maintenance. However, due to the complexity of large object-oriented software systems nowadays, it is impossible to recover manually the design patterns applied during the design and implementation of a system, which, in turn, impedes its comprehension. In the past few years, the structure and organization among classes were the predominant means of identifying design patterns in object-oriented software systems. In this paper, we show how to describe behavioral and creational design patterns as collaborations among objects and how these representations allow the identification of behavioral and creational design patterns using dynamic analysis and constraint programming.
    [bibtex-key = KaYeeNg07-PCODA-DynamicDPDetection]

  9. Yann-Gaël Guéhéneuc. Design Pattern Identification in Ptidej, March 2007. Note: Tool demo at GRASCOMP Graduate School in Computing Science 2007 (COMP013). [Text ] Keyword(s): Design patterns, GRASCOMP.
    Abstract:
    The Ptidej (Pattern Trace Identification, Detection, and Enhancement in Java) project aims at developing a tool suite to evaluate and to enhance the quality of object-oriented programs, promoting the use of patterns, at language-, design-, or architectural-level.
    [bibtex-key = Gueheneuc07-Demo-GRASCOMP]

  10. Yann-Gaël Guéhéneuc. Ptidej - A Tool Suite, May 2007. Note: Tool demo at the 5th World's Best Technologies Showcase. [Text ] [Slides ] Keyword(s): Design patterns, Code and design smells, WBT Showcase.
    Abstract:
    The Ptidej (Pattern Trace Identification, Detection, and Enhancement in Java) project aims at developing a tool suite to evaluate and to enhance the quality of object-oriented programs, promoting the use of patterns, at language-, design-, or architectural-level.
    [bibtex-key = Gueheneuc07-Demo-WBTShowcase]

  11. Yann-Gaël Guéhéneuc. Ptidej: A Flexible Reverse Engineering Tool Suite, October 2007. Note: Tool demo at the 23rd International Conference on Software Maintenance. [Text ] [Slides ] Keyword(s): Design patterns, ICSM.
    Abstract:
    The Ptidej{} project started in 2001 to study the automated identification of design patterns. Since then, it has evolved into a complete reverse-engineering tool suite that includes several identification algorithms for idioms, micro-patterns, design patterns, and design defects (code smells and antipatterns). It is a flexible tool suite that attempts to ease as much as possible the development of new identification algorithms. In this demonstration, we first present the key features of the tool suite user interface and the various identification algorithms. We then discuss the architecture and design choices of the tool suite and lesson learned in developing a reverse-engineering environment.
    [bibtex-key = Gueheneuc07-Demo-ICSM]

  12. Naouel Moha and Yann-Gaël Guéhéneuc. Ptidej and DECOR: Identification of Design Patterns and Design Defects, October 2007. Note: Tool demo at the 21st International Conference on Object-Oriented Programming, Systems, Languages and Applications. [Text ] [Slides ] Keyword(s): Code and design smells, OOPSLA.
    Abstract:
    The Ptidej{} project started in 2001 to study code generation from and identification of patterns. Since then, it has evolved into a complete reverse-engineering tool suite that includes several identification algorithms. It is a flexible tool suite that attempts to ease as much as possible the development of new identification and analysis algorithms. Recently, the module DECOR{} has been added to Ptidej{} and allows the detection of design defects, which are recurring design problems. In this demonstration, we particularly focus on the creation and use of identification algorithms for design patterns and defects.
    [bibtex-key = Moha07-Demo-OOPSLA]

  13. Naouel Moha and Yann-Gaël Guéhéneuc. Ptidej and DECOR: Identification of Design Patterns and Design Defects, November 2007. Note: Tool demo at the 22nd International Conference on Automated Software Engineering. [Slides ] Keyword(s): Code and design smells, ASE.
    Abstract:
    The Ptidej{} project started in 2001 to study code generation from and identification of patterns. Since then, it has evolved into a complete reverse-engineering tool suite that includes several identification algorithms. It is a flexible tool suite that attempts to ease as much as possible the development of new identification and analysis algorithms. Recently, the module DECOR{} has been added to Ptidej{} and allows the detection of design defects, which are recurring design problems. In this demonstration, we particularly focus on the creation and use of identification algorithms for design patterns and defects.
    [bibtex-key = Moha07-Demo-ASE]


2006
  1. Yann-Gaël Guéhéneuc, Jean-Yves Guyomarc'h, Khashayar Khosravi, and Houari Sahraoui. Design Patterns as Laws of Quality, chapter 5, pages 105--142. Idea Group, January 2006. Note: 35 pages. [Text ] Keyword(s): Quality models, Design patterns, OODK.
    Abstract:
    This chapter is a complete coverage of our current work on software quality models and on design pattern identification. In this chapter, we explore the idea of facts in science in relation with software quality models. We show how design patterns can be used as facts to devise a quality model and we describe the processes of building and of applying such a quality model.
    [bibtex-key = Gueheneuc05-OODK-DesignPatternLaws]

  2. Giuliano Antoniol and Yann-Gaël Guéhéneuc. Feature Identification: An Epidemiological Metaphor. Transactions on Software Engineering (TSE), 32(9):627--641, September 2006. Note: 15 pages. [Text ] Keyword(s): Features and requirements, TSE.
    Abstract:
    Feature identification is a technique to identify the source code constructs activated when exercising one of the features of a program. We propose new statistical analyses of static and dynamic data to accurately identify features in large multi-threaded object-oriented programs. We draw an inspiration from epidemiology to improve previous approaches to feature identification and develop an epidemiological metaphor. We build our metaphor on our previous approach to feature identification, in which we use processor emulation, knowledge-based filtering, probabilistic ranking, and meta-modelling. We carry out three case studies to assess the usefulness of our metaphor, using the ``save a bookmark" feature of Web browsers as illustration. In the first case study, we compare our approach with three previous approaches (a naive approach, a concept analysis-based approach, and our previous probabilistic approach) in identifying the feature in \ygg@product{Mozilla}, a large, real-life, multi-threaded object-oriented program. In the second case study, we compare the implementation of the feature in the \ygg@product{Firefox} and \ygg@product{Mozilla} Web browsers. In the third case study, we identify the same feature in two more Web browsers, Chimera (in \C) and ICEBrowser (in Java), and another feature in \ygg@product{JHotDraw} and \ygg@product{Xfig}, to highlight the generalisability of our metaphor.
    [bibtex-key = Antoniol06-TSE-FeatureIdentification]

  3. Salah Bouktif, Yann-Gaël Guéhéneuc, and Giuliano Antoniol. Extracting Change-patterns from CVS Repositories. In Susan Elliott Sim and Massimiliano Di Penta, editors, Proceedings of the 13th Working Conference on Reverse Engineering (WCRE), pages 221--230, October 2006. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Evolution patterns, WCRE.
    Abstract:
    Often, the only sources of information about the evolution of software systems are the systems themselves and their histories. Version control repositories contain information on several thousand of files and on millions of changes. We propose an approach based on dynamic time warping to discover change-patterns, which, for example, describe files that change together almost all the time. We define the Synchrony change-pattern to answer the question: given a software system and one file under modification, what others files must be changed? We have applied our approach on PADL{}, a software system developed in Java, and on Mozilla. Interesting results are achieved even when the discovered groups of co-changing files are compared with these provided by experts.
    [bibtex-key = Bouktif06-WCRE-MiningCVS]

  4. José Côté, Pilar Ramirez Garcia, Yann-Gaël Guéhéneuc, Xintao Wang, and Gaston Godin. Web support for person living with HIV for the immediate management of the treatment. In Gaston Godin, Jean Guy Baril, and Jean Pierre Routy, editors, Proceedings of the 15th annual Canadian Conference on HIV/Aids Research (CAHR), May 2006. Pulsus Group. [Text ] Keyword(s): VIHTAVIE, CAHR.
    Abstract:
    Objective: Demonstration of a Web application designed to equip and support persons living with HIV for the immediate and direct management of their daily antiretorviral treatment. ewline Method: This Web application is based on a comprehensive analysis of the predictors of adherence identified in a longitudinal study, on information collected in the field, and on explanatory and predictive models of health behaviour. ewline Results: The program consists of interactive sessions which enable the individual to develop and consolidate skills necessary for handling taking their medication. These skills include self-motivation and self-observation (basic skills), identification and management of secondary effects (specific skills) and problem-solving, control of emotions and social skills (transferable skills). The sessions help the user gain a sense of self-sufficiency by integrating verbal encouragement and physiological response and generating a sense of being in control. Based on the 'tailoring' approach, these interventions are customized to the users, according to the characteristics of their therapy, secondary effects they feel, and the difficulties or obstacles they experience. The interactive system has been conceived in such a way that repeat applications and re-visits are possible, to suit the needs of the user. In effect, this Web application is like having a vocal 'virtual health professional', who behaves like a peer and acts as a model in providing support to the user for managing taking their medication. ewline Conclusion: This Web application is a interactive tool with a triple interface. It is responsive and flexible and is designed to adapt to needs of the individual user. We will carry out a randomized, controlled trial to evaluate its efficacy in optimizing adherence and influencing virological and immunological markers.
    [bibtex-key = Cote06-WebSupportVIH]

  5. Yann-Gaël Guéhéneuc. Taupe: Towards Understanding Program Comprehension. In Hakan Erdogmus and Eleni Stroulia, editors, Proceedings of the 16th IBM Centers for Advanced Studies Conference (CASCON), pages 1--13, October 2006. ACM Press. Note: 13 pages. [Text ] [Slides ] Keyword(s): Understanding program comprehension, CASCON.
    Abstract:
    Program comprehension is a very important activity during the development and the maintenance of programs. This activity has been actively studied in the past decades to present software engineers with the most accurate and---hopefully---most useful pieces of information on the organisation, algorithms, executions, evolution, and documentation of a program. Yet, only few work tried \emph{to understand concretely how software engineers obtain and use this information}. Software engineers mainly use \emph{sight} to obtain information about a program, usually from source code or class diagrams. Therefore, we use eye-tracking to collect data about the use of class diagrams by software engineers during program comprehension. We introduce a new visualisation technique to aggregate and to present the collected data. We also report the results and surprising insights gained from two case studies.
    [bibtex-key = Gueheneuc06-CASCON-Taupe]

  6. Yann-Gaël Guéhéneuc, Kim Mens, and Roel Wuyts. A Comparative Framework for Design Recovery Tools. In Giuseppe Antonio di Lucca and Nicolas Gold, editors, Proceedings of the 10th Conference on Software Maintenance and Reengineering (CSMR), pages 121--130, March 2006. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Design patterns, CSMR.
    Abstract:
    While many commercial and academic design recovery tools have been proposed over the years, assessing their relevance and comparing them is difficult due to the lack of a well-defined, comprehensive, and common framework. In this paper, we introduce such a common comparative framework. The framework builds upon our own experience and extends existing comparative frameworks. We illustrate the comparative framework on two specific design recovery tools.
    [bibtex-key = Gueheneuc06-CSMR-REToolsTaxonomy]

  7. Olivier Kaczor, Yann-Gaël Guéhéneuc, and Sylvie Hamel. Efficient Identification of Design Patterns with Bit-vector Algorithm. In Giuseppe Antonio di Lucca and Nicolas Gold, editors, Proceedings of the 10th Conference on Software Maintenance and Reengineering (CSMR), pages 173--182, March 2006. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Design patterns, CSMR.
    Abstract:
    Design patterns are important in software maintenance because they help in designing, in understanding, and in re-engineering programs. The identification of occurrences of a design pattern consists in identifying, in a program, classes which structure and organisation match---strictly or approximately---the structure and organisation of classes as suggested by the design pattern. We express the problem of design pattern identification with operations on finite sets of bit-vectors. We use the inherent parallelism of bit-wise operations to derive an efficient bit-vector algorithm that finds exact and approximate occurrences of design patterns in a program. We apply our algorithm on three small-to-medium size programs, \JHotDraw{}, \ygg@product{Juzzle}, and \ygg@product{QuickUML}, with the \ygg@pattern{Abstract Factory} and \ygg@pattern{Composite} design patterns and compare its performance and results with two existing constraint-based approaches.
    [bibtex-key = Kaczor06-CSMR-EfficientIdentification]

  8. Naouel Moha, Saliha Bouden, and Yann-Gaël Guéhéneuc. Correction of High-Level Design Defects with Refactorings. In Serge Demeyer, Stéphane Ducasse, Yann-Gaël Guéhéneuc, Kim Mens, and Roel Wuyts, editors, Proceedings of the 7th ECOOP workshop on Object-Oriented Reengineering (WOOR), pages N/A, July 2006. N/A. Note: 4 pages. [Text ] Keyword(s): Code and design smells, WOOR.
    Abstract:
    We define design defects as ``poor" design solutions that hinder the maintenance of programs. Thus, their detection and correction are important to improve the maintainability and reduce the cost of maintenance. The detection of design defects has been actively investigated by the community. However, their correction still remains a problem to solve. We propose a first method to correct these defects systematically using refactorings. Then, we introduce some challenges that our community must meet.
    [bibtex-key = Moha06-WOOR-Correction]

  9. Naouel Moha, Yann-Gaël Guéhéneuc, and Pierre Leduc. Automatic Generation of Detection Algorithms for Design Defects. In Sebastian Uchitel and Steve Easterbrook, editors, Proceedings of the 21st Conference on Automated Software Engineering (ASE), pages 297--300, September 2006. IEEE CS Press. Note: Short paper. 4 pages. [Text ] [Slides ] Keyword(s): Code and design smells, ASE.
    Abstract:
    Maintenance is recognised as the most difficult and expansive activity of the software development process. Numerous techniques and processes have been proposed to ease the maintenance of software. In particular, several authors published design defects formalising ``bad" solutions to recurring design problems (e.g., anti-patterns, code smells). We propose a language and a framework to express design defects synthetically and to generate detection algorithms automatically. We show that this language is sufficient to describe some design defects and to generate detection algorithms, which have a good precision. We validate the generated algorithms on several programs.
    [bibtex-key = Moha06-ASE-P-DDMethod]

  10. Naouel Moha, Duc-Loc Huynh, and Yann-Gaël Guéhéneuc. Une taxonomie et un métamodèle pour la détection des défauts de conception. In Roger Rousseau, editor, Actes du 12e colloque Langages et Modèles à Objets (LMO), pages 201--216, mars 2006. Hermès Science Publications. Note: 16 pages. [Text ] [Slides ] Keyword(s): Code and design smells, LMO.
    Abstract:
    Les d\'efauts de conception sont \`a rapprocher des patrons de conception qui sont aujourd'hui largement utilis\'es~: les patrons de conception proposent de ``bonnes'' solutions \`a des probl\`emes r\'ecurrents dans les architectures \`a objets, tandis que les d\'efauts de conception sont de ``mauvaises'' solutions. Cependant, contrairement aux patrons, les d\'efauts de conception n'ont pas de repr\'esentation pr\'ecise et structur\'ee et existent seulement sous la forme de descriptions textuelles sujettes \`a interpr\'etation, qui ne permettent pas leur d\'etection et leur correction pr\'ecise et efficace. Nous proposons une m\'ethodologie pour repr\'esenter les d\'efauts de conception bas\'ee sur un m\'etamod\`ele \`a partir d'une taxonomie des d\'efauts. Nous appliquons et validons cette m\'ethodologie sur un ensemble de d\'efauts de conception, tels le Blob et le Swiss Army Knife.
    [bibtex-key = Moha06-LMO-DefautConception]

  11. Naouel Moha, Jihene Rezgui, Yann-Gaël Guéhéneuc, Petko Valtchev, and Ghizlane El Boussaidi. Using FCA to Suggest Refactorings to Correct Design Defects. In Sadok Ben Yahia and Engelbert Mephu Nguifo, editors, Proceedings of the 4th International Conference on Concept Lattices and their Applications (CLA), pages 297--302, September 2006. IEEE CS Press. Note: Short paper. 6 pages. [Text ] [Slides ] Keyword(s): Code and design smells, CLA.
    Abstract:
    Design defects are poor design choices resulting in a hard-to- maintain software, hence their detection and correction are key steps of a disciplined software process aimed at yielding high-quality software artifacts. While modern structure- and metric-based techniques enable precise detection of design defects, the correction of the discovered defects, e.g., by means of refactorings, remains a manual, hence error-prone, activity. As many of the refactorings amount to re-distributing class members over a (possibly extended) set of classes, formal concept analysis (FCA) has been successfully applied in the past as a formal framework for refactoring exploration. Here we propose a novel approach for defect removal in object-oriented programs that combines the effectiveness of metrics with the theoretical strength of FCA. A case study of a specific defect, the extit{Blob}, drawn from the Azureus project illustrates our approach.
    [bibtex-key = Moha06-CLA-RefactoringSuggestion]

  12. Denys Poshyvanyk, Yann-Gaël Guéhéneuc, Andrian Marcus, Giuliano Antoniol, and Václav Rajlich. Combining Probabilistic Ranking and Latent Semantic Indexing for Feature Identification. In Jurgen Ebert and Panos Linos, editors, Proceedings of the 14th International Conference on Program Comprehension (ICPC), pages 137--148, June 2006. IEEE CS Press. Note: Best paper. 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, ICPC.
    Abstract:
    The paper recasts the problem of feature location in source code as a decision-making problem in the presence of uncertainty. The main contribution consists in the combination of two existing techniques for feature location in source code. Both techniques provide a set of ranked facts from the software, as result to the feature identification problem. One of the techniques is based on a Scenario Based Probabilistic ranking of events observed while executing a program under given scenarios. The other technique is defined as an information retrieval task, based on the Latent Semantic Indexing of the source code. We show the viability and effectiveness of the combined technique with two case studies. A first case study is a replication of feature identification in Mozilla, which allows us to directly compare the results with previously published data. The other case study is a bug location problem in Mozilla. The results show that the combined technique improves feature identification significantly with respect to each technique used independently.
    [bibtex-key = Poshyvanyk06-ICPC-LSIFeature]

  13. Yann-Gaël Guéhéneuc. Taupe, since June 2006. Note: A tool to edit, visualise, and analyse the data collected by eye-trackers during experiments. [Text ] Keyword(s): Understanding program comprehension. [bibtex-key = Taupe]

  14. Naouel Moha and Yann-Gaël Guéhéneuc. DECOR and Ptidej, October 2006. Note: Tool demo at the 16th IBM Centers for Advanced Studies Conference. [Text ] [Slides ] Keyword(s): Code and design smells, Design patterns, CASCON.
    Abstract:
    We demonstrate the use of the Decor method and Ptidej tool suite on real case studies to specify, detect, and correct design defects. Design defects are problems that slow down and increase the cost of programs, because they make program understanding and change difficult. Targeted audience includes academics and industrial software developers, managers, and quality-insurance people.
    [bibtex-key = Moha06-Demo-CASCON]


2005
  1. Serge Demeyer, Kim Mens, Roel Wuyts, Yann-Gaël Guéhéneuc, Andy Zaidman, Neil Walkinshaw, Ademar Aguiar, and Stéphane Ducasse, editors. Report of the 6th international Workshop on Object-Oriented Reengineering (WOOR), July 2005. Springer-Verlag. Note: 12 pages. [Text ] [bibtex-key = WOOR05]

  2. Giuliano Antoniol and Yann-Gaël Guéhéneuc. Feature Identification: A Novel Approach and a Case Study. In Tibor Gyimóthy and Vaclav Rajlich, editors, Proceedings of the 21st International Conference on Software Maintenance (ICSM), pages 357--366, September 2005. IEEE CS Press. Note: Best paper. 10 pages. [Text ] [Slides ] Keyword(s): Features and requirements, ICSM.
    Abstract:
    Feature identification is a well-known technique to identify subsets of a program source code activated when exercising a functionality. Several approaches have been proposed to identify features. We present an approach to feature identification and comparison for large object-oriented multi-threaded programs using both static and dynamic data. We use processor emulation, knowledge filtering, and probabilistic ranking to overcome the difficulties of collecting dynamic data, i.e., imprecision and noise. We use model transformations to compare and to visualise identified features. We compare our approach with a naive approach and a concept analysis-based approach using a case study on a real-life large object-oriented multi-threaded program, \ygg@product{Mozilla}, to show the advantages of our approach. We also use the case study to compare processor emulation with statistical profiling.
    [bibtex-key = Antoniol05-ICSM-FeatureIdentification]

  3. Giuliano Antoniol, Yann-Gaël Guéhéneuc, Ettore Merlo, and Houari Sahraoui. Software Evolution: The Need for Empirical Evidence. In Paolo Tonella, editor, Proceedings of the 1st ICSM workshop on Empirical Studies in Reverse Engineering (WESRE), pages N/A, September 2005. IEEE CS Press. Note: 2 pages. [Text ] Keyword(s): Evolution patterns, WESRE.
    Abstract:
    An intrinsic property of software is its malleability, the fact that it may change and evolve. Software evolution is costly, because software systems tend to be highly complex and large. They are highly human intensive and risky, because unplanned and undisciplined changes in any software system of realistic size risk degrading software quality and may produce unwanted and unexpected side effects. As a software system is enhanced, modified, and adapted to new requirements, its code becomes increasingly complex, often drifting away from its original design. The current state-of-the-art in software evolution offers only short-term solutions to software change and evolution focused on software maintenance and defect repair, in which only the source code evolves, while the architecture, design, and---more generally---the documentation are not updated.
    [bibtex-key = Antoniol05-WESRE-NeedEmpiricalEvidence]

  4. Giuliano Antoniol, Ettore Merlo, Yann-Gaël Guéhéneuc, and Houari Sahraoui. Feature Traceability in Object Oriented Software. In Jonathan I. Maletic, Giuliano Antonio, Jane Cleland-Huang, and Jane Huffman Hayes, editors, Proceedings of the 3rd ASE workshop on Traceability in Emerging Forms of Software Engineering (TEFSE), pages 73--78, November 2005. ACM Press. Note: 6 pages. [Text ] [Slides ] Keyword(s): Features and requirements, TEFSE.
    Abstract:
    Open source and industrial software very often lack up-to- date documentation on where and how user observable functionalities are implemented. This lack of documentation is particularly hindering for large software. Moreover, as with any software artifacts, user observable functionalities evolve and are modified through software evolution activities. Modifications of one functionality sometimes has unwanted and unexpected side effects on other functionalities, causing these functionalities to fail or to malfunction. In this position paper, we support the idea that a traceability mapping between user observable functionalities and source code constituents (such as classes, methods\ldots) implementing the functionalities is essential to reduce software evolution effort. We outline an approach to recover and to study the evolution of features---subset of a software constituents---responsible to implement a functionality.
    [bibtex-key = Antoniol05-TEFSE-FeatureTraceability]

  5. Jean-Yves Guyomarc'h and Yann-Gaël Guéhéneuc. On the Impact of Aspect-Oriented Programming on Object-Oriented Metrics. In Fernando Brito e Abreu, Coral Calero, Michele Lanza, Geert Poels, and Houari A. Sahraoui, editors, Proceedings of the 9th ECOOP workshop on Quantitative Approaches in Object-Oriented Software Engineering (QAOOSE), pages 42--47, July 2005. Springer-Verlag. Note: 6 pages. [Text ] [Slides ] Keyword(s): Quality models, QAOOSE.
    Abstract:
    Aspect-oriented programming is a new paradigm designed to fulfill the limitations of object-oriented programming regarding separation of concerns. The advent of a new paradigm requires software engineers to define new metrics and quality models to measure the quality of programs in this paradigm. The close relationship of aspect-oriented programming and object-oriented languages drives us to wonder about the impact of this new paradigm over object-oriented languages, and especially over object metrics. In this position paper, we attempt to present an approach to study and to understand the impact of aspect-oriented programming on object-oriented metrics.
    [bibtex-key = Guyomarch05-QAOOSE-AspectQuality]

  6. Yann-Gaël Guéhéneuc. Ptidej: Promoting Patterns with Patterns. In Mohamed E. Fayad, editor, Proceedings of the 1st ECOOP workshop on Building a System using Patterns (BSUP), pages N/A, July 2005. Springer-Verlag. Note: 9 pages. [Text ] [Slides ] Keyword(s): Design patterns, BSUP.
    Abstract:
    We introduce the Ptidej{} project and its tool suite to evaluate and to enhance software quality by promoting patterns. First, we summarise the components of the tool suite and describe its implementation in Java, which uses several architectural, design, and language patterns. Then, we take position on issues related to pattern claims, choices, uses, and limits from our experience with pattern definition, formalisation, use for reverse-engineering and for implementation.
    [bibtex-key = Gueheneuc05-BSUP-Ptidej]

  7. Yann-Gaël Guéhéneuc, Stefan Monnier, and Giuliano Antoniol. Evaluating the Use of Design Patterns during Program Comprehension -- Experimental Setting. In Giuliano Antoniol and Yann-Gaël Guéhéneuc, editors, Proceedings of the 1st ICSM workshop in Design Pattern Theory and Practice (IWDPTP), pages N/A, September 2005. IEEE CS Press. Note: In the pre-proceedings. 6 pages. [Text ] Keyword(s): Understanding program comprehension, IWDPTP.
    Abstract:
    Many claims exist in the literature on the usefulness of design patterns for program comprehension. However, no experimental studies exist to confirm or to infirm these claims, partially due to the lack of appropriate techniques to define and to assess the benefits of design patterns. We present an experimental setting, based on eye-tracking techniques, to assess the benefits of design patterns during program comprehension and a first illustrative experiment. This experimental setting and experiment are but a first step towards a comprehensive understanding of the use of design patterns during program comprehension.
    [bibtex-key = Gueheneuc05-IWDPTP-ExperimentalSetting]

  8. Yann-Gaël Guéhéneuc and Houari Sahraoui. Des signatures numériques pour améliorer la recherche structurelle de patrons. In Marianne Huchard, Stéphane Ducasse, and Oscar Nierstrasz, editors, Actes du 11e colloque Langages et Modèles à Objets (LMO), pages 97--112, mars 2005. Hermès Science Publications. Note: 16 pages. [Text ] [Slides ] Keyword(s): Design patterns, LMO.
    Abstract:
    Les patrons de conception orient\'es-objets d\'ecrivent de bonnes solutions \`a des probl\`emes r\'ecurrents de conception des programmes. Les solutions propos\'ees sont des motifs de conception que les concepteurs introduisent dans l'architecture de leurs programmes. Il est important d'identifier, pendant la maintenance, les motifs de conception utilis\'es dans l'architecture d'un programme pour comprendre les probl\`emes de conception r\'esolus et faire des modifications pertinentes au programme. L'identification de micro-architectures similaires \`a des motifs de conception est difficile \`a cause du large espace de recherche, \ie{} les nombreuses combinaisons de classes possibles. Nous proposons une \'etude exp\'erimentale des classes jouant un r\^ole dans des motifs de conception avec des m\'etriques et un algorithme d'apprentissage pour associer des signatures num\'eriques aux r\^oles dans les motifs de conception. Une signature num\'erique est un ensemble de valeurs de m\'etriques qui caract\'erise les classes jouant un r\^ole dans un motif de conception. Nous montrons que les signatures num\'eriques permettent de r\'eduire efficacement l'espace de recherche des micro-architectures similaires \`a des motifs de conception sur l'exemple du patron de conception Composite et du programme \JHotDraw.
    [bibtex-key = Gueheneuc05-LMO-SignaturesNumeriques]

  9. Yann-Gaël Guéhéneuc and Tewfik Ziadi. Automated Reverse-Engineering of UML v2.0 Dynamic Models. In Serge Demeyer, Stéphane Ducasse, Kim Mens, and Roel Wuyts, editors, Proceedings of the 6th ECOOP workshop on Object-Oriented Reengineering (WOOR), pages N/A, July 2005. N/A. Note: 5 pages. [Text ] Keyword(s): Design patterns, WOOR.
    Abstract:
    In this position paper, we advocate the automated reverse-engineering of UML{} v2.0 dynamic models, \ie{} sequence diagrams and statecharts, to perform high-level analyses, such as conformance checking and pattern identification. Several approaches exist to reverse-engineer UML dynamic models; However, to our best knowledge, none of these approaches consider reverse-engineering UML v2.0 dynamic models and performing high-level analyses with these models. We present our approach to UML v2.0 dynamic models reverse-engineering and sketch some use of these models. We conclude by a discussion on some issues related to the models, their reverse-engineering, and their use.
    [bibtex-key = Gueheneuc05-WOOR-SequenceDiagrams]

  10. Khashayar Khosravi and Yann-Gaël Guéhéneuc. Open Issues with Quality Models. In Fernando Brito e Abreu, Coral Calero, Michele Lanza, Geert Poels, and Houari A. Sahraoui, editors, Proceedings of the 9th ECOOP workshop on Quantitative Approaches in Object-Oriented Software Engineering (QAOOSE), pages N/A, July 2005. Springer-Verlag. Note: 14 pages. [Text ] [Slides ] Keyword(s): Quality models, Design patterns, QAOOSE.
    Abstract:
    Software metrics and quality models play a pivotal role in measurement of software quality. A number of well-known quality models and software metrics are used to build quality software both in industry and in academia. However, during our research on measuring software quality using design patterns, we faced many issues related to existing software metrics and quality models. In this position paper, we discuss some of these issues and present our approach to software quality assessment.
    [bibtex-key = Khosravi05-QAOOSE-QualityIssues]

  11. Naouel Moha and Yann-Gaël Guéhéneuc. On the Automatic Detection and Correction of Design Defects. In Serge Demeyer, Kim Mens, Roel Wuyts, and Stéphane Ducasse, editors, Proceedings of the 6th ECOOP workshop on Object-Oriented Reengineering (WOOR), pages N/A, July 2005. N/A. Note: 7 pages. [Text ] [Slides ] Keyword(s): Code and design smells, WOOR.
    Abstract:
    Design defects, antipatterns, code smells are software defects at the architectural level that must be detected and corrected to improve software quality. Automatic detection and correction of these software architectural defects, which suffer of a lack of tools, are important to ease the maintenance of objectoriented architectures and thus to reduce the cost of maintenance. A clear understanding of the different types of software architectural defects defects and a classification of these defects is necessary before proposing any techniques related to their detection or correction. We introduce a first classification and summarise existing techniques. Then, we introduce some challenges that our community must meet.
    [bibtex-key = Moha05-WOOR-DesignDefects]

  12. Yann-Gaël Guéhéneuc. A Theory of Program Comprehension -- Joining Vision Science and Program Comprehension. Technical report 1267, University of Montreal, December 2005. Note: 26 pages. [Text ] Keyword(s): Understanding program comprehension.
    Abstract:
    There exists an extensive literature on vision science, on the one hand, and on program comprehension, on the other hand. However, these two domains of research have been so far rather disjoint. Indeed, several cognitive theories have been proposed to explain program comprehension. These theories explain the processes taking place in the software engineers' minds when they understand programs. They explain how software engineers \emph{process} available information to perform their tasks but not how software engineers \emph{acquire} this information. Vision science provides explanations on the processes used by people to acquire visual information from their environment. Joining vision science and program comprehension provides a more comprehensive theoretical framework to explain facts on program comprehension, to predict new facts, and to frame experiments. We join theories in vision science and in program comprehension; the resulting theory is consistent with facts on program comprehension and helps in predicting new facts, in devising experiments, and in putting certain program comprehension concepts in perspective.
    [bibtex-key = Gueheneuc05-TR-VisionComprehension]

  13. Yann-Gaël Guéhéneuc, Jean-Yves Guyomarc'h, Duc-Loc Huynh, Olivier Kaczor, Naouel Moha, and Samah Rached. Ptidej - A Tool Suite, October 2005. Note: Tool demo at the 15th IBM Centers for Advanced Studies Conference. [Text ] [Slides ] Keyword(s): Design patterns, CASCON.
    Abstract:
    The Ptidej (Pattern Trace Identification, Detection, and Enhancement in Java) project aims at developing a tool suite to evaluate and to enhance the quality of object-oriented programs, promoting the use of patterns, at language-, design-, or architectural-level.
    [bibtex-key = Gueheneuc05-Demo-CASCON]


2004
  1. Yann-Gaël Guéhéneuc. A Reverse Engineering Tool for Precise Class Diagrams. In Janice Singer and Hanan Lutfiyya, editors, Proceedings of the 14th IBM Centers for Advanced Studies Conference (CASCON), pages 28--41, October 2004. ACM Press. Note: 14 pages. [Text ] [Slides ] Keyword(s): Binary class relations, CASCON.
    Abstract:
    Developers use class diagrams to des\-cribe the architecture of their programs intensively. Class diagrams represent the structure and global behaviour of programs. They show the programs classes and interfaces and their relationships of inheritance, instantiation, use, association, aggregation and composition. Class diagrams could provide useful data during programs maintenance. However, they often are obsolete and imprecise: They do not reflect the \emph{real} implementation and behaviour of programs. We propose a reverse-engineering tool suite, Ptidej{}, to build precise class diagrams from Java{} programs, with respect to their implementation and behaviour. We describe static and dynamic models of Java{} programs and algorithms to analyse these models and to build class diagrams. In particular, we detail algorithms to infer use, association, aggregation, and composition relationships, because these relationships do not have precise definitions. We show that class diagrams obtained semi-automatically are similar to those obtained manually and more precise than those provided usually.
    [bibtex-key = Gueheneuc04-CASCON-PreciseClassDiagrams]

  2. Yann-Gaël Guéhéneuc. A Systematic Study of UML Class Diagram Constituents for their Abstract and Precise Recovery. In Doo-Hwan Bae and William C. Chu, editors, Proceedings of the 11th Asia-Pacific Software Engineering Conference (APSEC), pages 265--274, November-December 2004. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Binary class relations, APSEC.
    Abstract:
    Existing reverse-engineering tools use algorithms based on vague and verbose definitions of UML{} constituents to recover class diagrams from source code. Thus, reverse-engineered class diagrams are neither abstract nor precise representations of source code and are of little interest for software engineers. We propose a exhaustive study of class diagram constituents with respect to their recovery from \Cpp{}, Java{}, and \Smalltalk{} source code. Finally, we suggest a road-map to abstract and precise reverse-engineering. We exemplify our study by developing a tool to reverse-engineer Java{} programs in UML{} class diagrams abstractly and precisely. Such a reverse-engineering tool produces class diagrams that help software engineers in better understanding programs.
    [bibtex-key = Gueheneuc04-APSEC-SystematicUML]

  3. Yann-Gaël Guéhéneuc. Abstract and Precise Recovery of UML Class Diagram Constituents. In Mark Harman and Bogdan Korel, editors, Proceedings of the 20th International Conference and Software Maintenance (ICSM), pages 523, September 2004. IEEE CS Press. Note: Poster. 1 page. [Text ] Keyword(s): Binary class relations, ICSM.
    Abstract:
    Existing reverse-engineering tools use algorithms based on vague and verbose definitions of UML{} constituents to recover class diagrams from source code. Thus, reverse-engineered class diagrams are neither abstract nor precise representations of source code and are of little interest for software engineers. We propose a exhaustive study of class diagrams constituents with respect to their recovery from \Cpp{}, Java{}, and \Smalltalk{} source code. Finally, we suggest a road-map to abstract and precise reverse-engineering.
    [bibtex-key = Gueheneuc04-ICSM-P-UMLRecovery]

  4. Yann-Gaël Guéhéneuc and Hervé Albin-Amiot. Recovering Binary Class Relationships: Putting Icing on the UML Cake. In Doug C. Schmidt, editor, Proceedings of the 19th Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 301--314, October 2004. ACM Press. Note: 14 pages. [Text ] [Slides ] Keyword(s): Binary class relations, OOPSLA.
    Abstract:
    A discontinuity exists between object-oriented modeling and programming languages. This discontinuity arises from ambiguous concepts in modeling languages and a lack of corresponding concepts in programming languages. It is particularly acute for binary class relation\-ships---association, aggregation, and composition. It hinders the traceability between software implementation and design, thus hampering software analysis. We propose consensual definitions of the binary class relationships with four minimal properties---exclusivity, invocation site, lifetime, multiplicity. We describe algorithms to detect automatically the properties in source code and apply these on several frameworks. Thus, we bridge the gap between implementation and design for the binary class relationships, easing software analysis.
    [bibtex-key = Gueheneuc04-OOPSLA-RecoveringBCR]

  5. Yann-Gaël Guéhéneuc, Houari Sahraoui, and Farouk Zaidi. Fingerprinting Design Patterns. In Eleni Stroulia and Andrea de Lucia, editors, Proceedings of the 11th Working Conference on Reverse Engineering (WCRE), pages 172--181, November 2004. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Design patterns, WCRE.
    Abstract:
    Design patterns describe \emph{good} solutions to common and recurring problems in program design. The solutions are \emph{design motifs} which software engineers imitate and introduce in the architecture of their program. It is important to identify the design motifs used in a program architecture to understand solved design problems and to make informed changes to the program. The identification of \emph{micro-architectures} similar to design motifs is difficult because of the large search space, \ie{} the many possible combinations of classes. We propose an experimental study of classes playing roles in design motifs using metrics and a machine learning algorithm to \emph{fingerprint} design motifs roles. Fingerprints are sets of metric values characterising classes playing a given role. We devise fingerprints experimentally using a repository of micro-architectures similar to design motifs. We show that fingerprints help in reducing the search space of micro-architectures similar to design motifs efficiently using the \ygg@pattern{Composite} design motif and the \JHotDraw{} framework.
    [bibtex-key = Gueheneuc04-WCRE-ClassFingerprinting]

  6. Khashayar Khosravi and Yann-Gaël Guéhéneuc. A Quality Model for Design Patterns. Technical report 1249, University of Montreal, September 2004. Note: 94 pages. [Text ] Keyword(s): Quality models, Design patterns.
    Abstract:
    Design patterns are high level building blocks that are claimed to promote elegance in object-oriented programs by increasing flexibility, scalability, usability, reusability, and robustness. However, there is some evidence that design patterns do not intrinsically promote quality. We believe that the problem of quality with design patterns comes both from the design patterns themselves and from their misuse. Unfortunately, little work has attempted so far to study the quality characteristics of design patterns rigorously. The objective of this technical report is to introduce a quality model and metrics that help in assessing the quality characteristics of design patterns and in concluding on design patterns quality. We begin with a summary of definitions on quality and related concepts and by introducing the most common and standard quality models. Then, we define characteristics of the models in details and present the metrics used to measure programs. Some of the most common characteristics of quality models introduced are used to develop a quality model to assess and measure the quality characteristics that design patterns claim to possess.
    [bibtex-key = Khosravi04-TR-DPQualityModel]

  7. Yann-Gaël Guéhéneuc. PMARt, since November 2004. Note: A database of occurrences of patterns in object-oriented programs. [Text ] Keyword(s): Design patterns. [bibtex-key = PMARt]


2003
  1. Yann-Gaël Guéhéneuc. Un cadre pour la traçabilité des motifs de conception. PhD thesis, École des Mines de Nantes et Université de Nantes, juin 2003. Note: 350 pages. [Text ] Keyword(s): Design patterns, Binary class relations.
    Abstract:
    Les patrons de conception sont importants en g\'enie logiciel \`a objets car ils contribuent \`a la qualit\'e des programmes. Ils proposent des solutions \'el\'egantes \`a des probl\`emes r\'ecurrents de conception, des motifs utilis\'es pendant l'implan\-tation. \`A~l'usage, ces motifs de conception sont diss\'emin\'es dans le code source et ne sont plus explicites lors de la maintenance~; pourtant, ils aideraient \`a comprendre l'implantation et la conception des programmes, assurant leur qualit\'e. Ce m\'emoire propose des mod\`eles et des algorithmes pour garantir la tra\c cabilit\'e des motifs de conception entre les phases d'implantation et de r\'etroconception des programmes par l'identification semi-automatique des micro-architectures similaires \`a ces motifs dans le code source. La m\'etamod\'elisation est utilis\'ee pour d\'ecrire les motifs de conception et les programmes Java{}. Elle am\`ene \`a expliciter certaines relations interclasses (association, agr\'e\-gation et composition) offertes par les langages de conception comme UML{} et \`a pr\'eciser leurs propri\'et\'es (dur\'ee de vie, exclusivit\'e, multiplicit\'e et site d'invocation) pour les identifier avec des algorithmes d'analyses statiques et dynamiques. Elle conduit aussi \`a traduire les motifs en syst\`emes de contraintes et \`a identifier les micro-architectures similaires, formes compl\`etes et approch\'ees, par la r\'esolution de probl\`emes de satisfaction de contraintes. La programmation par contraintes avec explications permet de guider la r\'esolution et d'expliquer les micro-architectures identifi\'ees. La suite d'outils Ptidej{} est une implantation des mod\`eles et des algorithmes propos\'es. Elle est int\'egr\'ee \`a l'environnement \Eclipse{} de d\'eveloppement en Java{}. Elle inclut le m\'etamod\`ele PADL{}, d\'eriv\'e du m\'etamod\`ele \PDL{}~; des outils d'analyses statiques et dynamiques, \Introspector{} et Caffeine{}~; et un solveur de contraintes, PtidejSolver{}, d\'eriv\'e du solveur de contraintes avec explications de r\'ef\'erence \PaLM{}.
    [bibtex-key = Gueheneuc03-PhD]

  2. Andrés Farìas and Yann-Gaël Guéhéneuc. On the Coherence of Component Protocols. Electronic Notes in Theoretical Computer Science (ENTCS), 82(5):42--53, April 2003. Note: 12 pages. [Text ] Keyword(s): ENTCS.
    Abstract:
    Component-based programming promises to ease the construction of large-scale applications. The construction of applications using components relies on the notion of interfaces. However, the notion of interfaces provided by current component models is restricted: In particular, it does not include behavioral information to define the protocols of the components: Sequences of service requests. The lack of behavioral information limits our trust in components: Security, reuse, and quality relate directly on this missing information. In this paper, we consider the problem of verifying if a component implementation respects the protocol specified during its design. First, we define a notion of coherence between protocols and an algorithm to verify the coherence between two protocols. Then, we describe an algorithm to extract the protocol of a component from its source code. Finally, we present a tool that enables the static verification and enforcement of the notion of coherence.
    [bibtex-key = Farias03-ENTCS-CoherenceProtocols]

  3. Yann-Gaël Guéhéneuc and Hervé Albin-Amiot. A Pragmatic Study of Binary Class Relationships. In John Grundy and John Penix, editors, Proceedings of the 18th Conference on Automated Software Engineering (ASE), pages 277--280, September 2003. IEEE CS Press. Note: Short paper. 4 pages. [Text ] [Slides ] Keyword(s): Binary class relations, ASE.
    Abstract:
    A discontinuity exists between modeling and object-oriented programming languages. This discontinuity is a consequence of ambiguous notions in modeling languages and lack of corresponding notions in object-oriented programming languages. It hinders the transition between software implementation and design and hampers software maintenance. This discontinuity is particularly acute for binary class relationships, such as the association, aggregation, and composition relationships. We present a solution to bridge the discontinuity between implementation and design for the binary class relationships: We propose consensual definitions of the binary class relationships in terms of four properties (exclusivity, invocation site, lifetime, multiplicity). We describe algorithms to detect these properties in Java{} source code.
    [bibtex-key = Gueheneuc03-ASE-P-AAC]

  4. Yann-Gaël Guéhéneuc, Hervé Albin-Amiot, and Pierre Cointe. PatternsBox--Ptidej, intégration de deux outils de conception et de rétro-conception à Eclipse. In Jacques Malenfant, editor, Journée GDR ALP-OCM, pages N/A, février 2003. N/A. Note: 6 pages. [Text ] [Slides ] Keyword(s): Design patterns, GDR ALP-OCM.
    Abstract:
    Nous nous int{\'e}ressons aux phases de conception et de maintenance de programmes {\`a} objets. Nous pensons que l'utilisation des motifs (tels les motifs de conception de~\cite{GoF94-Patterns}) facilite, d'une part, la conception et la documentation~\cite{AlbinAmiot03-PhD} et, d'autre part, la compr{\'e}hension et l'am{\'e}lioration~\cite{Gueheneuc03-PhD} de ces programmes. Nous avons d{\'e}velopp{\'e} {\`a} l'occasion de nos travaux de th{\`e}se de doctorat, \PatternsBox{}~\cite{AlbinAmiot03-PhD} et Ptidej{}~\cite{Gueheneuc03-PhD}, deux outils de conception et de maintenance bas{\'e}s sur les motifs. \PatternsBox{} permet (i) d'appliquer les solutions recommand{\'e}es par un ensemble de motifs de conception et (ii) d'identifier dans l'architecture d'un programme {\`a} objets les solutions compl{\`e}tes correspondant {\`a} des motifs donn{\'e}s. Ptidej{} permet (i) d'identifier des solutions {\`a} des motifs donn{\'e}s et leurs variantes et~(ii) d'identifier des d{\'e}fauts de conception dans l'architecture du programme. Ces deux outils pr{\'e}sentent un int{\'e}r{\^e}t pour les d{\'e}veloppeurs essentiellement lorsqu'ils sont int{\'e}gr{\'e}s avec les outils utilis{\'e}s habituellement pendant les phases de conception et de maintenance. C'est pourquoi nous les avons int{\'e}gr{\'e}s {\`a} des environnements de d{\'e}veloppements int{\'e}gr{\'e}s (EDI). Dans cet article, et apr{\`e}s avoir pr{\'e}sent{\'e} l'EDI d'\ygg@company{OTI~/ IBM} \Eclipse{}~\cite{OTI01-Eclipse}, nous d{\'e}crivons notre premi{\`e}re exp{\'e}rience relative {\`a} l'int{\'e}\-gration de Ptidej{} avec \Eclipse{}, puis nos projets quant {\`a} l'int{\'e}gration de \PatternsBox{}.
    [bibtex-key = Gueheneuc03-GDRALPOCM-PtidejEclipse]

  5. Aline Lúcia Baroni, Yann-Gaël Guéhéneuc, and Hervé Albin-Amiot. Design Patterns Formalization. Technical report 03/03/INFO, Computer Science Department, École des Mines de Nantes, June 2003. Note: 59 pages. [Text ] Keyword(s): Design patterns.
    Abstract:
    Design patterns were introduced in software engineering as an effective mean of disseminating solutions to problems repeatedly encountered in object oriented programming and since their emergence, they have been widely accepted and adopted by software practitioners. Design patterns contribution covers the definition, the design and the documentation of class libraries and frameworks, offering elegant and reusable solutions to design problems, and consequently increasing productivity and development quality. Each design pattern lets some aspects of the system structure vary independently of other aspects, thereby making the system more robust to a particular kind of change. The majority of publications in the pattern field focuses on micro-architectures; i.e., intentionally abstract description of generic aspects of software systems. Despite this abstractness, the academic community recognizes that a better understanding of design patterns by means of systematic investigation is essential. Reflective tasks in this direction include comparative analyses of design patterns, proposals for precise means of specification, attempts for tools, analysis of relationships among patterns, and other discussions. However, few works offer methods of precise specification of design patterns, resulting in lack of formalism. In this sense, patterns remain empirical and manually applied. According to, manual application is tedious and error prone. Precise specification can improve the application of design patterns as well as the analysis of relationships among them and tools in support of their application. Very little progress has been made towards better understanding of the micro-architectures dictated by design patterns. This report tries to capture the ''essence'' of patterns, showing the importance of researches able to illuminate how design patterns are essentially structured.
    [bibtex-key = Baroni03-TR-DPFormalization]


2002
  1. Hervé Albin-Amiot, Pierre Cointe, and Yann-Gaël Guéhéneuc. Un méta-modèle pour coupler application et détection des design patterns. In Anne-Marie Kempf, editor, Journée sur le projet COM, pages N/A, février 2002. N/A. Note: 17 pages. [Text ] [Slides ] Keyword(s): Design patterns, JCOM.
    Abstract:
    Am{\'e}liorer la qualit{\'e}des d{\'e}veloppements par objets en favorisant l'utilisation des design patternspour aider {\`a} iImpl{\'e}menter ; comprendre ; documenter.
    [bibtex-key = AlbinAmiot02-JCOM-Couple]

  2. Hervé Albin-Amiot, Pierre Cointe, and Yann-Gaël Guéhéneuc. Un méta-modèle pour coupler application et détection des design patterns. In Michel Dao and Marianne Huchard, editors, Actes du 8e colloque Langages et Modèles à Objets (LMO), volume 8, numéro 1-2/2002 of RSTI -- L'objet, pages 41--58, janvier 2002. Hermès Science Publications. Note: 18 pages. [Text ] [Slides ] Keyword(s): Design patterns, LMO.
    Abstract:
    Les design patterns (ou patrons de conception) sont reconnus comme une des bonnes techniques du g\'enie logiciel \`a objets. Cette technique am\'eliore le cycle de vie du logiciel en facilitant la conception, la documentation, la maintenance et la r\'etro-conception. Peu d'environnements de d\'eveloppement int\'egr\'es (EDIs) sont \`a la fois outill\'es pour inciter l'utilisateur \`a appliquer un catalogue de patterns et pour l'aider \`a am\'eliorer ses programmes en y extrayant automatiquement des micro-architectures correspondant \`a celles de patterns. Ce papier pr\'esente une partie de nos travaux visant \`a outiller l'EDI Visual Age pour Java en lui adjoignant un catalogue recensant l'ensemble des patterns du GoF et deux assistants d\'edi\'es \`a l'application et \`a la d\'etection de patterns. Nous proposons un m\'eta-mod\`ele permettant de d\'ecrire ces diff\'erents patterns, de les manipuler, de les synth\'etiser et de les reconna\^{\i}tre dans des programmes existants. Nous discutons les limites de ce m\'eta-mod\`ele apparues apr\`es exp\'erimentation et sugg\'erons comment l'am\'eliorer pour prendre en charge l'aspect intentionnel des patterns et supporter la reconnaissance de micro-architectures voisines de celles de patterns d\'ej\`a r\'epertori\'es.
    [bibtex-key = AlbinAmiot02-LMO-MetaModele]

  3. Andrés Farìas, Yann-Gaël Guéhéneuc, and Mario Südholt. Integrating Behavioral Protocols in Enterprise Java Beans. In Kenneth Baclawski and Haim Kilov, editors, Proceedings of the 11th OOPSLA workshop on Behavioral Semantics: Serving the Customer (Behavioural Semantics), pages 80--89, October 2002. College of Computer Science, Northeastern University. Note: 10 pages. [Text ] [Slides ] Keyword(s): Behavioural Semantics.
    Abstract:
    Behavioral protocols have been proposed to enhance component-based systems by including sequencing constraints on component interactions in component interfaces. However, no existing component-based models provide support for behavioral protocols. In this paper, we discuss the integration of behavioral protocol in Sun's Enterprise JavaBeans (EJB) component model in three steps. First, we introduce the notion of coherence between behavioral protocols and component source code. Second, we discuss of the relations of behavioral protocols to the different interface-related concepts in EJB components (remote interface, deployment descriptor...). Third, we describe possibilities of automatic enforcement of behavioral protocols by means of automated extraction of protocols from components and verification of the notion of coherence against expected behavioral protocols.
    [bibtex-key = Farias02-WBS-ProtocolsEJB]

  4. Yann-Gaël Guéhéneuc. Three Musketeers to the Rescue -- Meta-Modelling, Logic Programming, and Explanation-based Constraint Programming for Pattern Description and Detection. In Kris De Volder, Kim Mens, Tom Mens, and Roel Wuyts, editors, Proceedings of the 1st ASE workshop on Declarative Meta-Prorgramming (WDMP), pages N/A, September 2002. Computer Science Department, University of British Columbia. Note: 8 pages. [Text ] [Slides ] Keyword(s): Design patterns, WDMP.
    Abstract:
    Software maintenance is a costly and tedious phase in the software development process Woods98-ConstraintRecovery. During this phase, a maintainer needs both to understand and to modify a program source code. Therefore, the maintainer must obtain a representation of the program that accurately reflects its structure and its behavior. Then, the maintainer must find those places in the program that require modification. Finally, the maintainer must perform changes that improve the program behavior and do not introduce further defects. In our research work, we focus on the maintainer's first and second tasks: The obtention of an accurate representation of the program structure and behavior, and the detection of places to improve. We propose a set of software engineering tools, for the structural and dynamic representation of Java program, and for the (semi-) automated detection of design patterns and design defects. Design patterns and design defects are related: A group of classes which micro-architecture is similar (but not identical) to a design pattern corresponds to a possible design defect
    [bibtex-key = Gueheneuc02-WDMP-ThreeMusketeers]

  5. Yann-Gaël Guéhéneuc, Rémi Douence, and Narendra Jussien. No Java Without Caffeine -- A Tool for Dynamic Analysis of Java Programs. In Wolfgang Emmerich and Dave Wile, editors, Proceedings of the 17th Conference on Automated Software Engineering (ASE), pages 117--126, September 2002. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Binary class relations, ASE.
    Abstract:
    To understand the behavior of a program, a maintainer reads some code, asks a question about this code, conjectures an answer, and searches the code and the documentation for confirmation of her conjecture. However, the confirmation of the conjecture can be error-prone and time-consuming because the maintainer has only static information at her disposal. She would benefit from dynamic information. In this paper, we present Caffeine{}, an assistant that helps the maintainer in checking her conjecture about the behavior of a Java{} program. Our assistant is a dynamic analysis tool that uses the Java{} platform debug architecture to generate a trace, \ie{} an execution history, and a \Prolog{} engine to perform queries over the trace. We present a usage scenario based on the n-queens problem, and two real-life examples based on the Singleton design pattern and on the composition relationship.
    [bibtex-key = Gueheneuc02-ASE-Caffeine]

  6. Yann-Gaël Guéhéneuc, Hervé Albin-Amiot, Rémi Douence, and Pierre Cointe. Bridging the Gap Between Modeling and Programming Languages. Technical report 02/09/INFO, Computer Science Department, École des Mines de Nantes, July 2002. Note: 56 pages. [Text ] Keyword(s): Binary class relations.
    Abstract:
    A discontinuity exists between modeling languages and ob\-ject-oriented programming languages. This discontinuity is a consequence of ambiguous notions in modeling languages and lack of corresponding notions in object-oriented programming languages. It hinders the transition between a software design and its implementation, and vice versa. Thus, it hampers the implementation and the maintenance processes. This discontinuity is particularly acute for binary class relationships, which describe, at the design level, notions such as association, aggregation, and composition. From the current state of the art, we propose synthetic definitions for the binary class relationships at the design level and corresponding definitions at the implementation level. We express the latter definitions in terms of common properties. We present algorithms to synthesize code for these properties and to detect these properties in code. These algorithms allow us to generate and to detect binary class relationships. We verify the detection algorithms on several well-known frameworks. The definitions and algorithms bring continuity between modeling languages and object-oriented programming languages.
    [bibtex-key = Gueheneuc02-TR-GapLanguages]

  7. Yann-Gaël Guéhéneuc, Rémi Douence, and Narendra Jussien. No Java Without Caffeine -- A Tool for Dynamic Analysis of Java Programs. Technical report 02/07/INFO, Computer Science Department, École des Mines de Nantes, May 2002. Note: 16 pages. [Text ] Keyword(s): Binary class relations.
    Abstract:
    To understand the behavior of a program, a maintainer reads some code, asks a question about this code, conjectures an answer, and searches the code and the documentation for confirmation of her conjecture. However, the confirmation of the conjecture can be error-prone and time-consuming because the maintainer only has static information at her disposal. She would benefit from dynamic information. In this paper, we present Caffeine{}, an assistant that helps the maintainer in checking her conjecture about the behavior of a Java{} program. Our assistant is a dynamic analysis tool that uses the Java{} platform debug architecture to generate a trace, \ie{} an execution history, and a \Prolog{} engine to perform queries over the trace. We present a usage scenario based on the n-queens problem, and two examples based on the Singleton design pattern and on the composition relationship.
    [bibtex-key = Gueheneuc02-TR-Caffeine]

  8. Yann-Gaël Guéhéneuc. Caffeine, since May 2002. Note: A tool to analyse Java programs dynamically. [Text ] Keyword(s): Design patterns. [bibtex-key = Caffeine]


2001
  1. Hervé Albin-Amiot, Pierre Cointe, Yann-Gaël Guéhéneuc, and Narendra Jussien. Instantiating and Detecting Design Patterns: Putting Bits and Pieces Together. In Debra Richardson, Martin Feather, and Michael Goedicke, editors, Proceedings of the 16th Conference on Automated Software Engineering (ASE), pages 166--173, November 2001. IEEE CS Press. Note: 8 pages. [Text ] [Slides ] Keyword(s): Design patterns, ASE.
    Abstract:
    Design patterns ease designing, understanding, and re-engineering software. Achieving a well-designed piece of software requires a deep understanding and a good practice of design patterns. Understanding existing software relies on the ability to identify architectural forms resulting of the implementation of design patterns. Maintaining software involves spotting places that can be improved by using better design decisions, like those advocated by design patterns. Nevertheless, there is a lack of tools automating the use of design patterns to achieve well-designed pieces of software, to identify recurrent architectural forms, and to maintain software. In this paper, we present a set of tools and techniques to help OO software practitioners design, understand, and re-engineer a piece of software, using design-patterns. A first prototype tool, PatternsBox, provides assistance in designing the architecture of a new piece of software, while a second prototype tool, Ptidej, identifies design patterns used in an existing one. These tools, in combination, support maintenance by highlighting defects in an existing design, and by suggesting and applying corrections based on widely-accepted design patterns solutions.
    [bibtex-key = AlbinAmiot01-ASE-BitsPieces]

  2. Hervé Albin-Amiot and Yann-Gaël Guéhéneuc. Design Patterns Application: Pure-generative Approach vs. Conservative-generative Approach. In Krzysztof Czarnecki, editor, Proceedings of the 1st OOPSLA workshop on Generative Programming (GP), pages N/A, October 2001. N/A. Note: 3 pages. [Text ] Keyword(s): Design patterns, GP.
    Abstract:
    For our discussion we summarize software developments in two kinds: Development of large applications (such as accounting application or billing systems); and, development of large framework (such as window system [SunAWT] or networking system [Zweig90]). In one hand, when developing large applications, the developers need to abstract the functional and non-functional requirements of the application. They must be particularly careful with the specifications of the business rules and policies of the application, while the language and the code implementing the application are not really important. On the other hand, when developing large frameworks, the developers need to abstract the potential extension and implementations of the framework. They must be particularly careful with the architecture, the design, and the implementation of the framework, which is, at least, as important as the functionalities provided. In this position paper, we present two tools that help the developers in implementing large applications and large frameworks, using design patterns. Scriptor [Scriptor] (Section 2) is an industrial-strength application generator. Developers use it to generate large applications from scripts stating their functional and non-functional requirements. PatternsBox [PatternsBox] (Section 3) is an academic conservative application generator. Developers use it to implement design patterns in existing applications. PatternsBox modifies or creates only the required code artifacts (class, interface, fields, methods) to implement the design patterns, leaving the rest of the code untouched.
    [bibtex-key = AlbinAmiot01-WGP-Generative]

  3. Hervé Albin-Amiot and Yann-Gaël Guéhéneuc. Design Patterns: A Round-Trip. In Gilles Ardourel, Michael Haupt, Jose Luis Herrero Agustin, Rainer Ruggaber, and Charles Suscheck, editors, Proceedings of the 11th ECOOP workshop for Ph.D. Students in Object-Oriented Systems (PHDOOS), pages N/A, June 2001. N/A. Note: 10 pages. [Text ] [Slides ] Keyword(s): Design patterns, PHDOOS.
    Abstract:
    Design patterns are of major interest to increase software quality and abstraction level. However, design patterns are difficult to choose, to apply, and to recover. We propose a set of tools to use design patterns in a round-trip fashion. We define a meta-model to describe design patterns. This meta-model is specifically oriented towards design patterns instantiation and detection. We develop a source-to-source transformation engine to modify the source code to comply with design patterns descriptions. Meanwhile, we use an explanation-based constraint solver to detect design patterns in source code from their descriptions. With these tools, we hope to offer a mean to apply and to recover design patterns without overhead for the developers.
    [bibtex-key = AlbinAmiot01-WPHDOOS-RoundTrip]

  4. Hervé Albin-Amiot and Yann-Gaël Guéhéneuc. Meta-Modeling Design Patterns: Application to Pattern Detection and Code Synthesis. In Pim van den Broek, Pavel Hruby, Motoshi Saeki, Gerson Sunyé, and Bedir Tekinerdogan, editors, Proceedings of the 1st ECOOP workshop on Automating Object-Oriented Software Development Methods (AOOSDM), pages 20--27, October 2001. Centre for Telematics and Information Technology, University of Twente. Note: TR-CTIT-01-35. 8 pages. [Text ] [Slides ] Keyword(s): Design patterns, AOOSDM.
    Abstract:
    Design Patterns have been quickly adopted by the object-oriented community, in particular since the publication of ``Design Patterns: Elements of Reusable Object-Oriented Software". They offer elegant and reusable solutions to recurring problems of design. Their use increases productivity and development quality. However, these solutions, at the boundary of programming languages and design models, suffer from a lack of formalism. For this reason, their application remains empirical and manually performed. This position paper presents how a meta-model can be used to obtain a representation of design patterns and how this representation allows both automatic code generation and design patterns detection.
    [bibtex-key = AlbinAmiot01-WAOOSDM-MetaModel]

  5. Yann-Gaël Guéhéneuc and Hervé Albin-Amiot. Using Design Patterns and Constraints to Automate the Detection and Correction of Inter-Class Design Defects. In Quioyun Li, Richard Riehle, Gilda Pour, and Bertrand Meyer, editors, Proceedings of the 39th Conference on the Technology of Object-Oriented Languages and Systems (TOOLS USA), pages 296--305, July 2001. IEEE CS Press. Note: 10 pages. [Text ] [Slides ] Keyword(s): Code and design smells, TOOLS USA.
    Abstract:
    Developing code free of defects is a major concern for the object-oriented software community. In this paper, we classify design defects as those within classes ( extit{intra-class}), those among classes ( extit{inter-classes}), and those of semantic nature ( extit{behavioral}). Then, we introduce guidelines to automate the detection and correction of inter-class design defects: We assume that design patterns embody good architectural solutions and that a group of entities with organization similar, but not equal, to a design pattern represents an inter-class design defect. Thus, the transformation of such a group of entities, such that its organization complies exactly with a design pattern, corresponds to the correction of an inter-class design defect. We use a meta-model to describe design patterns and we exploit the descriptions to infer sets of detection and transformation rules. A constraints solver with explanations uses the descriptions and rules to recognize groups of entities with organizations similar to the described design patterns. A transformation engine modifies the source code to comply with the recognized distorted design patterns. We apply these guidelines on the \ygg@pattern{Composite} pattern using \ygg@product{Ptidej}, our prototype tool that integrates the complete guidelines.
    [bibtex-key = Gueheneuc01-TOOLSUSA-DesignDefects]

  6. Yann-Gaël Guéhéneuc and Narendra Jussien. Quelques explications pour les patrons -- Une application de la PPC avec explications pour l'identification de patrons de conception. In Bertrand Neveu, editor, Actes des 7e Journées Nationales sur la résolution de Problèmes NP-Complets (JNPC), pages 111--122, juin 2001. ONERA. Note: 12 pages. [Text ] [Slides ] Keyword(s): Design patterns, JNPC.
    Abstract:
    Les patrons de conception d\'ecrivent des micro-architectures qui r\'esolvent des probl\`emes architecturaux r\'ecurrents. Il est important d'identifier ces micro-archi\-tectures lors de la maintenance des programmes orient\'es objets. Mais ces micro-architectures apparaissent souvent sous des formes d\'egrad\'ees dans le code source. Nous pr\'esentons une application de la programmation par contraintes avec explications pour l'identification de ces micro-architectures d\'egrad\'ees.
    [bibtex-key = Gueheneuc01-JNPC-Explications]

  7. Yann-Gaël Guéhéneuc and Narendra Jussien. Using Explanations for Design-Patterns Identification. In Christian Bessière, editor, Proceedings of the 1st IJCAI Workshop on Modeling and Solving Problems with Constraints (WMSPC), pages 57--64, August 2001. AAAI Press. Note: 8 pages. [Text ] [Slides ] Keyword(s): Design patterns, WMSPC.
    Abstract:
    Design-patterns describe micro-architectures that solve recurrent architectural problems in objec-oriented programming languages. It is important to identify these micro-architectures during the maintenant of objec-oriented programs. But, these micro-architectures often appear distorted in the source code. We present an application of explanation-based constraint programming for identifying these distorted micro-architectures.
    [bibtex-key = Gueheneuc01-WMSPC-Explanations]

  8. Yann-Gaël Guéhéneuc. Ptidej, since July 2001. Note: A tool suite to evaluate and to enhance the quality of object-oriented programs. [Text ] [bibtex-key = Ptidej]


1999
  1. Yann-Gaël Guéhéneuc. PADL, since July 1999. Note: A meta-model (and parsers) to represent and to manipulate object-oriented programs and design motifs. [Text ] [bibtex-key = PADL]


1998
  1. Yann-Gaël Guéhéneuc. Syntax-error Recovery in Interactive Environments. Master's thesis, École des Mines de Nantes et Université de Nantes, septembre 1998. Note: (Diplôme d'études approfondies). [bibtex-key = Gueheneuc98-DEA]