@INPROCEEDINGS{Yamashota17-MSR-P-Seodin,
  author = {Aiko Yamashita and S. Amirhossein Abtahizadeh and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Software Evolution and Quality Data from Controlled, Multiple, Industrial Case Studies},
  booktitle = {Proceedings of the 14<sup>{th}</sup> International Conference on Mining Software Repositories ({MSR})},
  year = {2017},
  month = {May},
  editor = {Lin Tan and Abram Hindle},
  publisher = {ACM Press},
  note = {Short paper. 4 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Understanding program comprehension ; MSR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/MSR17a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/MSR17a.ppt.pdf},
  pages = {507--510},
  comment = {Short paper.}
}

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.

@INPROCEEDINGS{Zolfagharinia17-MSR-CPANBuilds,
  author = {Mahdis Zolfagharinia and Bram Adams and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Do Not Trust Build Results at Face Value: An Empirical Study of 30 Million {CPAN} Builds},
  booktitle = {Proceedings of the 14<sup>{th}</sup> International Conference on Mining Software Repositories ({MSR})},
  year = {2017},
  month = {May},
  editor = {Lin Tan and Abram Hindle},
  publisher = {ACM Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Understanding program comprehension ; MSR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/MSR17b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/MSR17b.ppt.pdf},
  pages = {312--322}
}

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.

@INPROCEEDINGS{Shatnawi17-MSR-JEEDependencies,
  author = {Anas Shatnawi and Hafedh Mili and Ghizlane El-Boussaidi and Anis Boubaker and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Naouel Moha and Jean Privat and Manel Abdellatif},
  title = {Analyzing Program Dependencies in {J}ava {EE} Applications},
  booktitle = {Proceedings of the 14<sup>{th}</sup> International Conference on Mining Software Repositories ({MSR})},
  year = {2017},
  month = {May},
  editor = {Lin Tan and Abram Hindle},
  publisher = {ACM Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and FRQNT team grant},
  keywords = {Understanding program comprehension ; MSR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/MSR17c.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/MSR17c.ppt.pdf},
  pages = {64--74}
}

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.

@INPROCEEDINGS{Saborido17-ICPC-AndroidAds,
  author = {Rub{\'e}n Saborido and Foutse Khomh and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Comprehension of Ads-supported and Paid {A}ndroid Applications: Are They Different?},
  booktitle = {Proceedings of the 25<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2017},
  month = {May},
  editor = {David Lo and Alexander Serebrenik},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Understanding program comprehension ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC17.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC17.ppt.pdf},
  pages = {143--153}
}

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.

@MISC{Sakti17-Demo-SBST,
  author = {Abdelilah Sakti and Gilles Pesant and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{JTExpert} at the Fifth Unit Testing Tool Competition},
  year = {2017},
  month = {May},
  pages = {43--46},
  note = {Tool demo at the 10<sup>{th}</sup> International Workshop on Search-Based Software Testing. 4 pages.},
  comment = {Tool demo at the 10<sup>{th}</sup> International Workshop on Search-Based Software Testing.},
  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.},
  grant = {NSERC DG and FQRNT team grant},
  keywords = {Test case generation ; SBST},
  kind = {DEMO},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SBST17ToolDemo.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SBST17ToolDemo.ppt.pdf}
}

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.

@INPROCEEDINGS{Petrillo17-ICPC-CloudLexicon,
  author = {F{\'a}bio Petrillo and Philippe Merle and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Towards a {REST} Cloud Computing Lexicon},
  booktitle = {Proceedings of the 7<sup>{th}</sup> International Conference on Cloud Computing and Services Science ({CLOSER})},
  year = {2017},
  month = {April},
  editor = {Donald Ferguson and V{\'\i}ctor M{\'e}ndez Mu{\~n}oz and Jorge Cardoso},
  publisher = {SciTePress},
  note = {8 pages.},
  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.},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Code and design smells ; CLOSER},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CLOSER17.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CLOSER17.ppt.pdf},
  pages = {348--355}
}

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.

@ARTICLE{An17-SQJ-CrashInducingCommits,
  author = {Le An and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {An Empirical Study of Crash-inducing Commits in {M}ozilla {F}irefox},
  journal = {Software Quality Journal ({SQJ})},
  year = {2017},
  month = {March},
  MISSINGvolume = {XXX},
  MISSINGnumber = {XXX},
  pages = {1�-32},
  note = {33 pages.},
  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.},
  MISSINGeditor = {XXX},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Code and design smells ; SQJ},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/SQJ17a.doc.pdf}
}

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.

@ARTICLE{Soh17-EMSE-MylynNoise,
  author = {Z{\'e}phyrin Soh and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Noise in Mylyn Interaction Traces and Its Impact on Developers and Recommendation Systems},
  journal = {Journal of Empirical Software Engineering ({EMSE})},
  year = {2017},
  month = {June},
  MISSINGvolume = {XXX},
  MISSINGnumber = {XXX},
  pages = {1--48},
  note = {49 pages.},
  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.},
  MISSINGeditor = {XXX},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Understanding program comprehension ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE17a.doc.pdf}
}

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.

@ARTICLE{Sabane17-EMSE-FBCS,
  author = {Aminata Saban{\'e} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Venera Arnaoudova and Giuliano Antoniol},
  title = {Fragile Base-class Problem, Problem?},
  journal = {Journal of Empirical Software Engineering ({EMSE})},
  year = {2017},
  month = {October},
  volume = {22},
  number = {5},
  pages = {2612�-2657},
  note = {46 pages.},
  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.},
  editor = {Mika V. M{\"a}ntyl{\"a} and Magne J{\o}rgensen and Paul Ralph and Hakan Erdogmus},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE17b.doc.pdf}
}

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.

@ARTICLE{Guerrouj17-SQJ-LexicalSmells,
  author = {Latifa Guerrouj and Zeinab Kermansaravi and Venera Arnaoudova and Benjamin C. M. Fung and Foutse Khomh and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Investigating the Relation between Lexical Smells and Change- and Fault-proneness: An Empirical Study},
  journal = {Software Quality Journal ({SQJ})},
  year = {2017},
  month = {September},
  volume = {25},
  number = {3},
  pages = {641�-670},
  note = {30 pages.},
  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.},
  editor = {Rachel Harrison},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; SQJ},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/SQJ17b.doc.pdf}
}

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.

@ARTICLE{Jaafar17-JSS-AsynchronyChangePatterns,
  author = {Fehmi Jaafar and Angela Lozano and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Kim Mens},
  title = {Analyzing Software Evolution and Quality by Extracting Asynchrony Change Patterns},
  journal = {Journal of Systems and Software ({JSS})},
  year = {2017},
  month = {September},
  volume = {131},
  MISSINGnumber = {XXX},
  pages = {311�-322},
  note = {12 pages.},
  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.},
  editor = {Paris Avgeriou and David Shepherd},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Evolution patterns ; JSS},
  kind = {RIAS},
  language = {english},
  publisher = {Elsevier},
  url = {http://www.ptidej.net/publications/documents/JSS17.doc.pdf}
}

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.

@ARTICLE{Palma17-IJCIS-LexicalSmells,
  author = {Francis Palma and Javier Gonzalez-Huerta and Mohamed Founi and Naouel Moha and Guy Tremblay and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Semantic Analysis of {REST}ful {API}s for the Detection of Linguistic Patterns and Antipatterns},
  journal = {International Journal of Cooperative Information Systems ({IJCIS})},
  year = {2017},
  month = {June},
  volume = {26},
  number = {2},
  pages = {1�-37},
  note = {38 pages.},
  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.},
  editor = {Alistair Barros and Daniela Grigori and Nanjangud Narendra},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; IJCIS},
  kind = {RIAS},
  language = {english},
  publisher = {World Scientific},
  url = {http://www.ptidej.net/publications/documents/IJCIS17.doc.pdf}
}

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.

@INPROCEEDINGS{Cote17-DHC-TAVIE,
  author = {Jos{\'e} C{\^o}t{\'e} and Sylvie Cossette and Pilar Ramirez-Garcia and Genevi{\`e}ve Rouleau and Patricia Auger and Fran{\c{c}}ois Boudreau and Marie-Pierre Gagnon and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A {W}eb-based Nursing Tailored Intervention to Support Health Behaviour Change among People Living with {HIV}: Development and Demonstration of {TAVIE en sant{\'e}}},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> UCL Centre for Behaviour Change Digital Health Conference ({DHC})},
  year = {2017},
  month = {February},
  editor = {Susan Michie and Anne Blandford},
  publisher = {University College London Press},
  note = {Poster. 1 pages.},
  MISSINGabstract = {XXX},
  grant = {NSERC DG},
  keywords = {VIHTAVIE ; DHC},
  kind = {MNADR},
  language = {english},
  pdf = {http://www.ptidej.net/publications/documents/DHC17.ppt.pdf},
  comment = {Poster.}
}

@INPROCEEDINGS{Petrillo17-QRS-BreakpointToggling,
  author = {Fabio Petrillo and Hyan Mandian and Aiko Yamashita and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {How Do Developers Toggle Breakpoints? Observational Studies},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> International Conference on Software Quality, Reliability, and Security ({QRS})},
  year = {2017},
  month = {July},
  editor = {Manuel Nu{\~n}ez and Tadashi Dohi and Xiaoying Bai},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Understanding program comprehension ; QRS},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/QRS17a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/QRS17a.ppt.pdf},
  pages = {285--295}
}

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.

@INPROCEEDINGS{Jaafar17-QRS-CloneAntipatterns,
  author = {Fehmi Jaafar and Angela Lozano and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Kim Mens},
  title = {On the Analysis of Co-Occurrence of Anti-Patterns and Clones},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> International Conference on Software Quality, Reliability, and Security ({QRS})},
  year = {2017},
  month = {July},
  editor = {Manuel Nu{\~n}ez and Tadashi Dohi and Xiaoying Bai},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Code and design smells ; QRS},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/QRS17b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/QRS17b.ppt.pdf},
  pages = {274--284}
}

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.

@ARTICLE{Jaafar14-EMSE-PatternDependencies,
  author = {Fehmi Jaafar and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel and Foutse Khomh and Mohammad Zulkernine},
  title = {Evaluating the Impact of Design Pattern and Anti-pattern Dependencies on Changes and Faults},
  journal = {Journal of Empirical Software Engineering ({EMSE})},
  year = {2016},
  month = {February},
  volume = {21},
  number = {3},
  pages = {896--931},
  note = {35 pages.},
  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.},
  editor = {Massimiliano {Di Penta} and Rocco Oliveto and Romain Robbes},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; Design patterns ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE16b.doc.pdf}
}

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.

@INBOOK{Gueheneuc16-ISTGuestIntroductionForAPSEC14,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gi-hwon Kwon and Pornsiri Muenchaisri},
  title = {Guest Editorial: Special Section with the extensions to the best papers from APSEC'13 and APSEC'14},
  chapter = {1},
  booktitle = {Information and Software Technology ({IST})},
  pages = {181--182},
  publisher = {Elsevier},
  year = {2016},
  month = {June},
  note = {2 pages.},
  abstract = {},
  grant = {CRC on Software Patterns},
  keywords = {Evolution patterns ; IST},
  kind = {CDL},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/APSEC14IST16.doc.pdf},
  editor = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gi-hwon Kwon and Pornsiri Muenchaisri},
  number = {C},
  volume = {74}
}

@INPROCEEDINGS{Louadah16-MODELSWARD-ICD,
  author = {Hassna Louadah and Roger Champagne and Yvan Labiche and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Data Extraction Process for Avionics Systems' Interface Specifications},
  booktitle = {Proceedings of the 4<sup>{th}</sup> International Conference on Model-Driven Engineering and Software Development ({MODELSWARD})},
  pages = {544--554},
  note = {11 pages.},
  year = {2016},
  month = {February},
  editor = {Bran Selic and Philippe Desfray},
  publisher = {SCITEPRESS Press},
  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.},
  grant = {NSERC AVIO-506 RDC grant},
  keywords = {Understanding program comprehension ; MODELSWARD},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/MODELSWARD16.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/MODELSWARD16.ppt.pdf}
}

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.

@INPROCEEDINGS{Soh16-SANER-Noises,
  author = {Z{\'e}phyrin Soh and Aiko Yamashita and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Do Code Smells Impact the Effort of Different Maintenance Programming Activities?},
  booktitle = {Proceedings of the 23<sup>{rd}</sup> International Conference on Software Analysis, Evolution, and Reengineering ({SANER})},
  pages = {393--402},
  note = {10 pages.},
  year = {2016},
  month = {March},
  editor = {Michele Lanza and Yasutaka Kamei},
  publisher = {IEEE CS Press},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; SANER},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SANER16a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SANER16a.ppt.pdf}
}

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.

@INPROCEEDINGS{Karasneh16-SANER-ModelsCodeAPs,
  author = {Bilal Karasneh and Michel R.V. Chaudron and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Studying the Relation between Anti-patterns in Models and in Source Code},
  booktitle = {Proceedings of the 23<sup>{rd}</sup> International Conference on Software Analysis, Evolution, and Reengineering ({SANER})},
  pages = {36--45},
  note = {10 pages.},
  year = {2016},
  month = {March},
  editor = {Michele Lanza and Yasutaka Kamei},
  publisher = {IEEE CS Press},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; SANER},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SANER16b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SANER16b.ppt.pdf}
}

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.

@ARTICLE{Wu15-EMSE-APIChangeEcosystems,
  author = {Wei Wu and Foutse Khomh and and Bram Adams and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Exploratory Study of {API} Changes and Usages based on {A}pache and {E}clipse Ecosystems},
  journal = {Journal of Empirical Software Engineering ({EMSE})},
  year = {2016},
  month = {December},
  volume = {21},
  number = {6},
  pages = {2366�2412},
  note = {47 pages.},
  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.},
  editor = {Lionel Briand and Thomas Zimmermann},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE16a.doc.pdf}
}

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.

@INPROCEEDINGS{Politowski16-GAS-SEProcessesGame,
  author = {Cristiano Politowski and Lisandra Fontoura and F{\'a}bio Petrillo and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Are the Old Days Gone? {A} Survey on Actual Software Engineering Processes in Video Game Industry},
  booktitle = {Proceedings of the 5<sup>{th}</sup> ICSE International Workshop on Games and Software Engineering ({GAS})},
  pages = {22--28},
  note = {7 pages.},
  year = {2016},
  month = {May},
  editor = {Kendra Cooper},
  publisher = {ACM Press},
  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. },
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; GAS},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/GAS16.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/GAS16.ppt.pdf}
}

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.

@MISC{Sakti16-Demo-SBST,
  author = {Abdelilah Sakti and Gilles Pesant and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{JTExpert} at the Fourth Unit Testing Tool Competition},
  year = {2016},
  month = {May},
  pages = {37--40},
  note = {Tool demo at the 9<sup>{th}</sup> ICSE International Workshop on Search-Based Software Testing. 4 pages.},
  comment = {Tool demo at the 9<sup>{th}</sup> ICSE International Workshop on Search-Based Software Testing.},
  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.},
  grant = {NSERC DG and FQRNT team grant},
  keywords = {Test case generation ; SBST},
  kind = {DEMO},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SBST16ToolDemo.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SBST16ToolDemo.ppt.pdf}
}

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.

@INPROCEEDINGS{Petrillo16-ICSOC-CloudRestAPIs,
  author = {F{\'a}bio Petrillo and Philippe Merle and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Are {REST} {API}s for Cloud Computing Well-Designed? An Exploratory Study},
  booktitle = {Proceedings of the 14<sup>{th}</sup> International Conference on Service Oriented Computing ({ICSOC})},
  year = {2016},
  month = {October},
  editor = {Michael Sheng and Eleni Stroulia and Samir Tata},
  publisher = {Springer},
  note = {13 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; ICSOC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSOC16a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSOC16a.ppt.pdf},
  pages = {157--170}
}

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.

@INPROCEEDINGS{Bani16-ICSOC-CloudPatternEnergy,
  author = {B{\'e}chir Bani and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Study of the Energy Consumption of Databases and Cloud Patterns},
  booktitle = {Proceedings of the 14<sup>{th}</sup> International Conference on Service Oriented Computing ({ICSOC})},
  year = {2016},
  month = {October},
  editor = {Michael Sheng and Eleni Stroulia and Samir Tata},
  publisher = {Springer},
  note = {Short paper. 8 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; ICSOC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSOC16b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSOC16b.ppt.pdf},
  pages = {606--614}
}

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.

@INPROCEEDINGS{Petrillo16-ICPC-SwarmDebugging,
  author = {F{\'a}bio Petrillo and Z{\'e}phyrin Soh and Foutse Khomh and Marcelo Soares Pimenta and Carla Maria Dal Sasso and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Understanding Interactive Debugging with Swarm Debug Infrastructure},
  booktitle = {Proceedings of the 24<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2016},
  month = {May},
  editor = {Jonathan I.\ Maletic and Gabriele Bavota},
  publisher = {IEEE CS Press},
  note = {Short Paper. 4 pages.},
  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},
  grant = {NSERC DG},
  keywords = {Understanding program comprehension ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC16.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC16.ppt.pdf},
  pages = {1--4}
}

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

@INPROCEEDINGS{Petrillo16-QRS-InteractiveDebugging,
  author = {F{\'a}bio Petrillo and Z{\'e}phyrin Soh and Foutse Khomh and Marcelo Soares Pimenta and Carla Maria Dal Sasso and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Towards Understanding Interactive Debugging},
  booktitle = {Proceedings of the 24<sup>{th}</sup> International Conference on Software Quality, Reliability, and Security ({QRS})},
  year = {2016},
  month = {August},
  editor = {Yves Le Traon and Zhenyu Chen},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Understanding program comprehension ; QRS},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/QRS16.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/QRS16.ppt.pdf},
  pages = {152--163}
}

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.

@MISC{Gueheneuc16-WebZine-BoingBall,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Bidouille : fabriquer un bo{\^\i}tier Boing Ball pour AmigaOne XE (Traduction)},
  year = {2016},
  month = {juin},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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}.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/boitier_boingball_amigaone.php}
}

Voici l'histoire du boı̂tier "Boing Ball" que j'ai construit pour mon AmigaOne XE. Cela commença comme une blague qui se changea en un projet sérieux qui est maintenant devenu réalité.

@MISC{Gueheneuc16-WebZine-AustralianRoadshow,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Reportage : Australian Roadshow (Traduction)},
  year = {2016},
  month = {septembre},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/australian_roadshow.php}
}

Voici un reportage sur l'Australian Roadshow, une série de rassemblements sur le thème d'AmigaOS 4, qui s'est tenu à partie du 18 octobre 2003 à Sydney, Brisbane et Canberra.

@INPROCEEDINGS{Washizaki16-ICSME-Metamodels,
  author = {Hironori Washizaki and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Foutse Khomh},
  title = {A Taxonomy for Program Metamodels in Program Reverse Engineering},
  booktitle = {Proceedings of the 32<sup>{nd}</sup> International Conference on Software Maintenance and Evolution ({ICSME})},
  year = {2016},
  month = {October},
  editor = {Bram Adams and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; ICSM ; ICSME},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSME16.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSME16.ppt.pdf},
  pages = {44--55}
}

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.

@ARTICLE{Li16-JSEP-ErrorLeakage,
  author = {Wenbin Li and Jane Huffman Hayes and Giulio Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Bram Adams},
  title = {Error Leakage and Wasted Time: Sensitivity and Effort Analysis of a Requirements Consistency Checking Process},
  journal = {Journal of Software: Evolution and Process ({JSEP})},
  year = {2016},
  month = {October},
  volume = {28},
  number = {12},
  pages = {1061�-1080},
  note = {20 pages.},
  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.},
  editor = {Marouane Kessentini and Mel {\'O} Cinn{\'e}ide},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Requirement traceability ; JSEP},
  kind = {RIAS},
  language = {english},
  publisher = {Wiley},
  url = {http://www.ptidej.net/publications/documents/JSEP16.doc.pdf}
}

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.

@ARTICLE{Hayes16-REEN-AnalystEffort,
  author = {Jane Huffman Hayes and Alexander Dekhtyar and Jody Larsen and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Effective Use of Analysts' Effort in Automated Tracing},
  journal = {Requirements Engineering ({REEN})},
  year = {2016},
  month = {October},
  MISSINGvolume = {XXX},
  MISSINGnumber = {XXX},
  pages = {1--25},
  note = {26 pages.},
  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.},
  MISSINGeditor = {XXX},
  grant = {NSERC DG and CRC on Multi-language Systems},
  keywords = {Requirement traceability ; REEN},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/REEN16.doc.pdf}
}

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.

@INPROCEEDINGS{Cote16-Sante-TAVIE,
  author = {Jos{\'e} C{\^o}t{\'e} and Pilar Ramirez-Garcia and Gaston Godin and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Annick Hernandez and {les concepteurs des interventions TAVIE}},
  title = {Concept et plateforme informatique TAVIE : d{\'e}ploiement d�une pratique infirmi{\`e}re virtuelle au service de la gestion des maladies chroniques},
  booktitle = {Actes du 1<sup>{er}</sup> Forum Franco--Qu{\'e}b{\'e}cois d'Innovation en Sant{\'e} ({FFQIS})},
  year = {2016},
  month = {octobre},
  MISSINGeditor = {},
  publisher = {Aviesan},
  MISSINGnote = {},
  MISSINGabstract = {},
  grant = {NSERC DG},
  keywords = {VIHTAVIE ; FFQIS},
  kind = {MNADR},
  language = {francais}
}

@ARTICLE{Ali14-EMSE-EyeTrackingTraceability,
  author = {Nasir Ali and Zohreh Sharafi and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Empirical Study on the Importance of Source Code Entities for Requirements Traceability},
  journal = {Empirical Software Engineering ({EMSE})},
  year = {2015},
  month = {April},
  volume = {20},
  number = {2},
  pages = {442--478},
  note = {37 pages.},
  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.},
  editor = {Victor R. Basili and Lionel C. Briand},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Features and requirements ; Understanding program comprehension ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE14a.doc.pdf}
}

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, ıe 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, ıe 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.

@ARTICLE{Wu14-EMSE-EyeTrackingTraceability,
  author = {Wei Wu and Adrien Serveaux and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {The Impact of Imperfect Change Rules on Framework API Evolution Identification: An Empirical Study},
  journal = {Empirical Software Engineering ({EMSE})},
  year = {2015},
  month = {August},
  volume = {20},
  number = {4},
  pages = {1126--1158},
  note = {32 pages.},
  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, \textit{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.},
  editor = {Victor R. Basili and Lionel C. Briand},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE14b.doc.pdf}
}

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, 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.

@ARTICLE{Cote15-JMIR-VirtualIntervention,
  author = {Jos{\'e} C{\^o}t{\'e} and Gaston Godin and Pilar Ramirez-Garcia and Genevi{\`e}ve Rouleau and Anne Bourbonnais and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and C{\'e}cile Tremblay and Joanne Otis},
  title = {Virtual Intervention to Support Self-Management of Antiretroviral Therapy Among People Living With {HIV}},
  journal = {Journal of Medical Internet Research ({JMIR})},
  year = {2015},
  month = {January},
  volume = {17},
  number = {1},
  pages = {e6},
  abstract = {\textbf{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. \textbf{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. \textbf{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. \textbf{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. \textbf{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.},
  editor = {Gunther Eysenbach},
  grant = {NSERC DG},
  keywords = {VIHTAVIE ; JMIR},
  kind = {RIAS},
  language = {english},
  publisher = {JMIR Publications},
  url = {http://www.ptidej.net/publications/documents/JMIR15.doc.pdf}
}

\textbfBackground: 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. \textbfObjective: 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. \textbfMethods: 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. \textbfResults: 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. \textbfConclusions: 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.

@INPROCEEDINGS{Hayes15-NasBASE-ErrorLeakageTraceability,
  author = {Jane Huffman Hayes and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Wenbin Li and Mirek Truszczynski},
  title = {Error Leakage and Wasted Time: Sensitivity Analysis of a Requirements Consistency Checking Process},
  booktitle = {Proceedings of the 1<sup>{st}</sup> North American Search Based Software Engineering Symposium ({NasBASE})},
  year = {2015},
  month = {February},
  editor = {Marouane Kessentini},
  publisher = {Elsevier},
  note = {15 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Requirement traceability ; NasBASE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/NasBASE15.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/NasBASE15.ppt.pdf},
  pages = {1061--1080}
}

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.

@INPROCEEDINGS{Palma15-MCETech-AntiBusinessProcess,
  author = {Francis Palma and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Specification and Detection of Business Process Antipatterns},
  booktitle = {Proceedings of the 6<sup>{th}</sup> International Conference on eTechnologies ({MCETECH})},
  year = {2015},
  month = {May},
  editor = {Morad Benyoucef and Michael Weiss},
  publisher = {Springer},
  note = {15 pages.},
  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\%.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; MCETECH},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/MCETECH15.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/MCETECH15.ppt.pdf},
  pages = {37--52}
}

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%.

@INBOOK{Gueheneuc15-EMSEGuestIntroductionForICSM13,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Tom Mens},
  title = {Guest Editorial: Introduction to the Special Issue on Software Maintenance and Evolution Research},
  chapter = {1},
  booktitle = {Journal of Empirical Software Engineering ({EMSE})},
  pages = {1193--1197},
  publisher = {Springer},
  year = {2015},
  month = {February},
  note = {4 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Evolution patterns ; EMSE},
  kind = {CDL},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM13EMSE15.doc.pdf},
  editor = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc  and Tom Mens},
  number = {5},
  volume = {20}
}

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.

@INPROCEEDINGS{Rouleau15-ACFAS-VIHTAVIE,
  author = {Genevi{\`e}ve Rouleau and Jos{\'e} C{\^o}t{\'e} and Pilar Ramirez-Garcia and Annick Hernandez and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {VIH-TAVIE et TAVIE en sant{\'e} : interventions infirmi{\`e}res en cybersant{\'e} pour soutenir la prise des antir{\'e}troviraux et l'adoption de comportements de sant{\'e} aupr{\`e}s d'une client{\`e}le VIH},
  booktitle = {actes du 83<sup>{e}</sup> congr\`es de {l'ACFAS}},
  year = {2015},
  month = {mai},
  editor = {C{\'e}line Audet and Claude La Charit{\'e}},
  publisher = {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.},
  grant = {FRSQ team grant},
  keywords = {VIHTAVIE ; ACFAS},
  kind = {MNADR},
  language = {francais}
}

Il devient impératif d�innover dans de nouvelles modalités de soins pour relever les défis reliés à l�accroissement des problèmes chroniques de santé et aux soins complexes qui en découlent. Les interventions en cybersanté représentent une solution prometteuse. Objectifs : Un concept d�intervention infirmière virtuelle appelé TAVIE (Traitement, Assistance, virtuelle, infirmière et Enseignement) a été développé pour soutenir de manière personnalisée les personnes vivant avec un problème de santé chronique, comme les personnes vivant avec le VIH (PVVIH), dans la gestion des défis inhérents à leur condition de santé. Deux interventions seront présentées : VIH-TAVIE, conçue pour soutenir la prise des antirétroviraux; et TAVIE en santé, développée pour motiver l�adoption de comportements de santé. Méthode : Le développement des interventions est issu d�un croisement des savoirs clinique, empirique, théorique et d�un travail avec les experts des arts multimédia et de l�informatique. L�efficacité de VIH-TAVIE a été évaluée en milieu clinique à l�aide d�un devis quasi-expérimental et qualitatif. Résultats: Les PVVIH ont trouvé que l�infirmière virtuelle humanisait leur expérience de participer à VIH-TAVIE et ont retiré des bénéfices de l�intervention. Conclusion : VIH-TAVIE et TAVIE en santé sont présentement évaluées via un essai randomisé en ligne. L�évaluation de ces interventions ouvre une voie vers des changements dans les modes traditionnels de prestation des soins.

@INPROCEEDINGS{Sharafi15-APSEC-EyeTrackingMetrics,
  author = {Zohreh Sharafi and Timothy Shaffer and Bonita Sharif and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Eye-tracking Metrics in Software Engineering},
  booktitle = {Proceedings of the 22<sup>{nd}</sup> Asia-Pacific Software Engineering Conference ({APSEC})},
  pages = {96--103},
  note = {8 pages.},
  year = {2015},
  month = {December},
  editor = {Jing Sun and Y. Raghu Reddy},
  publisher = {IEEE CS Press},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; APSEC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/APSEC15.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/APSEC15.ppt.pdf}
}

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.

@INPROCEEDINGS{Soh15-ESEM-Noises,
  author = {Z{\'e}phyrin Soh and Thomas Drioul and Pierre-Antoine Rappe and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Naji Habra},
  title = {Noises in Interaction Traces Data and their Impact on Previous Research Studies},
  booktitle = {Proceedings of the 9<sup>{th}</sup> International Symposium of Empirical Software Engineering and Measurement ({ESEM})},
  year = {2015},
  pages = {1--10},
  month = {October},
  editor = {Jeff Carver and Oscar Dieste},
  publisher = {IEEE CS Press},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; ESEM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ESEM15.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ESEM15.ppt.pdf},
  note = {10 pages.}
}

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.

@INPROCEEDINGS{Palma15-ICSOC-RESTLinguisticAPs,
  author = {Francis Palma and Javier Gonzalez-Huerta and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Guy Tremblay},
  title = {Are {REST}ful {API}s Well-designed? Detection of Their Linguistic (Anti)Patterns},
  booktitle = {Proceedings of the 13<sup>{th}</sup> International Conference on Service Oriented Computing ({ICSOC})},
  year = {2015},
  month = {November},
  editor = {Alistair Barros and Daniela Grigori and N.C. Narendra},
  publisher = {Springer},
  note = {16 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; ICSOC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSOC15.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSOC15.ppt.pdf},
  pages = {171--187}
}

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.

@INPROCEEDINGS{Abtahizadeh15-IPCCC-GreenPatterns,
  author = {S. Amirhossein Abtahizadeh and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {How Green Are Cloud Patterns? A Case Study of Energy Consumption},
  booktitle = {Proceedings of the 34<sup>{th}</sup> International Performance Computing and Communications Conference ({IPCCC})},
  year = {2015},
  month = {December},
  editor = {Kui Ren and Tommaso Melodia},
  publisher = {IEEE CS Press},
  note = {8 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; Quality models ; IPCCC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/IPCCC15.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/IPCCC15.ppt.pdf},
  pages = {1--8}
}

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.

@INPROCEEDINGS{Hayes15-RENext-InherentCharacteristics,
  author = {Jane Huffman Hayes and Giuliano Antoniol and Bram Adams and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Inherent Characteristics of Traceability Artifacts: Less Is More},
  booktitle = {Proceedings of the 23<sup>{rd}</sup> International Requirements Engineering Conference ({RE})},
  pages = {196--201},
  note = {RE Next! 6 pages.},
  comment = {RE Next!},
  year = {2015},
  month = {August},
  editor = {Didar Zowghi and Vincenzo Gervasi},
  publisher = {IEEE CS Press},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; RE},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/RENext15.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/RENext15.ppt.pdf}
}

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.

@MISC{Sakti15-Demo-SBST,
  author = {Abdelilah Sakti and Gilles Pesant and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{JTExpert} at the Third Unit Testing Tool Competition},
  year = {2015},
  month = {May},
  pages = {52--55},
  note = {Tool demo at the 8<sup>{th}</sup> International Workshop on Search-Based Software Testing. 4 pages.},
  comment = {Tool demo at the 8<sup>{th}</sup> International Workshop on Search-Based Software Testing.},
  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.},
  grant = {NSERC DG and FQRNT team grant},
  keywords = {Test case generation ; SBST},
  kind = {DEMO},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SBST15ToolDemo.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SBST15ToolDemo.ppt.pdf}
}

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.

@ARTICLE{Sharafi15-IST-SLREyeTracking,
  author = {Zohreh Sharafi and Z{\'e}phyrin Soh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Systematic Literature Review on the Usage of Eye-tracking in Software Engineering},
  journal = {Journal of Information and Software Technology ({IST})},
  year = {2015},
  month = {November},
  volume = {67},
  pages = {79--107},
  note = {28 pages.},
  abstract = {
\textit{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.

\textit{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.

\textit{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.

\textit{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.

\textit{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.},
  editor = {Guenther Ruhe and Guilherme Horta Travassos and Laurie Williams},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; IST},
  kind = {RIAS},
  language = {english},
  publisher = {Elsevier},
  url = {http://www.ptidej.net/publications/documents/IST15.doc.pdf}
}

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. 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. 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. 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. 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.

@INPROCEEDINGS{Cote15-Medicine20-VirtualIntervention,
  author = {Jos{\'e} C{\^o}t{\'e} and Gaston Godin and Pilar Ramirez-Garcia and Genevi{\`e}ve Rouleau and Anne Bourbonnais and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and C{\'e}cile Tremblay and Joanne Otis},
  title = {Virtual Intervention to Support Self-Management of Antiretroviral Therapy Among People Living With {HIV}},
  booktitle = {Proceedings of the 5<sup>{th}</sup> World Congress on Social Media, Mobile Apps, and Internet/Web 2.0 in Health, Medicine and Biomedical Research ({Medicine 2.0})},
  MISSINGpages = {},
  MISSINGnote = {XXX pages.},
  MISSINGcomment = {},
  year = {2015},
  month = {October},
  MISSINGeditor = {},
  publisher = {Medicine 2.0},
  abstract = {
\textit{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. \textit{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. \textit{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. \textit{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. \textit{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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {VIHTAVIE ; Medicine 2.0},
  kind = {MIADR},
  language = {english},
  pdf = {http://www.ptidej.net/publications/documents/MEDICINE15.ppt.pdf}
}

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. 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. 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. 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. 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.

@ARTICLE{Cote15-BMC-RandomizedTrial,
  author = {Jos{\'e} C{\^o}t{\'e} and Sylvie Cossette and Pilar Ramirez-Garcia and Alexandra {De Pokomandy} and Catherine Worthington and Marie-Pierre Gagnon and Patricia Auger and Fran{\c{c}}ois Boudreau and Joyal Miranda and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and C{\'e}cile Tremblay},
  title = {Evaluation of a Web-based Tailored Intervention (TAVIE en sant{\'e}) to Support People Living with {HIV} in the Adoption of Health Promoting Behaviours: an Online Randomized Controlled Trial Protocol},
  journal = {BMC Public Health ({BMC})},
  year = {2015},
  month = {October},
  volume = {15},
  MISSINGnumber = {},
  MISSINGpages = {},
  MISSINGnote = {XXX pages.},
  abstract = {
\textit{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. \textit{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. \textit{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.},
  MISSINGeditor = {},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {VIHTAVIE ; BMC Public Health},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/BMC15.doc.pdf}
}

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é was developed. The aim of this study is to evaluate the effectiveness of TAVIE en santé in order to support people living with HIV in the adoption of health promoting behaviours. 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: $≥$ 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é, n = 375) or to a control group (websites, n = 375) (1:1 allocation ratio). The TAVIE en santé 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. 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é intervention could constitute an accessible complementary service in support of existing specialized services to support people living with HIV adopt health behaviors.

@MISC{Gueheneuc15-WebZine-FOTAQ,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Test de Flight Of The Amazon Queen},
  year = {2015},
  month = {mars},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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 !},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/flightoftheamazonqueen.php}
}

Flight of the Amazon Queen, ou FOTAQ pour ses amis, est un jeu d�aventure � pointe et clique � conçu pour l�Amiga et le MS-DOS développé par Interactive Binary Illusions et publié en 1995 par Warner Interactive et MojoTouch. Ce jeu rappel un peu les aventures de Indiana Jones, les Nazis démoniaques en moins mais avec un méchant mégalomaniaque, des dinosaures, des Amazones et des lederhosen !

@MISC{Gueheneuc15-WebZine-InterviewFleecyMoss,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Entrevue avec Fleecy Moss (Traduction)},
  year = {2015},
  month = {mai},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/itwmoss2.php}
}

Qu'est-ce qui arrive à l'Amiga ? Est-ce que l'arrêt de la publication de CU Amiga signifie la fin de l'Amiga ? La réponse courte est "non". Vous ne nous croyez pas ? Dans un dernier effort pour répondre à cela, nous avons demandé à Amiga Inc. de tout déballer. Fleecy Moss - l'homme que Petro appelle "Flossy" (en français : "ultra-chic") a beaucoup de choses à dire.

@MISC{Gueheneuc15-WebZine-GaryPeake,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Entrevue avec Gary Peake (Traduction)},
  year = {2015},
  month = {mars},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  abstract = {Gary Peake a {\'e}t{\'e} un pilier de l'Amiga depuis toujours.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/itwpeake_082000.php}
}

Gary Peake a été un pilier de l'Amiga depuis toujours.

@MISC{Gueheneuc15-WebZine-LorenEyrich,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Reportage : Loren Eyrich voyage avec un Amiga (Traduction)},
  year = {2015},
  month = {f{\'e}vrier},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  abstract = {Loren Eyrich pr{\'e}f{\`e}re les routes "moins fr{\'e}quent{\'e}es" au sens propre comme au figur{\'e}.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/loreneyrich_voyage_amiga.php}
}

Loren Eyrich préfère les routes "moins fréquentées" au sens propre comme au figuré.

@MISC{Gueheneuc15-WebZine-Multimedia,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {L'Amiga m{\`e}ne le bal dans les pr{\'e}sentations multim{\'e}dias interactives (Traduction)},
  year = {2015},
  month = {june},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/amiga_presentations_multimedias_interactives.php}
}

Vous serez peut-être surpris d'apprendre que des Amiga sont présents un peu partout pour faire des présentations multimédias interactives. Allons voir ce qui se trame derrière ces présentations pour comprendre comment cela est possible.

@MISC{Gueheneuc15-WebZine-AmigaInNASchools,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Reportage : l'Amiga dans les {\'e}coles nord-am{\'e}ricaines (Traduction)},
  year = {2015},
  month = {mars},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/amiga_ecoles_americaines.php}
}

Nous sommes tous au courant du rôle de l'Amiga dans les cours de graphismes et de vidéo au lycée dans tout le pays [NDLT : au Canada et aux États-Unis]. Mais l'Amiga est aussi présent dans des endroits moins courants : depuis l'école primaire jusqu'aux facultés de médecine.

@MISC{Gueheneuc15-WebZine-DevCon92,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Reportage : DevCon Commodore 1992 au Royaume-Uni (Traduction)},
  year = {2015},
  month = {janvier},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/devcon1992_royaumeuni.php}
}

Chaque année durant ces trois dernières années, Commodore UK a organisé une conférence dédiée aux développeurs pour donner à ces derniers résidant au Royaume-Uni la possibilité de voir les nouvelles technologies, d'être informés sur divers problèmes de programmation, de montrer leurs dernières astuces et, plus généralement, de se mêler à d'autres gens qui ont les mêmes intérêts.

@ARTICLE{Jaafar13-JSME-MacroCoChanges,
  author = {Fehmi Jaafar and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Guiliano Antoniol and Sylvie Hamel},
  title = {Detecting Asynchrony and Dephase Change Patterns by Mining Software Repositories},
  journal = {Journal of Software Maintenance and Evolution: Research and Practice ({JSME})},
  year = {2014},
  note = {Under publication.},
  month = {January},
  number = {1},
  volume = {26},
  pages = {77--106},
  editor = {Denys Poshyvanyk and Martin Pinzger},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; JSME-JSEP},
  kind = {RIAS},
  language = {english},
  publisher = {Wiley},
  url = {http://www.ptidej.net/publications/documents/JSME13.doc.pdf},
  comment = {Under publication.}
}

@ARTICLE{Palma14-IJCIS-SOAAntipatternsDetection,
  author = {Francis Palma and Mathieu Nayrolles and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Benoit Baudry and Jean-Marc J{\'e}z{\'e}quel},
  title = {SOA Antipatterns: An Approach for their Specification and Detection},
  journal = {International Journal of Cooperative Information Systems ({IJCIS})},
  year = {2014},
  month = {March},
  volume = {23},
  number = {1},
  note = {31 pages.},
  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 \textit{Multi Service} and \textit{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) \textit{Home-Automation}, an SBS with 13 services, and (2) \textit{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\%.},
  editor = {Mike P. Papazoglou and Gunter Schlageter},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; IJCIS},
  kind = {RIAS},
  language = {english},
  publisher = {World Scientific Publishing},
  url = {http://www.ptidej.net/publications/documents/IJCIS14.doc.pdf}
}

\def§BSSBSs\def§OASOA\def§ODASODA Like any other large and complex software systems, Service Based Systems (§BS) must evolve to fit new user requirements and execution contexts. The changes resulting from the evolution of §BS may degrade their design and quality of service (QoS) and may often cause the appearance of common poor solutions in their architecture, called \emphantipatterns, in opposition to \emphdesign patterns, which are good solutions to recurring problems. Antipatterns resulting from these changes may hinder the future maintenance and evolution of §BS. The detection of antipatterns is thus crucial to assess the design and QoS of §BS and facilitate their maintenance and evolution. However, methods and techniques for the detection of antipatterns in §BS 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 §BS. Using our approach, we specify ten well-known and common antipatterns, including Multi Service and 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) Home-Automation, an SBS with 13 services, and (2) 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%.

@INPROCEEDINGS{Bavota14-CSMR-WCRE-ClassRefactoringNashEquilibria,
  author = {Gabriele Bavota and Rocco Oliveto and Andrea {Di Lucia} and Andrian Marcus and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {In Medio Stat Virtus: Extract Class Refactoring through {Nash} Equilibria},
  booktitle = {Proceedings of the 1<sup>{st}</sup> CSMR-WCRE Software Evolution Week ({CSMR-WCRE})},
  year = {2014},
  month = {February},
  editor = {Dave Binkley and Filippo Ricca},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; CSMR-WCRE ; CSMR ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR-WCRE14.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR-WCRE14.ppt.pdf},
  pages = {214--223}
}

Extract Class refactoring (ECR) is used to divide large classes with low cohesion into smaller, more cohesive classes. However, splitting a class might result in increased coupling in the system due to new dependencies between the extracted classes. Thus, ECR requires that a software engineer identifies a trade off between cohesion and coupling. Such a trade off may be difficult to identify manually because of the high complexity of the class to be refactored. In this paper, we present an approach based on game theory to identify refactoring solutions that provide a compromise between the desired increment in cohesion and the undesired increment in coupling. The results of an empirical evaluation indicate that the approach identifies meaningful ECRs from a developer's point-of-view.

@INPROCEEDINGS{Lozano14-IWSC-ClonesMacroCochanges,
  author = {Angela Lozano and Fehmi Jaafar and Kim Mens and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Clones and Macro Co-changes},
  booktitle = {Proceedings of the 8<sup>{th}</sup> International Workshop on Software Clones ({IWSC})},
  year = {2014},
  month = {February},
  editor = {Nils G{\"o}de and Yoshiki Higo},
  publisher = {Electronic Communications of the EASST},
  note = {15 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; IWSC},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/IWSC14.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/IWSC14.ppt.pdf}
}

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 \emphonly 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.

@INPROCEEDINGS{Linares-Vasquez14-ICPC-DomainMatters,
  author = {Mario Linares-V{\'a}squez and Sam Klock and Collin McMillan and Aminata Saban{\'e} and Denys Poshyvanyk and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Domain Matters: Bringing Further Evidence of the Relationships among Anti-patterns, Application Domains, and Quality-related Metrics in Java Mobile Apps},
  booktitle = {Proceedings of the 22<sup>{nd}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2014},
  month = {June},
  editor = {Andrew Begel and Leon Moonen},
  publisher = {ACM Press},
  note = {11 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC14.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC14.ppt.pdf},
  pages = {232--243}
}

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.

@ARTICLE{Arnaoudova14-TSE-REPENT,
  author = {Venera Arnaoudova and Laleh Eshkevari and Massimiliano {Di Penta} and Rocco Oliveto and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{REPENT}: {A}nalyzing the Nature of Identifier Renamings},
  journal = {Transactions on Software Engineering ({TSE})},
  year = {2014},
  month = {May},
  volume = {40},
  number = {5},
  pages = {502--532},
  note = {30 pages.},
  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.},
  editor = {Harald Gall},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Linguistic smells ; TSE},
  kind = {RIAS},
  language = {english},
  publisher = {IEEE CS Press},
  url = {http://www.ptidej.net/publications/documents/TSE14.doc.pdf}
}

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, ıe altering the entity identifier, is an important activity during software evolution. Developers rename when they feel that the name of an entity is not (anymore) consistent with its functionality, or when such a name may be misleading. A survey that we performed with 71 developers suggests that 39% 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.

@INBOOK{Khomh14-EMSL-PQMOD,
  author = {Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Massimiliano {Di Penta}},
  title = {Mod{\`e}les de qualit{\'e} et conception des programmes},
  chapter = {3},
  booktitle = {{\'E}volution et maintenance des syst{\`e}mes logiciels ({EMSL})},
  pages = {85--116},
  editor = {Abdelhak-Djamel Seriai},
  publisher = {{\'E}ditions Lavoisier},
  year = {2014},
  month = {avril},
  note = {Hermes Science. Trait{\'e} IC2, s{\'e}rie Informatique et Syst{\`e}mes d'Information. 32 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models ; Design patterns ; EMSL},
  kind = {CDL},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/EMSL14.doc.pdf}
}

\paragraphContexte La qualité des programmes par objets se décompose en de nombreuses dimensions, qui requièrent des modèles pour les évaluer. Ces modèles décrivent des relations entre des dimensions de qualité (aussi appelées caractéristiques de qualité) d'une part et des attributs internes des classes des programmes d'autre part. Par exemple, le modèle \QM de Bansiya et Davis mesure six caractéristiques de qualité ; celui de Zimmermann \ygg@latinet al. mesure la propension aux fautes des classes. Les modèles de qualité utilisent des métriques de classes (\eg nombres de méthodes) ou de relations entre classes (\eg couplage) pour mesurer les attributs internes des classes et en dériver des valeurs pour les caractéristiques de qualité externes des programmes. \paragraphProblème La qualité des programmes par objets, ıe développés avec une méthodologie objet, ne dépend pas uniquement de la structure de leurs classes, que mesurent les métriques, mais aussi de la façon dont celles-ci sont organisées ; ıe leur conception qui se manifeste concrètement au travers de styles de conception, \eg des occurrences de patrons et d'anti-patrons de conception. \paragraphObjectif L'objectif de ce chapitre est de présenter l'état de l'art sur les modèles de qualité et d'introduire notre méthode \DQLT et son instantiation, ¶QM, pour la mesure de la propension aux changements et aux fautes des classes en prenant en compte la conception des programmes par objets. \paragraphMéthode Nous introduisons la méthode \DQLT pour construire systématiquement des modèles de qualité pour les programmes par objets qui prennent en compte les attributs internes des classes (au travers de métriques) et leurs conceptions (au travers des occurrences de patrons et d'anti-patrons de conception). \paragraphRésultats En utilisant \DQLT et nos récents résultats sur les propensions aux changements et aux fautes des classes qui jouent des rôles dans des anti-patrons ou patrons de conception, nous construisons le modèle de qualité ¶QM. Ce modèle prend en compte la conception des programmes par objets dans son évaluation de leurs propensions aux changements et aux fautes. Nous validons ¶QM sur trois programmes dont le code source est libre. Nous montrons ainsi les bonnes performances de ¶QM, en particulier dans le cas inter-projets : celui où le modèle est entraı̂né sur les données d'un programme et appliqué sur un autre programme. Nous comparons aussi ¶QM avec deux modèles précédents et montrons ainsi que ¶QM mesure avec une meilleure précision et un meilleur rappel les propensions aux changements et aux fautes des classes que les autres modèles. \paragraphConclusion Notre méthode \DQLT permet de construire systématiquement des modèles de qualité pour les programmes par objets en prenant en compte leur conception. Une instantiation de notre méthode, le modèle ¶QM, montre de meilleurs précisions et rappels dans l'évaluation des propensions aux changements et aux fautes des classes des programmes par objets que les précédents modèles.

@ARTICLE{Jaafar14-ECEASST-AntipatternRelationships,
  author = {Fehmi Jaafar and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel and Foutse Khomh},
  title = {Analysing Anti-patterns Static Relationships with Design Patterns},
  journal = {Electronic Communications of the EASST ({ECEASST})},
  year = {2014},
  month = {August},
  volume = {59},
  note = {26 pages.},
  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.},
  editor = {Aminata Saban{\'e} and Wei Wu and Tiziana Margaria and Julia Padberg and Gabriele Taentzer},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; ECEASST},
  kind = {RIAS},
  language = {english},
  publisher = {European Association of Software Science and Technology},
  url = {http://www.ptidej.net/publications/documents/ECEASST14.doc.pdf}
}

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.

@INPROCEEDINGS{Palma14-ECSA-SOAAntiPatternsWebServices,
  author = {Francis Palma and Naouel Moha and Guy Tremblay and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Specification and Detection of SOA Antipatterns in Web Services},
  booktitle = {Proceedings of the 8<sup>{th}</sup> European Conference on Software Architecture ({ECSA})},
  year = {2014},
  month = {August},
  editor = {Paris Avgeriou},
  publisher = {Springer},
  note = {15 pages.},
  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\%.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; ECSA},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECSA14.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ECSA14.ppt.pdf},
  pages = {58--73}
}

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%.

@INPROCEEDINGS{Palma14-ICSOC-SOAAntiPatternsWebServices,
  author = {Francis Palma and Johann Dubois and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Detection of {REST} Patterns and Antipatterns: A Heuristics-based Approach},
  booktitle = {Proceedings of the 12<sup>{th}</sup> International Conference on Service Oriented Computing ({ICSOC})},
  year = {2014},
  month = {November},
  editor = {Xavier Franch and Aditya Ghose and Grace Lewis},
  publisher = {Springer},
  note = {15 pages.},
  abstract = {\texttt{REST} (REpresentational State Transfer), relying on \textit{resources} as its architectural unit, is currently a popular architectural choice for building Web-based applications. It is shown that \textit{design patterns}---good solutions to recurring design problems---improve the design quality and facilitate maintenance and evolution of software systems. \textit{Antipatterns}, on the other hand, are poor and counter-productive solutions. Therefore, the detection of \texttt{REST} (anti)patterns is essential for improving the maintenance and evolution of \texttt{RESTful} systems. Until now, however, no approach has been proposed. In this paper, we propose \texttt{SODA-R} (Service Oriented Detection for Antipatterns in \texttt{REST}), a heuristics-based approach to detect (anti)patterns in \texttt{RESTful} systems. We define detection heuristics for eight \texttt{REST} antipatterns and five patterns, and perform their detection on a set of 12 widely-used \texttt{REST} \texttt{APIs} including BestBuy, Facebook, and DropBox. The results show that \texttt{SODA-R} can perform the detection of \texttt{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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; ICSOC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSOC14.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSOC14.ppt.pdf},
  pages = {230--244}
}

\textttREST (REpresentational State Transfer), relying on resources as its architectural unit, is currently a popular architectural choice for building Web-based applications. It is shown that design patterns—good solutions to recurring design problems—improve the design quality and facilitate maintenance and evolution of software systems. Antipatterns, on the other hand, are poor and counter-productive solutions. Therefore, the detection of \textttREST (anti)patterns is essential for improving the maintenance and evolution of \textttRESTful systems. Until now, however, no approach has been proposed. In this paper, we propose \textttSODA-R (Service Oriented Detection for Antipatterns in \textttREST), a heuristics-based approach to detect (anti)patterns in \textttRESTful systems. We define detection heuristics for eight \textttREST antipatterns and five patterns, and perform their detection on a set of 12 widely-used \textttREST \textttAPIs including BestBuy, Facebook, and DropBox. The results show that \textttSODA-R can perform the detection of \textttREST (anti)patterns with high accuracy. We also found that Twitter, DropBox, and Alchemy are not well-designed, \emphi.e., contain more antipatterns. In contrast, Facebook, BestBuy, and YouTube are well-designed, \emphi.e., contain more patterns and less antipatterns.

@INPROCEEDINGS{Jaafar14-QSIC-AntiPatternMutations,
  author = {Fehmi Jaafar and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Mohammad Zulkernine},
  title = {Anti-pattern Mutations and Fault-proneness},
  booktitle = {Proceedings of the 14<sup>{th}</sup> International Conference on Quality Software ({QSIC})},
  year = {2014},
  month = {October},
  editor = {Bruce McMillin},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; QSIC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/QSIC14.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/QSIC14.ppt.pdf},
  pages = {246--255}
}

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.

@MISC{Wu14-Demo-SCAM-ACUA,
  author = {Wei Wu and Bram Adams and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {{ACUA}: {API} Change and Usage Auditor},
  year = {2014},
  month = {September},
  note = {Tool demo at the 14<sup>{th}</sup> International Working Conference on Source Code Analysis and Manipulation. 6 pages.},
  comment = {Tool demo at the 14<sup>{th}</sup> International Working Conference on Source Code Analysis and Manipulation.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Code and design smells ; SCAM},
  kind = {DEMO},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SCAM14ToolDemo.doc.pdf},
}

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.

@INPROCEEDINGS{Palma14-SOCA-ServiceAntiPatternChangeProneness,
  author = {Francis Palma and An Le and Foutse Khomh and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Investigating the Change-Proneness of Service Patterns and Antipatterns},
  booktitle = {Proceedings of the 7<sup>{th}</sup> International Conference on Service-Oriented Computing and Applications ({SOCA})},
  year = {2014},
  month = {November},
  editor = {Christian Huemer},
  publisher = {IEEE CS Press},
  note = {8 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; SOCA},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SOCA14.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SOCA14.ppt.pdf},
  pages = {1--8}
}

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.

@ARTICLE{Sakti14-TSE-JTExpert,
  author = {Abdelilah Sakti and Gilles Pesant and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Instance Generator and Problem Representation to Improve Object Oriented Code Coverage},
  journal = {Transactions on Software Engineering ({TSE})},
  year = {2014},
  month = {October},
  volume = {40},
  number = {99},
  pages = {1--22},
  note = {22 pages.},
  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.},
  editor = {Matthew B.\ Dwyer},
  grant = {NSERC DG and FQRNT team grant},
  keywords = {Test case generation ; TSE},
  kind = {RIAS},
  language = {english},
  publisher = {IEEE CS Press},
  url = {http://www.ptidej.net/publications/documents/TSE14b.doc.pdf}
}

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.

@ARTICLE{Medini14-JSEP-SCAN,
  author = {Soumaya Medini and Venera Arnaoudova and Massimiliano {Di Penta} and Giulian Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Paolo Tonella},
  title = {{SCAN}: An Approach to Label and Relate Execution Trace Segments},
  journal = {Journal of Software: Evolution and Process ({JSEP})},
  year = {2014},
  month = {November},
  volume = {26},
  number = {11},
  pages = {962--995},
  note = {33 pages.},
  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.},
  editor = {Rocco Oliveto and Denys Poshyvanyk},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Features and requirements ; JSME-JSEP},
  kind = {RIAS},
  language = {english},
  publisher = {Wiley},
  url = {http://www.ptidej.net/publications/documents/JSEP14.doc.pdf}
}

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.

@PROCEEDINGS{APSEC14,
  title = {Proceedings of the 21<sup>{th}</sup> Asia-Pacific Software Engineering Conference},
  year = {2014},
  month = {December},
  editor = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gi-hwon Kwon},
  publisher = {IEEE CS Press},
  kind = {ACA},
  language = {english}
}

@MISC{Gueheneuc14-WebZine-InterviewMical,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Entrevue avec Robert J. Mical (Traduction)},
  year = {2014},
  month = {juillet},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/itwmical.php}
}

Publication d'une entrevue avec Robert J. Mical, un des développeurs de l'AmigaOS d'origine. Il s'agit de sa première entrevue, datant de 1987, où il raconte les développements en cours de l'époque mais aussi quelques faits historiques.

@MISC{Gueheneuc14-WebZine-ArtEffectTouchingUp,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {En pratique : Art Effect 4 - retoucher une image (trottoir) (Traduction)},
  year = {2014},
  month = {f{\'e}vrier},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  abstract = {Dans ce tutoriel, vous allez retoucher un trottoir en face d'un bar et le remplacer par une plage de galets.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/arteffect_retouches_trottoir.php}
}

Dans ce tutoriel, vous allez retoucher un trottoir en face d'un bar et le remplacer par une plage de galets.

@MISC{Gueheneuc14-WebZine-AndrewMorris,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Entrevue avec Andrew Morris (Traduction)},
  year = {2014},
  month = {d{\'e}cembre},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/itwmorris.php}
}

À 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éalisa les graphismes pour Super Scramble Simulator et ceux de grands jeux de Gremlin/Magnetic Fields, comme Super Cars et la série des Lotus.

@MISC{Gueheneuc14-WebZine-InterviewPlatt,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Entrevue avec Randy Platt (Traduction)},
  year = {2014},
  month = {octobre},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  abstract = {Voici une entrevue avec Randy Platt, programmeur de jeux vid{\'e}o chez Cinemaware (1987-1991).},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/itwplatt.php}
}

Voici une entrevue avec Randy Platt, programmeur de jeux vidéo chez Cinemaware (1987-1991).

@MISC{Gueheneuc14-WebZine-CES86,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Reportage : Consumer Electronic Show Summer 1986 (Traduction)},
  year = {2014},
  month = {avril},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  abstract = {Retour sur le Consumer Electronic Show Summer 1986, un salon informatique qui s'est tenu en juin 1986.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/ces_ete_1986.php}
}

Retour sur le Consumer Electronic Show Summer 1986, un salon informatique qui s'est tenu en juin 1986.

@MISC{Gueheneuc13-WebZine-AustralianRoadshow,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Entrevue avec Bill McEwen et Dick Van Dyke (Traduction)},
  year = {2014},
  month = {janvier},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/itwmcewen_vandyke.php}
}

Steve Young de CNN Financial Network a rencontré Bill McEwen, nouveau président d'Amiga Inc. et Dick Van Dyke, une célébrité du cinéma.

@INPROCEEDINGS{Duclos13-CSMR-ACRE,
  author = {{\'E}tienne Duclos and S{\'e}bastien {Le Digabel} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Bram Adams},
  title = {{ACRE}: An Automated Aspect Creator for Testing {C++} Applications},
  booktitle = {Proceedings of the 17<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2013},
  month = {March},
  editor = {Anthony Cleve and Filippo Ricca},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Test-case generation ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR13b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR13b.ppt.pdf},
  pages = {121--130}
}

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.

@INPROCEEDINGS{Sakti13-CPAIOR-ConstraintFitness,
  author = {Abdelilah Sakti and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gilles Pesant},
  title = {Constraint-based Fitness Function for Search-Based Software Testing},
  booktitle = {Proceedings of the 10<sup>{th}</sup> International Conference on Integration of Artificial Intelligence and Operations Research in Constraint Programming ({CPAIOR})},
  year = {2013},
  month = {May},
  editor = {Carla Gomes and Meinolf Sellmann},
  publisher = {Springer},
  note = {Short paper. 4 pages.},
  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.},
  grant = {NSERC DG and FQRNT team grant},
  keywords = {Test case generation ; CPAIOR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CPAIOR13.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CPAIOR13.ppt.pdf},
  pages = {378--385},
  comment = {Short paper.}
}

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.

@INPROCEEDINGS{Sabane13-CSMR-CostUnitTestAntipatterns,
  author = {Aminata Saban{\'e} and Massimiliano {Di Penta} and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Study on the Relation Between Antipatterns and the Cost of Class Unit Testing},
  booktitle = {Proceedings of the 17<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2013},
  month = {March},
  editor = {Anthony Cleve and Filippo Ricca},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Test-case generation ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR13a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR13a.ppt.pdf},
  pages = {167--176}
}

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.

@INPROCEEDINGS{Jaafar13-CSMR-MacroCoChangeBugProneness,
  author = {Fehmi Jaafar and Salima Hassaine and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel and Bram Adams},
  title = {On the Relationship Between Program Evolution and Fault-proneness: An Empirical Study},
  booktitle = {Proceedings of the 17<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2013},
  month = {March},
  editor = {Anthony Cleve and Filippo Ricca},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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. },
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR13c.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR13c.ppt.pdf},
  pages = {15--24}
}

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.

@INPROCEEDINGS{Jaafar13-PPAP-AntipatternDependencies,
  author = {Fehmi Jaafar and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel},
  title = {Analysing Anti-patterns Static Relationships with Design Patterns},
  booktitle = {Proceedings of the 1<sup>{st}</sup> International Workshop on Patterns Promotion and Anti-patterns Prevention ({PPAP})},
  year = {2013},
  month = {March},
  editor = {Surafel Lemma Abebe and Venera Arnaoudova and Laleh Eshkevari and Aminata Saban{\'e} and Wei Wu},
  publisher = {{\'E}PM},
  note = {6 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Code and design smells ; Design patterns ; PPAP},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/PPAP13a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/PPAP13a.ppt.pdf}
}

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.

@INPROCEEDINGS{Jaafar13-WCRE-AntipatternsFaults,
  author = {Fehmi Jaafar and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel and Foutse Khomh},
  title = {Mining the Relationship Between Anti-patterns Dependencies and Fault-proneness},
  booktitle = {Proceedings of the 20<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2013},
  month = {October},
  editor = {Rocco Oliveto and Romain Robbes},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Code and design smells ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE13c.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE13c.ppt.pdf}
}

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.

@INPROCEEDINGS{Palma13-MRIBP-BPELAntipatterns,
  author = {Francis Palma and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Detection of Process Antipatterns: A BPEL Perspective},
  booktitle = {Proceedings of the 1<sup>{st}</sup> Workshop on Methodologies for Robustness Injection into Business Processes ({MRI-BP})},
  year = {2013},
  month = {September},
  editor = {Hafedh Mili and Yasmine Charif and Emily Liu},
  publisher = {IEEE CS Press},
  note = {5 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Code and design smells ; MRI-BP},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/MRIBP13.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/MRIBP13.ppt.pdf},
  pages = {N/A}
}

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 \emphantipatterns, \emphi.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.

@ARTICLE{Guerrouj13-EMSE-TIDIER,
  author = {Latifa Guerrouj and Massimiliano {Di Penta} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Experimental Investigation on the Effects of Context on Source Code Identifiers Splitting and Expansion},
  journal = {Empirical Software Engineering (EMSE)},
  year = {2013},
  month = {July},
  pages = {1--48},
  note = {45 pages.},
  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.},
  editor = {Victor R. Basili and Lionel C. Briand},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Identifier analysis ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE13.doc.pdf}
}

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.

@INPROCEEDINGS{DaSilvaJr13-PPAP-SecurityPatterns,
  author = {Luis Sergio {Da Silva} Jr. and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and John Mullins},
  title = {An Approach to Formalise Security Patterns},
  booktitle = {Proceedings of the 1<sup>{st}</sup> International Workshop on Patterns Promotion and Anti-patterns Prevention ({PPAP})},
  year = {2013},
  month = {March},
  editor = {Surafel Lemma Abebe and Venera Arnaoudova and Laleh Eshkevari and Aminata Saban{\'e} and Wei Wu},
  publisher = {{\'E}PM},
  note = {6 pages.},
  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.},
  grant = {MITACS Globalink and CRC on Software Patterns},
  keywords = {Code and design smells ; PPAP},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/PPAP13b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/PPAP13b.ppt.pdf},
  pages = {N/A}
}

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.

@ARTICLE{Ali13-TSE-Trustrace,
  author = {Nasir Ali and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {{Trustrace}: Mining Software Repositories to Improve the Accuracy of Requirement Traceability Links},
  journal = {Transactions on Software Engineering ({TSE})},
  year = {2013},
  month = {May},
  volume = {39},
  number = {5},
  pages = {725--741},
  note = {20 pages.},
  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.},
  editor = {Tetsuo Tamai},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Features and requirements ; TSE},
  kind = {RIAS},
  language = {english},
  publisher = {IEEE CS Press},
  url = {http://www.ptidej.net/publications/documents/TSE13a.doc.pdf},
  page = {1--20}
}

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.

@ARTICLE{Kpodjedo13-JSME-ETGMEvolution,
  author = {S{\'e}gla Kpodjedo and Filippo Ricca and Philippe Galinier and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Studying Software Evolution of Large Object-oriented Software Systems using an {ETGM} Algorithm},
  journal = {Journal of Software Maintenance and Evolution: Research and Practice ({JSME})},
  year = {2013},
  month = {September},
  volume = {25},
  number = {2},
  pages = {139--163},
  note = {28 pages.},
  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.},
  editor = {Gerardo Canfora and David Raffo and Darren Dalcher},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; JSME-JSEP},
  kind = {RIAS},
  language = {english},
  publisher = {Wiley},
  url = {http://www.ptidej.net/publications/documents/JSME10.doc.pdf}
}

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, ıe Rhino, medium, ıe Azureus and ArgoUML, and large systems, ıe Mozilla and Eclipse.

@ARTICLE{Kpodjedo13-TSE-MADMatch,
  author = {S{\'e}gla Kpodjedo and Filippo Ricca and Philippe Galinier and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{MADMatch}: Many-to-many Approximate Diagram Matching for Design Comparison},
  journal = {Transactions on Software Engineering ({TSE})},
  year = {2013},
  month = {Feburary},
  volume = {39},
  number = {8},
  pages = {1090--1111},
  note = {23 pages.},
  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.},
  editor = {Martin Robillard},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; TSE},
  kind = {RIAS},
  language = {english},
  publisher = {IEEE CS Press},
  url = {http://www.ptidej.net/publications/documents/TSE13b.doc.pdf},
  page = {1--23}
}

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.

@INPROCEEDINGS{Arnaoudova13-CSMR-LinguisticAntipatterns,
  author = {Venera Arnaoudova and Massimiliano {Di Penta} and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A New Family of Software Anti-Patterns: Linguistic Anti-Patterns},
  booktitle = {Proceedings of the 17<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2013},
  month = {March},
  editor = {Anthony Cleve and Filippo Ricca},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Linguistic smells ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR13d.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR13d.ppt.pdf},
  pages = {187--196}
}

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, ıe 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.

@MISC{Wu13-CSER-MOFAE,
  author = {Wei Wu and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {{MOFAE}: Multi-objective Optimization Approach to Framework {API} Evolution},
  year = {2013},
  month = {June},
  note = {Poster at the 2013 Spring Meeting of the Consortium for Software Engineering Research. 24 pages.},
  comment = {Poster at the 2013 Spring Meeting of the Consortium for Software Engineering Research.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Evolution patterns ; CSER},
  kind = {MNADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSER13.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSER13.ppt.pdf}
}

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.

@TECHREPORT{Wu13-TR-HALO,
  author = {Wei Wu and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Miryung Kim},
  title = {{Halo}: A Multi-feature Two-pass Analysis to Identify Framework {API} Evolution},
  year = {2013},
  month = {June},
  note = {24 pages.},
  institution = {{\'E}cole Polytechnique de Montr{\'e}al},
  number = {EPM-RT-2013-05},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Evolution patterns},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+HALO+June13.doc.pdf}
}

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.

@TECHREPORT{Soh13-TR-MylynInteractionHistories,
  author = {Z{\'e}phyrin Soh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Towards the exploration strategies by mining Mylyn's interaction histories},
  year = {2013},
  month = {February},
  note = {24 pages.},
  institution = {{\'E}cole Polytechnique de Montr{\'e}al},
  number = {EPM-RT-2013-01},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Understanding program comprehension},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+MylynIH+Mar13.doc.pdf}
}

When developers perform a maintenance task, they always explore the program, ıe 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.

@INPROCEEDINGS{Soh13-WCRE-MatchingEffortTasks,
  author = {Z{\'e}phyrin Soh and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Towards Understanding How Developers Spend Their Effort During Maintenance Activities},
  booktitle = {Proceedings of the 20<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2013},
  month = {October},
  editor = {Rocco Oliveto and Romain Robbes},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Understanding program comprehension ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE13b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE13b.ppt.pdf},
  pages = {152--161}
}

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.

@INPROCEEDINGS{Soh13-WCRE-ProgramExploration,
  author = {Z{\'e}phyrin Soh and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Bram Adams},
  title = {On the Effect of Program Exploration on Maintenance Tasks},
  booktitle = {Proceedings of the 20<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2013},
  month = {October},
  editor = {Rocco Oliveto and Romain Robbes},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Understanding program comprehension ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE13a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE13a.ppt.pdf},
  pages = {391--400}
}

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.

@INPROCEEDINGS{Sharafi13-ICPC-EfficiencyTextvsGraph,
  author = {Zohreh Sharafi and Alessandro Marchetto and Angelo Susi and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {An Empirical Study on the Efficiency of Graphical vs.\ Textual Representations in Requirements Comprehension},
  booktitle = {Proceedings of the 21<sup>{st}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2013},
  month = {May},
  editor = {Denys Poshyvanyk and Massimiliano {Di Penta}},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Understanding program comprehension ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC13.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC13.ppt.pdf}
}

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.

@ARTICLE{Joyal13-JMIRResProtoc,
  author = {Joyal Miranda and Jos{\'e} C{\^o}t{\'e} and Gaston Godin and Martin Blais and Joanne Otis and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Ghayas Fadel and Luisa Barton and Shawn Fowler},
  title = {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},
  journal = {JMIR Research Protocols},
  year = {2013},
  month = {October},
  volume = {2},
  number = {2},
  pages = {e39},
  note = {8 pages.},
  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.},
  editor = {Gunther Eysenbach},
  grant = {NSERC DG},
  keywords = {VIHTAVIE ; JMIRResProtoc},
  kind = {RIAS},
  language = {english},
  publisher = {Journal of Medical Internet Research},
  url = {http://www.ptidej.net/publications/documents/JMIRResProtoc13.doc.pdf}
}

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.

@PROCEEDINGS{ICSM13,
  title = {Proceedings of the 29<sup>{th}</sup> International Conference on Software Maintenance},
  year = {2013},
  month = {September},
  editor = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Tom Mens},
  publisher = {IEEE CS Press},
  kind = {ACA},
  language = {english}
}

@MISC{Gueheneuc13-WebZine-ArtEffectWatermarks,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {En pratique : Art Effect 4 - r{\'e}aliser des filigranes (Traduction)},
  year = {2013},
  month = {ao{\^u}t},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  abstract = {Dans ce tutoriel, vous allez apprendre comment faire des filigranes.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/arteffect_filigranes.php}
}

Dans ce tutoriel, vous allez apprendre comment faire des filigranes.

@MISC{Gueheneuc13-WebZine-LureOfTheTemptress,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Test de Lure Of The Temptress},
  year = {2013},
  month = {juillet},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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...},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/lureofthetemptress.php}
}

Lure Of The Temptress est un jeu informatique conçu pour l'Amiga, l'Atari ST et le DOS, développé par Revolution Software et distribué 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éressante, une intrigue prenante, de beaux graphismes, une belle trame sonore et fait bien rire avec ses dialogues assez spirituels...

@MISC{Gueheneuc13-WebZine-GeekGadgetsInstallation,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Installation de Geek Gadgets sur AmigaOS 3.x},
  year = {2013},
  month = {janvier},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/installation_geek_gadgets.php}
}

Les Geek Gadgets ont pour objectif d'offrir un environnement UN*X complet sur l'Amiga. Ils se décomposent essentiellement en trois choses : d'abord, d'une bibliothèque émulant des fonctions UN*X pour rendre la vie facile aux développeurs, il s'agit de ixemul.library. Ensuite, les Geek Gadgets incluent de nombreux outils UN*X portés sur Amiga, grâce à IXEmul. Enfin, il s'agit d'un environnement de compilation permettant de recompiler des outils UN*X sur Amiga en faisant appel à IXEmul.

@MISC{Gueheneuc13-WebZine-Comparatifs,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Comparatifs : quelques correctifs AmigaOS 68k (processeur et op{\'e}rations sur disque)},
  year = {2013},
  month = {Mai},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/comparatifs_correctifs_amiga.php}
}

Voici donc un petit résumé de quelques correctifs appliqués sur mon Amiga 1200/040 avec AmigaOS 3.x : BlizKick, SetPatch, RalLibPatch, PoolMem, CopyMem040.safe, FBlit, SystemPatch et PFS3.

@INPROCEEDINGS{Maiga12-ASE-FeedbackAntipatterns,
  author = {Abddou Maiga and Nasir Ali and Neelesh Bhattacharya and Aminata Saban{\'e} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Esma Aimeur},
  title = {Support Vector Machines for Anti-pattern Detection},
  booktitle = {Proceedings of the 27<sup>{th}</sup> Conference on Automated Software Engineering ({ASE})},
  year = {2012},
  month = {September},
  editor = {Tim Menzies and Motoshi Saeki},
  publisher = {ACM Press},
  note = {Short paper. 4 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; ASE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ASE12.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ASE12.ppt.pdf},
  pages = {278--281},
  comment = {Short paper.}
}

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.

@INPROCEEDINGS{Sakti12-SSBSE-BoostingSBTwithCBT,
  author = {Abdelilah Sakti and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gilles Pesant},
  title = {Boosting Search-Based Testing by using Constraint-based Testing},
  booktitle = {Proceedings of the 4<sup>{th}</sup> Symposium on Search Based Software Engineering ({SSBSE})},
  year = {2012},
  month = {September},
  editor = {Gordon Fraser and Jerffeson Teixeira de Souza},
  publisher = {IEEE CS Press},
  note = {15 pages.},
  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.},
  grant = {NSERC DG and FQRNT team grant},
  keywords = {Test case generation ; SSBSE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SSBSE12a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SSBSE12a.ppt.pdf},
  pages = {213--227}
}

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.

@INPROCEEDINGS{Maiga12-WCRE-SMURF,
  author = {Abdou Maiga and Nasir Ali and Neelesh Bhattacharya and Aminata Saban{\'e} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Esma Aimeur},
  title = {SMURF: {A} {SVM}-based Incremental Anti-pattern Detection Approach},
  booktitle = {Proceedings of the 19<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2012},
  month = {October},
  editor = {Rocco Oliveto and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE12a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE12a.ppt.pdf},
  pages = {466--475}
}

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.

@ARTICLE{DeSmet11-SCP-Taupe,
  author = {Beno{\^\i}t de Smet and Lorent Lempereur and Zohreh Sharafi and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Naji Habra},
  title = {{Taupe}: Visualising and Analysing Eye-tracking Data},
  journal = {Science of Computer Programming ({SCP})},
  year = {2012},
  month = {February},
  volume = {79},
  pages = {260--278},
  note = {2<sup>{nd}</sup> special issue on Experimental Software and Toolkits. 20 pages.},
  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 \taupe{} software system to help researchers visualise, analyse and edit the data recorded by eye-tracking devices. The two main objectives of \taupe{} 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 \taupe{}: (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 \taupe{}, the architectural and design choices made during its development, and its documentation, validation and verification process. It also illustrates the application of \taupe{} in three experiments on the use of design patterns by developers during program comprehension.},
  editor = {Mark van den Brand},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; SCP},
  kind = {RIAS},
  language = {english},
  publisher = {Elsevier},
  url = {http://www.ptidej.net/publications/documents/SCP11.doc.pdf},
  comment = {2<sup>{nd}</sup> special issue on Experimental Software and Toolkits.}
}

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 τpe software system to help researchers visualise, analyse and edit the data recorded by eye-tracking devices. The two main objectives of τpe 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 τpe: (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 τpe, the architectural and design choices made during its development, and its documentation, validation and verification process. It also illustrates the application of τpe in three experiments on the use of design patterns by developers during program comprehension.

@TECHREPORT{Duclos12-TR-ACRE,
  author = {Etienne Duclos and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and S{\'e}bastien {Le Digabel}},
  title = {{ACRE}: An {A}utomated {A}spect {C}reator for {T}esting {C}++ {A}pplications},
  year = {2012},
  month = {June},
  note = {17 pages.},
  institution = {Les cahiers du GERAD},
  number = {G-2012-19},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Test-case generation ; CSMR},
  kind = {RR},
  language = {english},
  url = {http://goo.gl/kO8zw}
}

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.

@ARTICLE{Khomh11-EMSE-AntiPatternsImpact,
  author = {Foutse Khomh and Massimiliano {Di Penta} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Exploratory Study of the Impact of Antipatterns on Class Change- and Fault-Proneness},
  journal = {Empirical Software Engineering ({EMSE})},
  year = {2012},
  month = {June},
  volume = {17},
  number = {3},
  pages = {243--275},
  note = {27 pages.},
  abstract = {{\bf Context: } Antipatterns are poor design choices that are conjectured to make object-orien\-ted systems harder to maintain. \newline\noindent {\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. \newline\noindent {\bf Method: } We detect \numberofap{} antipatterns in \numberofver{} 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. \newline\noindent {\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. \newline\noindent {\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.},
  editor = {Victor R. Basili and Lionel C. Briand},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE11b.doc.pdf}
}

\bf Context: Antipatterns are poor design choices that are conjectured to make object-orien­ted systems harder to maintain. \newline\noindent \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. \newline\noindent \bf Method: We detect νmberofap antipatterns in νmberofver 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. \newline\noindent \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. \newline\noindent \bf Conclusions: The obtained results justify \empha posteriori previous work on the specification and detection of antipatterns and could help to better focus quality assurance and testing activities.

@INPROCEEDINGS{Palma12-RSSE-DPR,
  author = {Francis Palma and Hadi Farzin and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Naouel Moha},
  title = {Recommendation System for Design Patterns in Software Development: {A} {DPR} Overview},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> International Workshop on Recommendation Systems for Software ({RSSE})},
  year = {2012},
  month = {June},
  editor = {Walid Maalej and Martin Robillard and Robert J. Walker and Thomas Zimmermann},
  publisher = {ACM Press},
  note = {5 pages.},
  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 \textit{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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Design patterns ; RSSE},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/RSSE12.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/RSSE12.ppt.pdf},
  pages = {N/A}
}

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

@INPROCEEDINGS{Guerrouj12-WCRE-TRIS,
  author = {Latifa Guerrouj and Philippe Galinier and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Massimiliano {Di Penta}},
  title = {{TRIS}: a Fast and Accurate Identifiers Splitting and Expansion Algorithm},
  booktitle = {Proceedings of the 19<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2012},
  month = {October},
  editor = {Rocco Oliveto and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Identifier analysis ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE12b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE12b.ppt.pdf},
  pages = {103--112}
}

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, ıe 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.

@MISC{Nayrolles12-Demo-ICSOC,
  author = {Mathieu Nayrolles and Francis Palma and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Soda}: A Tool Support for the Detection of {SOA} Antipatterns},
  year = {2012},
  month = {November},
  note = {Tool demo at the 11<sup>{th}</sup> International Conference on Service Oriented Computing. 4 pages.},
  comment = {Tool demo at the 11<sup>{th}</sup> International Conference on Service Oriented Computing.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Code and design smells ; ICSOC},
  kind = {DEMO},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSOC12ToolDemo.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSOC12ToolDemo.ppt.pdf}
}

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.

@INPROCEEDINGS{Ali12-SCAM-ImprovingBugLocationBCR,
  author = {Nasir Ali and Aminata Saban{\'e} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Improving Bug Location Using Binary Class Relationships},
  booktitle = {Proceedings of the 12<sup>{th}</sup> International Working Conference on Source Code Analysis and Manipulation ({SCAM})},
  year = {2012},
  month = {September},
  editor = {Mariano Ceccato and Zheng Li},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Binary class relations ; Features and requirements ; SCAM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SCAM12.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SCAM12.ppt.pdf},
  pages = {174--183}
}

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.

@INPROCEEDINGS{Ali12-ICSM-RequirementsEyetracking,
  author = {Nasir Ali and Zohreh Sharafi and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Empirical Study on Requirements Traceability Using Eye-Tracking},
  booktitle = {Proceedings of the 28<sup>{th}</sup> International Conference on Source Maintenance ({ICSM})},
  year = {2012},
  month = {September},
  editor = {Massimiliano {Di Penta} and Jonathan I. Maletic},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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}$.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Requirement traceability ; Understanding program comprehension ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM12.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM12.ppt.pdf},
  pages = {191--200}
}

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}$.

@INBOOK{Ali11-SST-FactorImpactingTraceability,
  author = {Nasir Ali and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Factors Impacting the Inputs of Traceability Recovery Approaches},
  chapter = {7},
  booktitle = {Software and Systems Traceability ({SST})},
  pages = {99--127},
  publisher = {Springer},
  year = {2012},
  month = {September},
  note = {28 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Features and requirements ; SST},
  kind = {CDL},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SST11.doc.pdf},
  editor = {Andrea Zisman and Jane Cleland-Huang}
}

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 \emphsource document, \emphtarget document, and \emphexperts' 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.

@INPROCEEDINGS{Bhattacharya12-SSBSE-ThreadAlignment,
  author = {Neelesh Bhattacharya and Olfat El-Mahi and Etienne Duclos and Giovanni Beltrame and Giuliano Antoniol and S{\'e}bastien {Le Digabel} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Optimizing Threads Schedule Alignments to Expose the Interference Bug Pattern},
  booktitle = {Proceedings of the 4<sup>{th}</sup> Symposium on Search Based Software Engineering ({SSBSE})},
  year = {2012},
  month = {September},
  editor = {Gordon Fraser and Jerffeson Teixeira de Souza},
  publisher = {IEEE CS Press},
  note = {15 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Test case generation ; SSBSE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SSBSE12b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SSBSE12b.ppt.pdf},
  pages = {90--104}
}

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.

@INPROCEEDINGS{Hassaine12-CSMR-ADvISE,
  author = {Salima Hassaine and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel and Giuliano Antoniol},
  title = {ADvISE: Architectural Decay In Software Evolution},
  booktitle = {Proceedings of the 16<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2012},
  month = {March},
  editor = {Tom Mens, Anthony Cleve, Rudolf Ferenc},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR12.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR12.ppt.pdf},
  pages = {267--276}
}

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.

@INPROCEEDINGS{Medini12-WCRE-SCAN,
  author = {Soumaya Medini and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Massimiliano {Di Penta} and Paolo Tonella},
  title = {SCAN: an Approach to Label and Relate Execution Trace Segments},
  booktitle = {Proceedings of the 19<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2012},
  month = {October},
  editor = {Rocco Oliveto and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {Best paper. 10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Features and requirements ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE12c.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE12c.ppt.pdf},
  pages = {135--144},
  comment = {Best paper.}
}

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.

@INPROCEEDINGS{Abebe12-WCRE-LBS,
  author = {Surafel Lemma Abebe and Paolo Tonella and Venera Arnaoudova and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Can Lexicon Bad Smells Improve Fault Prediction?},
  booktitle = {Proceedings of the 19<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2012},
  month = {October},
  editor = {Rocco Oliveto and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE12d.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE12d.ppt.pdf},
  pages = {235--244}
}

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.

@INPROCEEDINGS{Soh12-ICPC-StatusExpertise,
  author = {Z{\'e}phyrin Soh and Zohreh Sharafi and Bertrand van den Plas and Gerardo {Cepeda Porras} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Professional Status and Expertise for UML Class Diagram Comprehension: {A}n Empirical Study},
  booktitle = {Proceedings of the 20<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2012},
  month = {June},
  editor = {Arie van Deursen and Michael W. Godfrey},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC12a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC12a.ppt.pdf},
  pages = {163--172}
}

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.

@INPROCEEDINGS{Sharafi12-ICPC-MenWomen,
  author = {Zohreh Sharafi and Z{\'e}phyrin Soh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Women \& Men -- Different but Equal: {O}n the Impact of Identifier Style on Source Code Reading},
  booktitle = {Proceedings of the 20<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2012},
  month = {June},
  editor = {Arie van Deursen and Michael W. Godfrey},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC12b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC12b.ppt.pdf},
  pages = {27--36}
}

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.

@INPROCEEDINGS{Cote12-Medicine20-VIHTAVIESelfManagement,
  author = {Jos{\'e} C{\^o}t{\'e} and Genevi{\`e}ve Rouleau and Pilar Ramirez-garcia and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gaston Godin and Annick Hernandez},
  title = {VIH-TAVIE: Tailored Virtual Support for Better Self-Management of Antiretroviral Therapy},
  booktitle = {Proceedings of the 5<sup>{th}</sup> World Congress on Social Media, Mobile Apps, and Internet/Web 2.0 in Health, Medicine and Biomedical Research ({Medicine 2.0})},
  year = {2012},
  month = {September},
  publisher = {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.},
  grant = {FRSQ team grant},
  keywords = {VIHTAVIE ; Medicine 2.0},
  kind = {MNADR},
  language = {english},
  url = {http://www.medicine20congress.com/ocs/index.php/med/med2012/schedConf/presentations},
  relevance = {100},
  relevantfor = {Web support; HIV/Aids}
}

Background: The VIH-TAVIE (VIH � Traitement Assistance Virtuelle Infirmiè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.

@ARTICLE{Cote12-Telemedecie-AcceptabilityFeasabilityStudy,
  author = {Jos{\'e} C{\^o}t{\'e} and Genevi{\`e}ve Rouleau and Gaston Godin and Pilar Ramirez-Garc{\`\i}a and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Georgette Nahas and C{\'e}cile Tremblay and Joanne Otis and Annick Hernandez},
  title = {Acceptability and Feasibility Study of a Virtual Intervention to Help Persons Living with {HIV} Manage their Daily Therapies},
  journal = {Journal of Telemedecine and Telecare ({JTT})},
  year = {2012},
  month = {October},
  volume = {18},
  number = {7},
  pages = {409--421},
  note = {12 pages.},
  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. \newline 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. \newline 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. \newline Conclusion. Still only at an experimental stage, the VIH-TAVIE approach is intended to be complementary to clinical follow-up.},
  editor = {Elizabeth Krupinski},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {VIHTAVIE ; JTT},
  kind = {RIAS},
  language = {english},
  publisher = {Royal Society of Medicine Press},
  url = {http://www.ptidej.net/publications/documents/JTT12.doc.pdf}
}

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. \newline 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. \newline 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. \newline Conclusion. Still only at an experimental stage, the VIH-TAVIE approach is intended to be complementary to clinical follow-up.

@INPROCEEDINGS{Cote12-Medicine20-VIHTAVIEVirtualNursing,
  author = {Jos{\'e} C{\^o}t{\'e} and Genevi{\`e}ve Rouleau and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gaston Godin and Pilar Ramirez-garcia and Annick Hernandez and G{\'e}raldine Martorella and Sylvie Cossette },
  title = {Virtual Nursing Interventions: Tailored Real-Time Support for People Living with a Chronic Health Problem},
  booktitle = {Proceedings of the 5<sup>{th}</sup> World Congress on Social Media, Mobile Apps, and Internet/Web 2.0 in Health, Medicine and Biomedical Research ({Medicine 2.0})},
  year = {2012},
  month = {September},
  publisher = {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.},
  grant = {FRSQ team grant},
  keywords = {VIHTAVIE ; Medicine 2.0},
  kind = {MNADR},
  language = {english},
  url = {http://www.medicine20congress.com/ocs/index.php/med/med2012/schedConf/presentations},
  relevance = {100},
  relevantfor = {Web support; HIV/Aids}
}

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è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.

@INPROCEEDINGS{Cote12-WebSupportVIH,
  author = {Jos{\'e} C{\^o}t{\'e} and Genevi{\`e}ve Rouleau and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Pilar Ramirez-Garc{\`\i}a and Gaston Godin and Joanne Otis and Riyas Fadel and C{\'e}cile Tremblay},
  title = {{HIV-MEDIC} Online: Evaluation of a {W}eb-based Intervention to Better Support People Living with {HIV} ({PLHIV}) for Taking Their Antiretroviral Therapy},
  booktitle = {Proceedings of the 21<sup>{th}</sup> Canadian Conference on {HIV/Aids} Research ({CAHR})},
  year = {2012},
  month = {April},
  editor = {Pierre C{\^o}t{\'e} and Jean-Pierre Routy},
  publisher = {Pulsus Group},
  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.},
  grant = {FRSQ team grant},
  keywords = {VIHTAVIE ; CAHR},
  kind = {MNADR},
  language = {english},
  url = {http://www.cahr-acrv.ca/english/resources/archive.html},
  relevance = {100},
  relevantfor = {Web support; HIV/Aids}
}

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.

@ARTICLE{Cote12-TRIALS-EvaluationHIV,
  author = {Jos{\'e} Cot{\'e} and Gaston Godin and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Genevi{\`e}ve Rouleau and Pilar Ramirez-Garcia and Joanne Otis and C{\'e}cile Tremblay and Ghayas Fadel},
  title = {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},
  journal = {Trials Journal ({Trials})},
  year = {2012},
  month = {December},
  volume = {13},
  number = {1},
  note = {27 pages.},
  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.},
  editor = {Doug Altman and Curt Furberg and Jeremy Grimshaw and Peter Rothwell},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {VIHTAVIE ; Trials},
  kind = {RIAS},
  language = {english},
  publisher = {BioMed Central},
  url = {http://www.ptidej.net/publications/documents/Trials12.doc.pdf}
}

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.

@INPROCEEDINGS{DiPenta12-SEE-PASED,
  author = {Massimiliano {Di Penta} and Giuliano Antoniol and Daniel M. German and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Bram Adams},
  title = {Five Days of Empirical Software Engineering: the PASED Experience},
  booktitle = {Proceedings of the 34<sup>{th}</sup> International Conference on Software Engineering ({ICSE})},
  year = {2012},
  month = {June},
  editor = {Jochen Ludewig and Hausi A. M{\"u}ller},
  publisher = {ACM Press},
  note = {Software Engineering Education Track. 4 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {ICSE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SEE12.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SEE12.ppt.pdf},
  pages = {1255--1258},
  comment = {Software Engineering Education Track.}
}

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.

@INPROCEEDINGS{Moha12-ICSOC-DetectionSOAAntipatterns,
  author = {Naouel Moha and Francis Palma and Mathieu Nayrolles and Benjamin Joyen Conseil and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Benoit Baudry and Jean-Marc J{\'e}z{\'e}quel},
  title = {Specification and Detection of SOA Antipatterns},
  booktitle = {Proceedings of the 10<sup>{th}</sup> International Conference on Service Oriented Computing ({ICSOC})},
  year = {2012},
  month = {November},
  editor = {Chengfei Liu and Heiko Ludwig and Farouk Toumani},
  publisher = {Springer},
  note = {Runner-up best paper. 15 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; ICSOC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSOC12.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSOC12.ppt.pdf},
  pages = {1--16},
  comment = {Runner-up best paper.}
}

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.

@MISC{Gueheneuc12-WebZine-TestTowerOfBabel,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Test de Tower Of Babel},
  year = {2012},
  month = {d{\'e}cembre},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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...},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/towerofbabel.php}
}

Tower Of Babel est un jeu informatique pour l'Amiga, l'Atari ST et l'Archimedes d'Acorn créé par Pete Cooke, développé par Rainbird Software et distribué par MicroProse Software en 1990. C'est un jeu réflexion (puzzle) tridimensionel qui se déroule dans des tours en graphique vectoriel avec polygones pleins. Tower Of Babel est un jeu de réflexion très intéressant et parfois très difficile à résoudre...

@MISC{Gueheneuc12-WebZine-CompilePortTHTTPDAmiga,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Compiler/porter THTTPd sur AmigaOS 3.x},
  year = {2012},
  month = {juillet},
  note = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  comment = {Obligement, un magazine en ligne (webzine) d{\'e}di{\'e} au monde de l'Amiga.},
  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.},
  grant = {N/A},
  keywords = {Amiga ; Obligement},
  kind = {MNADR},
  language = {francais},
  url = {http://obligement.free.fr/articles/compiler_thttpd_amiga.php}
}

Voici les étapes pour recompiler/porter THTTPd v2.21b + PHP v4.2.3 sur AmigaOS 3.x. Ces étapes ont été toutes validées : le résultat que vous obtiendrez à la fin est visible sur ces pages, qui sont gérées avec THTTPd et PHP sur Amiga. Ces étapes font l'hypothèse que vous avez installé GCC v3.4.0 pour faire de la compilation croisée sur votre Windows/Cygwin et les Geek Gadgets sur votre Amiga, pour tester PHP.

@INPROCEEDINGS{Sakti11-JFPC-CPTestGeneration,
  author = {Abdelilah Sakti and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gilles Pesant},
  title = {CP-SST : approche bass{\'e}e sur la programmation par contraintes pour le test structurel du logiciel},
  booktitle = {Actes des 7<sup>{e}</sup> Journ{\'e}es Francophones de Programmation par Contraintes ({JFPC})},
  year = {2011},
  month = {juin},
  editor = {Arnaud Lallouet},
  publisher = {LIRIS},
  note = {10 pages.},
  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.},
  grant = {Projet en {\'e}quipe FQRNT},
  keywords = {Test case generation ; JFPC},
  kind = {MNSA},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/JFPC11.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/JFPC11.ppt.pdf},
  pages = {289--298}
}

Le coût du test peut facilement dépasser 50% du coût total d'un logiciel critique. Le test structurel est la stratégie de choix pour tester un système critique. En fonction de la criticité du système, différentes applications de test structurel sont exigées (analyse de couverture structurelle, génération des données de test, preuve de la post condition). Cet article s'intéresse au problème de combinaison des applications de test structurel, peu touché jusqu'à maintenant, qui peut faciliter l'automatisation du processus de test structurel et réduire de manière significative le nombre de données de test générées. Pour intégrer plusieurs applications de test structurel en une seule approche, nous modélisons le programme sous test et son graphe de flot et de contrôle (GFC) par un problème de satisfaction de contraintes (PSC). Nous utilisons une nouvelle classification des sommets du GFC, la dépendance de contrôle, les techniques statiques d'assignation unique (SSA) et l'inférence de la programmation par contraintes. Le modèle PSC que nous proposons conserve toute la sémantique structurelle du programme, cette caractéristique le rendant utilisable pour différentes applications de test structurel : analyser une couverture structurelle, générer des données de test ou prouver la post condition. Nos expérimentations sur des benchmarks traditionnels montrent un gain de temps par rapport aux approches existantes de test structurel.

@INPROCEEDINGS{Belderrar11-CSMR-SubgraphsEvolution,
  author = {Ahmed Belderrar and S{\'e}gla Kpodjedo and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Philippe Galinier},
  title = {Sub-graph Mining: Identifying Micro-architectures in Evolving Object-oriented Software},
  booktitle = {Proceedings of the 15<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2011},
  month = {March},
  editor = {Yiannis Kanellopoulos and Tom Mens},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR11b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR11b.ppt.pdf},
  pages = {171--180}
}

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.

@INPROCEEDINGS{Jaafar11-WCRE-MacroCoChange,
  author = {Fehmi Jaafar and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel and Giuliano Antoniol},
  title = {An Exploratory Study of Macro Co-changes},
  booktitle = {Proceedings of the 18<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2011},
  month = {October},
  editor = {Martin Pinzger and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE11a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE11a.ppt.pdf},
  pages = {325--334}
}

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 \emphmacro co-changes (MCC), ıe of artefacts that co-change within a large time interval, and of \emphdephase macro co-changes (DMCC), ıe 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.

@ARTICLE{Khomh11-JSS-GQMBayesianDesignSmells,
  author = {Foutse Khomh and St{\'e}phane Vaucher and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Houari Sahraoui},
  title = {A {GQM}-based Method and a {B}ayesian Approach for the Detection of Code and Design Smells},
  journal = {Journal of Software and Systems ({JSS})},
  year = {2011},
  month = {April},
  volume = {84},
  number = {4},
  pages = {559--572},
  note = {35 pages.},
  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.},
  editor = {Hans van Vliet},
  grant = {NSERC DG},
  keywords = {Code and design smells ; JSS},
  kind = {RIAS},
  language = {english},
  publisher = {Elsevier},
  url = {http://www.ptidej.net/publications/documents/JSS11.doc.pdf},
  page = {559--572}
}

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, ∏uctGanttProject v1.10.2 and ∏uctXerces 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.

@INPROCEEDINGS{Eshkevari11-MSR-IdentifierRenamingTaxonomy,
  author = {Laleh Eshkevari and Venera Arnaoudova and Massimiliano {Di Penta} and Rocco Oliveto and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Exploratory Study of Identifier Renamings},
  booktitle = {Proceedings of the 8<sup>{th}</sup> Working Conference on Mining Software Repositories ({MSR})},
  year = {2011},
  month = {May},
  editor = {Tao Xie and Thomas Zimmermann},
  publisher = {ACM Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Quality models ; MSR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/MSR11.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/MSR11.ppt.pdf},
  pages = {33--42}
}

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.

@ARTICLE{Guerrouj11-JSME-TIDIER,
  author = {Latifa Guerrouj and Massimiliano {Di Penta} and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {TIDIER: An Identifier Splitting Approach using Speech Recognition Techniques},
  journal = {Journal of Software Maintenance and Evolution: Research and Practice ({JSME})},
  year = {2011},
  month = {June},
  volume = {25},
  number = {6},
  pages = {575-599},
  note = {24 pages.},
  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.},
  editor = {Rudolf Ferenc and Juan Carlos Due{\~n}as},
  grant = {NSERC DG},
  keywords = {Identifier analysis ; JSME-JSEP},
  kind = {RIAS},
  language = {english},
  publisher = {Wiley},
  url = {http://www.ptidej.net/publications/documents/JSME11.doc.pdf}
}

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.

@INPROCEEDINGS{Abbes11-CSMR-AntipatternsImpactComprehension,
  author = {Marwen Abbes and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Empirical Study of the Impact of Two Antipatterns, Blob and Spaghetti Code, On Program Comprehension},
  booktitle = {Proceedings of the 15<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2011},
  month = {March},
  editor = {Yiannis Kanellopoulos and Tom Mens},
  publisher = {IEEE CS Press},
  note = {Best paper. 10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; Understanding program comprehension ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR11a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR11a.ppt.pdf},
  pages = {181--190},
  comment = {Best paper.}
}

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.

@INPROCEEDINGS{Ali11-ICSM-Miniaturisation,
  author = {Nasir Ali and Wei Wu and Giuliano Antoniol and Massimiliano {Di Penta} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Jane Huffman Hayes},
  title = {MoMS: Multi-objective Miniaturization of Software},
  booktitle = {Proceedings of the 27<sup>{th}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2011},
  month = {September},
  editor = {James R. Cordy and Paolo Tonella},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Features and requirements ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM11a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM11a.ppt.pdf},
  pages = {153--162}
}

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, ØdMoMS, 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 ØdMoMS supports optimized miniaturization and helps reduce effort by 77%, on average, over a manual approach.

@INPROCEEDINGS{Ali11-WCRE-Partitioning,
  author = {Nasir Ali and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Requirements Traceability for Object Oriented Systems by Partitioning Source Code},
  booktitle = {Proceedings of the 18<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2011},
  month = {October},
  editor = {Martin Pinzger and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Requirement traceability ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE11b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE11b.ppt.pdf},
  pages = {45--54}
}

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 ıe 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.

@INPROCEEDINGS{Ali11-ICPC-TrustTraceability,
  author = {Nasir Ali and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Trust-Based Requirements Traceability},
  booktitle = {Proceedings of the 19<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2011},
  month = {June},
  editor = {Susan E. Sim and Filippo Ricca},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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<sup>{\text{VSM},~\text{Histrace}}</sup> in which we use Histrace as one expert adding knowledge to the traceability links extractted from CVS/SVN change logs. We apply Trustrace<sup>{\text{VSM},~\text{Histrace}}</sup> 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<sup>{\text{VSM},~\text{Histrace}}</sup> improves with statistical significance the precision of the traceability links while also improving recall but without statistical significance.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Requirement traceability ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC11c.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC11c.ppt.pdf},
  pages = {111--120}
}

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^{\textVSM, \textHistrace} in which we use Histrace as one expert adding knowledge to the traceability links extractted from CVS/SVN change logs. We apply Trustrace^{\textVSM, \textHistrace} 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^{\textVSM, \textHistrace} improves with statistical significance the precision of the traceability links while also improving recall but without statistical significance.

@INPROCEEDINGS{Bhattacharya11-ICST-P-CSPGAComparisonTestGeneration,
  author = {Neelesh Bhattacharya and Abdelilah Sakti and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gilles Pesant},
  title = {Performance Analysis of Metaheuristic and Constraint Programming Approaches to Generate Structural Test Cases},
  booktitle = {Proceedings of the 4<sup>{th}</sup> International Conference on Software Testing, Verification, and Validation ({ICST})},
  year = {2011},
  month = {March},
  editor = {Fevzi Belli and Michael Linschulte},
  publisher = {IEEE CS Press},
  note = {Poster. 2 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Test case generation ; ICST},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICST11.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICST11.ppt.pdf},
  pages = {N/A},
  comment = {Poster.}
}

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.

@INPROCEEDINGS{Bhattacharya11-SSBSE-DivideByZero,
  author = {Neelesh Bhattacharya and Abdelilah Sakti and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gilles Pesant},
  title = {Divide-by-zero Exceptions Raising via Branch Coverage},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> International Symposium on Search-based Software Engineering ({SSBSE})},
  year = {2011},
  month = {September},
  editor = {Myra Cohen and Mel {\'O} Cinn{\'e}ide},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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).},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Test case generation ; SSBSE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SSBSE11a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SSBSE11a.ppt.pdf},
  pages = {204--218}
}

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 \emphapproach level and \emphbranch distance. We then use different search strategies, ıe 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).

@ARTICLE{Kpodjedo11-EMSE-DesignEvolutionMetrics,
  author = {S{\'e}gla Kpodjedo and Filippo Ricca and Philippe Galinier and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Design Evolution Metrics for Defect Prediction in Object Oriented Systems},
  journal = {Empirical Software Engineering ({EMSE})},
  year = {2011},
  month = {February},
  volume = {16},
  number = {1},
  pages = {141--175},
  note = {34 pages.},
  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 \textit{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.},
  editor = {Simon Poulding and Massimiliano {Di Penta}},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE11a.doc.pdf},
  page = {141--175}
}

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 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.

@INPROCEEDINGS{Hassaine11-ICSM-ChangeImpactSeismology,
  author = {Salima Hassaine and Ferdaous Boughanmi and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel and Giuliano Antoniol},
  title = {A Seismology-inspired Approach for Change Impact Analysis},
  booktitle = {Proceedings of the 27<sup>{th}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2011},
  month = {September},
  editor = {James R. Cordy and Paolo Tonella},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM11b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM11b.ppt.pdf},
  pages = {53--62}
}

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.

@INPROCEEDINGS{Hassaine11-ICPC-P-EarthquakeSE,
  author = {Salima Hassaine and Ferdaous Boughanmi and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel and Giuliano Antoniol},
  title = {Change Impact Analysis: An Earthquake Metaphor},
  booktitle = {Proceedings of the 19<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2011},
  month = {June},
  editor = {Susan E. Sim and Filippo Ricca},
  publisher = {IEEE CS Press},
  note = {Poster. 2 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; ICPC},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC11a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC11a.ppt.pdf},
  pages = {209--210},
  comment = {Poster.}
}

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.

@INPROCEEDINGS{Medini11-SSBSE-FastConceptSplitting,
  author = {Soumaya Medini and Philippe Galinier and Massimiliano {Di Penta} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {A Fast Algorithm to Locate Concepts in Execution Traces},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> International Symposium on Search-based Software Engineering ({SSBSE})},
  year = {2011},
  month = {September},
  editor = {Myra Cohen and Mel {\'O} Cinn{\'e}ide},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Features and requirements ; SSBSE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SSBSE11b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SSBSE11b.ppt.pdf},
  pages = {252--266}
}

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.

@INPROCEEDINGS{Cote11-ISI-SuitablityFeasabilityVirtualNursing,
  author = {Jos{\'e} C{\^o}t{\'e} and Genevi{\`e}ve Rouleau and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gaston Godin and Pilar Ramirez-Garcia and Joanne Otis and Georgette Nahas},
  title = {Suitability and Feasability Study of a Virtual Nursing Intervention to Help Person Living with {HIV} Manage their Daily Therapies},
  booktitle = {Actes du 1<sup>{er}</sup> symposium international sur la recherche en intervention en sciences infirmi{\`e}res : d{\'e}veloppement, {\'e}valuation et partage ({ISI})},
  year = {2011},
  month = {avril},
  grant = {FRSQ team grant},
  keywords = {VIHTAVIE ; ISI},
  kind = {MNADR},
  language = {english},
  url = {http://www.ncbi.nlm.nih.gov/pubmed/23034932},
  relevance = {100},
  relevantfor = {Web support; HIV/Aids}
}

@INPROCEEDINGS{Asadi10-SSBSE-ComparisonDistributedArchitectures,
  author = {Fatemeh Asadi and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Concept Location with Genetic Algorithms: {A} Comparison of Four Distributed Architectures},
  booktitle = {Proceedings of the 2<sup>{nd}</sup> International Symposium on Search Based Software Engineering ({SSBSE})},
  year = {2010},
  month = {September},
  editor = {Lionel Briand},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Features and requirements ; SSBSE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SSBSE10.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/SSBSE10.ppt.pdf},
  pages = {153--162}
}

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.

@INPROCEEDINGS{Asadi10-CSMR-IdentifyConceptsTraces,
  author = {Fatemeh Asadi and Massimiliano {Di Penta} and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Heuristic-based Approach to Identify Concepts in Execution Traces},
  booktitle = {Proceedings of the 14<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2010},
  month = {March},
  editor = {Rudolf Ferenc and Juan Carlos Due{\~n}as},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Features and requirements ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR10a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR10a.ppt.pdf},
  pages = {31--40}
}

Concept or feature identification, ıe 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.

@INPROCEEDINGS{Bavota10-ICSM-ERA-RefactoringGameTheory,
  author = {Gabriele Bavota and Rocco Oliveto and Andrea {De Lucia} and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Playing with Refactoring: Identifying Extract Class Opportunities through Game Theory},
  booktitle = {Proceedings of the 26<sup>{th}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2010},
  month = {September},
  editor = {Rudolf Ferenc and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {Early Research Achievements Track. 5 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Code and design smells ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM10b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM10b.ppt.pdf},
  pages = {1--5},
  comment = {Early Research Achievements Track.}
}

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.

@ARTICLE{CepedaPorras10-EMSE-UMLNotations,
  author = {Gerardo {Cepeda Porras} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {An Empirical Study on the Efficiency of Different Design Pattern Representations in {UML} Class Diagrams},
  journal = {Empirical Software Engineering (EMSE)},
  year = {2010},
  month = {February},
  volume = {15},
  number = {5},
  pages = {493--522},
  note = {29 pages.},
  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.},
  editor = {Lionel Briand},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Understanding program comprehension ; EMSE},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/EMSE10.doc.pdf},
  page = {493--522}
}

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.

@ARTICLE{Moha09-TSE-DECOR,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Laurence Duchien and Anne-Fran{\c{c}}oise {Le Meur}},
  title = {{DECOR}: A Method for the Specification and Detection of Code and Design Smells},
  journal = {Transactions on Software Engineering ({TSE})},
  year = {2010},
  month = {January--February},
  volume = {36},
  number = {1},
  pages = {20--36},
  note = {16 pages.},
  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.},
  editor = {Mark Harman},
  grant = {NSERC DG},
  keywords = {Code and design smells ; TSE},
  kind = {RIAS},
  language = {english},
  publisher = {IEEE CS Press},
  url = {http://www.ptidej.net/publications/documents/TSE09.doc.pdf},
  page = {20--36}
}

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 ∏uctXerces v2.7.0, and discuss the precision of these algorithms on 11 open-source systems.

@ARTICLE{Moha09-FAC-DDDomainAnalysis,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Anne-Fran{\c{c}}oise {Le Meur} and Laurence Duchien and Alban Tiberghien},
  title = {From a Domain Analysis to the Specification and Detection of Code and Design Smells},
  journal = {Formal Aspects of Computing ({FAC})},
  year = {2010},
  month = {May},
  volume = {22},
  number = {3},
  pages = {345--368},
  note = {23 pages.},
  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.},
  editor = {Jos{\'e} Luiz Fiadeiro},
  grant = {NSERC DG},
  keywords = {Code and design smells ; FAC},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/FAC09.doc.pdf}
}

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@productXerces v2.7.0 and \ygg@productGanttProject v1.10.2, two open-source object-oriented systems.

@INPROCEEDINGS{Madani10-CSMR-IdentifiersSpeechRecognition,
  author = {Nioosha Madani and Latifa Guerrouj and Massimiliano {Di Penta} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Recognizing Words from Source Code Identifiers using Speech Recognition Techniques},
  booktitle = {Proceedings of the 14<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2010},
  month = {March},
  editor = {Rudolf Ferenc and Juan Carlos Due{\~n}as},
  publisher = {IEEE CS Press},
  note = {Best paper. 10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Identifier analysis ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR10c.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR10c.ppt.pdf},
  pages = {68--77},
  comment = {Best paper.}
}

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, ıe 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.

@ARTICLE{Kaczor09-IST-EfficientDPIdentification,
  author = {Olivier Kaczor and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel},
  title = {Identification of Design Motifs with Pattern Matching Algorithms},
  journal = {Information and Software Technology ({IST})},
  year = {2010},
  month = {February},
  volume = {52},
  number = {2},
  pages = {152--168},
  note = {16 pages.},
  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.},
  editor = {Claes Wohlin},
  grant = {FQRNT team grant and NSERC DG},
  keywords = {Design patterns ; IST},
  kind = {RIAS},
  language = {english},
  publisher = {Elsevier},
  url = {http://www.ptidej.net/publications/documents/IST09.doc.pdf},
  issue = {2},
  page = {152--168}
}

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@productJuzzle, and \ygg@productQuickUML. Our studies show that approximate string matching based on bit-vector processing provides efficient algorithms to identify design motifs.

@INPROCEEDINGS{Hassaine10-QUATIC-IDS,
  author = {Salima Hassaine and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel},
  title = {IDS: An Immune-inspired Approach for the Detection of Software Design Smells},
  booktitle = {Proceedings of the 7<sup>{th}</sup> International Conference on the Quality of Information and Communications Technology ({QUATIC})},
  year = {2010},
  month = {September--October},
  editor = {Mel {\'O} Cinn{\'e}ide},
  publisher = {IEEE CS Press},
  note = {Quality in ICT Reengineering and Refactoring Track. 6 pages.},
  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.},
  grant = {FQRNT team grant and CRC on Software Patterns},
  keywords = {Code and design smells ; QUATIC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/QUATIC10.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/QUATIC10.ppt.pdf},
  pages = {343--348},
  comment = {Quality in ICT Reengineering and Refactoring Track.}
}

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.

@INPROCEEDINGS{Arnaoudova10-ICSM-ERA-IdentifierEntropy,
  author = {Venera Arnaoudova and Laleh Eshkevari and Rocco Oliveto and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Physical and Conceptual Identifier Dispersion: {M}easures and Relation to Fault Proneness},
  booktitle = {Proceedings of the 26<sup>{th}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2010},
  month = {September},
  editor = {Rudolf Ferenc and Denys Poshyvanyk},
  publisher = {IEEE CS Press},
  note = {Early Research Achievements Track. Best paper. 5 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Identifier analysis ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM10a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM10a.ppt.pdf},
  pages = {1--5},
  comment = {Early Research Achievements Track. Best paper.}
}

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 \emphphysical dispersion of terms in a program: the higher the entropy, the more scattered across the program the terms. Context coverage measures the \emphconceptual 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.

@INPROCEEDINGS{Wu10-ICSE-AURA,
  author = {Wei Wu and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol and Miryung Kim},
  title = {{AURA}: A Hybrid Approach to Identify Framework Evolution},
  booktitle = {Proceedings of the 32<sup>{nd}</sup> International Conference on Software Engineering (ICSE)},
  year = {2010},
  month = {May},
  editor = {Prem Devanbu and Sebastian Uchitel},
  publisher = {ACM Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; ICSE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSE10b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSE10b.ppt.pdf},
  pages = {325--334}
}

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@latinet al., and Schäfer \ygg@latinet al. The comparison shows that, on average, the recall of AURA is 53.07% higher while its precision is similar, \ygg@latine.g., 0.10% lower.

@ARTICLE{Cote09-CIN-VirtualIntervention,
  author = {Jos{\'e} C{\^o}t{\'e} and Pilar Ramirez-Garcia and Genevi{\`e}ve Rouleau and Diane Saulnier and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Annick Hernandez and Gaston Godin},
  title = {A Nursing Virtual Intervention: Real-Time Support for Managing Antiretroviral Therapy},
  journal = {Computers, Informatics, Nursing ({CIN})},
  year = {2010},
  month = {January--February},
  pages = {43--51},
  volume = {29},
  number = {1},
  note = {22 pages.},
  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.},
  editor = {Leslie H. Nicoll},
  grant = {NSERC DG},
  keywords = {VIHTAVIE ; CIN},
  kind = {RIAS},
  language = {english},
  publisher = {Lippincott, Williams, and Wilkins},
  url = {http://www.ptidej.net/publications/documents/CIN09.doc.pdf},
  page = {43--51}
}

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.

@INPROCEEDINGS{Cote10-ACFAS-ModeVirtuel,
  author = {Jos{\'e} C{\^o}t{\'e} and Genevi{\`e}ve Rouleau and Diane Saulnier and C{\'e}cile Tremblay and H{\'e}l{\`e}ne Morin and Pilar Ramirez-Garcia and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Gaston Godin and Joanne Otis},
  title = {D\'ecouvrir aujourd'hui, r\'einventer demain ! Le mode virtuel : une voie prometteuse pour le soutien des client\`eles dans l'autogestion de leur condition de sant\'e},
  booktitle = {actes du 78<sup>{e}</sup> congr\`es de {l'ACFAS}},
  year = {2010},
  month = {mai},
  editor = {Christine Thoer and Joseph Levy},
  publisher = {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.},
  grant = {FRSQ team grant},
  keywords = {VIHTAVIE ; ACFAS},
  kind = {MNADR},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/ACFAS10.doc.pdf},
  MISSINGnote = {XXX pages.}
}

Basée sur une philosophie d'empowerment, VIH-TAVIE (VIH - Traitement, Assistance Virtuelle Infirmière et Enseignement) vise à outiller la personne vivant avec le VIH (PVVIH) dans la gestion quotidienne de ses antirétroviraux. Le but de cette communication est de faire une démonstration de VIH-TAVIE et de présenter les résultats préliminaires sur l'acceptabilité et la faisabilité de VIH-TAVIE.

@INPROCEEDINGS{DiPenta10-ICSE-SoftwareLicensingEvolution,
  author = {Massimiliano {Di Penta} and Daniel M. German and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Exploratory Study of the Evolution of Software Licensing},
  booktitle = {Proceedings of the 32<sup>{nd}</sup> International Conference on Software Engineering ({ICSE})},
  year = {2010},
  month = {May},
  editor = {Prem Devanbu and Sebastian Uchitel},
  publisher = {ACM Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Evolution patterns ; ICSE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSE10a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSE10a.ppt.pdf},
  pages = {145--154}
}

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.

@INBOOK{Gueheneuc10-ESE-DesignPatterns,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Design Patterns: Empirical Studies on the Impact of Design Patterns on Quality},
  chapter = {19},
  booktitle = {Encyclopedia of Software Engineering ({ESE})},
  pages = {204--219},
  publisher = {Taylor and Francis Group},
  year = {2010},
  month = {September},
  note = {16 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Design patterns ; ESE},
  kind = {CDL},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ESE10.doc.pdf},
  editor = {Phil Laplante}
}

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.

@BOOK{Gueheneuc-EUE-PhDThesis,
  title = {Un cadre pour la tra\c cabilit\'e des motifs de conception},
  publisher = {\'Editions universitaires europ\'eennes},
  year = {2010},
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  month = {June},
  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.},
  isbn = {978-613-1-50950-6},
  kind = {LEDL},
  language = {francais},
  url = {http://www.yann-gael.gueheneuc.net/Work/PhDThesis/Documents/LongPhDThesisYannGaelGueheneuc.doc.zip},
  note = {360 pages.}
}

Les patrons de conception sont importants en génie logiciel à objets car ils contribuent à la qualité des programmes. Ils proposent des solutions élégantes à des problèmes récurrents de conception, des motifs utilisés pendant l'implantation. À l'usage, ces motifs de conception sont disséminés dans le code source et ne sont plus explicites lors de la maintenance ; pourtant, ils aideraient à comprendre l'implantation et la conception des programmes, assurant leur qualité. Ce mémoire propose des modèles et des algorithmes pour garantir la tra ̧cabilité des motifs de conception entre les phases d'implantation et de rétroconception des programmes par l'identification semi-automatique des micro-architectures similaires à ces motifs dans le code source. La métamodélisation est utilisée pour décrire les motifs de conception et les programmes Java. Elle amène à expliciter certaines relations interclasses (association, agrégation et composition) offertes par les langages de conception comme UML et à préciser leurs propriétés (durée de vie, exclusivité, multiplicité et site d'invocation) pour les identifier avec des algorithmes d'analyses statiques et dynamiques. Elle conduit aussi à traduire les motifs en systèmes de contraintes et à identifier les micro-architectures similaires, formes complètes et approchées, par la résolution de problèmes de satisfaction de contraintes. La programmation par contraintes avec explications permet de guider la résolution et d'expliquer les micro-architectures identifiées. La suite d'outils Ptidej est une implantation des modèles et des algorithmes proposés. Elle est intégrée à l'environnement Eclipse de développement en Java. Elle inclut le métamodèle PADL, dérivé du métamodèle PDL ; des outils d'analyses statiques et dynamiques, Introspector et Caffeine ; et un solveur de contraintes, PtidejSolver, dérivé du solveur de contraintes avec explications de référence PaLM.

@ARTICLE{Gueheneuc10-SQJ-MetricalPtidejSolver,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Jean-Yves Guyomarc'h and Houari Sahraoui},
  title = {Improving Design Pattern Identification: a New Approach and an Exploratory Study},
  journal = {Software Quality Journal ({SQJ})},
  year = {2010},
  month = {March},
  volume = {18},
  number = {1},
  pages = {145--166},
  note = {21 pages.},
  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.},
  editor = {Rachel Harrison},
  grant = {NSERC DG},
  keywords = {Design patterns ; SQJ},
  kind = {RIAS},
  language = {english},
  publisher = {Springer},
  url = {http://www.ptidej.net/publications/documents/SQJ10.doc.pdf}
}

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.

@INPROCEEDINGS{Kniesel10-CSMR-DPDX,
  author = {G{\"u}nter Kniesel and Alexander Binun and P{\'e}ter Heged\H{u}s and Lajos Jen\H{o} F{\"u}l{\"o}p and Alexander Chatzigeorgiou and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Nikolaos Tsantalis},
  title = {{DPDX} -- A Common Exchange Format for Design Pattern Detection Tools},
  booktitle = {Proceedings of the 14<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2010},
  month = {March},
  editor = {Rudolf Ferenc and Juan Carlos Due{\~n}as},
  publisher = {IEEE CS Press},
  note = {Short paper. 5 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Design patterns ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR10b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR10b.ppt.pdf},
  pages = {232--235},
  comment = {Short paper.}
}

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.

@INBOOK{Mens10-IEEESoftwareGuestIntroduction,
  author = {Tom Mens and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Juan Fernandez-Ramil and Maja D'Hondt},
  title = {Guest Editorial: Software Evolution},
  chapter = {1},
  booktitle = {IEEE Software},
  pages = {22--25},
  publisher = {IEEE CS Press},
  year = {2010},
  month = {July--August},
  note = {4 pages.},
  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.},
  grant = {CRC on Software Patterns},
  keywords = {Evolution patterns ; IEEE Software},
  kind = {CDL},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/IEEESoftware10.doc.pdf},
  doi = {10.1109/MS.2010.100},
  editor = {Tom Mens and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Juan Fernandez-Ramil and Maja D'Hondt},
  issn = {0740-7459},
  number = {4},
  volume = {27}
}

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.

@INPROCEEDINGS{Oliveto10-CSMR-BSplineSmellDetection,
  author = {Rocco Oliveto and Foutse Khomh and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Numerical Signatures of Antipatterns: An Approach based on B-Splines},
  booktitle = {Proceedings of the 14<sup>{th}</sup> European Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2010},
  month = {March},
  editor = {Rudolf Ferenc and Juan Carlos Due{\~n}as},
  publisher = {IEEE CS Press},
  note = {Short paper. 5 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Code and design smells ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR10d.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR10d.ppt.pdf},
  pages = {248--251},
  comment = {Short paper.}
}

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.

@ARTICLE{Sahraoui10-IST-ImpactMeasurementProgram,
  author = {Houari Sahraoui and Lionel C. Briand and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Olivier Beaurepaire},
  title = {Investigating the Impact of a Measurement Program on Software Quality},
  journal = {Information and Software Technology ({IST})},
  year = {2010},
  month = {September},
  volume = {52},
  number = {9},
  pages = {923--933},
  note = {10 pages.},
  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.},
  editor = {Claes Wohlin},
  grant = {NSERC DG and Project MOVER},
  keywords = {Quality models ; IST},
  kind = {RIAS},
  language = {english},
  publisher = {Elsevier},
  url = {http://www.ptidej.net/publications/documents/IST10.doc.pdf},
  issue = {9},
  page = {923--933}
}

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.

@TECHREPORT{Khomh09-TR-DEQUALITE,
  author = {Foutse Khomh and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{DEQUALITE} : m\'ethode de construction de mod\`eles de qualit\'e prenant en compte la conception des syst\`emes},
  year = {2009},
  month = {avril},
  note = {31 pages.},
  institution = {\'Ecole Polytechnique de Montr\'eal},
  number = {EPM-RT-2009-04},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models},
  kind = {RR},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/Research+report+DEQUALITE+April09.doc.pdf}
}

La plupart des modèles de qualité présentés dans la littérature ou utilisés dans l'industrie pour évaluer les systèmes par objets utilisent des métriques de classes (nombre de méthodes d'une classe par exemple) ou des métriques de relations entre classes (couplage entre deux classes par exemple) pour mesurer les attributs internes des systèmes. Cependant, la qualité des systèmes par objets ne dépend pas uniquement de la structure de leurs classes mais aussi de la fa ̧con dont celles-ci sont organisées, c'est-à-dire de leur conception. Nous proposons DEQUALITE, une méthode de construction de modèles de qualité permettant de mesurer la qualité des systèmes par objets en prenant en compte non seulement les attributs internes du système mais aussi sa conception. Notre méthode utilise une approche par apprentissage. Elle s'appuie sur une étude des patrons de conception pour prendre en compte la conception des systèmes. Notre méthode permet aussi de combiner des modèles de qualité afin d'augmenter la capacité de prédiction. Nous illustrons notre méthode sur un ensemble de systèmes implantant des patrons de conception et sur le modèle de qualité QMOOD de Bansiya. Nous discutons les avantages et les inconvénients de cette méthode et procédons à la validation d'un modèle de qualité résultant sur un ensemble de systèmes. Nous terminons par une discussion sur les avantages et limitations de l'utilisation des patrons de conception pour la construction de modèles de qualité.

@INPROCEEDINGS{Khomh09-QSIC-BayesianDD,
  author = {Foutse Khomh and St{\'e}phane Vaucher and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Houari Sahraoui},
  title = {A Bayesian Approach for the Detection of Code and Design Smells},
  booktitle = {Proceedings of the 9<sup>{th}</sup> International Conference on Quality Software ({QSIC})},
  year = {2009},
  month = {August},
  editor = {Choi Byoung-ju},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; QSIC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/QSIC09.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/QSIC09.ppt.pdf},
  pages = {305--314}
}

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, ∏uctGanttProject v1.10.2 and ∏uctXerces 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.

@INPROCEEDINGS{Khomh09-WCRE-CodeSmellsChanges,
  author = {Foutse Khomh and Massimiliano {Di Penta} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {An Exploratory Study of the Impact of Code Smells on Software Change-proneness},
  booktitle = {Proceedings of the 16<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2009},
  month = {October},
  editor = {Giuliano Antoniol and Andy Zaidman},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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 \numberofsmells{} 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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE09a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE09a.ppt.pdf},
  pages = {75--84}
}

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 νmberofsmells 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 \empha posteriori previous work on the specification and detection of code smells and could help focusing quality assurance and testing activities.

@TECHREPORT{Khomh09-TR-AntipatternsChangeability,
  author = {Foutse Khomh and Massimiliano {Di Penta} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Guiliano Antoniol},
  title = {An Exploratory Study of the Impact of Antipatterns on Software Changeability},
  year = {2009},
  month = {April},
  note = {15 pages.},
  institution = {\'Ecole Polytechnique de Montr\'eal},
  number = {EPM-RT-2009-02},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; Evolution patterns},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+Antipatterns+Changeability+April09.doc.pdf}
}

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.

@INPROCEEDINGS{Khomh09-ICSM-DPRoles,
  author = {Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Playing Roles in Design Patterns: An Empirical Descriptive and Analytic Study},
  booktitle = {Proceedings of the 25<sup>{th}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2009},
  month = {September},
  editor = {Kostas Kontogiannis and Tao Xie},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM09.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM09.ppt.pdf},
  pages = {83--92}
}

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.

@TECHREPORT{Khomh09-TR-DesignPatternsRoles,
  author = {Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Guiliano Antoniol},
  title = {An Empirical Descriptive and Analytic Study of Playing Roles in Design Patterns},
  year = {2009},
  month = {April},
  note = {15 pages.},
  institution = {\'Ecole Polytechnique de Montr\'eal},
  number = {EPM-RT-2009-03},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; Evolution patterns},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+Design+Patterns+Roles+April09.doc.pdf}
}

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.

@ARTICLE{KaYeeNg09-JSME-BehaviouralCreationalIdentification,
  author = {Janice Ka-Yee Ng and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Identification of Behavioral and Creational Design Motifs through Dynamic Analysis},
  journal = {Journal of Software Maintenance and Evolution: Research and Practice ({JSME})},
  year = {2009},
  month = {November},
  volume = {22},
  number = {8},
  pages = {597--627},
  note = {30 pages.},
  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 \textsf{Builder}, \textsf{Command}, and \textsf{Visitor}, we show that MoDeC has a better precision than a state-of-the-art static approaches.},
  editor = {Maria Tortorella and Aniello Cimitile},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Design patterns ; JSME-JSEP},
  kind = {RIAS},
  language = {english},
  publisher = {Wiley},
  url = {http://www.ptidej.net/publications/documents/JSME09.doc.pdf},
  page = {597--627}
}

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 \textsfBuilder, \textsfCommand, and \textsfVisitor, we show that MoDeC has a better precision than a state-of-the-art static approaches.

@INPROCEEDINGS{Jeanmart09-ESEM-VisitorImpact,
  author = {S{\'e}bastien Jeanmart and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Houari Sahraoui and Naji Habra},
  title = {Impact of the Visitor Pattern on Program Comprehension and Maintenance},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> International Symposium on Empirical Software Engineering and Measurement ({ESEM})},
  year = {2009},
  month = {October},
  editor = {James Miller and Rick Selby},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Understanding program comprehension ; ESEM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ESEM09.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ESEM09.ppt.pdf},
  pages = {69--78}
}

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.

@INPROCEEDINGS{Vaucher09-WCRE-CurePreventionSmells,
  author = {St{\'e}phane Vaucher and Foutse Khomh and Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Tracking Design Smells: Lessons from a Study of God Classes},
  booktitle = {Proceedings of the 16<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2009},
  month = {October},
  editor = {Giuliano Antoniol and Andy Zaidman},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; Quality models ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE09b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE09b.ppt.pdf},
  pages = {145--154}
}

``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. \GCs 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 \GCs: 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.

@INBOOK{Charest09-NETTechnology-PatternsHardware,
  author = {Luc Charest and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Yousra Tagmouti},
  title = {Translating Design Pattern Concepts to Hardware Concepts},
  chapter = {4},
  booktitle = {System Level Design with {.Net} Technology ({NET})},
  pages = {93--118},
  publisher = {CRC Press},
  year = {2009},
  month = {September},
  note = {25 pages.},
  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.},
  grant = {NSERC DG and CRC on Software Patterns},
  keywords = {Design patterns ; NET},
  kind = {CDL},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/NET09.doc.pdf},
  editor = {El Mostapha Aboulhamid and Fr{\'e}d{\'e}ric Rousseau}
}

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 \emphmixed 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.

@INPROCEEDINGS{German09-MSR-CodeSiblings,
  author = {Daniel M. German and Massimiliano {Di Penta} and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Code Siblings: Technical and Legal Implications of Copying Code between Systems},
  booktitle = {Proceedings of the 6<sup>{th}</sup> Working Conference on Mining Software Repositories {(MSR)}},
  year = {2009},
  month = {May},
  editor = {Michael W. Godfrey and Jim Whitehead},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG and Start-up fund},
  keywords = {Evolution patterns ; MSR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/MSR09.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/MSR09.ppt.pdf},
  pages = {81--90}
}

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.

@ARTICLE{Gueheneuc08-JSSCI-VisionTheory,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Theory of Program Comprehension---Joining Vision Science and Program Comprehension},
  journal = {International Journal of Software Science and Computational Intelligence ({IJSSCI})},
  year = {2009},
  month = {April-June},
  volume = {1},
  number = {2},
  pages = {54--72},
  note = {18 pages.},
  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.},
  editor = {Yingxu Wang},
  grant = {NSERC DG},
  keywords = {Understanding program comprehension ; JSSCI},
  kind = {RIAS},
  language = {english},
  publisher = {IGI Global},
  url = {http://www.ptidej.net/publications/documents/JSSCI09.doc.pdf},
  page = {54--72}
}

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.

@INPROCEEDINGS{Ghannem08-LMO-AnalyseLogiciels,
  author = {Adnane Ghannem and Salima Hassaine and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel},
  title = {L'analyse de logiciels, phylog\'enie et histoire},
  booktitle = {Actes du 14<sup>{e}</sup> colloque Langages et Mod\`eles \`a Objets ({LMO})},
  year = {2008},
  month = {mars},
  editor = {Mireille Blay-Fornarino},
  publisher = {\'Editions C\'epadu\`es},
  note = {Poster. 2 pages.},
  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.},
  grant = {FQRNT team grant},
  keywords = {Evolution patterns ; LMO},
  kind = {MNADR},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/LMO08b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/LMO08b.ppt.pdf},
  pages = {N/A},
  comment = {Poster.}
}

La maintenance des logiciels de grande taille est une activité coûteuse, car leur évolution incontrôlée compromet leur compréhension et modification. Une étude de leur évolution pourrait réduire les coûts. Notre travail a pour objectif de proposer des techniques d'analyse de l'évolution (historique et phylogénie), en adaptant des algorithmes de bioinformatique.

@TECHREPORT{Khomh08-TR-EmpStudyDPQuality,
  author = {Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {An Empirical Study of Design Patterns and Software Quality},
  year = {2008},
  month = {january},
  note = {44 pages.},
  institution = {University of Montreal},
  number = {1315},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models ; Design patterns},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+DP+Quality+January08.doc.pdf},
  editor = {University of Montr{\'e}al},
  relevance = {99},
  relevantfor = {design patterns and quality}
}

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.

@INPROCEEDINGS{Khomh08-CSMR-DPQuality,
  author = {Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Do Design Patterns Impact Software Quality Positively?},
  booktitle = {Proceedings of the 12<sup>{th}</sup> Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2008},
  month = {April},
  editor = {Christos Tjortjis and Andreas Winter},
  publisher = {IEEE CS Press},
  note = {Short Paper. 5 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR08.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR08.ppt.pdf},
  pages = {274--278},
  comment = {Short paper.}
}

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 \emphin 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.

@INBOOK{Khosravi08-SQM-IssuesQualityModels,
  author = {Khashayar Khosravi and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {On Issues with Software Quality Models},
  chapter = {11},
  booktitle = {Software Quality Metrics},
  pages = {218--235},
  publisher = {ICFAI University Press},
  year = {2008},
  month = {January},
  note = {28 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models ; Design patterns ; SQM},
  kind = {CDL},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SQM08.doc.pdf}
}

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.

@INPROCEEDINGS{Eaddy08-ICPC-Cerberus,
  author = {Marc Eaddy and Alfred V. Aho and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Cerberus: {T}racing Requirements to Source Code Using Information Retrieval, Dynamic Analysis, and Program Analysis},
  booktitle = {Proceedings of the 16<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2008},
  month = {June},
  editor = {Ren{\'e} Krikhaar and Ralf L{\"a}mmel},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Features and requirements ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC08b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC08b.ppt.pdf},
  pages = {53--62}
}

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.

@INPROCEEDINGS{Moha08-ICFCA-RefactoringsDesignDefects,
  author = {Naouel Moha and Amine Mohamed Rouane Hacene and Petko Valtchev and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Refactorings of Design Defects using Relational Concept Analysis},
  booktitle = {Proceedings of the 4<sup>{th}</sup> International Conference on Formal Concept Analysis ({ICFCA})},
  year = {2008},
  month = {February},
  editor = {Raoul Medina and Sergei Obiedkov},
  publisher = {Springer-Verlag},
  note = {18 pages.},
  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 \textit{Blob} design defect taken from four different open-source programs.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; ICFCA},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICFCA08.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICFCA08.ppt.pdf},
  pages = {289--304}
}

Software engineers often need to identify and correct design defects, ıe 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 Blob design defect taken from four different open-source programs.

@INPROCEEDINGS{Moha08-LMO-DefautConception,
  author = {Naouel Moha and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {G\'en\'eration automatique d'algorithmes de d\'etection des d\'efauts de conception},
  booktitle = {Actes du 14<sup>{e}</sup> colloque Langages et Mod\`eles \`a Objets ({LMO})},
  year = {2008},
  month = {mars},
  editor = {Mireille Blay-Fornarino},
  publisher = {\'Editions C\'epadu\`es},
  note = {13 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; LMO},
  kind = {MNSA},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/LMO08a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/LMO08a.ppt.pdf},
  pages = {93--106}
}

Les défauts de conception sont des problèmes récurrents de conception qui diminuent la qualité des programmes et donc freinent leur développement et maintenance. Plusieurs approches outillées de détection des défauts ont été proposées dans la littérature mais, à notre connaissance, elles utilisent toutes des algorithmes de détection ad hoc, ce qui rend difficile leur généralisation à d'autres défauts, et elles sont basées principalement sur des métriques, qui ne rendent pas compte de certaines caractéristiques importantes des systèmes analysés, telle leur architecture. Dans cet article, nous développons notre approche basée sur un méta-modèle des défauts de conception en présentant une génération automatique des algorithmes de détection à partir de gabarits. Nous présentons aussi les performances de la génération et évaluons les algorithmes générés en terme de précision et de rappel. Nous fournissons ainsi des moyens concrets pour automatiser la génération des algorithmes de détection et donc de détecter de nouveaux défauts tout en prenant en compte toutes les caractéristiques des systèmes.

@MISC{Moha08-Demo-SATToSE,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Ptidej} and {DECOR}: {I}dentification of Design Patterns and Design Defects},
  year = {2008},
  month = {February},
  note = {SATToSE: Seminar on Advanced Tools and Techniques for Software Evolution, Waulsort, Belgium.},
  comment = {SATToSE: Seminar on Advanced Tools and Techniques for Software Evolution, Waulsort, Belgium.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; SATToSE},
  kind = {DEMO},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/SATToSE08ToolDemo.ppt.pdf}
}

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.

@INPROCEEDINGS{Moha08-FASE-DDDomainAnalysis,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Anne-Fran{\c{c}}oise {Le Meur} and Laurence Duchien},
  title = {A Domain Analysis to Specify Design Defects and Generate Detection Algorithms},
  booktitle = {Proceedings of the 11<sup>{th}</sup> international conference on Fundamental Approaches to Software Engineering ({FASE})},
  year = {2008},
  month = {March-April},
  editor = {Jos{\'e} Fiadeiro and Paola Inverardi},
  publisher = {Springer-Verlag},
  note = {15 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; FASE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/FASE08.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/FASE08.ppt.pdf},
  pages = {276--291}
}

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@productXerces v2.7.0, an open-source object-oriented system.

@TECHREPORT{Denier08-TR-DPStateOfTheArt,
  author = {Simon Denier and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Reverse-Engineering the Literature on Design Patterns and Reverse-Engineering},
  year = {2008},
  month = {October},
  note = {18 pages.},
  institution = {DGIGL, \'Ecole Polytechnique Montr\'eal},
  number = {EPM-RT-2008-09},
  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.},
  grant = {NSERC DG},
  keywords = {Understanding program comprehension},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+DP+SotA+October09.doc.pdf}
}

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.

@INPROCEEDINGS{Denier08-ICPC-Mendel,
  author = {Simon Denier and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Mendel}: {A} Model, Metrics, and Rules to Understand Class Hierarchies},
  booktitle = {Proceedings of the 16<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2008},
  month = {June},
  editor = {Ren{\'e} Krikhaar and Ralf L{\"a}mmel},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Understanding program comprehension ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC08a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC08a.ppt.pdf},
  pages = {143--152}
}

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.

@INPROCEEDINGS{Antoniol08-CASCON-ClassificationofChangeReq,
  author = {Giuliano Antoniol and Kamel Ayari and Massimiliano {Di Penta} and Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Is It a Bug or an Enhancement? A Text-based Approach to Classify Change Requests},
  booktitle = {Proceedings of the 18<sup>{th}</sup> {IBM} Centers for Advanced Studies Conference ({CASCON})},
  year = {2008},
  month = {October},
  editor = {Mark Vigder and Marsha Chechik},
  publisher = {ACM Press},
  note = {15 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Evolution patterns ; CASCON},
  kind = {MNSA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CASCON08.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CASCON08.ppt.pdf},
  pages = {23-37}
}

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.

@INPROCEEDINGS{Antoniol08-ICSM-ReORe,
  author = {Giuliano Antoniol and Jane Huffman Hayes and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Massimiliano {Di Penta}},
  title = {Reuse or Rewrite: Combining Textual, Static, and Dynamic Analyses to Assess the Cost of Keeping a System Up-to-date},
  booktitle = {Proceedings of the 24<sup>{th}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2008},
  month = {September--October},
  editor = {Hong Mei and Kenny Wong},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Features and requirements ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM08a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM08a.ppt.pdf},
  pages = {147--156}
}

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.

@INPROCEEDINGS{DiPenta08-ICSM-DPRoles,
  author = {Massimiliano {Di Penta} and Luigi Cerulo and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {An Empirical Study of the Relationships between Design Pattern Roles and Class Change Proneness},
  booktitle = {Proceedings of the 24<sup>{th}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2008},
  month = {September--October},
  editor = {Hong Mei and Kenny Wong},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM08b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM08b.ppt.pdf},
  pages = {217--226}
}

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.

@ARTICLE{Gueheneuc07-TSE-MultiLayeredFramework,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {{DeMIMA}: {A} Multi-layered Framework for Design Pattern Identification},
  journal = {Transactions on Software Engineering ({TSE})},
  year = {2008},
  month = {September},
  volume = {34},
  number = {5},
  pages = {667--684},
  note = {18 pages.},
  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.},
  editor = {Sebastian Elbaum and David S. Rosenblum},
  grant = {NSERC DG, Start-up fund, and \ygg@company{IBM} Eclipse Fellowship},
  keywords = {Design patterns ; TSE},
  kind = {RIAS},
  language = {english},
  publisher = {IEEE CS Press},
  url = {http://www.ptidej.net/publications/documents/TSE08.doc.pdf}
}

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.

@INPROCEEDINGS{Hayes08-WCRE-PREREQIR,
  author = {Jane Huffman Hayes and Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Prereqir: {R}ecovering Pre-Requirements via Cluster Analysis},
  booktitle = {Proceedings of the 15<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2008},
  month = {October},
  editor = {Andy Zaidman and Massimilano {Di Penta} and Ahmed Hassan},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Features and requirements ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE08.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE08.ppt.pdf},
  pages = {165--174}
}

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.

@ARTICLE{Poshyvanyk07-TSE-Promesir,
  author = {Denys Poshyvanyk and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Andrian Marcus and Giuliano Antoniol and V{\'a}clav Rajlich},
  title = {Feature Location using Probabilistic Ranking of Methods based on Execution Scenarios and Information Retrieval},
  journal = {Transactions on Software Engineering ({TSE})},
  year = {2007},
  month = {June},
  volume = {33},
  number = {6},
  pages = {420--432},
  note = {14 pages.},
  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.},
  editor = {Jeff Kramer},
  grant = {NSERC DG},
  keywords = {Features and requirements ; TSE},
  kind = {RIAS},
  language = {english},
  publisher = {IEEE CS Press},
  url = {http://www.ptidej.net/publications/documents/TSE07.doc.pdf}
}

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.

@INPROCEEDINGS{Khomh07-QAOOSE-DPQuality,
  author = {Foutse Khomh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Perception and Reality: {W}hat are Design Patterns Good For?},
  booktitle = {Proceedings of the 11<sup>{th}</sup> {ECOOP} workshop on Quantitative Approaches in Object-Oriented Software Engineering ({QAOOSE})},
  year = {2007},
  month = {July--August},
  editor = {Fernando Brito e Abreu and Coral Calero and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Christian Lange and Michele Lanza and Houari A. Sahraoui},
  publisher = {Springer-Verlag},
  note = {7 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models ; Design patterns ; QAOOSE},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP07QAOOSE.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ECOOP07QAOOSE.ppt.pdf},
  pages = {N/A}
}

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.

@INPROCEEDINGS{KaYeeNg07-PCODA-DynamicDPDetection,
  author = {Janice Ka-Yee Ng and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Identification of Behavioral and Creational Design Patterns through Dynamic Analysis},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> International Workshop on Program Comprehension through Dynamic Analysis ({PCODA})},
  year = {2007},
  month = {October},
  editor = {Andy Zaidman and Abdelwahab Hamou-Lhadj and Orla Greevy},
  publisher = {Delft University of Technology},
  note = {TUD-SERG-2007-022. 9 pages.},
  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.},
  grant = {FQRNT team grant},
  keywords = {Design patterns ; PCODA},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/PCODA07.doc.pdf},
  pages = {34--42},
  comment = {TUD-SERG-2007-022.}
}

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.

@MISC{Moha07-Demo-ASE,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Ptidej} and {DECOR}: {I}dentification of Design Patterns and Design Defects},
  year = {2007},
  month = {November},
  note = {Tool demo at the 22<sup>{nd}</sup> International Conference on Automated Software Engineering.},
  comment = {Tool demo at the 22<sup>{nd}</sup> International Conference on Automated Software Engineering.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; ASE},
  kind = {DEMO},
  language = {english},
  pdf = {http://www.ptidej.net/publications/documents/ASE07ToolDemo.ppt.pdf}
}

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.

@MISC{Moha07-Demo-OOPSLA,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Ptidej} and {DECOR}: {I}dentification of Design Patterns and Design Defects},
  year = {2007},
  month = {October},
  note = {Tool demo at the 21<sup>{st}</sup> International Conference on Object-Oriented Programming, Systems, Languages and Applications.},
  comment = {Tool demo at the 21<sup>{st}</sup> International Conference on Object-Oriented Programming, Systems, Languages and Applications.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; OOPSLA},
  kind = {DEMO},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/OOPSLA07ToolDemo.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/OOPSLA07ToolDemo.ppt.pdf}
}

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.

@INPROCEEDINGS{Moha07-WOOR-DesignDefects,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Laurence Duchien and Anne-Fran{\c{c}}oise {Le Meur}},
  title = {Discussion on the Results of the Detection of Design Defects},
  booktitle = {Proceedings of the 8<sup>{th}</sup> {ECOOP} workshop on Object-Oriented Reengineering ({WOOR})},
  year = {2007},
  month = {July--August},
  editor = {Serge Demeyer and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Christian Lange and Kim Mens and Roel Wuyts and St{\'e}phane Ducasse},
  publisher = {N/A},
  note = {6 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; WOOR},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP07WOOR.doc.pdf},
  pages = {N/A}
}

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.

@INPROCEEDINGS{Antoniol07-ICSM-LexiconEvolution,
  author = {Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Ettore Merlo and Paolo Tonella},
  title = {Mining the Lexicon Used by Programmers during Software Evolution},
  booktitle = {Proceedings of the 23<sup>{rd}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2007},
  month = {October},
  editor = {Ladan Tahvildari and Gerardo Canfora},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Identifier analysis ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM07.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM07.ppt.pdf},
  pages = {14--23}
}

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.

@INPROCEEDINGS{Cote07-CICM-GereMedicationAntiretrovirale,
  author = {Jos{\'e} C{\^o}t{\'e} and Pilar Ramirez Garcia and Gaston Godin and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {G\'erer sa m\'edication antir\'etrovirale avec une assistance en ligne... une approche en cours d'\'evaluation},
  booktitle = {Actes du 2<sup>{e}</sup> Congr\`es international sur la cha\^{\i}ne des m\'edicaments ({CICM})},
  year = {2007},
  month = {Octobre},
  editor = {Bernard B{\'e}gaud and Pavel Hamet and Andr{\'e} Jacques and Vittorio A. Sironi},
  publisher = {Groupe d'\'etude sur l'interdisciplinarit\'e et les repr\'esentations sociales},
  keywords = {VIHTAVIE ; CICM},
  kind = {MISA},
  language = {francais}
}

@INPROCEEDINGS{Gueheneuc07-EPFPR-PMARt,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{PMARt}: {P}attern-like Micro Architecture Repository},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {EuroPLoP} Focus Group on Pattern Repositories ({EPFPR})},
  year = {2007},
  month = {July},
  editor = {Michael Weiss and Aliaksandr Birukou and Paolo Giorgini},
  publisher = {N/A},
  note = {3 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; EPFPR},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/EuroPLoP07PRa.doc.pdf},
  pages = {N/A}
}

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.

@MISC{Gueheneuc07-Demo-GRASCOMP,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Design Pattern Identification in {Ptidej}},
  year = {2007},
  month = {March},
  note = {Tool demo at GRASCOMP Graduate School in Computing Science 2007 (COMP013).},
  comment = {Tool demo at GRASCOMP Graduate School in Computing Science 2007 (COMP013).},
  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.},
  grant = {INRIA mobility grant},
  keywords = {Design patterns ; GRASCOMP},
  kind = {DEMO},
  language = {english},
  url = {http://www.grascomp.be/inauguration-en.php}
}

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.

@MISC{Gueheneuc07-Demo-ICSM,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Ptidej}: {A} Flexible Reverse Engineering Tool Suite},
  year = {2007},
  month = {October},
  note = {Tool demo at the 23<sup>{rd}</sup> International Conference on Software Maintenance.},
  comment = {Tool demo at the 23<sup>{rd}</sup> International Conference on Software Maintenance.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; ICSM},
  kind = {DEMO},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM07ToolDemo.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM07ToolDemo.ppt.pdf}
}

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.

@MISC{Gueheneuc07-Demo-WBTShowcase,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Ptidej} - A Tool Suite},
  year = {2007},
  month = {May},
  note = {Tool demo at the 5<sup>{th}</sup> World's Best Technologies Showcase.},
  comment = {Tool demo at the 5<sup>{th}</sup> World's Best Technologies 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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; Code and design smells ; WBT Showcase},
  kind = {DEMO},
  language = {english},
  url = {http://www.wbtshowcase.com/wbt/wbt07web.nsf/pages/index.html},
  pdf = {http://www.ptidej.net/publications/documents/WBT07ToolDemo.ppt.pdf}
}

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.

@INPROCEEDINGS{Gueheneuc07-EPFPR-Recommander,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Rabih Mustapha},
  title = {A Simple Recommender System for Design Patterns},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {EuroPLoP} Focus Group on Pattern Repositories ({EPFPR})},
  year = {2007},
  month = {July},
  editor = {Michael Weiss and Aliaksandr Birukou and Paolo Giorgini},
  publisher = {N/A},
  note = {2 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; EPFPR},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/EuroPLoP07PRb.doc.pdf},
  pages = {N/A}
}

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.

@INPROCEEDINGS{Poshyvanyk06-ICPC-LSIFeature,
  author = {Denys Poshyvanyk and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Andrian Marcus and Giuliano Antoniol and V{\'a}clav Rajlich},
  title = {Combining Probabilistic Ranking and Latent Semantic Indexing for Feature Identification},
  booktitle = {Proceedings of the 14<sup>{th}</sup> International Conference on Program Comprehension ({ICPC})},
  year = {2006},
  month = {June},
  editor = {Jurgen Ebert and Panos Linos},
  publisher = {IEEE CS Press},
  note = {Best paper. 10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Features and requirements ; ICPC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICPC06.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICPC06.ppt.pdf},
  pages = {137--148},
  comment = {Best paper.}
}

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.

@INPROCEEDINGS{Moha06-LMO-DefautConception,
  author = {Naouel Moha and Duc-Loc Huynh and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Une taxonomie et un m\'etamod\`ele pour la d\'etection des d\'efauts de conception},
  booktitle = {Actes du 12<sup>{e}</sup> colloque Langages et Mod\`eles \`a Objets ({LMO})},
  year = {2006},
  month = {mars},
  editor = {Roger Rousseau},
  publisher = {Herm\`es Science Publications},
  note = {16 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; LMO},
  kind = {MNSA},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/LMO06.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/LMO06.ppt.pdf},
  pages = {201--216}
}

Les défauts de conception sont à rapprocher des patrons de conception qui sont aujourd'hui largement utilisés : les patrons de conception proposent de ``bonnes'' solutions à des problèmes récurrents dans les architectures à objets, tandis que les défauts de conception sont de ``mauvaises'' solutions. Cependant, contrairement aux patrons, les défauts de conception n'ont pas de représentation précise et structurée et existent seulement sous la forme de descriptions textuelles sujettes à interprétation, qui ne permettent pas leur détection et leur correction précise et efficace. Nous proposons une méthodologie pour représenter les défauts de conception basée sur un métamodèle à partir d'une taxonomie des défauts. Nous appliquons et validons cette méthodologie sur un ensemble de défauts de conception, tels le Blob et le Swiss Army Knife.

@INPROCEEDINGS{Moha06-CLA-RefactoringSuggestion,
  author = {Naouel Moha and Jihene Rezgui and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Petko Valtchev and Ghizlane {El Boussaidi}},
  title = {Using {FCA} to Suggest Refactorings to Correct Design Defects},
  booktitle = {Proceedings of the 4<sup>{th}</sup> International Conference on Concept Lattices and their Applications ({CLA})},
  year = {2006},
  month = {September},
  editor = {Sadok Ben Yahia and Engelbert Mephu Nguifo},
  publisher = {IEEE CS Press},
  note = {Short paper. 6 pages.},
  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 \textit{Blob}, drawn from the Azureus project illustrates our approach.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; CLA},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CLA06.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CLA06.ppt.pdf},
  pages = {297--302},
  comment = {Short paper.}
}

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 Blob, drawn from the Azureus project illustrates our approach.

@INPROCEEDINGS{Moha06-WOOR-Correction,
  author = {Naouel Moha and Saliha Bouden and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Correction of High-Level Design Defects with Refactorings},
  booktitle = {Proceedings of the 7<sup>{th}</sup> {ECOOP} workshop on Object-Oriented Reengineering ({WOOR})},
  year = {2006},
  month = {July},
  editor = {Serge Demeyer and St{\'e}phane Ducasse and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Kim Mens and Roel Wuyts},
  publisher = {N/A},
  note = {4 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; WOOR},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WOOR06.doc.pdf},
  pages = {N/A}
}

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.

@MISC{Moha06-Demo-CASCON,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{DECOR} and {Ptidej}},
  year = {2006},
  month = {October},
  note = {Tool demo at the 16<sup>{th}</sup> {IBM} Centers for Advanced Studies Conference.},
  comment = {Tool demo at the 16<sup>{th}</sup> {IBM} Centers for Advanced Studies Conference.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; Design patterns ; CASCON},
  kind = {DEMO},
  language = {english},
  url = {https://www-927.ibm.com/ibm/cas/archives/2006/demos/mdlware.shtml},
  pdf = {http://www.ptidej.net/publications/documents/CASCON06ToolDemo.ppt.pdf}
}

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.

@INPROCEEDINGS{Moha06-ASE-P-DDMethod,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Pierre Leduc},
  title = {Automatic Generation of Detection Algorithms for Design Defects},
  booktitle = {Proceedings of the 21<sup>{st}</sup> Conference on Automated Software Engineering ({ASE})},
  year = {2006},
  month = {September},
  editor = {Sebastian Uchitel and Steve Easterbrook},
  publisher = {IEEE CS Press},
  note = {Short paper. 4 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; ASE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ASE06.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ASE06.ppt.pdf},
  pages = {297--300},
  comment = {Short paper.}
}

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.

@INPROCEEDINGS{Kaczor06-CSMR-EfficientIdentification,
  author = {Olivier Kaczor and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Sylvie Hamel},
  title = {Efficient Identification of Design Patterns with Bit-vector Algorithm},
  booktitle = {Proceedings of the 10<sup>{th}</sup> Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2006},
  month = {March},
  editor = {Giuseppe Antonio di Lucca and Nicolas Gold},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR06a.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR06a.ppt.pdf},
  pages = {173--182}
}

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@productJuzzle, and \ygg@productQuickUML, with the \ygg@patternAbstract Factory and \ygg@patternComposite design patterns and compare its performance and results with two existing constraint-based approaches.

@INPROCEEDINGS{Bouktif06-WCRE-MiningCVS,
  author = {Salah Bouktif and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Giuliano Antoniol},
  title = {Extracting Change-patterns from {CVS} Repositories},
  booktitle = {Proceedings of the 13<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2006},
  month = {October},
  editor = {Susan Elliott Sim and Massimiliano {Di Penta}},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Evolution patterns ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE06.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE06.ppt.pdf},
  pages = {221--230}
}

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.

@ARTICLE{Antoniol06-TSE-FeatureIdentification,
  author = {Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Feature Identification: {A}n Epidemiological Metaphor},
  journal = {Transactions on Software Engineering ({TSE})},
  year = {2006},
  month = {September},
  volume = {32},
  number = {9},
  pages = {627--641},
  note = {15 pages.},
  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.},
  editor = {Tibor Gyim{\'o}thy and Vaclav Rajlich},
  grant = {NSERC DG},
  keywords = {Features and requirements ; TSE},
  kind = {RIAS},
  language = {english},
  publisher = {IEEE CS Press},
  url = {http://www.ptidej.net/publications/documents/TSE06.doc.pdf}
}

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@productMozilla, a large, real-life, multi-threaded object-oriented program. In the second case study, we compare the implementation of the feature in the \ygg@productFirefox and \ygg@productMozilla 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@productJHotDraw and \ygg@productXfig, to highlight the generalisability of our metaphor.

@INPROCEEDINGS{Cote06-WebSupportVIH,
  author = {Jos{\'e} C{\^o}t{\'e} and Pilar Ramirez Garcia and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Xintao Wang and Gaston Godin},
  title = {Web support for person living with {HIV} for the immediate management of the treatment},
  booktitle = {Proceedings of the 15<sup>{th}</sup> annual Canadian Conference on {HIV/Aids} Research ({CAHR})},
  year = {2006},
  month = {May},
  editor = {Gaston Godin and Jean Guy Baril and Jean Pierre Routy},
  publisher = {Pulsus Group},
  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.\newline 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.\newline 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.\newline 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.},
  grant = {FRSQ team grant},
  keywords = {VIHTAVIE ; CAHR},
  kind = {MNADR},
  language = {english},
  url = {http://www.cahr-acrv.ca/english/resources/archive.html},
  relevance = {100},
  relevantfor = {Web support; HIV/Aids}
}

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.\newline 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.\newline 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.\newline 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.

@INPROCEEDINGS{Gueheneuc06-CASCON-Taupe,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Taupe}: {T}owards Understanding Program Comprehension},
  booktitle = {Proceedings of the 16<sup>{th}</sup> {IBM} Centers for Advanced Studies Conference ({CASCON})},
  year = {2006},
  month = {October},
  editor = {Hakan Erdogmus and Eleni Stroulia},
  publisher = {ACM Press},
  note = {13 pages.},
  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.},
  grant = {CFI project 10363},
  keywords = {Understanding program comprehension ; CASCON},
  kind = {MNSA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CASCON06.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CASCON06.ppt.pdf},
  pages = {1--13}
}

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 \emphto understand concretely how software engineers obtain and use this information. Software engineers mainly use \emphsight 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.

@MISC{Taupe,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Taupe}},
  year = {2006},
  month = {since June},
  note = {A tool to edit, visualise, and analyse the data collected by eye-trackers during experiments.},
  comment = {A tool to edit, visualise, and analyse the data collected by eye-trackers during experiments.},
  keywords = {Understanding program comprehension},
  kind = {OUTIL},
  language = {english},
  url = {http://www.ptidej.net/research/programcomprehension/}
}

@INBOOK{Gueheneuc05-OODK-DesignPatternLaws,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Jean-Yves Guyomarc'h and Khashayar Khosravi and Houari Sahraoui},
  title = {Design Patterns as Laws of Quality},
  chapter = {5},
  booktitle = {Object-oriented Design Knowledge: {P}rinciples, Heuristics, Best Practices ({OODK})},
  pages = {105--142},
  publisher = {Idea Group},
  year = {2006},
  month = {January},
  note = {35 pages.},
  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.},
  grant = {NSERC DG and Start-up fund},
  keywords = {Quality models ; Design patterns ; OODK},
  kind = {CDL},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/OODK05.doc.pdf}
}

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.

@INPROCEEDINGS{Gueheneuc06-CSMR-REToolsTaxonomy,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Kim Mens and Roel Wuyts},
  title = {A Comparative Framework for Design Recovery Tools},
  booktitle = {Proceedings of the 10<sup>{th}</sup> Conference on Software Maintenance and Reengineering ({CSMR})},
  year = {2006},
  month = {March},
  editor = {Giuseppe Antonio di Lucca and Nicolas Gold},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {Start-up fund},
  keywords = {Design patterns ; CSMR},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CSMR06b.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CSMR06b.ppt.pdf},
  pages = {121--130}
}

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.

@INPROCEEDINGS{Guyomarch05-QAOOSE-AspectQuality,
  author = {Jean-Yves Guyomarc'h and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {On the Impact of Aspect-Oriented Programming on Object-Oriented Metrics},
  booktitle = {Proceedings of the 9<sup>{th}</sup> {ECOOP} workshop on Quantitative Approaches in Object-Oriented Software Engineering ({QAOOSE})},
  year = {2005},
  month = {July},
  editor = {Fernando Brito e Abreu and Coral Calero and Michele Lanza and Geert Poels and Houari A. Sahraoui},
  publisher = {Springer-Verlag},
  note = {6 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models ; QAOOSE},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP05QAOOSEa.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ECOOP05QAOOSEa.ppt.pdf},
  pages = {42--47}
}

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.

@INPROCEEDINGS{Khosravi05-QAOOSE-QualityIssues,
  author = {Khashayar Khosravi and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Open Issues with Quality Models},
  booktitle = {Proceedings of the 9<sup>{th}</sup> {ECOOP} workshop on Quantitative Approaches in Object-Oriented Software Engineering ({QAOOSE})},
  year = {2005},
  month = {July},
  editor = {Fernando Brito e Abreu and Coral Calero and Michele Lanza and Geert Poels and Houari A. Sahraoui},
  publisher = {Springer-Verlag},
  note = {14 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models ; Design patterns ; QAOOSE},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP05QAOOSEb.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ECOOP05QAOOSEb.ppt.pdf},
  pages = {N/A}
}

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.

@INPROCEEDINGS{Moha05-WOOR-DesignDefects,
  author = {Naouel Moha and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {On the Automatic Detection and Correction of Design Defects},
  booktitle = {Proceedings of the 6<sup>{th}</sup> {ECOOP} workshop on Object-Oriented Reengineering ({WOOR})},
  year = {2005},
  month = {July},
  editor = {Serge Demeyer and Kim Mens and Roel Wuyts and St{\'e}phane Ducasse},
  publisher = {N/A},
  note = {7 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Code and design smells ; WOOR},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP05WOORa.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ECOOP05WOORa.ppt.pdf},
  pages = {N/A}
}

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.

@INPROCEEDINGS{Antoniol05-ICSM-FeatureIdentification,
  author = {Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Feature Identification: {A} Novel Approach and a Case Study},
  booktitle = {Proceedings of the 21<sup>{st}</sup> International Conference on Software Maintenance ({ICSM})},
  year = {2005},
  month = {September},
  editor = {Tibor Gyim{\'o}thy and Vaclav Rajlich},
  publisher = {IEEE CS Press},
  note = {Best paper. 10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Features and requirements ; ICSM},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM05.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ICSM05.ppt.pdf},
  pages = {357--366},
  comment = {Best paper.}
}

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@productMozilla, to show the advantages of our approach. We also use the case study to compare processor emulation with statistical profiling.

@INPROCEEDINGS{Antoniol05-WESRE-NeedEmpiricalEvidence,
  author = {Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Ettore Merlo and Houari Sahraoui},
  title = {Software Evolution: {T}he Need for Empirical Evidence},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {ICSM} workshop on Empirical Studies in Reverse Engineering ({WESRE})},
  year = {2005},
  month = {September},
  editor = {Paolo Tonella},
  publisher = {IEEE CS Press},
  note = {2 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Evolution patterns ; WESRE},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WESRE05.doc.pdf},
  pages = {N/A}
}

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.

@INPROCEEDINGS{Antoniol05-TEFSE-FeatureTraceability,
  author = {Giuliano Antoniol and Ettore Merlo and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Houari Sahraoui},
  title = {Feature Traceability in Object Oriented Software},
  booktitle = {Proceedings of the 3<sup>{rd}</sup> {ASE} workshop on Traceability in Emerging Forms of Software Engineering ({TEFSE})},
  year = {2005},
  month = {November},
  editor = {Jonathan I. Maletic and Giuliano Antonio and Jane Cleland-Huang and Jane Huffman Hayes},
  publisher = {ACM Press},
  note = {6 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Features and requirements ; TEFSE},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/TEFSE05.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/TEFSE05.ppt.pdf},
  pages = {73--78}
}

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…) 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.

@INPROCEEDINGS{Gueheneuc05-BSUP-Ptidej,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Ptidej}: {P}romoting Patterns with Patterns},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {ECOOP} workshop on Building a System using Patterns ({BSUP})},
  year = {2005},
  month = {July},
  editor = {Mohamed E. Fayad},
  publisher = {Springer-Verlag},
  note = {9 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; BSUP},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP05BSUP.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ECOOP05BSUP.ppt.pdf},
  pages = {N/A}
}

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.

@TECHREPORT{Gueheneuc05-TR-VisionComprehension,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Theory of Program Comprehension -- Joining Vision Science and Program Comprehension},
  year = {2005},
  month = {December},
  note = {26 pages.},
  institution = {University of Montreal},
  number = {1267},
  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.},
  grant = {CFI project 10363},
  keywords = {Understanding program comprehension},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+Vision+Comprehension+December05.doc.pdf}
}

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 \emphprocess available information to perform their tasks but not how software engineers \emphacquire 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.

@MISC{Gueheneuc05-Demo-CASCON,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Jean-Yves Guyomarc'h and Duc-Loc Huynh and Olivier Kaczor and Naouel Moha and Samah Rached},
  title = {{Ptidej} - A Tool Suite},
  year = {2005},
  month = {October},
  note = {Tool demo at the 15<sup>{th}</sup> {IBM} Centers for Advanced Studies Conference.},
  comment = {Tool demo at the 15<sup>{th}</sup> {IBM} Centers for Advanced Studies Conference.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; CASCON},
  kind = {DEMO},
  language = {english},
  url = {https://www-927.ibm.com/ibm/cas/archives/2005/demos/},
  pdf = {http://www.ptidej.net/publications/documents/CASCON05ToolDemo.ppt.pdf}
}

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.

@INPROCEEDINGS{Gueheneuc05-IWDPTP-ExperimentalSetting,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Stefan Monnier and Giuliano Antoniol},
  title = {Evaluating the Use of Design Patterns during Program Comprehension -- Experimental Setting},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {ICSM} workshop in Design Pattern Theory and Practice ({IWDPTP})},
  year = {2005},
  month = {September},
  editor = {Giuliano Antoniol and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  publisher = {IEEE CS Press},
  note = {In the pre-proceedings. 6 pages.},
  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.},
  grant = {CFI project 10363},
  keywords = {Understanding program comprehension ; IWDPTP},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/IWDPTP05.doc.pdf},
  pages = {N/A},
  comment = {In the pre-proceedings.}
}

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.

@INPROCEEDINGS{Gueheneuc05-LMO-SignaturesNumeriques,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Houari Sahraoui},
  title = {Des signatures num\'eriques pour am\'eliorer la recherche structurelle de patrons},
  booktitle = {Actes du 11<sup>{e}</sup> colloque Langages et Mod{\`e}les {\`a} Objets ({LMO})},
  year = {2005},
  month = {mars},
  editor = {Marianne Huchard and St{\'e}phane Ducasse and Oscar Nierstrasz},
  publisher = {Herm\`es Science Publications},
  note = {16 pages.},
  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.},
  grant = {NSERC DG and Start-up fund},
  keywords = {Design patterns ; LMO},
  kind = {MNSA},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/LMO05.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/LMO05.ppt.pdf},
  pages = {97--112}
}

Les patrons de conception orientés-objets décrivent de bonnes solutions à des problèmes récurrents de conception des programmes. Les solutions proposées 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és dans l'architecture d'un programme pour comprendre les problèmes de conception résolus et faire des modifications pertinentes au programme. L'identification de micro-architectures similaires à des motifs de conception est difficile à cause du large espace de recherche, ıe les nombreuses combinaisons de classes possibles. Nous proposons une étude expérimentale des classes jouant un rôle dans des motifs de conception avec des métriques et un algorithme d'apprentissage pour associer des signatures numériques aux rôles dans les motifs de conception. Une signature numérique est un ensemble de valeurs de métriques qui caractérise les classes jouant un rôle dans un motif de conception. Nous montrons que les signatures numériques permettent de réduire efficacement l'espace de recherche des micro-architectures similaires à des motifs de conception sur l'exemple du patron de conception Composite et du programme \JHotDraw.

@INPROCEEDINGS{Gueheneuc05-WOOR-SequenceDiagrams,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Tewfik Ziadi},
  title = {Automated Reverse-Engineering of {UML} v2.0 Dynamic Models},
  booktitle = {Proceedings of the 6<sup>{th}</sup> {ECOOP} workshop on Object-Oriented Reengineering ({WOOR})},
  year = {2005},
  month = {July},
  editor = {Serge Demeyer and St{\'e}phane Ducasse and Kim Mens and Roel Wuyts},
  publisher = {N/A},
  note = {5 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; WOOR},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP05WOORb.doc.pdf},
  pages = {N/A}
}

In this position paper, we advocate the automated reverse-engineering of UML v2.0 dynamic models, ıe 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.

@PROCEEDINGS{WOOR05,
  title = {Report of the 6<sup>{th}</sup> international Workshop on Object-Oriented Reengineering ({WOOR})},
  year = {2005},
  month = {July},
  editor = {Serge Demeyer and Kim Mens and Roel Wuyts and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Andy Zaidman and Neil Walkinshaw and Ademar Aguiar and St{\'e}phane Ducasse},
  publisher = {Springer-Verlag},
  note = {12 pages.},
  kind = {ACA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP05WOORReader.doc.pdf}
}

@TECHREPORT{Khosravi04-TR-DPQualityModel,
  author = {Khashayar Khosravi and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Quality Model for Design Patterns},
  year = {2004},
  month = {September},
  note = {94 pages.},
  institution = {University of Montreal},
  number = {1249},
  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.},
  grant = {NSERC DG},
  keywords = {Quality models ; Design patterns},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+Quality+Models+September04.doc.pdf}
}

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.

@INPROCEEDINGS{Gueheneuc04-APSEC-SystematicUML,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Systematic Study of {UML{}} Class Diagram Constituents for their Abstract and Precise Recovery},
  booktitle = {Proceedings of the 11<sup>{th}</sup> Asia-Pacific Software Engineering Conference ({APSEC})},
  year = {2004},
  month = {November-December},
  editor = {Doo-Hwan Bae and William C. Chu},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Binary class relations ; APSEC},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/APSEC04.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/APSEC04.ppt.pdf},
  pages = {265--274}
}

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 §malltalk 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.

@INPROCEEDINGS{Gueheneuc04-ICSM-P-UMLRecovery,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Abstract and Precise Recovery of {UML{}} Class Diagram Constituents},
  booktitle = {Proceedings of the 20<sup>{th}</sup> International Conference and Software Maintenance ({ICSM})},
  year = {2004},
  month = {September},
  editor = {Mark Harman and Bogdan Korel},
  publisher = {IEEE CS Press},
  note = {Poster. 1 page.},
  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.},
  grant = {NSERC DG},
  keywords = {Binary class relations ; ICSM},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ICSM04.doc.pdf},
  pages = {523},
  comment = {Poster.}
}

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 §malltalk source code. Finally, we suggest a road-map to abstract and precise reverse-engineering.

@INPROCEEDINGS{Gueheneuc04-CASCON-PreciseClassDiagrams,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {A Reverse Engineering Tool for Precise Class Diagrams},
  booktitle = {Proceedings of the 14<sup>{th}</sup> {IBM} Centers for Advanced Studies Conference ({CASCON})},
  year = {2004},
  month = {October},
  editor = {Janice Singer and Hanan Lutfiyya},
  publisher = {ACM Press},
  note = {14 pages.},
  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.},
  grant = {NSERC DG and Start-up fund},
  keywords = {Binary class relations ; CASCON},
  kind = {MNSA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/CASCON04.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/CASCON04.ppt.pdf},
  pages = {28--41}
}

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 \emphreal 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.

@MISC{PMARt,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{PMARt}},
  year = {2004},
  month = {since November},
  note = {A database of occurrences of patterns in object-oriented programs.},
  comment = {A database of occurrences of patterns in object-oriented programs.},
  keywords = {Design patterns},
  kind = {OUTIL},
  language = {english},
  url = {http://www.ptidej.net/research/designpatterns/}
}

@INPROCEEDINGS{Gueheneuc04-OOPSLA-RecoveringBCR,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Herv{\'e} Albin-Amiot},
  title = {Recovering Binary Class Relationships: {P}utting Icing on the {UML} Cake},
  booktitle = {Proceedings of the 19<sup>{th}</sup> Conference on Object-Oriented Programming, Systems, Languages, and Applications ({OOPSLA})},
  year = {2004},
  month = {October},
  editor = {Doug C. Schmidt},
  publisher = {ACM Press},
  note = {14 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Binary class relations ; OOPSLA},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/OOPSLA04.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/OOPSLA04.ppt.pdf},
  pages = {301--314}
}

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.

@INPROCEEDINGS{Gueheneuc04-WCRE-ClassFingerprinting,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Houari Sahraoui and Farouk Zaidi},
  title = {Fingerprinting Design Patterns},
  booktitle = {Proceedings of the 11<sup>{th}</sup> Working Conference on Reverse Engineering ({WCRE})},
  year = {2004},
  month = {November},
  editor = {Eleni Stroulia and Andrea de Lucia},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {NSERC DG},
  keywords = {Design patterns ; WCRE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/WCRE04.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/WCRE04.ppt.pdf},
  pages = {172--181}
}

Design patterns describe \emphgood solutions to common and recurring problems in program design. The solutions are \emphdesign 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 \emphmicro-architectures similar to design motifs is difficult because of the large search space, ıe 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 \emphfingerprint 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@patternComposite design motif and the \JHotDraw framework.

@TECHREPORT{Baroni03-TR-DPFormalization,
  author = {Aline L{\'u}cia Baroni and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Herv{\'e} Albin-Amiot},
  title = {Design Patterns Formalization},
  year = {2003},
  month = {June},
  note = {59 pages.},
  institution = {Computer Science Department, \'Ecole des Mines de Nantes},
  number = {03/03/INFO},
  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.},
  grant = {\ygg@company{IBM} Eclipse Fellowship},
  keywords = {Design patterns},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+Metamodeling+June03.doc.pdf},
  relevance = {100},
  relevantfor = {Design patterns formalization}
}

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.

@ARTICLE{Farias03-ENTCS-CoherenceProtocols,
  author = {Andr{\'e}s Far{\'{\i}}as and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {On the Coherence of Component Protocols},
  journal = {Electronic Notes in Theoretical Computer Science ({ENTCS})},
  year = {2003},
  month = {April},
  volume = {82},
  number = {5},
  pages = {42--53},
  note = {12 pages.},
  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.},
  editor = {Uwe Assmann and Elke Pulvermueller and Isabelle Borne and Noury Bouraqadi and Pierre Cointe},
  grant = {\ygg@company{IBM} Eclipse Fellowship},
  keywords = {ENTCS},
  kind = {RIAS},
  language = {english},
  publisher = {Elsevier},
  url = {http://www.ptidej.net/publications/documents/ETAPS03SC.doc.pdf}
}

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.

@PHDTHESIS{Gueheneuc03-PhD,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Un cadre pour la tra\c cabilit\'e des motifs de conception},
  school = {\'Ecole des Mines de Nantes et Universit\'e de Nantes},
  year = {2003},
  month = {juin},
  note = {350 pages.},
  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{}.},
  grant = {\ygg@company{Object Technology International, Inc.} et \ygg@company{IBM} Eclipse Fellowship},
  keywords = {Design patterns ; Binary class relations},
  kind = {THESE},
  language = {francais},
  url = {http://www.yann-gael.gueheneuc.net/Work/PhDThesis/}
}

Les patrons de conception sont importants en génie logiciel à objets car ils contribuent à la qualité des programmes. Ils proposent des solutions élégantes à des problèmes récurrents de conception, des motifs utilisés pendant l'implan­tation. À l'usage, ces motifs de conception sont disséminés dans le code source et ne sont plus explicites lors de la maintenance ; pourtant, ils aideraient à comprendre l'implantation et la conception des programmes, assurant leur qualité. Ce mémoire propose des modèles et des algorithmes pour garantir la tra ̧cabilité des motifs de conception entre les phases d'implantation et de rétroconception des programmes par l'identification semi-automatique des micro-architectures similaires à ces motifs dans le code source. La métamodélisation est utilisée pour décrire les motifs de conception et les programmes Java. Elle amène à expliciter certaines relations interclasses (association, agré­gation et composition) offertes par les langages de conception comme UML et à préciser leurs propriétés (durée de vie, exclusivité, multiplicité et site d'invocation) pour les identifier avec des algorithmes d'analyses statiques et dynamiques. Elle conduit aussi à traduire les motifs en systèmes de contraintes et à identifier les micro-architectures similaires, formes complètes et approchées, par la résolution de problèmes de satisfaction de contraintes. La programmation par contraintes avec explications permet de guider la résolution et d'expliquer les micro-architectures identifiées. La suite d'outils Ptidej est une implantation des modèles et des algorithmes proposés. Elle est intégrée à l'environnement \Eclipse de développement en Java. Elle inclut le métamodèle PADL, dérivé du métamodèle ¶DL ; des outils d'analyses statiques et dynamiques, \Introspector et Caffeine ; et un solveur de contraintes, PtidejSolver, dérivé du solveur de contraintes avec explications de référence ¶aLM.

@INPROCEEDINGS{Gueheneuc03-ASE-P-AAC,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Herv{\'e} Albin-Amiot},
  title = {A Pragmatic Study of Binary Class Relationships},
  booktitle = {Proceedings of the 18<sup>{th}</sup> Conference on Automated Software Engineering ({ASE})},
  year = {2003},
  month = {September},
  editor = {John Grundy and John Penix},
  publisher = {IEEE CS Press},
  note = {Short paper. 4 pages.},
  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.},
  grant = {\ygg@company{IBM} Eclipse Fellowship and Start-up fund},
  keywords = {Binary class relations ; ASE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ASE03.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ASE03.ppt.pdf},
  pages = {277--280},
  comment = {Short paper.}
}

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.

@INPROCEEDINGS{Gueheneuc03-GDRALPOCM-PtidejEclipse,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Herv{\'e} Albin-Amiot and Pierre Cointe},
  title = {{PatternsBox}--{Ptidej}, int\'egration de deux outils de conception et de r\'etro-conception \`a {Eclipse}},
  booktitle = {Journ\'ee {GDR} {ALP}-{OCM}},
  year = {2003},
  month = {f\'evrier},
  editor = {Jacques Malenfant},
  publisher = {N/A},
  note = {6 pages.},
  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{}.},
  grant = {\ygg@company{IBM} Eclipse Fellowship},
  keywords = {Design patterns ; GDR ALP-OCM},
  kind = {MNADR},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/Projet+GDRALP+OCM03.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/Projet+GDRALP+OCM03.ppt.pdf},
  pages = {N/A}
}

Nous nous intéressons aux phases de conception et de maintenance de programmes à objets. Nous pensons que l'utilisation des motifs (tels les motifs de conception de i̧teGoF94-Patterns) facilite, d'une part, la conception et la documentation i̧teAlbinAmiot03-PhD et, d'autre part, la compréhension et l'amélioration i̧teGueheneuc03-PhD de ces programmes. Nous avons développé à l'occasion de nos travaux de thèse de doctorat, ¶atternsBox i̧teAlbinAmiot03-PhD et Ptidej i̧teGueheneuc03-PhD, deux outils de conception et de maintenance basés sur les motifs. ¶atternsBox permet (i) d'appliquer les solutions recommandées par un ensemble de motifs de conception et (ii) d'identifier dans l'architecture d'un programme à objets les solutions complètes correspondant à des motifs donnés. Ptidej permet (i) d'identifier des solutions à des motifs donnés et leurs variantes et (ii) d'identifier des défauts de conception dans l'architecture du programme. Ces deux outils présentent un intérêt pour les développeurs essentiellement lorsqu'ils sont intégrés avec les outils utilisés habituellement pendant les phases de conception et de maintenance. C'est pourquoi nous les avons intégrés à des environnements de développements intégrés (EDI). Dans cet article, et après avoir présenté l'EDI d'\ygg@companyOTI / IBM \Eclipse i̧teOTI01-Eclipse, nous décrivons notre première expérience relative à l'inté­gration de Ptidej avec \Eclipse, puis nos projets quant à l'intégration de ¶atternsBox.

@INPROCEEDINGS{AlbinAmiot02-LMO-MetaModele,
  author = {Herv{\'e} Albin-Amiot and Pierre Cointe and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Un m\'eta-mod\`ele pour coupler application et d\'etection des design patterns},
  booktitle = {Actes du 8<sup>{e}</sup> colloque Langages et Mod{\`e}les {\`a} Objets ({LMO})},
  year = {2002},
  month = {janvier},
  editor = {Michel Dao and Marianne Huchard},
  publisher = {Herm\`es Science Publications},
  note = {18 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Design patterns ; LMO},
  kind = {MNSA},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/LMO02.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/LMO02.ppt.pdf},
  pages = {41--58},
  series = {{RSTI} -- {L'objet}},
  volume = {8, num\'ero 1-2/2002}
}

Les design patterns (ou patrons de conception) sont reconnus comme une des bonnes techniques du génie logiciel à objets. Cette technique améliore le cycle de vie du logiciel en facilitant la conception, la documentation, la maintenance et la rétro-conception. Peu d'environnements de développement intégrés (EDIs) sont à la fois outillés pour inciter l'utilisateur à appliquer un catalogue de patterns et pour l'aider à améliorer ses programmes en y extrayant automatiquement des micro-architectures correspondant à celles de patterns. Ce papier présente une partie de nos travaux visant à outiller l'EDI Visual Age pour Java en lui adjoignant un catalogue recensant l'ensemble des patterns du GoF et deux assistants dédiés à l'application et à la détection de patterns. Nous proposons un méta-modèle permettant de décrire ces différents patterns, de les manipuler, de les synthétiser et de les reconnaître dans des programmes existants. Nous discutons les limites de ce méta-modèle apparues après expérimentation et suggérons comment l'améliorer pour prendre en charge l'aspect intentionnel des patterns et supporter la reconnaissance de micro-architectures voisines de celles de patterns déjà répertoriés.

@INPROCEEDINGS{AlbinAmiot02-JCOM-Couple,
  author = {Herv{\'e} Albin-Amiot and Pierre Cointe and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Un m\'eta-mod\`ele pour coupler application et d\'etection des design patterns},
  booktitle = {Journ\'ee sur le projet {COM}},
  year = {2002},
  month = {f\'evrier},
  editor = {Anne-Marie Kempf},
  publisher = {N/A},
  note = {17 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.} and \ygg@company{IBM} Eclipse Fellowship},
  keywords = {Design patterns ; JCOM},
  kind = {MNADR},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/JCOM02.ppt.pdf},
  pdf = {http://www.ptidej.net/publications/documents/JCOM02.ppt.pdf},
  pages = {N/A}
}

Améliorer la qualitédes développements par objets en favorisant l'utilisation des design patternspour aider à iImplémenter ; comprendre ; documenter.

@INPROCEEDINGS{Farias02-WBS-ProtocolsEJB,
  author = {Andr{\'e}s Far{\'{\i}}as and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Mario S{\"u}dholt},
  title = {Integrating Behavioral Protocols in {Enterprise Java Beans}},
  booktitle = {Proceedings of the 11<sup>{th}</sup> {OOPSLA} workshop on Behavioral Semantics: {S}erving the Customer ({Behavioural Semantics})},
  year = {2002},
  month = {October},
  editor = {Kenneth Baclawski and Haim Kilov},
  publisher = {Northeastern University},
  note = {10 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Behavioural Semantics},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/OOPSLA02BehavioralSemantics.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/OOPSLA02BehavioralSemantics.ppt.pdf},
  pages = {80--89},
  organization = {College of Computer Science}
}

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.

@INPROCEEDINGS{Gueheneuc02-WDMP-ThreeMusketeers,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Three Musketeers to the Rescue~-- {M}eta-Modelling, Logic Programming, and Explanation-based Constraint Programming for Pattern Description and Detection},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {ASE} workshop on Declarative Meta-Prorgramming ({WDMP})},
  year = {2002},
  month = {September},
  editor = {Kris De Volder and Kim Mens and Tom Mens and Roel Wuyts},
  publisher = {Computer Science Department, University of British Columbia},
  note = {8 pages.},
  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},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Design patterns ; WDMP},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ASE02DMP.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ASE02DMP.ppt.pdf},
  pages = {N/A}
}

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

@MISC{Caffeine,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Caffeine}},
  year = {2002},
  month = {since May},
  note = {A tool to analyse Java{} programs dynamically.},
  comment = {A tool to analyse Java{} programs dynamically.},
  keywords = {Design patterns},
  kind = {OUTIL},
  language = {english},
  url = {http://www.ptidej.net}
}

@TECHREPORT{Gueheneuc02-TR-GapLanguages,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Herv{\'e} Albin-Amiot and R{\'e}mi Douence and Pierre Cointe},
  title = {Bridging the Gap Between Modeling and Programming Languages},
  year = {2002},
  month = {July},
  note = {56 pages.},
  institution = {Computer Science Department, \'Ecole des Mines de Nantes},
  number = {02/09/INFO},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Binary class relations},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+AAC+July02.doc.pdf}
}

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.

@INPROCEEDINGS{Gueheneuc02-ASE-Caffeine,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and R{\'e}mi Douence and Narendra Jussien},
  title = {No {J}ava Without {C}affeine~-- {A} Tool for Dynamic Analysis of {J}ava Programs},
  booktitle = {Proceedings of the 17<sup>{th}</sup> Conference on Automated Software Engineering ({ASE})},
  year = {2002},
  month = {September},
  editor = {Wolfgang Emmerich and Dave Wile},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Binary class relations ; ASE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ASE02.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ASE02.ppt.pdf},
  pages = {117--126}
}

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, ıe an execution history, and a ¶rolog 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.

@TECHREPORT{Gueheneuc02-TR-Caffeine,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and R{\'e}mi Douence and Narendra Jussien},
  title = {No {J}ava Without {C}affeine~-- {A} Tool for Dynamic Analysis of {J}ava Programs},
  year = {2002},
  month = {May},
  note = {16 pages.},
  institution = {Computer Science Department, \'Ecole des Mines de Nantes},
  number = {02/07/INFO},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Binary class relations},
  kind = {RR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/Research+report+Caffeine+May02.doc.pdf}
}

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, ıe an execution history, and a ¶rolog 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.

@INPROCEEDINGS{AlbinAmiot01-ASE-BitsPieces,
  author = {Herv{\'e} Albin-Amiot and Pierre Cointe and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Narendra Jussien},
  title = {Instantiating and Detecting Design Patterns: {P}utting Bits and Pieces Together},
  booktitle = {Proceedings of the 16<sup>{th}</sup> Conference on Automated Software Engineering ({ASE})},
  year = {2001},
  month = {November},
  editor = {Debra Richardson and Martin Feather and Michael Goedicke},
  publisher = {IEEE CS Press},
  note = {8 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Design patterns ; ASE},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ASE01.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ASE01.ppt.pdf},
  pages = {166--173}
}

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.

@INPROCEEDINGS{AlbinAmiot01-WPHDOOS-RoundTrip,
  author = {Herv{\'e} Albin-Amiot and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Design Patterns: {A} Round-Trip},
  booktitle = {Proceedings of the 11<sup>{th}</sup> {ECOOP} workshop for {Ph.D.} Students in Object-Oriented Systems ({PHDOOS})},
  year = {2001},
  month = {June},
  editor = {Gilles Ardourel and Michael Haupt and Jose Luis Herrero Agustin and Rainer Ruggaber and Charles Suscheck},
  publisher = {N/A},
  note = {10 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Design patterns ; PHDOOS},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP01PHDOOS.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ECOOP01PHDOOS.ppt.pdf},
  pages = {N/A}
}

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.

@INPROCEEDINGS{AlbinAmiot01-WAOOSDM-MetaModel,
  author = {Herv{\'e} Albin-Amiot and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Meta-Modeling Design Patterns: {A}pplication to Pattern Detection and Code Synthesis},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {ECOOP} workshop on Automating Object-Oriented Software Development Methods ({AOOSDM})},
  year = {2001},
  month = {October},
  editor = {Pim van den Broek and Pavel Hruby and Motoshi Saeki and Gerson Suny{\'e} and Bedir Tekinerdogan},
  publisher = {University of Twente},
  note = {TR-CTIT-01-35. 8 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Design patterns ; AOOSDM},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/ECOOP01AOOSDM.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/ECOOP01AOOSDM.ppt.pdf},
  pages = {20--27},
  comment = {TR-CTIT-01-35.},
  organization = {Centre for Telematics and Information Technology}
}

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.

@INPROCEEDINGS{AlbinAmiot01-WGP-Generative,
  author = {Herv{\'e} Albin-Amiot and Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Design Patterns Application: {P}ure-generative Approach {vs.} Conservative-generative Approach},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {OOPSLA} workshop on Generative Programming ({GP})},
  year = {2001},
  month = {October},
  editor = {Krzysztof Czarnecki},
  publisher = {N/A},
  note = {3 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Design patterns ; GP},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/OOPSLA01GP.doc.pdf},
  pages = {N/A}
}

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.

@MISC{Ptidej,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{Ptidej}},
  year = {2001},
  month = {since July},
  note = {A tool suite to evaluate and to enhance the quality of object-oriented programs.},
  comment = {A tool suite to evaluate and to enhance the quality of object-oriented programs.},
  kind = {OUTIL},
  language = {english},
  url = {http://www.ptidej.net/research/designpatterns/}
}

@INPROCEEDINGS{Gueheneuc01-TOOLSUSA-DesignDefects,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Herv{\'e} Albin-Amiot},
  title = {Using Design Patterns and Constraints to Automate the Detection and Correction of Inter-Class Design Defects},
  booktitle = {Proceedings of the 39<sup>{th}</sup> Conference on the Technology of Object-Oriented Languages and Systems ({TOOLS USA})},
  year = {2001},
  month = {July},
  editor = {Quioyun Li and Richard Riehle and Gilda Pour and Bertrand Meyer},
  publisher = {IEEE CS Press},
  note = {10 pages.},
  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 (\textit{intra-class}), those among classes (\textit{inter-classes}), and those of semantic nature (\textit{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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Code and design smells ; TOOLS USA},
  kind = {MISA},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/TOOLSUSA01.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/TOOLSUSA01.ppt.pdf},
  pages = {296--305}
}

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 (intra-class), those among classes (inter-classes), and those of semantic nature (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@patternComposite pattern using \ygg@productPtidej, our prototype tool that integrates the complete guidelines.

@INPROCEEDINGS{Gueheneuc01-WMSPC-Explanations,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Narendra Jussien},
  title = {Using Explanations for Design-Patterns Identification},
  booktitle = {Proceedings of the 1<sup>{st}</sup> {IJCAI} Workshop on Modeling and Solving Problems with Constraints ({WMSPC})},
  year = {2001},
  month = {August},
  editor = {Christian Bessi{\`e}re},
  publisher = {AAAI Press},
  note = {8 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Design patterns ; WMSPC},
  kind = {MIADR},
  language = {english},
  url = {http://www.ptidej.net/publications/documents/IJCAI01MSPC.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/IJCAI01MSPC.ppt.pdf},
  pages = {57--64}
}

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.

@INPROCEEDINGS{Gueheneuc01-JNPC-Explications,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc and Narendra Jussien},
  title = {Quelques explications pour les patrons~-- {U}ne application de la {PPC} avec explications pour {l'}identification de patrons de conception},
  booktitle = {Actes des 7<sup>{e}</sup> Journ{\'e}es Nationales sur la r{\'e}solution de Probl{\`e}mes NP-Complets ({JNPC})},
  year = {2001},
  month = {juin},
  editor = {Bertrand Neveu},
  publisher = {ONERA},
  note = {12 pages.},
  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.},
  grant = {\ygg@company{Object Technology International, Inc.}},
  keywords = {Design patterns ; JNPC},
  kind = {MNSA},
  language = {francais},
  url = {http://www.ptidej.net/publications/documents/JNPC01.doc.pdf},
  pdf = {http://www.ptidej.net/publications/documents/JNPC01.ppt.pdf},
  pages = {111--122}
}

Les patrons de conception décrivent des micro-architectures qui résolvent des problèmes architecturaux récurrents. Il est important d'identifier ces micro-archi­tectures lors de la maintenance des programmes orientés objets. Mais ces micro-architectures apparaissent souvent sous des formes dégradées dans le code source. Nous présentons une application de la programmation par contraintes avec explications pour l'identification de ces micro-architectures dégradées.

@MISC{PADL,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {{PADL}},
  year = {1999},
  month = {since July},
  note = {A meta-model (and parsers) to represent and to manipulate object-oriented programs and design motifs.},
  comment = {A meta-model (and parsers) to represent and to manipulate object-oriented programs and design motifs.},
  kind = {OUTIL},
  language = {english},
  url = {http://www.ptidej.net/research/designpatterns/}
}

@MASTERSTHESIS{Gueheneuc98-DEA,
  author = {Yann-Ga{\"e}l Gu{\'e}h{\'e}neuc},
  title = {Syntax-error Recovery in Interactive Environments},
  school = {\'Ecole des Mines de Nantes et Universit\'e de Nantes},
  year = {1998},
  month = {septembre},
  note = {(Dipl\^ome d'\'etudes approfondies)},
  kind = {THESE},
  language = {francais}
}