@INCOLLECTION{Hayashi23-EMSEGuestIntroduction,
   AUTHOR       = {Shinpei Hayashi and Yann-Ga�l Gu�h�neuc and 
      Michel R. V. Chaudron},
   BOOKTITLE    = {Empirical Software Engineering},
   PUBLISHER    = {Springer},
   TITLE        = {Introduction to the Special Issue on Program 
      Comprehension},
   YEAR         = {2023},
   OPTADDRESS   = {},
   CHAPTER      = {1},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {Shinpei Hayashi and Yann-Ga�l Gu�h�neuc and 
      Michel R. V. Chaudron},
   MONTH        = {February},
   NOTE         = {1 pages.},
   OPTNUMBER    = {},
   PAGES        = {68},
   OPTSERIES    = {},
   OPTTYPE      = {},
   VOLUME       = {28},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>EMSE</b>},
   URL          = {http://www.ptidej.net/publications/documents/EMSE23.doc.pdf},
   ABSTRACT     = {The Research Track of the 28th IEEE/ACM International 
      Conference on Program Comprehension (ICPC 2020) provided a quality 
      forum for researchers and practitioners from academia, industry, and 
      government to present and discuss new results, negative results, and 
      replications in program-comprehension research. The Research Track 
      welcomed submissions on any program comprehension research and 
      accepted 32 papers out of 84 submissions. For this special issue, we 
      invited authors of five high-quality papers presented in the Research 
      Track of ICPC 2020 to submit an extension of their papers. The 
      program co-chairs selected the top five papers with the highest 
      ratings from the reviewers. Each of these papers received all 
      positive ratings. Eventually, four extensions were submitted by their 
      authors. Three experts reviewed each submission to guarantee the 
      quality and sufficient novelty of the extensions. Some reviewers of 
      the extensions had reviewed the original ICPC papers. Finally, we 
      accepted the following three papers: \begin{itemize}\item The paper 
      entitled Quick remedy commits and their impact on mining software 
      repositories, authored by Fengcai Wen, Csaba Nagy, Michele Lanza, and 
      Gabriele Bavota, presents a study investigating ``quick remedy 
      commits'' performed by developers to implement changes omitted in 
      previous commits. Through a manual analysis of 500 quick remedy 
      commits, the authors defined a taxonomy of the types of changes that 
      developers tend to omit. The authors showed that consideration of 
      quick remedy commits accounts for some noisy data points when 
      performing commit mining. \item The paper entitled Software testing 
      and Android applications: a large-scale empirical study, authored by 
      Fabiano Pecorelli, Gemma Catolino, Filomena Ferrucci, Andrea De 
      Lucia, and Fabio Palomba, presents a large-scale empirical study 
      targeting 1,693 open-source Android apps and assessing the extent to 
      which these apps are actually tested, how well-designed are their 
      tests, etc. The authors showed that Android apps are poorly tested 
      and that their tests have low design quality, effectiveness, and 
      ability to find defects. \item The paper entitled A unified 
      multi-task learning model for AST-level and token-level code 
      completion, authored by Fang Liu, Ge Li, Bolin Wei, Xin Xia, Zhiyi 
      Fu, and Zhi Jin, proposes an approach to code completion based on 
      neural networks. It overcomes the limitations of previous approaches 
      by combining AST-level and token-level code completion. Hence, it can 
      take into account token probability but also syntactic structure and 
      semantic relationships. The authors showed that this novel approach 
      is more effective than previous ones through experiments. 
      \end{itemize} We would like to thank the authors of these papers. We 
      also thank the reviewers who helped authors improve their papers. 
      Finally, we would like to thank the editorial board of the Springer 
      Empirical Software Engineering Journal, who provided the opportunity 
      for this special issue and greatly assisted the editing process.}
}

The Research Track of the 28th IEEE/ACM International Conference on Program Comprehension (ICPC 2020) provided a quality forum for researchers and practitioners from academia, industry, and government to present and discuss new results, negative results, and replications in program-comprehension research. The Research Track welcomed submissions on any program comprehension research and accepted 32 papers out of 84 submissions. For this special issue, we invited authors of five high-quality papers presented in the Research Track of ICPC 2020 to submit an extension of their papers. The program co-chairs selected the top five papers with the highest ratings from the reviewers. Each of these papers received all positive ratings. Eventually, four extensions were submitted by their authors. Three experts reviewed each submission to guarantee the quality and sufficient novelty of the extensions. Some reviewers of the extensions had reviewed the original ICPC papers. Finally, we accepted the following three papers: \beginitemizeıtem The paper entitled Quick remedy commits and their impact on mining software repositories, authored by Fengcai Wen, Csaba Nagy, Michele Lanza, and Gabriele Bavota, presents a study investigating ``quick remedy commits'' performed by developers to implement changes omitted in previous commits. Through a manual analysis of 500 quick remedy commits, the authors defined a taxonomy of the types of changes that developers tend to omit. The authors showed that consideration of quick remedy commits accounts for some noisy data points when performing commit mining. ıtem The paper entitled Software testing and Android applications: a large-scale empirical study, authored by Fabiano Pecorelli, Gemma Catolino, Filomena Ferrucci, Andrea De Lucia, and Fabio Palomba, presents a large-scale empirical study targeting 1,693 open-source Android apps and assessing the extent to which these apps are actually tested, how well-designed are their tests, etc. The authors showed that Android apps are poorly tested and that their tests have low design quality, effectiveness, and ability to find defects. ıtem The paper entitled A unified multi-task learning model for AST-level and token-level code completion, authored by Fang Liu, Ge Li, Bolin Wei, Xin Xia, Zhiyi Fu, and Zhi Jin, proposes an approach to code completion based on neural networks. It overcomes the limitations of previous approaches by combining AST-level and token-level code completion. Hence, it can take into account token probability but also syntactic structure and semantic relationships. The authors showed that this novel approach is more effective than previous ones through experiments. \enditemize We would like to thank the authors of these papers. We also thank the reviewers who helped authors improve their papers. Finally, we would like to thank the editorial board of the Springer Empirical Software Engineering Journal, who provided the opportunity for this special issue and greatly assisted the editing process.

@ARTICLE{Flageol23-IST-MappingStudyOOFeatures,
   AUTHOR       = {William Flageol and �loi Menaud and Yann-Ga�l Gu�h�neuc and 
      Mourad Badri and Stefan Monnier},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {A Mapping study of Language Features Improving 
      Object-oriented Design Patterns},
   YEAR         = {2023},
   MONTH        = {August},
   NOTE         = {22 pages.},
   OPTNUMBER    = {},
   PAGES        = {107222},
   VOLUME       = {160},
   EDITOR       = {Claes Wohlin},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST23.doc.pdf},
   ABSTRACT     = {\textbf{Context:} Object-Oriented Programming design 
      patterns are well-known in the industry and taught in universities as 
      part of software engineering curricula. Many primary studies exist on 
      the impact of design patterns on software, in addition to secondary 
      studies summarizing these publications. Some primary studies have 
      proposed new language features and used them to re-implement design 
      patterns as a way to show improvements. While secondary studies 
      exist, they mainly focus on measuring the impact of design patterns 
      on software. \textbf{Objectives:} We performed a systematic mapping 
      study to catalogue language features in the literature claiming to 
      improve object-oriented design patterns implementations, as well as 
      how primary studies measure these improvements. \textbf{Methods:} We 
      performed a search in three databases, yielding a total of 874 
      papers, from which we obtained 34 relevant papers. We extracted and 
      studied data about the language features claiming to improve design 
      patterns implementations, the most often cited design patterns, the 
      measures used to assess the improvements, and the case studies and 
      experiments with which these improvements were studied. 
      \textbf{Results:} Using the results, we catalogue 18 language 
      features claimed in the literature to improve design patterns and 
      categorize them into paradigms. We find that some design patterns are 
      more prevalent than others, such as Observer and Visitor. Measures 
      related to code size, code scattering and understandability are 
      preferred. Case studies are done in-vitro, and experiments are rare. 
      \textbf{Conclusion:} This catalogue is useful to identify trends and 
      create a road map for research on language features to improve 
      object-oriented design patterns. Considering the prevalence of design 
      patterns, improving their implementation and adding language features 
      to better solve their underlying concerns is an efficient way to 
      improve object-oriented programming. We intend in the future to use 
      this as a basis to research specific language features that may help 
      in improving object-oriented programming.}
}

\textbfContext: Object-Oriented Programming design patterns are well-known in the industry and taught in universities as part of software engineering curricula. Many primary studies exist on the impact of design patterns on software, in addition to secondary studies summarizing these publications. Some primary studies have proposed new language features and used them to re-implement design patterns as a way to show improvements. While secondary studies exist, they mainly focus on measuring the impact of design patterns on software. \textbfObjectives: We performed a systematic mapping study to catalogue language features in the literature claiming to improve object-oriented design patterns implementations, as well as how primary studies measure these improvements. \textbfMethods: We performed a search in three databases, yielding a total of 874 papers, from which we obtained 34 relevant papers. We extracted and studied data about the language features claiming to improve design patterns implementations, the most often cited design patterns, the measures used to assess the improvements, and the case studies and experiments with which these improvements were studied. \textbfResults: Using the results, we catalogue 18 language features claimed in the literature to improve design patterns and categorize them into paradigms. We find that some design patterns are more prevalent than others, such as Observer and Visitor. Measures related to code size, code scattering and understandability are preferred. Case studies are done in-vitro, and experiments are rare. \textbfConclusion: This catalogue is useful to identify trends and create a road map for research on language features to improve object-oriented design patterns. Considering the prevalence of design patterns, improving their implementation and adding language features to better solve their underlying concerns is an efficient way to improve object-oriented programming. We intend in the future to use this as a basis to research specific language features that may help in improving object-oriented programming.

@ARTICLE{Mili23-TSE-FeatureDiscovery,
   AUTHOR       = {Hafedh Mili and Imen Benzarti and El Kharraz, Amel and 
      El Boussaidi, Ghizlane and Yann-Ga�l Gu�h�neuc and Petko Valtchev},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {Discovering Reusable Functional Features in Legacy 
      Object-oriented Systems},
   YEAR         = {2023},
   MONTH        = {July},
   NOTE         = {29 pages.},
   NUMBER       = {7},
   PAGES        = {3827--3856},
   VOLUME       = {49},
   EDITOR       = {Emerson Murphy-Hill},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE23.doc.pdf},
   ABSTRACT     = {Typical object-oriented (OO) systems implement several 
      functional features that are interwoven into class hierarchies. In 
      the absence of aspect-oriented techniques to develop and compose 
      these features, developers resort to object-oriented design and 
      programming idioms to separate features as well as possible. Given a 
      legacy OO system, discovering existing functional features helps 
      understand the design of the system and extract these features to 
      ease their maintenance and reuse. We want to discover candidate 
      functional features in OO systems. We first define functional 
      features and then discuss the footprints that such features are 
      likely to leave in an OO system. We identify three such footprints: 
      (1) multiple inheritance, (2) delegation, and (3) ad-hoc. We develop 
      a set of algorithms for identifying such footprints in OO code and 
      implemented them for the Java language using Eclipse JDT. In this 
      article, we present the algorithms, and the results of applying the 
      corresponding tools on five open-source systems: FreeMind, 
      JavaWebMail, JHotDraw, JReversePro, and Lucene. Our experimental 
      results show that: (1) the different algorithms can identify 
      interesting and useful candidate functional features in OO systems, 
      (2) they can identify opportunities for refactoring, and (3) they are 
      complementary and could help developers.}
}

Typical object-oriented (OO) systems implement several functional features that are interwoven into class hierarchies. In the absence of aspect-oriented techniques to develop and compose these features, developers resort to object-oriented design and programming idioms to separate features as well as possible. Given a legacy OO system, discovering existing functional features helps understand the design of the system and extract these features to ease their maintenance and reuse. We want to discover candidate functional features in OO systems. We first define functional features and then discuss the footprints that such features are likely to leave in an OO system. We identify three such footprints: (1) multiple inheritance, (2) delegation, and (3) ad-hoc. We develop a set of algorithms for identifying such footprints in OO code and implemented them for the Java language using Eclipse JDT. In this article, we present the algorithms, and the results of applying the corresponding tools on five open-source systems: FreeMind, JavaWebMail, JHotDraw, JReversePro, and Lucene. Our experimental results show that: (1) the different algorithms can identify interesting and useful candidate functional features in OO systems, (2) they can identify opportunities for refactoring, and (3) they are complementary and could help developers.

@ARTICLE{Minani23-IoTJ-TestingIndustry,
   AUTHOR       = {Jean Baptiste Minani and Fatima Sabir and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Internet of Things Journal (IoTJ)},
   TITLE        = {A Multi-Method Study of Internet of Things Systems 
      Testing in Industry},
   YEAR         = {2023},
   OPTMONTH     = {},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTPAGES     = {},
   OPTVOLUME    = {},
   EDITOR       = {Nei Kato},
   KEYWORDS     = {Topic: <b>ESE for the IoT</b>, Venue: <b>IoTJ</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/IoTJ23.doc.pdf},
   ABSTRACT     = {As the Internet of Things (IoT) grows, its failures may 
      have dramatic consequences on the lives of people who depend on it. 
      Yet, it is hard to test IoT systems before they are deployed. Several 
      researchers have provided state-of-the-art approaches for testing IoT 
      systems. However, many of those approaches are based on academia 
      rather than industry. Therefore, we conducted a multi-method study of 
      IoT systems testing in the industry with IoT practitioners. We used 
      three methods: 1 an industry survey, 2 practitioners interviews, and 
      3 analysis of Eclipse IoT surveys. This study focuses on testing IoT 
      systems by industry practitioners. The findings show that 1 testing 
      focuses more on the device, network, and application layers. IoT 
      testing gives more importance to integration testing than acceptance 
      testing. Test coverage is the most important metric, but metrics may 
      vary depending on the project. 2 IoT system testing mainly uses the 
      model-based approach and is often manual or semi-automated, with low 
      adoption of white box testing. Node-RED is commonly used in testing 
      IoT systems, while Amazon AWS IoT is popular for cloud platform 
      testing of IoT devices. 3 Log analysis is the main approach to 
      analyzing the root cause of bugs. 4 The main challenges in IoT 
      testing include the lack of standards, security, connectivity, and 
      reference architecture. Generating test cases and establishing a 
      standard test approach are recommended for further research. This 
      studyfs findings can help IoT practitioners and researchers to 
      identify and tackle challenges in IoT system testing, leading to 
      future research opportunities.}
}

As the Internet of Things (IoT) grows, its failures may have dramatic consequences on the lives of people who depend on it. Yet, it is hard to test IoT systems before they are deployed. Several researchers have provided state-of-the-art approaches for testing IoT systems. However, many of those approaches are based on academia rather than industry. Therefore, we conducted a multi-method study of IoT systems testing in the industry with IoT practitioners. We used three methods: 1 an industry survey, 2 practitioners interviews, and 3 analysis of Eclipse IoT surveys. This study focuses on testing IoT systems by industry practitioners. The findings show that 1 testing focuses more on the device, network, and application layers. IoT testing gives more importance to integration testing than acceptance testing. Test coverage is the most important metric, but metrics may vary depending on the project. 2 IoT system testing mainly uses the model-based approach and is often manual or semi-automated, with low adoption of white box testing. Node-RED is commonly used in testing IoT systems, while Amazon AWS IoT is popular for cloud platform testing of IoT devices. 3 Log analysis is the main approach to analyzing the root cause of bugs. 4 The main challenges in IoT testing include the lack of standards, security, connectivity, and reference architecture. Generating test cases and establishing a standard test approach are recommended for further research. This studyfs findings can help IoT practitioners and researchers to identify and tackle challenges in IoT system testing, leading to future research opportunities.

@ARTICLE{Tighilt23-JSS-MicroserviceAntipatterns,
   AUTHOR       = {Rafik Tighilt and Manel Abdellatif and Imen Trabelsi and 
      Lo�c Madern and Naouel Moha and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Systems and Software (JSS)},
   TITLE        = {On the Maintenance Support for Microservice-based 
      Systems through the Specification and the Detection of Microservice 
      Antipatterns},
   YEAR         = {2023},
   MONTH        = {October},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTPAGES     = {},
   VOLUME       = {204},
   EDITOR       = {Paris Avgeriou and David Shepherd},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>JSS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/JSS23.doc.pdf},
   ABSTRACT     = {The software industry is currently moving from 
      monolithic to microservice architectures, which are made up of 
      independent, reusable, and fine-grained services. A lack of 
      understanding of the core concepts of microservice architectures can 
      lead to poorly designed systems that include microservice 
      antipatterns. These microservice antipatterns may affect the quality 
      of services and hinder the maintenance and evolution of software 
      systems. The specification and detection of microservice antipatterns 
      could help in evaluating and assessing the design quality of systems. 
      Several research works have studied patterns and antipatterns in 
      microservice-based systems, but the automatic detection of these 
      antipatterns is still in its infancy. We propose MARS (Microservice 
      Antipatterns Research Software), a fully automated approach supported 
      by a framework for specifying and identifying microservice 
      antipatterns. Using MARS, we specify and identify 16 microservice 
      antipatterns in 24 microservice-based systems. The results show that 
      MARS can effectively detect microservice antipatterns with an average 
      precision of 82\% and a recall of 89\%. Thus, our approach can help 
      developers assert and improve the quality of their microservices and 
      development practices.}
}

The software industry is currently moving from monolithic to microservice architectures, which are made up of independent, reusable, and fine-grained services. A lack of understanding of the core concepts of microservice architectures can lead to poorly designed systems that include microservice antipatterns. These microservice antipatterns may affect the quality of services and hinder the maintenance and evolution of software systems. The specification and detection of microservice antipatterns could help in evaluating and assessing the design quality of systems. Several research works have studied patterns and antipatterns in microservice-based systems, but the automatic detection of these antipatterns is still in its infancy. We propose MARS (Microservice Antipatterns Research Software), a fully automated approach supported by a framework for specifying and identifying microservice antipatterns. Using MARS, we specify and identify 16 microservice antipatterns in 24 microservice-based systems. The results show that MARS can effectively detect microservice antipatterns with an average precision of 82% and a recall of 89%. Thus, our approach can help developers assert and improve the quality of their microservices and development practices.

@INPROCEEDINGS{Flagoel23-EuroPLoP-APsforMLS,
   AUTHOR       = {William Flageol and Yann-Ga�l Gu�h�neuc and Mourad Badri and 
      Stefan Monnier},
   BOOKTITLE    = {Proceedings of the 28<sup>th</sup> European Conference on Pattern Languages of Programs (EuroPLoP)},
   TITLE        = {Design Pattern for Reusing Immutable Methods in 
      Object-Oriented Languages},
   YEAR         = {2023},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Cesare Pautasso},
   MONTH        = {July},
   NOTE         = {16 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>PLoP</c>},
   URL          = {http://www.ptidej.net/publications/documents/EuroPLoP23.doc.pdf},
   ABSTRACT     = {\textbf{Context.} Features and styles inspired by 
      functional programming have grown in popularity in the world of 
      object-oriented programming. Immutability is a core concept of 
      functional programming, which brings advantages to software 
      development. However, introducing immutability in object-oriented 
      programming presents some challenges. \textbf{Problem.} One of these 
      challenges is method overriding. When inheriting non-destructive 
      mutators (methods used on immutable objects which return a new object 
      instead of modifying the receiver), a naive approach generates code 
      duplication and has scalability issues. \textbf{Contribution.} We 
      analyse an example of this overriding problem and propose a solution 
      in a new design pattern based on the factory method pattern. We also 
      discuss the advantages and limitations of this pattern, as well as 
      implementations in Clojure, Java, and Kotlin. We also identify and 
      discuss the language features that mostly affect the implementation 
      of this pattern. \textbf{Conclusion.} Our proposed design pattern 
      helps mitigate some of the code duplication and scalability problems 
      of a naive approach. However, the inclusion of a functional updating 
      language feature is required to completely remove the scalability 
      issues.}
}

\textbfContext. Features and styles inspired by functional programming have grown in popularity in the world of object-oriented programming. Immutability is a core concept of functional programming, which brings advantages to software development. However, introducing immutability in object-oriented programming presents some challenges. \textbfProblem. One of these challenges is method overriding. When inheriting non-destructive mutators (methods used on immutable objects which return a new object instead of modifying the receiver), a naive approach generates code duplication and has scalability issues. \textbfContribution. We analyse an example of this overriding problem and propose a solution in a new design pattern based on the factory method pattern. We also discuss the advantages and limitations of this pattern, as well as implementations in Clojure, Java, and Kotlin. We also identify and discuss the language features that mostly affect the implementation of this pattern. \textbfConclusion. Our proposed design pattern helps mitigate some of the code duplication and scalability problems of a naive approach. However, the inclusion of a functional updating language feature is required to completely remove the scalability issues.

@INPROCEEDINGS{Politowski23-GAS-VideoGamesBalance,
   AUTHOR       = {Cristiano Politowski and Fabio Petrillo and 
      El Boussaidi, Ghizlane and Gabriel Cavalheiro Ullmann and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 7<sup>th</sup> ICSE International Workshop on Games and Software Engineering (GAS)},
   TITLE        = {Assessing Video Game Balance using Autonomous Agents},
   YEAR         = {2023},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kendra Cooper},
   MONTH        = {May},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {25--32},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Video game development</b>, 
      Topic: <b>Test case generation</b>, Venue: <i>GAS</i>},
   URL          = {http://www.ptidej.net/publications/documents/GAS23b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/GAS23b.ppt.pdf},
   ABSTRACT     = {As the complexity and scope of games increase, game 
      testing, also called playtesting, becomes an essential activity to 
      ensure the quality of video games. Yet, the manual, ad-hoc nature of 
      game testing leaves space for automation. In this paper, we research, 
      design, and implement an approach to supplement game testing to 
      balance video games with autonomous agents. We evaluate our approach 
      with two platform games. We bring a systematic way to assess if a 
      game is balanced by (1) comparing the difficulty levels between game 
      versions and issues with the game design, and (2) the game demands 
      for skill or luck.}
}

As the complexity and scope of games increase, game testing, also called playtesting, becomes an essential activity to ensure the quality of video games. Yet, the manual, ad-hoc nature of game testing leaves space for automation. In this paper, we research, design, and implement an approach to supplement game testing to balance video games with autonomous agents. We evaluate our approach with two platform games. We bring a systematic way to assess if a game is balanced by (1) comparing the difficulty levels between game versions and issues with the game design, and (2) the game demands for skill or luck.

@INPROCEEDINGS{Ullmann23-GAS-GameEngineArchitectureRecovery,
   AUTHOR       = {Gabriel Cavalheiro Ullmann and Yann-Ga�l Gu�h�neuc and 
      Fabio Petrillo and Nicolas Anquetil and Cristiano Politowski},
   BOOKTITLE    = {Proceedings of the 7<sup>th</sup> ICSE International Workshop on Games and Software Engineering (GAS)},
   TITLE        = {An Exploratory Approach for Game Engine Architecture 
      Recovery},
   YEAR         = {2023},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kendra Cooper},
   MONTH        = {May},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {8--15},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Video game development</b>, Venue: <i>GAS</i>},
   URL          = {http://www.ptidej.net/publications/documents/GAS23a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/GAS23a.ppt.pdf},
   ABSTRACT     = {Game engines provide video game developers with a wide 
      range of fundamental subsystems for creating games, such as 2D/3D 
      graphics rendering, input device management, and audio playback. 
      Developers often integrate these subsystems with other applications 
      or extend them via plugins. To integrate or extend correctly, 
      developers need a broad system architectural understanding. However, 
      architectural information is not always readily available and is 
      often overlooked in this kind of system. In this work, we propose an 
      approach for game engine architecture recovery and explore the 
      architecture of three popular open-source game engines (Cocos2d-x, 
      Godot, and Urho3D). We perform manual subsystem detection and use 
      Moose, a platform for software analysis, to generate architectural 
      models. With these models, we answer the following questions: Which 
      subsystems are present in game engines? Which subsystems are more 
      often coupled with one another? Why are these subsystems coupled with 
      each other? Results show that the platform independence, resource 
      management, world editor, and core subsystems are frequently included 
      by others and therefore act as foundations for the game engines. 
      Furthermore, we show that, by applying our approach, game engine 
      developers can understand whether subsystems are related and divide 
      responsibilities. They can also assess whether relationships among 
      subsystems are appropriate for the game engine.}
}

Game engines provide video game developers with a wide range of fundamental subsystems for creating games, such as 2D/3D graphics rendering, input device management, and audio playback. Developers often integrate these subsystems with other applications or extend them via plugins. To integrate or extend correctly, developers need a broad system architectural understanding. However, architectural information is not always readily available and is often overlooked in this kind of system. In this work, we propose an approach for game engine architecture recovery and explore the architecture of three popular open-source game engines (Cocos2d-x, Godot, and Urho3D). We perform manual subsystem detection and use Moose, a platform for software analysis, to generate architectural models. With these models, we answer the following questions: Which subsystems are present in game engines? Which subsystems are more often coupled with one another? Why are these subsystems coupled with each other? Results show that the platform independence, resource management, world editor, and core subsystems are frequently included by others and therefore act as foundations for the game engines. Furthermore, we show that, by applying our approach, game engine developers can understand whether subsystems are related and divide responsibilities. They can also assess whether relationships among subsystems are appropriate for the game engine.

@INPROCEEDINGS{Ullmann23-ICEC-GameEnginesCouplingPatterns,
   AUTHOR       = {Gabriel Cavalheiro Ullmann and Yann-Ga�l Gu�h�neuc and 
      Fabio Petrillo and Nicolas Anquetil and Cristiano Politowski},
   BOOKTITLE    = {Proceedings of the 22<sup>st</sup> International Conference on Entertainment Computing (ICEC)},
   TITLE        = {Visualising Game Engine Subsystem Coupling Patterns},
   YEAR         = {2023},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Helmut Hlavacs and Angelo Di Iorio},
   MONTH        = {November},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ICEC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICEC23.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICEC23.ppt.pdf},
   ABSTRACT     = {Game engines provide video game developers with a wide 
      range of fundamental subsystems for creating games, such as 2D/3D 
      graphics rendering, input device management, and audio playback. 
      Developers often integrate these subsystems with other applications 
      or extend them via plugins. To integrate or extend correctly, 
      developers need a broad system architectural understanding. However, 
      architectural information is not always readily available and is 
      often overlooked in this kind of system. In this work, we propose an 
      approach for game engine architecture recovery and explore the 
      architecture of three popular opensource game engines (Cocos2d-x, 
      Godot, and Urho3D). We perform manual subsystem detection and use 
      Moose, a platform for software analysis, to generate architectural 
      models. With these models, we answer the following questions: Which 
      subsystems are present in game engines? Which subsystems are more 
      often coupled with one another? Why are these subsystems coupled with 
      each other? Results show that the platform independence, resource 
      management, world editor, and core subsystems are frequently included 
      by others and therefore act as foundations for the game engines. 
      Furthermore, we show that, by applying our approach, game engine 
      developers can understand whether subsystems are related and divide 
      responsibilities. They can also assess whether relationships among 
      subsystems are appropriate for the game engine.}
}

Game engines provide video game developers with a wide range of fundamental subsystems for creating games, such as 2D/3D graphics rendering, input device management, and audio playback. Developers often integrate these subsystems with other applications or extend them via plugins. To integrate or extend correctly, developers need a broad system architectural understanding. However, architectural information is not always readily available and is often overlooked in this kind of system. In this work, we propose an approach for game engine architecture recovery and explore the architecture of three popular opensource game engines (Cocos2d-x, Godot, and Urho3D). We perform manual subsystem detection and use Moose, a platform for software analysis, to generate architectural models. With these models, we answer the following questions: Which subsystems are present in game engines? Which subsystems are more often coupled with one another? Why are these subsystems coupled with each other? Results show that the platform independence, resource management, world editor, and core subsystems are frequently included by others and therefore act as foundations for the game engines. Furthermore, we show that, by applying our approach, game engine developers can understand whether subsystems are related and divide responsibilities. They can also assess whether relationships among subsystems are appropriate for the game engine.

@MISC{Gueheneuc23-WebZine-Amiga1200EvoX500,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {janvier},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Bidouille : Installation de mon Amiga 1200 (GibChingu) 
      dans un bo�tier Evo X500},
   YEAR         = {2023},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/gibchingu_installation_a1200_x500evo.php},
   ABSTRACT     = {GibChingu est le nom de mon Amiga que j'ai log{\'e} dans 
      le bo{\^\i}tier X500 Evo. Le bo{\^\i}tier X500 Evo est probablement 
      le plus beau bo{\^\i}tier jamais con{\c{c}}u pour un Amiga.}
}

GibChingu est le nom de mon Amiga que j'ai logé dans le boı̂tier X500 Evo. Le boı̂tier X500 Evo est probablement le plus beau boı̂tier jamais conçu pour un Amiga.

@ARTICLE{Anquetil22-IST-MagicLiterals,
   AUTHOR       = {Nicolas Anquetil and Julien Delplanque and 
      St�phane Ducasse and Oleksandr Zaitsev and Christopher P. Fuhrman and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {What Do Developers Consider Magic Literals? A Smalltalk 
      Perspective},
   YEAR         = {2022},
   MONTH        = {September},
   NOTE         = {14 pages.},
   OPTNUMBER    = {},
   PAGES        = {106942},
   VOLUME       = {149},
   EDITOR       = {Claes Wohlin},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST22.doc.pdf},
   ABSTRACT     = {Context: Literals are constant values (numbers, strings, 
      etc.) used in the source code. Magic literals are such values used 
      without an explicit explanation of their meaning. Such undocumented 
      values may hinder sourcecode comprehension, negatively impacting 
      maintenance. Relatively little literature can be found on the subject 
      beyond the usual (and very old) recommendation of avoiding literals 
      and preferring named constants. Yet, magic literals are still 
      routinely found in source code. Objective: We studied literal values 
      in source code to understand when they should be considered magic or 
      not (i.e., acceptable). Methods: First, we perform a qualitative 
      study of magic literals, to establish why and under which conditions 
      they are considered harmful. We formalize hypotheses about the 
      reasoning behind how literals are considered magic. Second, we 
      perform a quantitative study on seven real systems ranging from small 
      (a few classes) to large (thousands of classes). We report the 
      literals' types (number, string, Boolean,. . .), their grammatical 
      function (e.g., argument in a call, operand in an expression, value 
      assigned,. . .), or the purpose of the code in which they appear 
      (test methods, regular code). Third, we report on another study 
      involving 26 programmers who analyzed about 24,000 literals, to 
      understand which ones they consider magic. Finally, we evaluate the 
      hypotheses defining specific conditions under which literals are 
      acceptable. Results: We show that (1) literals still exist and are 
      relatively frequent (found in close to 50\% of the methods 
      considered); (2) they are more frequent in test methods (in 80\% of 
      test methods); (3) to a large extent, they were considered acceptable 
      (only 25\% considered magic); and (4) the hypotheses concerning 
      acceptable literals are valid to various degrees. Conclusion: We thus 
      pave the way to future research on magic literals, for example, with 
      tools that could help developers deciding if a literal is acceptable.}
}

Context: Literals are constant values (numbers, strings, etc.) used in the source code. Magic literals are such values used without an explicit explanation of their meaning. Such undocumented values may hinder sourcecode comprehension, negatively impacting maintenance. Relatively little literature can be found on the subject beyond the usual (and very old) recommendation of avoiding literals and preferring named constants. Yet, magic literals are still routinely found in source code. Objective: We studied literal values in source code to understand when they should be considered magic or not (i.e., acceptable). Methods: First, we perform a qualitative study of magic literals, to establish why and under which conditions they are considered harmful. We formalize hypotheses about the reasoning behind how literals are considered magic. Second, we perform a quantitative study on seven real systems ranging from small (a few classes) to large (thousands of classes). We report the literals' types (number, string, Boolean,. . .), their grammatical function (e.g., argument in a call, operand in an expression, value assigned,. . .), or the purpose of the code in which they appear (test methods, regular code). Third, we report on another study involving 26 programmers who analyzed about 24,000 literals, to understand which ones they consider magic. Finally, we evaluate the hypotheses defining specific conditions under which literals are acceptable. Results: We show that (1) literals still exist and are relatively frequent (found in close to 50% of the methods considered); (2) they are more frequent in test methods (in 80% of test methods); (3) to a large extent, they were considered acceptable (only 25% considered magic); and (4) the hypotheses concerning acceptable literals are valid to various degrees. Conclusion: We thus pave the way to future research on magic literals, for example, with tools that could help developers deciding if a literal is acceptable.

@ARTICLE{Cooper21-SEN-ASE4Games21,
   AUTHOR       = {Kendra M. L. Cooper and Fabio Petrillo and 
      Yann-Ga�l Gu�h�neuc and Cristiano Politowski},
   JOURNAL      = {ACM SIGSOFT Software Engineering Notes},
   TITLE        = {ASE4Games'21 Workshop Report},
   YEAR         = {2022},
   MONTH        = {April},
   NOTE         = {2 pages.},
   NUMBER       = {2},
   PAGES        = {10--11},
   VOLUME       = {47},
   KEYWORDS     = {Venue: <i>ASE4Games</i>},
   URL          = {http://www.ptidej.net/publications/documents/ASE4Games21.doc.pdf},
   ABSTRACT     = {The first edition of the workshop on Automated Software 
      Engineering For Games (ASE4Games 2021) was held virtually on November 
      14<sup>{th}</sup>, 2021, co-located with the 36<sup>{th}</sup> 
      IEEE/ACM International Conference on Automated Software Engineering 
      (ASE 2021). Five papers from all over the world were submitted, two 
      full-papers and two short-papers were accepted. The program also 
      featured a keynote by Mathieu Nayrolles, researcher at Ubisoft, 
      entitled Automated Software Engineering for AAA Games.}
}

The first edition of the workshop on Automated Software Engineering For Games (ASE4Games 2021) was held virtually on November 14^th, 2021, co-located with the 36^th IEEE/ACM International Conference on Automated Software Engineering (ASE 2021). Five papers from all over the world were submitted, two full-papers and two short-papers were accepted. The program also featured a keynote by Mathieu Nayrolles, researcher at Ubisoft, entitled Automated Software Engineering for AAA Games.

@ARTICLE{Trabelsi22-JSEP-LegacyMicroservices,
   AUTHOR       = {Imen Trabelsi and Manel Abdellatif and 
      Abdalgader Abubaker and Naouel Moha and S�bastien Mosser and 
      Samira Ebrahimi-Kahou and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Software: Evolution and Process (JSEP)},
   TITLE        = {From Legacy to Microservices: A Type-based Approach for 
      Microservices Identification using Machine Learning and Semantic 
      Analysis},
   YEAR         = {2022},
   MONTH        = {September},
   NOTE         = {28 pages.},
   OPTNUMBER    = {},
   OPTPAGES     = {},
   OPTVOLUME    = {},
   EDITOR       = {Mel � Cinn�ide},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>JSME</b>, 
      Venue: <b>JSEP</b>},
   PUBLISHER    = {Wiley},
   URL          = {http://www.ptidej.net/publications/documents/JSEP22.doc.pdf},
   ABSTRACT     = {Abstract The microservices architecture (MSA) style has 
      been gaining interest in recent years because of its high 
      scalability, ability to be deployed in the cloud, and suitability for 
      DevOps practices. While new applications can adopt MSA from their 
      inception, many legacy monolithic systems must be migrated to an MSA 
      to benefit from the advantages of this architectural style. To 
      support the migration process, we propose MicroMiner, a microservices 
      identification approach that is based on static-relationship analyses 
      between code elements as well as semantic analyses of the source 
      code. Our approach relies on machine learning (ML) techniques and 
      uses service types to guide the identification of microservices from 
      legacy monolithic systems. We evaluate the efficiency of our approach 
      on four systems and compare our results to ground-truths and to those 
      of two state-of-the-art approaches. We perform a qualitative 
      evaluation of the resulted microservices by analyzing the business 
      capabilities of the identified microservices. Also a quantitative 
      analysis using the state-of-the-art metrics on independence of 
      functionality and modularity of services was conducted. Our results 
      show the effectiveness of our approach to automate one of the most 
      time-consuming steps in the migration of legacy systems to 
      microservices. The proposed approach identifies architecturally 
      significant microservices with a 68.15\% precision and 77\% recall.}
}

Abstract The microservices architecture (MSA) style has been gaining interest in recent years because of its high scalability, ability to be deployed in the cloud, and suitability for DevOps practices. While new applications can adopt MSA from their inception, many legacy monolithic systems must be migrated to an MSA to benefit from the advantages of this architectural style. To support the migration process, we propose MicroMiner, a microservices identification approach that is based on static-relationship analyses between code elements as well as semantic analyses of the source code. Our approach relies on machine learning (ML) techniques and uses service types to guide the identification of microservices from legacy monolithic systems. We evaluate the efficiency of our approach on four systems and compare our results to ground-truths and to those of two state-of-the-art approaches. We perform a qualitative evaluation of the resulted microservices by analyzing the business capabilities of the identified microservices. Also a quantitative analysis using the state-of-the-art metrics on independence of functionality and modularity of services was conducted. Our results show the effectiveness of our approach to automate one of the most time-consuming steps in the migration of legacy systems to microservices. The proposed approach identifies architecturally significant microservices with a 68.15% precision and 77% recall.

@ARTICLE{Uddin22-TOSEM-CombinedSentiments,
   AUTHOR       = {Gias Uddin and Yann-Ga�l Gu�h�neuc and Foutse Khomh and 
      Chanchal Roy},
   JOURNAL      = {Transactions on Software Engineering and Methodology (TOSEM)},
   TITLE        = {An Empirical Study of the Effectiveness of an Ensemble 
      of Stand-alone Sentiment Detection Tools for Software Engineering 
      Datasets},
   YEAR         = {2022},
   MONTH        = {April},
   NOTE         = {37 pages.},
   NUMBER       = {3},
   PAGES        = {48:1--48:38},
   VOLUME       = {31},
   EDITOR       = {Mauro Pezze},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <b>TOSEM</b>},
   PUBLISHER    = {ACM Press},
   URL          = {http://www.ptidej.net/publications/documents/TOSEM21.doc.pdf},
   ABSTRACT     = {Sentiment analysis in software engineering (SE) has 
      shown promise to analyze and support diverse development activities. 
      Recently, several tools are proposed to detect sentiments in software 
      artifacts. While the tools improve accuracy over off-the-shelf tools, 
      recent research shows that their performance could still be 
      unsatisfactory. A more accurate sentiment detector for SE can help 
      reduce noise in analysis of software scenarios where sentiment 
      analysis is required. Recently, combinations, i.e., hybrids of 
      stand-alone classifiers are found to offer better performance than 
      the stand-alone classifiers for fault detection. However, we are 
      aware of no such approach for sentiment detection for software 
      artifacts. We report the results of an empirical study that we 
      conducted to determine the feasibility of developing an ensemble 
      engine by combining the polarity labels of stand-alone SE-specific 
      sentiment detectors. Our study has two phases. In the first phase, we 
      pick five SE-specific sentiment detection tools from two recently 
      published papers by Lin et al., who first reported negative results 
      with stand alone sentiment detectors and then proposed an improved 
      SE-specific sentiment detector, POME. We report the study results on 
      17,581 units (sentences/documents) coming from six currently 
      available sentiment benchmarks for software engineering. We find that 
      the existing tools can be complementary to each other in 85-95\% of 
      the cases, i.e., one is wrong but another is right. However, a 
      majority voting-based ensemble of those tools fails to improve the 
      accuracy of sentiment detection. We develop Sentisead, a supervised 
      tool by combining the polarity labels and bag of words as features. 
      Sentisead improves the performance (F1-score) of the individual tools 
      by 4\% (over Senti4SD) -- 100\% (over POME). The initial development 
      of Sentisead occurred before we observed the use of deep learning 
      models for SE-specific sentiment detection. In particular, recent 
      papers show the superiority of advanced language-based pre-trained 
      transformer models (PTM) over rule-based and shallow learning models. 
      Consequently, in a second phase, we compare and improve Sentisead 
      infrastructure using the PTMs. We find that a Sentisead 
      infrastructure with RoBERTa as the ensemble of the five stand-alone 
      rule-based and shallow learning SE-specific tools from Lin et al.\ 
      offers the best F1-score of 0.805 across the six datasets, while a 
      stand-alone RoBERTa shows an F1-score of 0.801.}
}

Sentiment analysis in software engineering (SE) has shown promise to analyze and support diverse development activities. Recently, several tools are proposed to detect sentiments in software artifacts. While the tools improve accuracy over off-the-shelf tools, recent research shows that their performance could still be unsatisfactory. A more accurate sentiment detector for SE can help reduce noise in analysis of software scenarios where sentiment analysis is required. Recently, combinations, i.e., hybrids of stand-alone classifiers are found to offer better performance than the stand-alone classifiers for fault detection. However, we are aware of no such approach for sentiment detection for software artifacts. We report the results of an empirical study that we conducted to determine the feasibility of developing an ensemble engine by combining the polarity labels of stand-alone SE-specific sentiment detectors. Our study has two phases. In the first phase, we pick five SE-specific sentiment detection tools from two recently published papers by Lin et al., who first reported negative results with stand alone sentiment detectors and then proposed an improved SE-specific sentiment detector, POME. We report the study results on 17,581 units (sentences/documents) coming from six currently available sentiment benchmarks for software engineering. We find that the existing tools can be complementary to each other in 85-95% of the cases, i.e., one is wrong but another is right. However, a majority voting-based ensemble of those tools fails to improve the accuracy of sentiment detection. We develop Sentisead, a supervised tool by combining the polarity labels and bag of words as features. Sentisead improves the performance (F1-score) of the individual tools by 4% (over Senti4SD) – 100% (over POME). The initial development of Sentisead occurred before we observed the use of deep learning models for SE-specific sentiment detection. In particular, recent papers show the superiority of advanced language-based pre-trained transformer models (PTM) over rule-based and shallow learning models. Consequently, in a second phase, we compare and improve Sentisead infrastructure using the PTMs. We find that a Sentisead infrastructure with RoBERTa as the ensemble of the five stand-alone rule-based and shallow learning SE-specific tools from Lin et al.\ offers the best F1-score of 0.805 across the six datasets, while a stand-alone RoBERTa shows an F1-score of 0.801.

@ARTICLE{Washizaki22-Computer-SEDP4MLA,
   AUTHOR       = {Hironori Washizaki and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc and Hironori Takeuchi and Naotake Natori and 
      Takuo Doi and Satoshi Okuda},
   JOURNAL      = {Computer},
   TITLE        = {Software Engineering Design Patterns for Machine 
      Learning Applications},
   YEAR         = {2022},
   MONTH        = {March},
   NOTE         = {10 pages.},
   NUMBER       = {3},
   PAGES        = {30--39},
   VOLUME       = {55},
   EDITOR       = {Atif Mashkoor and Tim Menzies and Alexander Egyed and 
      Rudolf Ramler},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <b>Computer</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/Computer22.doc.pdf},
   ABSTRACT     = {In this study, a multivocal literature review identified 
      15 software-engineering design patterns for machine learning 
      applications. Findings suggest that there are opportunities to 
      increase the patterns' adoption in practice by raising awareness of 
      such patterns within the community.}
}

In this study, a multivocal literature review identified 15 software-engineering design patterns for machine learning applications. Findings suggest that there are opportunities to increase the patterns' adoption in practice by raising awareness of such patterns within the community.

@INPROCEEDINGS{Politowski22-GAS-VideoGamesTesting,
   AUTHOR       = {Cristiano Politowski and Yann-Ga�l Gu�h�neuc and 
      Fabio Petrillo},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> ICSE International Workshop on Games and Software Engineering (GAS)},
   TITLE        = {Towards Automated Video Game Testing: Still a Long Way 
      to Go},
   YEAR         = {2022},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kendra Cooper},
   MONTH        = {May},
   NOTE         = {7 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {37--43},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Video game development</b>, 
      Topic: <b>Test case generation</b>, Venue: <i>GAS</i>},
   URL          = {http://www.ptidej.net/publications/documents/GAS22c.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/GAS22c.ppt.pdf},
   ABSTRACT     = {As the complexity and scope of game development 
      increases, play testing remains an essential activity to ensure the 
      quality of video games. Yet, the manual, ad-hoc nature of play 
      testing gives space to improvements in the process. In this study, we 
      investigate gaps between academic solutions in the literature for 
      automated video game testing and the needs of video game developers 
      in the indus-try. We performed a literature review on video game 
      automated testing and applied an online survey with video game 
      develop-ers. The literature results show a rise in research topics 
      related to automated video game testing. The survey results show that 
      game developers are skeptical about using automated agents to test 
      games. We conclude that there is a need for new testing approaches 
      that did not disrupt the developer workflow. As for the researchers, 
      the focus should be on the testing goal and testing oracle.}
}

As the complexity and scope of game development increases, play testing remains an essential activity to ensure the quality of video games. Yet, the manual, ad-hoc nature of play testing gives space to improvements in the process. In this study, we investigate gaps between academic solutions in the literature for automated video game testing and the needs of video game developers in the indus-try. We performed a literature review on video game automated testing and applied an online survey with video game develop-ers. The literature results show a rise in research topics related to automated video game testing. The survey results show that game developers are skeptical about using automated agents to test games. We conclude that there is a need for new testing approaches that did not disrupt the developer workflow. As for the researchers, the focus should be on the testing goal and testing oracle.

@INPROCEEDINGS{Rahman22-SE4RAI-ChallengesMLAIndustry,
   AUTHOR       = {Md Saidur Rahman and Foutse Khomh and Emilio Rivera and 
      Yann-Ga�l Gu�h�neuc and Bernd Lehnert},
   BOOKTITLE    = {Proceedings of the 1<sup>th</sup> ICSE International Workshop on Software Engineering for Responsible Artificial Intelligence (SE4RAI)},
   TITLE        = {Challenges in Machine Learning Application Development: 
      An Industrial Experience Report},
   YEAR         = {2022},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Qinghua Lu and Xiwei (Sherry) Xu and Liming Zhu and 
      John Grundy},
   MONTH        = {May},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {21--28},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <i>SE4RAI</i>},
   URL          = {http://www.ptidej.net/publications/documents/SE4RAI22.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SE4RAI22.ppt.pdf},
   ABSTRACT     = {SAP is the market leader in enterprise application 
      software offering an end-to-end suite of applications and services to 
      enable their customers worldwide to operate their business. 
      Especially, retail customers of SAP deal with millions of sales 
      transactions for their day-to-day business. Transactions are created 
      during retail sales at the point of sale (POS) terminals and those 
      transactions are then sent to some central servers for validations 
      and other business operations. A considerable proportion of the 
      retail transactions may have inconsistencies or anomalies due to many 
      technical and human errors. SAP provides an automated process for 
      error detection but still requires a manual process by dedicated 
      employees using workbench software for correction. However, manual 
      corrections of these errors are time-consuming, labor-intensive, and 
      might be prone to further errors due to incorrect modifications. 
      Thus, automated detection and correction of transaction errors are 
      very important regarding their potential business values and the 
      improvement in the business workflow. In this paper, we report on our 
      experience from a project where we develop an AI-based system to 
      automatically detect transaction errors and propose corrections. We 
      identify and discuss the challenges that we faced during this 
      collaborative research and development project, from two distinct 
      perspectives: Software Engineering and Machine Learning. We report on 
      our experience and insights from the project with guidelines for the 
      identified challenges. We collect developers' feedback for 
      qualitative analysis of our findings. We believe that our findings 
      and recommendations can help other researchers and practitioners 
      embarking into similar endeavours.}
}

SAP is the market leader in enterprise application software offering an end-to-end suite of applications and services to enable their customers worldwide to operate their business. Especially, retail customers of SAP deal with millions of sales transactions for their day-to-day business. Transactions are created during retail sales at the point of sale (POS) terminals and those transactions are then sent to some central servers for validations and other business operations. A considerable proportion of the retail transactions may have inconsistencies or anomalies due to many technical and human errors. SAP provides an automated process for error detection but still requires a manual process by dedicated employees using workbench software for correction. However, manual corrections of these errors are time-consuming, labor-intensive, and might be prone to further errors due to incorrect modifications. Thus, automated detection and correction of transaction errors are very important regarding their potential business values and the improvement in the business workflow. In this paper, we report on our experience from a project where we develop an AI-based system to automatically detect transaction errors and propose corrections. We identify and discuss the challenges that we faced during this collaborative research and development project, from two distinct perspectives: Software Engineering and Machine Learning. We report on our experience and insights from the project with guidelines for the identified challenges. We collect developers' feedback for qualitative analysis of our findings. We believe that our findings and recommendations can help other researchers and practitioners embarking into similar endeavours.

@INPROCEEDINGS{Ullmann22-ICEC-GameEnginesAnatomies,
   AUTHOR       = {Gabriel Cavalheiro Ullmann and Cristiano Politowski and 
      Yann-Ga�l Gu�h�neuc and Fabio Petrillo},
   BOOKTITLE    = {Proceedings of the 21<sup>st</sup> International Conference on Entertainment Computing (ICEC)},
   TITLE        = {Game Engine Comparative Anatomy},
   YEAR         = {2022},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Barbara G�bl and van der Spek, Erik},
   MONTH        = {November},
   NOTE         = {9 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {103--111},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ICEC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICEC22.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICEC22.ppt.pdf},
   ABSTRACT     = {Video game developers use game engines as a tool to 
      manage complex aspects of game development. While engines play a big 
      role in the success of games, to the best of our knowledge, they are 
      often developed in isolation, in a closed-source manner, without 
      architectural discussions, comparison, and collaboration among 
      projects. In this work in progress, we compare the call graphs of two 
      open-source engines: Godot 3.4.4 and Urho3D 1.8. While static 
      analysis tools could provide us with a general picture without 
      precise call graph paths, the use of a profiler such as Callgrind 
      allows us to also view the call order and frequency. These graphs 
      give us insight into the engines' designs. We showed that, by using 
      Callgrind, we can obtain a high-level view of an engine's 
      architecture, which can be used to understand it. In future work, we 
      intend to apply both dynamic and static analysis to other open-source 
      engines to understand architectural patterns and their impact on 
      aspects such as performance and maintenance.}
}

Video game developers use game engines as a tool to manage complex aspects of game development. While engines play a big role in the success of games, to the best of our knowledge, they are often developed in isolation, in a closed-source manner, without architectural discussions, comparison, and collaboration among projects. In this work in progress, we compare the call graphs of two open-source engines: Godot 3.4.4 and Urho3D 1.8. While static analysis tools could provide us with a general picture without precise call graph paths, the use of a profiler such as Callgrind allows us to also view the call order and frequency. These graphs give us insight into the engines' designs. We showed that, by using Callgrind, we can obtain a high-level view of an engine's architecture, which can be used to understand it. In future work, we intend to apply both dynamic and static analysis to other open-source engines to understand architectural patterns and their impact on aspects such as performance and maintenance.

@INPROCEEDINGS{Ullmann22-GAS-HighRatedGames,
   AUTHOR       = {Gabriel Cavalheiro Ullmann and Cristiano Politowski and 
      Yann-Ga�l Gu�h�neuc and Fabio Petrillo},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> ICSE International Workshop on Games and Software Engineering (GAS)},
   TITLE        = {What Makes a Game High-rated? Towards Factors of Video 
      Game Success},
   YEAR         = {2022},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kendra Cooper},
   MONTH        = {May},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {16--23},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Video game development</b>, Venue: <i>GAS</i>},
   URL          = {http://www.ptidej.net/publications/documents/GAS22b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/GAS22b.ppt.pdf},
   ABSTRACT     = {As the video game market grows larger, it becomes harder 
      for games to stand out from the crowd. Launching a successful game 
      encompasses different factors, some of which are not well-known. In 
      this paper, we investigate some factors that affect game scores, 
      considering high-rated video games from a dataset of 200 projects. 
      Results show that smaller team sizes are often linked to higher 
      scores. On the other hand, the level of freedom given to developers, 
      as well as genre, graphical perspective, game modes and platforms do 
      not correlate to score. Additionally, teams from successful games 
      also experience more crunch time while fewer problems with schedule 
      and budget allocation. Further analysis shows that team, technical, 
      and game design factors should be the main focus of the game 
      developers.}
}

As the video game market grows larger, it becomes harder for games to stand out from the crowd. Launching a successful game encompasses different factors, some of which are not well-known. In this paper, we investigate some factors that affect game scores, considering high-rated video games from a dataset of 200 projects. Results show that smaller team sizes are often linked to higher scores. On the other hand, the level of freedom given to developers, as well as genre, graphical perspective, game modes and platforms do not correlate to score. Additionally, teams from successful games also experience more crunch time while fewer problems with schedule and budget allocation. Further analysis shows that team, technical, and game design factors should be the main focus of the game developers.

@INPROCEEDINGS{Ullmann22-GAS-VideoGamesProjectManagementAPs,
   AUTHOR       = {Gabriel Cavalheiro Ullmann and Cristiano Politowski and 
      Yann-Ga�l Gu�h�neuc and Fabio Petrillo and Jo�o Eduardo Montandon},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> ICSE International Workshop on Games and Software Engineering (GAS)},
   TITLE        = {Video Game Project Management Anti-patterns},
   YEAR         = {2022},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kendra Cooper},
   MONTH        = {May},
   NOTE         = {7 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {9--15},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Video game development</b>, 
      Topic: <b>Code and design smells</b>, Venue: <i>GAS</i>},
   URL          = {http://www.ptidej.net/publications/documents/GAS22a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/GAS22a.ppt.pdf},
   ABSTRACT     = {Project Management anti-patterns are well-documented in 
      the software-engineering literature, and studying them allows 
      under-standing their impacts on teams and projects. The video game 
      de-velopment industry is known for its mismanagement practices, and 
      therefore applying this knowledge would help improve game 
      devel-opers' productivity and well-being. In this paper, we map 
      project management anti-patterns to anti-patterns reported by game 
      de-velopers in the gray literature. We read 440 postmortem problems, 
      identified anti-pattern candidates, and related them with definitions 
      from the software-engineering literature. We discovered that most 
      anti-pattern candidates could be mapped to anti-patterns in the 
      software-engineering literature, except for Feature Creep, Feature 
      Cuts, Working on Multiple Projects, and Absent or Inadequate Tools. 
      We discussed the impact of the unmapped candidates on the development 
      process while also drawing a parallel between video games and 
      traditional software development. Future works include validating the 
      definitions of the candidates via survey with practitioners and also 
      considering development anti-patterns.}
}

Project Management anti-patterns are well-documented in the software-engineering literature, and studying them allows under-standing their impacts on teams and projects. The video game de-velopment industry is known for its mismanagement practices, and therefore applying this knowledge would help improve game devel-opers' productivity and well-being. In this paper, we map project management anti-patterns to anti-patterns reported by game de-velopers in the gray literature. We read 440 postmortem problems, identified anti-pattern candidates, and related them with definitions from the software-engineering literature. We discovered that most anti-pattern candidates could be mapped to anti-patterns in the software-engineering literature, except for Feature Creep, Feature Cuts, Working on Multiple Projects, and Absent or Inadequate Tools. We discussed the impact of the unmapped candidates on the development process while also drawing a parallel between video games and traditional software development. Future works include validating the definitions of the candidates via survey with practitioners and also considering development anti-patterns.

@INPROCEEDINGS{DosSantos22-IRC-P-AcceptanceTestingRobots,
   AUTHOR       = {dos Santos, Marcela G. and Fabio Petrillo and 
      Sylvain Hall� and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> International Conference on Robotic Computing (IRC)},
   TITLE        = {An Approach to Apply Automated Acceptance Testing for 
      Industrial Robotic Systems},
   YEAR         = {2022},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Daniela D'Auria and Peter Kazanzides and Eric Matson and 
      Luca Muratore},
   MONTH        = {December},
   NOTE         = {Poster. 2 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>ESE for the IoT</b>, 
      Topic: <b>Test case generation</b>, Venue: <c>IRC</c>},
   URL          = {http://www.ptidej.net/publications/documents/IRC22.doc.pdf},
   ABSTRACT     = {Industrial robotic systems (IRS) are systems composed of 
      industrial robots that automate industrial processes. They execute 
      repetitive tasks with high accuracy, replacing or supporting 
      dangerous jobs. Consequently, a low failure rate is crucial in IRS. 
      However, to the best of our knowledge, there is a lack of automated 
      software testing for industrial robots. In this paper, we describe a 
      test strategy implementation to apply BDD to automate acceptance 
      testing for IRS.}
}

Industrial robotic systems (IRS) are systems composed of industrial robots that automate industrial processes. They execute repetitive tasks with high accuracy, replacing or supporting dangerous jobs. Consequently, a low failure rate is crucial in IRS. However, to the best of our knowledge, there is a lack of automated software testing for industrial robots. In this paper, we describe a test strategy implementation to apply BDD to automate acceptance testing for IRS.

@MISC{Gueheneuc22-WebZine-InterviewCross,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {mai},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Andrew Cross (Traduction)},
   YEAR         = {2022},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwandrewcross.php},
   ABSTRACT     = {Publication d'une entrevue avec Andrew Cross de NewTek, 
      qui discute d'acquisition et de plans pour le salon NAB.}
}

Publication d'une entrevue avec Andrew Cross de NewTek, qui discute d'acquisition et de plans pour le salon NAB.

@ARTICLE{Gueheneuc21-SEN-SERP4IoT21,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Shah Rukh Humayoun and 
      Rodrigo Morales and Rub�n Saborido},
   JOURNAL      = {ACM SIGSOFT Software Engineering Notes},
   TITLE        = {SERP4IoT'21 Workshop Report},
   YEAR         = {2021},
   MONTH        = {October},
   NOTE         = {2 pages.},
   NUMBER       = {4},
   PAGES        = {26--27},
   VOLUME       = {46},
   KEYWORDS     = {Topic: <b>ESE for the IoT</b>, Venue: <i>SERP4IoT</i>},
   URL          = {http://www.ptidej.net/publications/documents/SERP4IoT21.doc.pdf},
   ABSTRACT     = {We face a new software crisis. In 1968, computer 
      scientists learned that developing robust software requires skills, 
      methods, and tools. Today, software and hardware engineers realize 
      that developing a robust Internet of Things (IoT) also pushes the 
      states of their art and practice. Recent news illustrate the many 
      problems faced by IoT: from lack of interoperability to broken 
      updates to massive security attacks. In this context, the 3rd 
      International Workshop on Software Engineering Research and Practices 
      for the Internet of Things (SERP4IoT) aims to provide a highly 
      interactive forum for researchers and practitioners to address the 
      challenges of, and solutions for, and share experiences with the 
      development, release, and testing of robust software for IoT systems.}
}

We face a new software crisis. In 1968, computer scientists learned that developing robust software requires skills, methods, and tools. Today, software and hardware engineers realize that developing a robust Internet of Things (IoT) also pushes the states of their art and practice. Recent news illustrate the many problems faced by IoT: from lack of interoperability to broken updates to massive security attacks. In this context, the 3rd International Workshop on Software Engineering Research and Practices for the Internet of Things (SERP4IoT) aims to provide a highly interactive forum for researchers and practitioners to address the challenges of, and solutions for, and share experiences with the development, release, and testing of robust software for IoT systems.

@ARTICLE{Kermansaravi21-EMSE-DPAPMutations,
   AUTHOR       = {Zeinab Kermansaravi and Md. Saidur Rahman and 
      Foutse Khomh and Fehmi Jaafar and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {Investigating Design Patterns and Design Anti-pattern 
      Mutations and their Change- and Fault-proneness},
   YEAR         = {2021},
   MONTH        = {January},
   NOTE         = {41 pages.},
   NUMBER       = {9},
   OPTPAGES     = {},
   VOLUME       = {26},
   EDITOR       = {Robert Feldt and Thomas Zimmermann},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Topic: <b>Design patterns</b>, Topic: <b>Evolution patterns</b>, 
      Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE21a.doc.pdf},
   ABSTRACT     = {During software evolution, inexperienced developers may 
      introduce design anti-patterns when they modify their software 
      systems to fix bugs or to add new functionalities based on changes in 
      requirements. Developers may also use design patterns to promote 
      software quality or as a possible cure for some design anti-patterns. 
      Thus, design patterns and design anti-patterns are introduced, 
      removed, and mutated from one another by developers. Many studies 
      investigated the evolution of design patterns and design 
      anti-patterns and their impact on software development. However, they 
      investigated design patterns or design anti-patterns in isolation and 
      did not consider their mutations and the impact of these mutations on 
      software quality. Therefore, we report our study of bidirectional 
      mutations between design patterns and design anti-patterns and the 
      impacts of these mutations on software change- and fault-proneness. 
      We analyzed snapshots of seven Java software systems with diverse 
      sizes, evolution histories, and application domains. We built Markov 
      models to capture the probability of occurrences of the different 
      design patterns and design anti-patterns mutations. Results from our 
      study show that (1) design patterns and design anti-patterns mutate 
      into other design patterns and--or design anti-patterns. They also 
      show that (2) some change types primarily trigger mutations of design 
      patterns and design anti-patterns (renaming and changes to comments, 
      declarations, and operators), and (3) some mutations of design 
      anti-patterns and design patterns are more faulty in specific 
      contexts. These results provide important insights into the evolution 
      of design patterns and design anti-patterns and its impact on the 
      change- and fault-proneness of software systems.}
}

During software evolution, inexperienced developers may introduce design anti-patterns when they modify their software systems to fix bugs or to add new functionalities based on changes in requirements. Developers may also use design patterns to promote software quality or as a possible cure for some design anti-patterns. Thus, design patterns and design anti-patterns are introduced, removed, and mutated from one another by developers. Many studies investigated the evolution of design patterns and design anti-patterns and their impact on software development. However, they investigated design patterns or design anti-patterns in isolation and did not consider their mutations and the impact of these mutations on software quality. Therefore, we report our study of bidirectional mutations between design patterns and design anti-patterns and the impacts of these mutations on software change- and fault-proneness. We analyzed snapshots of seven Java software systems with diverse sizes, evolution histories, and application domains. We built Markov models to capture the probability of occurrences of the different design patterns and design anti-patterns mutations. Results from our study show that (1) design patterns and design anti-patterns mutate into other design patterns and–or design anti-patterns. They also show that (2) some change types primarily trigger mutations of design patterns and design anti-patterns (renaming and changes to comments, declarations, and operators), and (3) some mutations of design anti-patterns and design patterns are more faulty in specific contexts. These results provide important insights into the evolution of design patterns and design anti-patterns and its impact on the change- and fault-proneness of software systems.

@ARTICLE{Lamothe21-CSUR-APIEvolution,
   AUTHOR       = {Maxime Lamothe and Yann-Ga�l Gu�h�neuc and Weiyi Shang},
   JOURNAL      = {Computing Surveys (CSUR)},
   TITLE        = {A Systematic Review of API Evolution Literature},
   YEAR         = {2021},
   MONTH        = {October},
   NOTE         = {36 pages.},
   NUMBER       = {8},
   PAGES        = {1--26},
   VOLUME       = {54},
   EDITOR       = {Albert Zomaya},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>CSUR</b>},
   PUBLISHER    = {ACM Press},
   URL          = {http://www.ptidej.net/publications/documents/CSUR22.doc.pdf},
   ABSTRACT     = {Recent software advances have led to an expansion of the 
      development and usage of application programming interfaces (APIs). 
      From millions of Android packages (APKs) available on Google Store to 
      millions of open-source packages available in Maven, PyPI, and npm, 
      APIs have become an integral part of software development. Like any 
      software artifact, software APIs evolve and suffer from this 
      evolution. Prior research has uncovered many challenges to the 
      development, usage, and evolution of APIs. While some challenges have 
      been studied and solved, many remain. These challenges are scattered 
      in the literature, which hides advances and cloaks the remaining 
      challenges. In this systematic literature review on APIs and API 
      evolution, we uncover and describe publication trends and trending 
      topics. We compile common research goals, evaluation methods, 
      metrics, and subjects. We summarize the current state-of-the-art and 
      outline known existing challenges as well as new challenges uncovered 
      during this review. We conclude that the main remaining challenges 
      related to APIs and API evolution are (1) automatically identifying 
      and leveraging factors that drive API changes, (2) creating and using 
      uniform benchmarks for research evaluation, and (3) understanding the 
      impact of API evolution on API developers and users with respect to 
      various programming languages.}
}

Recent software advances have led to an expansion of the development and usage of application programming interfaces (APIs). From millions of Android packages (APKs) available on Google Store to millions of open-source packages available in Maven, PyPI, and npm, APIs have become an integral part of software development. Like any software artifact, software APIs evolve and suffer from this evolution. Prior research has uncovered many challenges to the development, usage, and evolution of APIs. While some challenges have been studied and solved, many remain. These challenges are scattered in the literature, which hides advances and cloaks the remaining challenges. In this systematic literature review on APIs and API evolution, we uncover and describe publication trends and trending topics. We compile common research goals, evaluation methods, metrics, and subjects. We summarize the current state-of-the-art and outline known existing challenges as well as new challenges uncovered during this review. We conclude that the main remaining challenges related to APIs and API evolution are (1) automatically identifying and leveraging factors that drive API changes, (2) creating and using uniform benchmarks for research evaluation, and (3) understanding the impact of API evolution on API developers and users with respect to various programming languages.

@ARTICLE{Politowski20-IST-GameIndustryProblems,
   AUTHOR       = {Cristiano Politowski and Fabio Petrillo and 
      Gabriel Cavalheiro Ullmann and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {Game Industry Problems: an Extensive Analysis of the 
      Gray Literature},
   YEAR         = {2021},
   MONTH        = {June},
   NOTE         = {18 pages.},
   OPTNUMBER    = {},
   PAGES        = {106538},
   VOLUME       = {134},
   EDITOR       = {G�nther Ruhe},
   KEYWORDS     = {Topic: <b>Video game development</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST21.doc.pdf},
   ABSTRACT     = {\textbf{Context:} Given its competitiveness, the 
      video-game industry has a closed-source culture. Hence, little is 
      known about the problems faced by game developers. However, game 
      developers do share information about their game projects through 
      postmortems, which describe informally what happened during the 
      projects. \textbf{Objective:} The software-engineering research 
      community and game developers would benefit from a state of the 
      problems of the video game industry, in particular the problems faced 
      by game developers, their evolution in time, and their root causes. 
      This state of the practice would allow researchers and practitioners 
      to work towards solving these problems. \textbf{Method:} We analyzed 
      200 postmortems from 1997 to 2019, resulting in 927 problems divided 
      into 20 types. Through our analysis, we described the overall 
      landscape of game industry problems in the past 23 years and how 
      these problems evolved over the years. We also give details on the 
      most common problems, their root causes, and possible solutions. We 
      finally discuss suggestions for future projects. \textbf{Results:} We 
      observe that (1) the game industry suffers from management and 
      production problems in the same proportion; (2) management problems 
      decreased over the years, giving space to business problems, while 
      production problems remained constant; (3a) technical and game design 
      problems are decreasing over the years, the latter only after the 
      last decade; (3b) problems related to the team increase over the last 
      decade; (3c) marketing problems are the ones that had the biggest 
      increase over the 23 years compared to other problem types; (4) 
      finally, the majority of the main root causes are related to people, 
      not technologies. Conclusions: In this paper, we provide a state of 
      the practice for researchers to understand and study video-game 
      development problems. We also offer suggestions to help practitioners 
      to avoid the most common problems in future projects.}
}

\textbfContext: Given its competitiveness, the video-game industry has a closed-source culture. Hence, little is known about the problems faced by game developers. However, game developers do share information about their game projects through postmortems, which describe informally what happened during the projects. \textbfObjective: The software-engineering research community and game developers would benefit from a state of the problems of the video game industry, in particular the problems faced by game developers, their evolution in time, and their root causes. This state of the practice would allow researchers and practitioners to work towards solving these problems. \textbfMethod: We analyzed 200 postmortems from 1997 to 2019, resulting in 927 problems divided into 20 types. Through our analysis, we described the overall landscape of game industry problems in the past 23 years and how these problems evolved over the years. We also give details on the most common problems, their root causes, and possible solutions. We finally discuss suggestions for future projects. \textbfResults: We observe that (1) the game industry suffers from management and production problems in the same proportion; (2) management problems decreased over the years, giving space to business problems, while production problems remained constant; (3a) technical and game design problems are decreasing over the years, the latter only after the last decade; (3b) problems related to the team increase over the last decade; (3c) marketing problems are the ones that had the biggest increase over the 23 years compared to other problem types; (4) finally, the majority of the main root causes are related to people, not technologies. Conclusions: In this paper, we provide a state of the practice for researchers to understand and study video-game development problems. We also offer suggestions to help practitioners to avoid the most common problems in future projects.

@ARTICLE{Sabir21-TSE-RESTAPCorrections,
   AUTHOR       = {Fatima Sabir and Yann-Ga�l Gu�h�neuc and Francis Palma and 
      Naouel Moha and Ghulam Rasool and Hassan Akhtar},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {A Mixed-method Approach to Recommend Corrections and 
      Correct REST Antipatterns},
   YEAR         = {2021},
   MONTH        = {October},
   NOTE         = {19 pages.},
   NUMBER       = {11},
   PAGES        = {4319--4338},
   VOLUME       = {48},
   EDITOR       = {Emerson Murphy-Hill},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE21.doc.pdf},
   ABSTRACT     = {Many companies, e.g., Facebook and YouTube, use the REST 
      architecture and provide REST APIs to their clients. Like any other 
      software systems, REST APIs need maintenance and must evolve to 
      improve and stay relevant. Antipatterns---poor design 
      practices---hinder this maintenance and evolution. Although the 
      literature defines many antipatterns and proposes approaches for 
      their (automatic) detection, their \emph{correction} did not receive 
      much attention. Therefore, \textbf{we apply a mixed-method approach 
      to study REST APIs and REST antipatterns with the objectives to 
      recommend corrections or, when possible, actually correct the REST 
      antipatterns.} \emph{Qualitatively, via case studies}, we analyse the 
      evolution of 11 REST APIs, including Facebook, Twitter, and YouTube, 
      over six years. We detect occurrences of eight REST antipatterns in 
      the years 2014, 2017, and 2020 in 17 versions of 11 REST APIs. Thus, 
      we show that (1) REST APIs and antipatterns evolve over time and (2) 
      developers seem to remove antipatterns. \emph{Qualitatively via a 
      discourse analysis}, we analyse developers' forums and report that 
      developers are concerned with the occurrences of REST antipatterns 
      and discuss corrections to these antipatterns. Following these 
      qualitative studies, using an \emph{engineering-research approach}, 
      we propose the following novel and unique contributions: (1) we 
      describe and compare the corrections of eight REST antipatterns from 
      the academic literature and from developers' forums; (2) we devise 
      and describe algorithms to recommend corrections to some of these 
      antipatterns; (3) we present algorithms and a tool to correct some of 
      these antipatterns by intercepting and modifying responses from REST 
      APIs; and, (4) we validate the recommendations and the corrections 
      manually and via a survey answered by 24 REST developers. 
      \textbf{Thus, we propose to REST API developers and researchers the 
      first, grounded approach to correct REST antipatterns.}}
}

Many companies, e.g., Facebook and YouTube, use the REST architecture and provide REST APIs to their clients. Like any other software systems, REST APIs need maintenance and must evolve to improve and stay relevant. Antipatterns—poor design practices—hinder this maintenance and evolution. Although the literature defines many antipatterns and proposes approaches for their (automatic) detection, their \emphcorrection did not receive much attention. Therefore, \textbfwe apply a mixed-method approach to study REST APIs and REST antipatterns with the objectives to recommend corrections or, when possible, actually correct the REST antipatterns. \emphQualitatively, via case studies, we analyse the evolution of 11 REST APIs, including Facebook, Twitter, and YouTube, over six years. We detect occurrences of eight REST antipatterns in the years 2014, 2017, and 2020 in 17 versions of 11 REST APIs. Thus, we show that (1) REST APIs and antipatterns evolve over time and (2) developers seem to remove antipatterns. \emphQualitatively via a discourse analysis, we analyse developers' forums and report that developers are concerned with the occurrences of REST antipatterns and discuss corrections to these antipatterns. Following these qualitative studies, using an \emphengineering-research approach, we propose the following novel and unique contributions: (1) we describe and compare the corrections of eight REST antipatterns from the academic literature and from developers' forums; (2) we devise and describe algorithms to recommend corrections to some of these antipatterns; (3) we present algorithms and a tool to correct some of these antipatterns by intercepting and modifying responses from REST APIs; and, (4) we validate the recommendations and the corrections manually and via a survey answered by 24 REST developers. \textbfThus, we propose to REST API developers and researchers the first, grounded approach to correct REST antipatterns.

@ARTICLE{Uddin21-EMSE-IoTTopicsSO,
   AUTHOR       = {Gias Uddin and Fatima Sabir and Yann-Ga�l Gu�h�neuc and 
      Omar Alam and Foutse Khomh},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {An Empirical Study of IoT Topics in IoT Developer 
      Discussions on Stack Overflow},
   YEAR         = {2021},
   MONTH        = {September},
   NOTE         = {47 pages.},
   NUMBER       = {6},
   OPTPAGES     = {},
   VOLUME       = {26},
   EDITOR       = {Robert Feldt and Thomas Zimmermann},
   KEYWORDS     = {Topic: <b>ESE for the IoT</b>, 
      Topic: <b>Evolution patterns</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE21b.doc.pdf},
   ABSTRACT     = {Internet of Things (IoT) is defined as the connection 
      between places and physical objects (i.e., things) over the Internet 
      via smart computing devices. It is a rapidly emerging paradigm that 
      encompasses almost every aspect of our modern life, such as smart 
      home, cars, and so on. With interest in IoT growing, we observe that 
      the IoT discussions are becoming prevalent in online developer 
      forums, such as Stack Overflow (SO). An understanding of such 
      discussions can offer insights into the prevalence, popularity, and 
      difficulty of various IoT topics. For this paper, we download a large 
      number of SO posts that contain discussions about various IoT 
      technologies. We apply topic modeling on the textual contents of the 
      posts. We label the topics and categorize the topics into 
      hierarchies. We analyze the popularity and difficulty of the topics. 
      Our study offers several findings. First, IoT developers discuss a 
      range of topics in SO related to Hardware, Software, Network, and 
      Tutorials. Second, secure messaging using IoT devices from the 
      Network category is the most prevalent topic, followed by scheduling 
      of IoT script in the Software category. Third, all the topic 
      categories are evolving rapidly in SO, i.e., new questions are being 
      added more and more in SO about IoT tools and techniques. Fourth, the 
      ``How type of questions are asked more across the three topic 
      categories (Software, Network, and Hardware), although a large number 
      of questions are also of the ``What'' type: IoT developers are using 
      SO not only to discuss how to address a problem related to IoT, but 
      also to learn what the different IoT techniques and tools offer. 
      Fifth, topics related to data parsing and micro-controller 
      configuration are the most popular. Sixth, topics related to 
      multimedia streaming and Bluetooth are the most difficult. Our study 
      findings have implications for all four different IoT stakeholders: 
      tool builders, developers, educators, and researchers. For example, 
      IoT developers and newcomers can use our findings on topic popularity 
      to learn about popular IoT techniques. Educators and researchers can 
      make more tutorials or develop new techniques to make difficult IoT 
      topics easier. IoT tool builders can look at our identified topics 
      and categories to learn about IoT developers' preferences, which then 
      can help them develop new tools or enhance their current offerings.}
}

Internet of Things (IoT) is defined as the connection between places and physical objects (i.e., things) over the Internet via smart computing devices. It is a rapidly emerging paradigm that encompasses almost every aspect of our modern life, such as smart home, cars, and so on. With interest in IoT growing, we observe that the IoT discussions are becoming prevalent in online developer forums, such as Stack Overflow (SO). An understanding of such discussions can offer insights into the prevalence, popularity, and difficulty of various IoT topics. For this paper, we download a large number of SO posts that contain discussions about various IoT technologies. We apply topic modeling on the textual contents of the posts. We label the topics and categorize the topics into hierarchies. We analyze the popularity and difficulty of the topics. Our study offers several findings. First, IoT developers discuss a range of topics in SO related to Hardware, Software, Network, and Tutorials. Second, secure messaging using IoT devices from the Network category is the most prevalent topic, followed by scheduling of IoT script in the Software category. Third, all the topic categories are evolving rapidly in SO, i.e., new questions are being added more and more in SO about IoT tools and techniques. Fourth, the ``How type of questions are asked more across the three topic categories (Software, Network, and Hardware), although a large number of questions are also of the ``What'' type: IoT developers are using SO not only to discuss how to address a problem related to IoT, but also to learn what the different IoT techniques and tools offer. Fifth, topics related to data parsing and micro-controller configuration are the most popular. Sixth, topics related to multimedia streaming and Bluetooth are the most difficult. Our study findings have implications for all four different IoT stakeholders: tool builders, developers, educators, and researchers. For example, IoT developers and newcomers can use our findings on topic popularity to learn about popular IoT techniques. Educators and researchers can make more tutorials or develop new techniques to make difficult IoT topics easier. IoT tool builders can look at our identified topics and categories to learn about IoT developers' preferences, which then can help them develop new tools or enhance their current offerings.

@INPROCEEDINGS{Politowski21-AST-SurveyVideoGamesTesting,
   AUTHOR       = {Cristiano Politowski and Fabio Petrillo and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 2<sup>nd</sup> International Conference on Automation of Software (AST)},
   TITLE        = {A Survey of Video Game Testing},
   YEAR         = {2021},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Alejandra Garrido and Breno Miranda and Javier Tuya},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {90--99},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Video game development</b>, 
      Topic: <b>Test case generation</b>, Venue: <c>AST</c>},
   URL          = {http://www.ptidej.net/publications/documents/AST21.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/AST21.ppt.pdf},
   ABSTRACT     = {Video-game projects are notorious for having day-one 
      bugs, no matter how big their budget or team size. The quality of a 
      game is essential for its success. This quality could be assessed and 
      ensured through testing. However, to the best of our knowledge, 
      little is known about video-game testing. In this paper, we want to 
      understand how game developers perform game testing. We investigate, 
      through a survey, the academic and gray literature to identify and 
      report on existing testing processes and how they could automate 
      them. We found that game developers rely, almost exclusively, upon 
      manual play-testing and the testers’ intrinsic knowledge. We 
      conclude that current testing processes fall short because of their 
      lack of automation, which seems to be the natural next step to 
      improve the quality of games while maintaining costs. However, the 
      current game-testing techniques may not generalize to different types 
      of games.}
}

Video-game projects are notorious for having day-one bugs, no matter how big their budget or team size. The quality of a game is essential for its success. This quality could be assessed and ensured through testing. However, to the best of our knowledge, little is known about video-game testing. In this paper, we want to understand how game developers perform game testing. We investigate, through a survey, the academic and gray literature to identify and report on existing testing processes and how they could automate them. We found that game developers rely, almost exclusively, upon manual play-testing and the testers’ intrinsic knowledge. We conclude that current testing processes fall short because of their lack of automation, which seems to be the natural next step to improve the quality of games while maintaining costs. However, the current game-testing techniques may not generalize to different types of games.

@INPROCEEDINGS{Tran21-ICSOC-RESTAPs,
   AUTHOR       = {Van Tran, Tuan and Manel Abdellatif and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 19<sup>th</sup> International Conference on Service Oriented Computing (ICSOC)},
   TITLE        = {Formalising Solutions to REST API Bad Practices as 
      Anti-patterns},
   YEAR         = {2021},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Massimo Mecella and Naouel Moha and Helen Paik},
   MONTH        = {October},
   NOTE         = {16 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {153–-170},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC21.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC21.ppt.pdf},
   ABSTRACT     = {REST APIs are nowadays the de-facto standard for Web 
      applications. However, as more systems and services adopt the REST 
      architectural style, many problems arise regularly. To avoid these 
      repetitive problems, developers should follow good practices and 
      avoid bad practices. Thus, research on good and bad practices and how 
      to design a simple but effective REST API are essential. Yet, to the 
      best of our knowledge, there are only a few concrete solutions to 
      recurring REST API practices, like ``API Versioning''. There are 
      works on defining or detecting some practices, but not on solutions 
      to the practices. We present the most up-to-date list of REST API 
      practices and formalize them in the form of REST API (anti)patterns. 
      We validate our design (anti)patterns with a survey and interviews of 
      55 developers.}
}

REST APIs are nowadays the de-facto standard for Web applications. However, as more systems and services adopt the REST architectural style, many problems arise regularly. To avoid these repetitive problems, developers should follow good practices and avoid bad practices. Thus, research on good and bad practices and how to design a simple but effective REST API are essential. Yet, to the best of our knowledge, there are only a few concrete solutions to recurring REST API practices, like ``API Versioning''. There are works on defining or detecting some practices, but not on solutions to the practices. We present the most up-to-date list of REST API practices and formalize them in the form of REST API (anti)patterns. We validate our design (anti)patterns with a survey and interviews of 55 developers.

@INPROCEEDINGS{Tran21-VISSOFT-NIER-SECO,
   AUTHOR       = {Van Tran, Tuan and Cheng Cheng and Fabio Petrillo and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 9<sup>th</sup> Working Conference on Software Visualisation (VISSOFT)},
   TITLE        = {Analyzing and Visualizing Projects and their Relations 
      in Software Ecosystems},
   YEAR         = {2021},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Leonel Merino and Juan Pablo Sandoval Alcocer},
   MONTH        = {September},
   NOTE         = {New Ideas and Emerging Results. 5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {105--109},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <c>VISSOFT</c>},
   URL          = {http://www.ptidej.net/publications/documents/VISSOFT21.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/VISSOFT21.ppt.pdf},
   ABSTRACT     = {More and more software projects are being consolidated 
      into ecosystems to increase their discovery, usability, and 
      usefulness. Some of the most popular ecosystems exist in npmjs, 
      Python Package Indexing, and Apache Maven Repository. It is difficult 
      for developers to relate these projects and use them to their full 
      potential because of their number, the spread and depth of their 
      features, and their intrinsic and accidental complexities. We present 
      a technique---SECO Storms Maker---to capture and present the 
      essential information from projects in an ecosystem to help 
      developers join, use, and contribute to the ecosystem. We generate 
      word-clouds based on the projects' documentation via tokenization and 
      distribution frequency. We identify relations among projects using 
      grammar patterns scanning after part-of-speech tagging. We put these 
      word-clouds into a graph to ease navigation and exploration. We 
      evaluate our technique by manually building a ground truth and 
      comparing a randomly-selected project with SECO to show its benefits.}
}

More and more software projects are being consolidated into ecosystems to increase their discovery, usability, and usefulness. Some of the most popular ecosystems exist in npmjs, Python Package Indexing, and Apache Maven Repository. It is difficult for developers to relate these projects and use them to their full potential because of their number, the spread and depth of their features, and their intrinsic and accidental complexities. We present a technique—SECO Storms Maker—to capture and present the essential information from projects in an ecosystem to help developers join, use, and contribute to the ecosystem. We generate word-clouds based on the projects' documentation via tokenization and distribution frequency. We identify relations among projects using grammar patterns scanning after part-of-speech tagging. We put these word-clouds into a graph to ease navigation and exploration. We evaluate our technique by manually building a ground truth and comparing a randomly-selected project with SECO to show its benefits.

@MISC{Gueheneuc21-WebZine-InterviewDodge,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {mars},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Dan Dodge (Traduction)},
   YEAR         = {2021},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwdandodge.php},
   ABSTRACT     = {Publication d'une entrevue avec Dan Dodge, le fondateur 
      de QNX, qui {\'e}tait pressenti pour fournir le noyau du nouveau 
      syst{\`e}me Amiga en 1999.}
}

Publication d'une entrevue avec Dan Dodge, le fondateur de QNX, qui était pressenti pour fournir le noyau du nouveau système Amiga en 1999.

@PROCEEDINGS{ICPC20,
   TITLE        = {Proceedings of the 28<sup>th</sup> International 
      Conference on Program Comprehension},
   YEAR         = {2020},
   OPTADDRESS   = {},
   EDITOR       = {Yann-Ga�l Gu�h�neuc and Shinpei Hayashi},
   MONTH        = {July},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {}
}

@ARTICLE{Abdelatif20-JSS-TaxonomySIA,
   AUTHOR       = {Manel Abdellatif and Anas Shatnawi and Hafedh Mili and 
      Naouel Moha and El Boussaidi, Ghizlane and Geoffrey Hecht and 
      Jean Privat and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Systems and Software (JSS)},
   TITLE        = {A Taxonomy of Service Identification Approaches for 
      Legacy Software Systems Modernization},
   YEAR         = {2020},
   MONTH        = {November},
   NOTE         = {21 pages.},
   OPTNUMBER    = {},
   PAGES        = {110868},
   VOLUME       = {173},
   EDITOR       = {Paris Avgeriou and David Shepherd},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>JSS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/JSS21a.doc.pdf},
   ABSTRACT     = {The success of modernizing legacy software systems to 
      Service-Oriented Architecture (SOA) depends on Service Identification 
      Approaches (SIAs), which identify reusable functionalities that could 
      become services. The literature describes several SIAs. However, the 
      selection of an identification approach that is suitable for a 
      practitioner is difficult because it depends on several factors, 
      including the goal of modernization, the available legacy artifacts, 
      the organization's development process, the desired output, and the 
      usability of the approach. Accordingly, to select a suitable service 
      identification approach, a practitioner must have a comprehensive 
      view of existing techniques. We report a systematic literature review 
      (SLR) that covers 41 SIAs based on software-systems analyses. Based 
      on this SLR, we create a taxonomy of SIAs and build a multi-layer 
      classification of existing identification approaches. We start from a 
      high-level classification based on the used inputs, the applied 
      processes, the given outputs, and the usability of the SIAs. We then 
      divide each category into a fine-grained taxonomy that helps 
      practitioners in selecting a suitable approach for identifying 
      services in legacy software systems. We build our SLR based on our 
      experience with legacy software modernization, on discussions and 
      experiences working with industrial partners, and analyses of 
      existing SIAs. We validate the correctness and the coverage of our 
      review with industrial experts who modernize(d) legacy software 
      systems to SOA. The results show that our classification conforms to 
      the industrial experts' experiences. We also show that most of the 
      studied SIAs are still at their infancy. Finally, we identify the 
      main challenges that SIAs need to address, to improve their quality.}
}

The success of modernizing legacy software systems to Service-Oriented Architecture (SOA) depends on Service Identification Approaches (SIAs), which identify reusable functionalities that could become services. The literature describes several SIAs. However, the selection of an identification approach that is suitable for a practitioner is difficult because it depends on several factors, including the goal of modernization, the available legacy artifacts, the organization's development process, the desired output, and the usability of the approach. Accordingly, to select a suitable service identification approach, a practitioner must have a comprehensive view of existing techniques. We report a systematic literature review (SLR) that covers 41 SIAs based on software-systems analyses. Based on this SLR, we create a taxonomy of SIAs and build a multi-layer classification of existing identification approaches. We start from a high-level classification based on the used inputs, the applied processes, the given outputs, and the usability of the SIAs. We then divide each category into a fine-grained taxonomy that helps practitioners in selecting a suitable approach for identifying services in legacy software systems. We build our SLR based on our experience with legacy software modernization, on discussions and experiences working with industrial partners, and analyses of existing SIAs. We validate the correctness and the coverage of our review with industrial experts who modernize(d) legacy software systems to SOA. The results show that our classification conforms to the industrial experts' experiences. We also show that most of the studied SIAs are still at their infancy. Finally, we identify the main challenges that SIAs need to address, to improve their quality.

@ARTICLE{Abdellatif20-JASE-AndroidRESTPractices,
   AUTHOR       = {Manel Abdellatif and Rafik Tighilt and 
      Abdelkarim Belkhir and Naouel Moha and Yann-Ga�l Gu�h�neuc and 
      �ric Beaudry},
   JOURNAL      = {Automated Software Engineering (JASE)},
   TITLE        = {A Multi-dimensional Study on the State of the Practice 
      of REST APIs Usage in Android Apps},
   YEAR         = {2020},
   MONTH        = {August},
   NOTE         = {42 pages.},
   OPTNUMBER    = {},
   PAGES        = {pages187--228},
   VOLUME       = {27},
   EDITOR       = {Robert J. Hall},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>JASE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/JASE20.doc.pdf},
   ABSTRACT     = {REST APIs are gaining a tremendous attraction in 
      industry and a growing usage in mobile platforms. They are well 
      suited for providing content to apps running on small devices, like 
      smartphones and tablets. Several research works studied REST APIs 
      development practices for mobile apps. However, little is known about 
      how Android apps use/consume these APIs in practice. Consequently, we 
      propose a multidimensional study on the state of the practice of REST 
      APIs usage in Android apps. We follow three directions: analysing of 
      Android apps, mining Stack Overflow posts on REST APIs usage in 
      Android apps, and surveying Android developers about their usage of 
      REST APIs in their mobile apps. We (1) build a catalog of Android 
      REST mobile clients practices, (2) propose an automatic approach to 
      detect these practices, (3) analyze 1,595 Android apps downloaded 
      from the Google Play store, (4) mine 12,478 Stack Overflow posts to 
      study REST APIs usage in Android apps, and (5) conduct an online 
      survey with 118 Android developers to understand their usage of these 
      practices. We report that only two good practices are widely 
      considered by Android developers when implementing their mobile apps. 
      These practices are network connectivity awareness and JSON vs. XML 
      response parsing. We also report Android developers' recommendations 
      for the use of third-party HTTP libraries and their role in 
      implementing the recommended practices.}
}

REST APIs are gaining a tremendous attraction in industry and a growing usage in mobile platforms. They are well suited for providing content to apps running on small devices, like smartphones and tablets. Several research works studied REST APIs development practices for mobile apps. However, little is known about how Android apps use/consume these APIs in practice. Consequently, we propose a multidimensional study on the state of the practice of REST APIs usage in Android apps. We follow three directions: analysing of Android apps, mining Stack Overflow posts on REST APIs usage in Android apps, and surveying Android developers about their usage of REST APIs in their mobile apps. We (1) build a catalog of Android REST mobile clients practices, (2) propose an automatic approach to detect these practices, (3) analyze 1,595 Android apps downloaded from the Google Play store, (4) mine 12,478 Stack Overflow posts to study REST APIs usage in Android apps, and (5) conduct an online survey with 118 Android developers to understand their usage of these practices. We report that only two good practices are widely considered by Android developers when implementing their mobile apps. These practices are network connectivity awareness and JSON vs. XML response parsing. We also report Android developers' recommendations for the use of third-party HTTP libraries and their role in implementing the recommended practices.

@ARTICLE{Barbez19-JSS-AntiPatternsEsembleMethod,
   AUTHOR       = {Antoine Barbez and Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Systems and Software (JSS)},
   TITLE        = {A Machine-learning based Ensemble Method for 
      Anti-patterns Detection},
   YEAR         = {2020},
   MONTH        = {March},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   PAGES        = {110486},
   VOLUME       = {161},
   EDITOR       = {Paris Avgeriou and David Shepherd},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>JSS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/JSS20a.doc.pdf},
   ABSTRACT     = {Anti-patterns are poor solutions to recurring design 
      problems. Several empirical studies have highlighted their negative 
      impact on program comprehension, maintainability, as well as 
      fault-proneness. A variety of detection approaches have been proposed 
      to identify their occurrences in source code. However, these 
      approaches can identify only a subset of the occurrences and report 
      large numbers of false positives and misses. Furthermore, a low 
      agreement is generally observed among different approaches. Recent 
      studies have shown the potential of machine-learning models to 
      improve this situation. However, such algorithms require large sets 
      of manually-produced training-data, which often limits their 
      application in practice. In this paper, we present SMAD (SMart 
      Aggregation of Anti-patterns Detectors), a machine-learning based 
      ensemble method to aggregate various anti-patterns detection 
      approaches on the basis of their internal detection rules. Thus, our 
      method uses several detection tools to produce an improved prediction 
      from a reasonable number of training examples. We implemented SMAD 
      for the detection of two well known anti-patterns: God Class and 
      Feature Envy. With the results of our experiments conducted on eight 
      java projects, we show that: (1) Our method clearly improves the so 
      aggregated tools; (2) SMAD significantly outperforms other ensemble 
      methods.}
}

Anti-patterns are poor solutions to recurring design problems. Several empirical studies have highlighted their negative impact on program comprehension, maintainability, as well as fault-proneness. A variety of detection approaches have been proposed to identify their occurrences in source code. However, these approaches can identify only a subset of the occurrences and report large numbers of false positives and misses. Furthermore, a low agreement is generally observed among different approaches. Recent studies have shown the potential of machine-learning models to improve this situation. However, such algorithms require large sets of manually-produced training-data, which often limits their application in practice. In this paper, we present SMAD (SMart Aggregation of Anti-patterns Detectors), a machine-learning based ensemble method to aggregate various anti-patterns detection approaches on the basis of their internal detection rules. Thus, our method uses several detection tools to produce an improved prediction from a reasonable number of training examples. We implemented SMAD for the detection of two well known anti-patterns: God Class and Feature Envy. With the results of our experiments conducted on eight java projects, we show that: (1) Our method clearly improves the so aggregated tools; (2) SMAD significantly outperforms other ensemble methods.

@ARTICLE{ElMasri20-IST-SLRonALATs,
   AUTHOR       = {El Masri, Diana and F�bio Petrillo and 
      Yann-Ga�l Gu�h�neuc and Abdelwahab Hamou-Lhadj and Anas Bouziane},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {A Systematic Literature Review on Automated Log 
      Abstraction Techniques},
   YEAR         = {2020},
   MONTH        = {June},
   NOTE         = {23 pages.},
   OPTNUMBER    = {},
   PAGES        = {106276},
   VOLUME       = {122},
   EDITOR       = {G�nther Ruhe},
   KEYWORDS     = {Topic: <b>Quality models</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST20b.doc.pdf},
   ABSTRACT     = {\textbf{Context:} Logs are often the first and only 
      information available to software engineers to understand and debug 
      their systems. Automated log-analysis techniques help software 
      engineers gain insights into large log data. These techniques have 
      several steps, among which log abstraction is the most important 
      because it transforms raw log-data into high-level information. Thus, 
      log abstraction allows software engineers to perform further 
      analyses. Existing log-abstraction techniques vary significantly in 
      their designs and performances. To the best of our knowledge, there 
      is no study that examines the performances of these techniques with 
      respect to the following seven quality aspects concurrently: mode, 
      coverage, delimiter independence, efficiency,scalability, system 
      knowledge independence, and parameter tuning effort. 
      \textbf{Objectives:} We want (1) to build a quality model for 
      evaluating automated log-abstraction techniques and (2) to evaluate 
      and recommend existing automated log-abstraction techniques using 
      this quality model. \textbf{Method:} We perform a systematic 
      literature review (SLR) of automated log-abstraction techniques. We 
      review 89 research papers out of 2,864 initial papers. 
      \textbf{Results:} Through this SLR, we (1) identify 17 automated 
      log-abstraction techniques, (2) build a quality model composed of 
      seven desirable aspects: mode, coverage, delimiter independence, 
      efficiency, scalability, system knowledge independence, and parameter 
      tuning effort, and (3) make recommendations for researchers on future 
      research directions. \textbf{Conclusion:} Our quality model and 
      recommendations help researchers learn about the state-of-the-art 
      automated log-abstraction techniques, identify research gaps to 
      enhance existing techniques, and develop new ones. We also support 
      software engineers in understanding the advantages and limitations of 
      existing techniques and in choosing the suitable technique to their 
      unique use cases.}
}

\textbfContext: Logs are often the first and only information available to software engineers to understand and debug their systems. Automated log-analysis techniques help software engineers gain insights into large log data. These techniques have several steps, among which log abstraction is the most important because it transforms raw log-data into high-level information. Thus, log abstraction allows software engineers to perform further analyses. Existing log-abstraction techniques vary significantly in their designs and performances. To the best of our knowledge, there is no study that examines the performances of these techniques with respect to the following seven quality aspects concurrently: mode, coverage, delimiter independence, efficiency,scalability, system knowledge independence, and parameter tuning effort. \textbfObjectives: We want (1) to build a quality model for evaluating automated log-abstraction techniques and (2) to evaluate and recommend existing automated log-abstraction techniques using this quality model. \textbfMethod: We perform a systematic literature review (SLR) of automated log-abstraction techniques. We review 89 research papers out of 2,864 initial papers. \textbfResults: Through this SLR, we (1) identify 17 automated log-abstraction techniques, (2) build a quality model composed of seven desirable aspects: mode, coverage, delimiter independence, efficiency, scalability, system knowledge independence, and parameter tuning effort, and (3) make recommendations for researchers on future research directions. \textbfConclusion: Our quality model and recommendations help researchers learn about the state-of-the-art automated log-abstraction techniques, identify research gaps to enhance existing techniques, and develop new ones. We also support software engineers in understanding the advantages and limitations of existing techniques and in choosing the suitable technique to their unique use cases.

@ARTICLE{Lacerda20-JSS-CodeSmellsRefactorings,
   AUTHOR       = {Guilherme Lacerda and Fabio Petrillo and 
      Marcelo Soares Pimenta and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Systems and Software (JSS)},
   TITLE        = {Code Smells and Refactoring: A Tertiary Systematic 
      Review of Challenges and Observations},
   YEAR         = {2020},
   MONTH        = {September},
   NOTE         = {44 pages.},
   OPTNUMBER    = {},
   PAGES        = {110610},
   VOLUME       = {167},
   EDITOR       = {Paris Avgeriou and David Shepherd},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>JSS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/JSS20b.doc.pdf},
   ABSTRACT     = {Refactoring and smells have been well researched by the 
      software-engineering research community these past decades. Several 
      secondary studies have been published on code smells, discussing 
      their implications on software quality,their impact on maintenance 
      and evolution, and existing tools for their detection. Other 
      secondary studies addressed refactoring, discussing refactoring 
      techniques, opportunities for refactoring, impact on quality, and 
      tools support. In this paper, we present a tertiary systematic 
      literature review of previous surveys, secondary systematic 
      literature reviews, and systematic mappings. We identify the main 
      observations (what we know) and challenges (what we do not know) on 
      code smells and refactoring. We perform this tertiary review using 
      eight scientific databases, based on a set of five research 
      questions, identifying 40 secondary studies between 1992 and 2018. We 
      organize the main observations and challenges about code smell and 
      their refactoring into: smells definitions, most common code-smell 
      detection approaches, code-smell detection tools, most common 
      refactoring, and refactoring tools. We show that code smells and 
      refactoring have a strong relationship with quality attributes, i.e., 
      with understandability, maintainability, testability, complexity, 
      functionality, and reusability. We argue that code smells and 
      refactoring could be considered as the two faces of a same coin. 
      Besides, we identify how refactoring affects quality attributes, more 
      than code smells. We also discuss the implications of this work for 
      practitioners, researchers, and instructors. We identify 13 open 
      issues that could guide future research work. Thus, we want to 
      highlight the gap between code smells and refactoring in the current 
      state of software-engineering research. We wish that this work could 
      help the software-engineering research community in collaborating on 
      future work on code smells and refactoring.}
}

Refactoring and smells have been well researched by the software-engineering research community these past decades. Several secondary studies have been published on code smells, discussing their implications on software quality,their impact on maintenance and evolution, and existing tools for their detection. Other secondary studies addressed refactoring, discussing refactoring techniques, opportunities for refactoring, impact on quality, and tools support. In this paper, we present a tertiary systematic literature review of previous surveys, secondary systematic literature reviews, and systematic mappings. We identify the main observations (what we know) and challenges (what we do not know) on code smells and refactoring. We perform this tertiary review using eight scientific databases, based on a set of five research questions, identifying 40 secondary studies between 1992 and 2018. We organize the main observations and challenges about code smell and their refactoring into: smells definitions, most common code-smell detection approaches, code-smell detection tools, most common refactoring, and refactoring tools. We show that code smells and refactoring have a strong relationship with quality attributes, i.e., with understandability, maintainability, testability, complexity, functionality, and reusability. We argue that code smells and refactoring could be considered as the two faces of a same coin. Besides, we identify how refactoring affects quality attributes, more than code smells. We also discuss the implications of this work for practitioners, researchers, and instructors. We identify 13 open issues that could guide future research work. Thus, we want to highlight the gap between code smells and refactoring in the current state of software-engineering research. We wish that this work could help the software-engineering research community in collaborating on future work on code smells and refactoring.

@ARTICLE{Montandon20-IST-DevelopersSkills,
   AUTHOR       = {Jo�o Eduardo Montandon and Cristiano Politowski and 
      Luciana Lourdes Silva and Marco Tulio Valente and F�bio Petrillo and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {What Skills do IT Companies look for in New Developers? 
      A Study with Stack Overflow Jobs},
   YEAR         = {2020},
   MONTH        = {January},
   NOTE         = {Short article. 6 pages.},
   OPTNUMBER    = {},
   PAGES        = {106429},
   VOLUME       = {129},
   EDITOR       = {G�nther Ruhe},
   KEYWORDS     = {Topic: <b>Quality models</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST20c.doc.pdf},
   ABSTRACT     = {\textbf{Context:} There is a growing demand for 
      information on how IT companies look for candidates to their open 
      positions. \textbf{Objective:} This paper investigates which hard and 
      soft skills are more required in IT companies by analyzing the 
      description of 20,000 job opportunities. \textbf{Method:} We applied 
      open card sorting to perform a high-level analysis on which types of 
      hard skills are more requested. Further, we manually analyzed the 
      most mentioned soft skills. \textbf{Results:} Programming languages 
      are the most demanded hard skills. Communication, collaboration, and 
      problem-solving are the most demanded soft skills. 
      \textbf{Conclusion:} We recommend developers to organize their 
      resum{\'e} according to the positions they are applying. We also 
      highlight the importance of soft skills, as they appear in many job 
      opportunities.}
}

\textbfContext: There is a growing demand for information on how IT companies look for candidates to their open positions. \textbfObjective: This paper investigates which hard and soft skills are more required in IT companies by analyzing the description of 20,000 job opportunities. \textbfMethod: We applied open card sorting to perform a high-level analysis on which types of hard skills are more requested. Further, we manually analyzed the most mentioned soft skills. \textbfResults: Programming languages are the most demanded hard skills. Communication, collaboration, and problem-solving are the most demanded soft skills. \textbfConclusion: We recommend developers to organize their resumé according to the positions they are applying. We also highlight the importance of soft skills, as they appear in many job opportunities.

@ARTICLE{Morales20-TSE-MoMITQuarterCoin,
   AUTHOR       = {Rodrigo Morales and Rub�n Saborido and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {MoMIT: Porting a JavaScript Interpreter on a Quarter 
      Coin},
   YEAR         = {2020},
   MONTH        = {January},
   NOTE         = {15 pages.},
   NUMBER       = {12},
   PAGES        = {2771--2785},
   VOLUME       = {47},
   EDITOR       = {Sebastian Uchitel},
   KEYWORDS     = {Topic: <b>ESE for the IoT</b>, 
      Topic: <b>Requirements and features</b>, Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE20.doc.pdf},
   ABSTRACT     = {The Internet of Things (IoT) is a network of physical, 
      connected devices providing services through private networks and the 
      Internet. The devices connect through the Internet to Web servers and 
      other devices. One of the popular programming languages for 
      communicating Web pages and Web apps is JavaScript (JS). Hence, the 
      devices would benefit from JS apps. However, porting JS apps to the 
      many IoT devices, e.g., System-on-a-Chip (SoCs) devices (e.g., 
      Arduino Uno), is challenging because of their limited memory, 
      storage, and CPU capabilities. Also, some devices may lack 
      hardware/software capabilities for running JS apps "as is". Thus, we 
      propose MoMIT, a multiobjective optimization approach to miniaturize 
      JS apps to run on IoT devices. We implement MoMIT using three 
      different search algorithms. We miniaturize a JS interpreter and 
      measure the characteristics of 23 apps before/after applying MoMIT. 
      We find reductions of code size, memory usage, and CPU time of 31%, 
      56%, and 36%, respectively (medians). We show that MoMIT allows apps 
      to run on up to two additional devices in comparison to the original 
      JS interpreter.}
}

The Internet of Things (IoT) is a network of physical, connected devices providing services through private networks and the Internet. The devices connect through the Internet to Web servers and other devices. One of the popular programming languages for communicating Web pages and Web apps is JavaScript (JS). Hence, the devices would benefit from JS apps. However, porting JS apps to the many IoT devices, e.g., System-on-a-Chip (SoCs) devices (e.g., Arduino Uno), is challenging because of their limited memory, storage, and CPU capabilities. Also, some devices may lack hardware/software capabilities for running JS apps "as is". Thus, we propose MoMIT, a multiobjective optimization approach to miniaturize JS apps to run on IoT devices. We implement MoMIT using three different search algorithms. We miniaturize a JS interpreter and measure the characteristics of 23 apps before/after applying MoMIT. We find reductions of code size, memory usage, and CPU time of 31%, 56%, and 36%, respectively (medians). We show that MoMIT allows apps to run on up to two additional devices in comparison to the original JS interpreter.

@ARTICLE{Politowski20-IST-BlobAndSpaghetti,
   AUTHOR       = {Cristiano Politowski and Foutse Khomh and Simone Romano and 
      Giuseppe Scanniello and Fabio Petrillo and Yann-Ga�l Gu�h�neuc and 
      Abdou Maiga},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {A Large Scale Empirical Study of the Impact of Spaghetti 
      Code and Blob Anti-patterns on Program Comprehension},
   YEAR         = {2020},
   MONTH        = {June},
   NOTE         = {17 pages.},
   OPTNUMBER    = {},
   PAGES        = {106278},
   VOLUME       = {122},
   EDITOR       = {G�nther Ruhe},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST20a.doc.pdf},
   ABSTRACT     = {\textbf{Context.} Several studies investigated the 
      impact of anti-patterns (i.e., poor solutions to recurring design 
      problems) during maintenance activities and reported that 
      anti-patterns significantly affect the developers' effort required to 
      edit files. However, before developers edit files, they must 
      understand the source code of the systems. This source code must be 
      easy to understand by developers. \textbf{Objective.} In this work, 
      we provide a complete assessment of the impact of two instances of 
      two anti-patterns, Blob or Spaghetti Code, on program comprehension. 
      \textbf{Method.} We analyze the impact of these two anti-patterns 
      through three empirical studies conducted at Polytechnique Montr{\'e} 
      al (Canada) with 24 participants; at Carlton University (Canada) with 
      30 participants; and at University Basilicata (Italy) with 79 
      participants. \textbf{Results.} We collect data from 372 tasks 
      obtained thanks to 133 different participants from the three 
      universities. We use three metrics to assess the developers' 
      comprehension of the source code: (1) the duration to complete each 
      task; (2) their percentage of correct answers; and, (3) the NASA task 
      load index for their effort. \textbf{Conclusions.} We report that, 
      although single occurrences of Blob or Spaghetti code anti-patterns 
      have little effect on code comprehension, two occurrences of either 
      Blob or Spaghetti Code significantly increases the developers' time 
      spent in their tasks, reduce their percentage of correct answers, and 
      increase their effort. Hence, we recommend that developers act on 
      both anti-patterns, which should be refactored out of the source code 
      whenever possible. We also recommend further studies on combinations 
      of anti-patterns rather than on single anti-patterns one at a time.}
}

\textbfContext. Several studies investigated the impact of anti-patterns (i.e., poor solutions to recurring design problems) during maintenance activities and reported that anti-patterns significantly affect the developers' effort required to edit files. However, before developers edit files, they must understand the source code of the systems. This source code must be easy to understand by developers. \textbfObjective. In this work, we provide a complete assessment of the impact of two instances of two anti-patterns, Blob or Spaghetti Code, on program comprehension. \textbfMethod. We analyze the impact of these two anti-patterns through three empirical studies conducted at Polytechnique Montré al (Canada) with 24 participants; at Carlton University (Canada) with 30 participants; and at University Basilicata (Italy) with 79 participants. \textbfResults. We collect data from 372 tasks obtained thanks to 133 different participants from the three universities. We use three metrics to assess the developers' comprehension of the source code: (1) the duration to complete each task; (2) their percentage of correct answers; and, (3) the NASA task load index for their effort. \textbfConclusions. We report that, although single occurrences of Blob or Spaghetti code anti-patterns have little effect on code comprehension, two occurrences of either Blob or Spaghetti Code significantly increases the developers' time spent in their tasks, reduce their percentage of correct answers, and increase their effort. Hence, we recommend that developers act on both anti-patterns, which should be refactored out of the source code whenever possible. We also recommend further studies on combinations of anti-patterns rather than on single anti-patterns one at a time.

@ARTICLE{Politowski20-JSS-GamesFrameworks,
   AUTHOR       = {Cristiano Politowski and Fabio Petrillo and 
      Jo�o Eduardo Montandon and Marco Tulio Valente and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Systems and Software (JSS)},
   TITLE        = {Are Game Engines Software Frameworks? A 
      Three-perspective Study},
   YEAR         = {2020},
   MONTH        = {October},
   NOTE         = {22 pages.},
   OPTNUMBER    = {},
   PAGES        = {110846},
   VOLUME       = {171},
   EDITOR       = {Paris Avgeriou and David Shepherd},
   KEYWORDS     = {Topic: <b>Video game development</b>, Venue: <b>JSS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/JSS21b.doc.pdf},
   ABSTRACT     = {Game engines help developers create video games and 
      avoid duplication of code and effort, like frameworks for traditional 
      software systems. In this paper, we explore open-source game engines 
      along three perspectives: literature, code, and human. First, we 
      explore and summarize the academic literature on game engines. 
      Second, we compare the characteristics of the 282 most popular 
      engines and the 282 most popular frameworks in GitHub. Finally, we 
      survey 124 engine developers about their experience with the 
      development of their engines. We report that: (1) Game engines are 
      not well-studied in software-engineering research with few studies 
      having engines as object of research. (2) Open-source game engines 
      are slightly larger in terms of size and complexity and less popular 
      and engaging than traditional frameworks. Their programming languages 
      differ greatly from frameworks. Engine projects have shorter 
      histories with less releases. (3) Developers perceive game engines as 
      different from traditional frameworks. Generally, they build game 
      engines to (a) better control the environment and source code, (b) 
      learn about game engines, and (c) develop specific games. We conclude 
      that open-source game engines have differences compared to 
      traditional open-source frameworks although this differences do not 
      demand special treatments.}
}

Game engines help developers create video games and avoid duplication of code and effort, like frameworks for traditional software systems. In this paper, we explore open-source game engines along three perspectives: literature, code, and human. First, we explore and summarize the academic literature on game engines. Second, we compare the characteristics of the 282 most popular engines and the 282 most popular frameworks in GitHub. Finally, we survey 124 engine developers about their experience with the development of their engines. We report that: (1) Game engines are not well-studied in software-engineering research with few studies having engines as object of research. (2) Open-source game engines are slightly larger in terms of size and complexity and less popular and engaging than traditional frameworks. Their programming languages differ greatly from frameworks. Engine projects have shorter histories with less releases. (3) Developers perceive game engines as different from traditional frameworks. Generally, they build game engines to (a) better control the environment and source code, (b) learn about game engines, and (c) develop specific games. We conclude that open-source game engines have differences compared to traditional open-source frameworks although this differences do not demand special treatments.

@ARTICLE{Sharafi20-EMSE-PracticalEyeTracking,
   AUTHOR       = {Zohreh Sharafi and Bonita Sharif and Yann-Ga�l Gu�h�neuc and 
      Andrew Begel and Romain Bednarik and Martha Crosby},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {A Practical Guide on Conducting Eye Tracking Studies in 
      Software Engineering},
   YEAR         = {2020},
   MONTH        = {June},
   NOTE         = {52 pages.},
   NUMBER       = {5},
   PAGES        = {3128--3174},
   VOLUME       = {25},
   EDITOR       = {Robert Feldt and Thomas Zimmermann},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE20.doc.pdf},
   ABSTRACT     = {For several years, the software engineering research 
      community used eye trackers to study program comprehension, bug 
      localization, pair programming, and other software engineering tasks. 
      Eye trackers provide researchers with insights on software engineers' 
      cognitive processes, data that can augment those acquired through 
      other means, such as on-line surveys and questionnaires. While there 
      are many ways to take advantage of eye trackers, advancing their use 
      requires defining standards for experimental design, execution, and 
      reporting. We begin by presenting the foundations of eye tracking to 
      provide context and perspective. Based on previous surveys of eye 
      tracking for programming and software engineering tasks and our 
      collective, extensive experience with eye trackers, we discuss when 
      and why researchers should use eye trackers as well as how they 
      should use them. We compile a list of typical use cases---real and 
      anticipated---of eye trackers, as well as metrics, visualizations, 
      and statistical analyses to analyze and report eye-tracking data. We 
      also discuss the pragmatics of eye tracking studies. Finally, we 
      offer lessons learned about using eye trackers to study software 
      engineering tasks. This paper is intended to be a one-stop resource 
      for researchers interested in designing, executing, and reporting eye 
      tracking studies of software engineering tasks.}
}

For several years, the software engineering research community used eye trackers to study program comprehension, bug localization, pair programming, and other software engineering tasks. Eye trackers provide researchers with insights on software engineers' cognitive processes, data that can augment those acquired through other means, such as on-line surveys and questionnaires. While there are many ways to take advantage of eye trackers, advancing their use requires defining standards for experimental design, execution, and reporting. We begin by presenting the foundations of eye tracking to provide context and perspective. Based on previous surveys of eye tracking for programming and software engineering tasks and our collective, extensive experience with eye trackers, we discuss when and why researchers should use eye trackers as well as how they should use them. We compile a list of typical use cases—real and anticipated—of eye trackers, as well as metrics, visualizations, and statistical analyses to analyze and report eye-tracking data. We also discuss the pragmatics of eye tracking studies. Finally, we offer lessons learned about using eye trackers to study software engineering tasks. This paper is intended to be a one-stop resource for researchers interested in designing, executing, and reporting eye tracking studies of software engineering tasks.

@INPROCEEDINGS{Abdellatif20-ICSOC-TypeSensitiveServiceIdentification,
   AUTHOR       = {Manel Abdellatif and Rafik Tighilt and Naouel Moha and 
      Hafedh Mili and El Boussaidi, Ghizlane and Jean Privat and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 18<sup>th</sup> International Conference on Service Oriented Computing (ICSOC)},
   TITLE        = {A Type-Sensitive Service Identification Approach for 
      Legacy-to-SOA Migration},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Eleana Kafeza and Boualem Benatallah and 
      Fabio Martinelli},
   MONTH        = {December},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {476--491},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC20.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC20.ppt.pdf},
   ABSTRACT     = {A common strategy for modernizing legacy systems is to 
      migrate them to service-oriented architecture (SOA). A key step in 
      the migration process is the identification of reusable 
      functionalities in the system that qualify as candidate services in 
      the target architecture. We propose ServiceMiner, a bottom-up service 
      identification approach that relies on source code analysis, because 
      other sources of information may be unavailable or out of sync with 
      the actual code. Our bottom-up, codebased approach uses service-type 
      specific functional-clustering criteria. We use a categorization of 
      service types that builds on published service taxonomies and 
      describes the code-level patterns characterizing types of services. 
      We evaluate ServiceMiner on an open-source, enterprise-scale legacy 
      ERP system and compare our results to those of two state-of-theart 
      approaches. We show that ServiceMiner automates one of the main 
      labor-intensive steps for migrating legacy systems to SOA. It 
      identifies architecturally-significant services with 77.9% of 
      precision, 66.4% of recall, and 71.7% of F-measure. Also, we show 
      that it could be used to assist practitioners in the identification 
      of candidate services in existing systems and thus to support the 
      migration process of legacy systems to SOA.}
}

A common strategy for modernizing legacy systems is to migrate them to service-oriented architecture (SOA). A key step in the migration process is the identification of reusable functionalities in the system that qualify as candidate services in the target architecture. We propose ServiceMiner, a bottom-up service identification approach that relies on source code analysis, because other sources of information may be unavailable or out of sync with the actual code. Our bottom-up, codebased approach uses service-type specific functional-clustering criteria. We use a categorization of service types that builds on published service taxonomies and describes the code-level patterns characterizing types of services. We evaluate ServiceMiner on an open-source, enterprise-scale legacy ERP system and compare our results to those of two state-of-theart approaches. We show that ServiceMiner automates one of the main labor-intensive steps for migrating legacy systems to SOA. It identifies architecturally-significant services with 77.9% of precision, 66.4% of recall, and 71.7% of F-measure. Also, we show that it could be used to assist practitioners in the identification of candidate services in existing systems and thus to support the migration process of legacy systems to SOA.

@INPROCEEDINGS{BabaCheikh20-SERP4IoT-OpenSoureIoTFrameworks,
   AUTHOR       = {Zeineb Baba-Cheikh and Ghizlane El-Boussaidi and 
      Julien Gascon-Samson and Hafedh Mili and Yann-Gael Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 2<sup>nd</sup> ICSE International Workshop on Software Engineering Research and Practices for the Internet of Things (SERP4IoT)},
   TITLE        = {A Preliminary Study of Open-source IoT Development 
      Frameworks},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rodrigo Morales and Rub�n Saborido and 
      Shah Rukh Humayoun and Yann-Ga�l Gu�h�neuc},
   MONTH        = {May},
   NOTE         = {7 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {679--686},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>ESE for the IoT</b>, Venue: <i>SERP4IoT</i>},
   URL          = {http://www.ptidej.net/publications/documents/SERP4IoT20a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SERP4IoT20a.ppt.pdf},
   ABSTRACT     = {The Internet of Things (IoT) market is growing fast with 
      an increasing number of connected devices. This led many software 
      companies to shift their focus to develop and provide IoT solutions. 
      IoT development has its own challenges as typical IoT solutions are 
      composed of heterogeneous devices, protocols and software. To cope 
      with these challenges, many frameworks are available to help 
      developers to build IoT applications. Some of these frameworks are 
      open source and might be of great interest for small and medium-sized 
      companies wishing to build IoT solutions at a lower cost. In this 
      paper, we present the results of a preliminary study of four open 
      source IoT development frameworks. In particular, we used these 
      frameworks to implement a sample of three IoT applications and we 
      analyze them against a minimal set of IoT requirements. We focus in 
      our study on the IoT development for Raspberry PI as it is a very 
      low-cost and popular platform.}
}

The Internet of Things (IoT) market is growing fast with an increasing number of connected devices. This led many software companies to shift their focus to develop and provide IoT solutions. IoT development has its own challenges as typical IoT solutions are composed of heterogeneous devices, protocols and software. To cope with these challenges, many frameworks are available to help developers to build IoT applications. Some of these frameworks are open source and might be of great interest for small and medium-sized companies wishing to build IoT solutions at a lower cost. In this paper, we present the results of a preliminary study of four open source IoT development frameworks. In particular, we used these frameworks to implement a sample of three IoT applications and we analyze them against a minimal set of IoT requirements. We focus in our study on the IoT development for Raspberry PI as it is a very low-cost and popular platform.

@INPROCEEDINGS{Benni20-SPLC-SPLReferenceArchitectures,
   AUTHOR       = {Benjamin Benni and S�bastien Mosser and 
      Jean-Philippe Caissy and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 24<sup>th</sup> Conference on Systems and Software Product Line (SPLC)},
   TITLE        = {Can Microservice-based Online-retailers Be Used as an 
      SPL? A Study of Six Reference Architectures},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   OPTEDITOR    = {},
   MONTH        = {October},
   NOTE         = {Short paper. 6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--6},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>SPLC</c>},
   URL          = {http://www.ptidej.net/publications/documents/SPLC20.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SPLC20.ppt.pdf},
   ABSTRACT     = {Microservices are deployable software artifacts that 
      combine a set of business features and expose them to other 
      microservices. Ideally, the reuse and interchanging of microservices 
      should be easy as they are supposed to be independent of each other, 
      both conceptually and technologically. Selecting a service to fulfill 
      a given feature (e.g., managing a cart in a website) recalls the way 
      Software Product Lines (SPL) allow variability. However, in practice, 
      interchanging microservices requires knowing the features that the 
      services propose, how they communicate with other services and their 
      types. In this work, we propose to analyze service dependencies as 
      feature dependencies, at the feature, structural, technological, and 
      versioning level, to assess the interchangeability of services. We 
      analyze six community-selected use-cases and report that services are 
      non-interchangeable systematically.}
}

Microservices are deployable software artifacts that combine a set of business features and expose them to other microservices. Ideally, the reuse and interchanging of microservices should be easy as they are supposed to be independent of each other, both conceptually and technologically. Selecting a service to fulfill a given feature (e.g., managing a cart in a website) recalls the way Software Product Lines (SPL) allow variability. However, in practice, interchanging microservices requires knowing the features that the services propose, how they communicate with other services and their types. In this work, we propose to analyze service dependencies as feature dependencies, at the feature, structural, technological, and versioning level, to assess the interchangeability of services. We analyze six community-selected use-cases and report that services are non-interchangeable systematically.

@INPROCEEDINGS{Etaiwi20-COMPSAC-ConsensusMobileApps,
   AUTHOR       = {Mashael (Layan) Etaiwi and Sylvie Hamel and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 44<sup>th</sup> Computer Software and Applications Conference (COMPSAC)},
   TITLE        = {Order in Chaos: Prioritizing Mobile App Reviews using 
      Consensus Algorithms},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {W. K. Chan and Bill Claycomb and Hiroki Takakura},
   MONTH        = {July},
   NOTE         = {9 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>COMPSAC</c>},
   URL          = {http://www.ptidej.net/publications/documents/COMPSAC20.doc.pdf},
   ABSTRACT     = {The continuous growth of the mobile apps industry 
      creates a competition among apps developers. To succeed, app 
      developers must attract and retain users. User reviews provide a 
      wealth of information about bugs to fix and features to add and can 
      help app developers offer high-quality apps. However, apps may 
      receive hundreds of unstructured reviews, which makes transforming 
      them into change requests a difficult task. Approaches exist for 
      analyzing and extracting topics from mobile app reviews, however, 
      prioritizing these reviews has not gained much attention. In this 
      study, we introduce the use of a consensus algorithm to help 
      developers prioritize user reviews for the purpose of app evolution. 
      We evaluate the usefulness of our approach and meaningfulness of its 
      consensus rankings on four Android apps. We compare the rankings 
      against reviews ranked by app developers manually and show that there 
      is a strong correlation between the two (average Kendall rank 
      correlation coefficient = 0.516). Thus, our approach can prioritize 
      user reviews and help developers focus their time/effort on improving 
      their apps instead of on identifying reviews to address in the next 
      release.}
}

The continuous growth of the mobile apps industry creates a competition among apps developers. To succeed, app developers must attract and retain users. User reviews provide a wealth of information about bugs to fix and features to add and can help app developers offer high-quality apps. However, apps may receive hundreds of unstructured reviews, which makes transforming them into change requests a difficult task. Approaches exist for analyzing and extracting topics from mobile app reviews, however, prioritizing these reviews has not gained much attention. In this study, we introduce the use of a consensus algorithm to help developers prioritize user reviews for the purpose of app evolution. We evaluate the usefulness of our approach and meaningfulness of its consensus rankings on four Android apps. We compare the rankings against reviews ranked by app developers manually and show that there is a strong correlation between the two (average Kendall rank correlation coefficient = 0.516). Thus, our approach can prioritize user reviews and help developers focus their time/effort on improving their apps instead of on identifying reviews to address in the next release.

@INPROCEEDINGS{Lacerda20-ICSM-CodeSmellsRefactorings,
   AUTHOR       = {Guilherme Lacerda and Fabio Petrillo and 
      Marcelo Soares Pimenta and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 36<sup>th</sup> International Conference on Software Maintenance and Evolution (ICSM)},
   TITLE        = {Code Smells and Refactoring: A Tertiary Systematic 
      Review of Challenges and Observations},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {David Lo and David Shepherd},
   MONTH        = {September--October},
   NOTE         = {Journal FirstJournal First / Conference Second track (J1C2). 1 page.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSM</c>, Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM20.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM20.ppt.pdf},
   ABSTRACT     = {Refactoring and smells have been well researched by the 
      software-engineering research community these past decades. Several 
      secondary studies have been published on code smells, discussing 
      their implications on software quality,their impact on maintenance 
      and evolution, and existing tools for their detection. Other 
      secondary studies addressed refactoring, discussing refactoring 
      techniques, opportunities for refactoring, impact on quality, and 
      tools support. In this paper, we present a tertiary systematic 
      literature review of previous surveys, secondary systematic 
      literature reviews, and systematic mappings. We identify the main 
      observations (what we know) and challenges (what we do not know) on 
      code smells and refactoring. We perform this tertiary review using 
      eight scientific databases, based on a set of five research 
      questions, identifying 40 secondary studies between 1992 and 2018. We 
      organize the main observations and challenges about code smell and 
      their refactoring into: smells definitions, most common code-smell 
      detection approaches, code-smell detection tools, most common 
      refactoring, and refactoring tools. We show that code smells and 
      refactoring have a strong relationship with quality attributes, i.e., 
      with understandability, maintainability, testability, complexity, 
      functionality, and reusability. We argue that code smells and 
      refactoring could be considered as the two faces of a same coin. 
      Besides, we identify how refactoring affects quality attributes, more 
      than code smells. We also discuss the implications of this work for 
      practitioners, researchers, and instructors. We identify 13 open 
      issues that could guide future research work. Thus, we want to 
      highlight the gap between code smells and refactoring in the current 
      state of software-engineering research. We wish that this work could 
      help the software-engineering research community in collaborating on 
      future work on code smells and refactoring.}
}

Refactoring and smells have been well researched by the software-engineering research community these past decades. Several secondary studies have been published on code smells, discussing their implications on software quality,their impact on maintenance and evolution, and existing tools for their detection. Other secondary studies addressed refactoring, discussing refactoring techniques, opportunities for refactoring, impact on quality, and tools support. In this paper, we present a tertiary systematic literature review of previous surveys, secondary systematic literature reviews, and systematic mappings. We identify the main observations (what we know) and challenges (what we do not know) on code smells and refactoring. We perform this tertiary review using eight scientific databases, based on a set of five research questions, identifying 40 secondary studies between 1992 and 2018. We organize the main observations and challenges about code smell and their refactoring into: smells definitions, most common code-smell detection approaches, code-smell detection tools, most common refactoring, and refactoring tools. We show that code smells and refactoring have a strong relationship with quality attributes, i.e., with understandability, maintainability, testability, complexity, functionality, and reusability. We argue that code smells and refactoring could be considered as the two faces of a same coin. Besides, we identify how refactoring affects quality attributes, more than code smells. We also discuss the implications of this work for practitioners, researchers, and instructors. We identify 13 open issues that could guide future research work. Thus, we want to highlight the gap between code smells and refactoring in the current state of software-engineering research. We wish that this work could help the software-engineering research community in collaborating on future work on code smells and refactoring.

@INPROCEEDINGS{Politowski20-SERP4IoT-EngagementIoTSensors,
   AUTHOR       = {Cristiano Politowski and Fabio Petrillo and 
      Yann-Gael Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 2<sup>nd</sup> ICSE International Workshop on Software Engineering Research and Practices for the Internet of Things (SERP4IoT)},
   TITLE        = {Improving Engagement Assessment in Gameplay Testing 
      Sessions using IoT Sensors},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rodrigo Morales and Rub�n Saborido and 
      Shah Rukh Humayoun and Yann-Ga�l Gu�h�neuc},
   MONTH        = {May},
   NOTE         = {Short paper. 5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {655--659},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>ESE for the IoT</b>, 
      Topic: <b>Video game development</b>, Venue: <i>SERP4IoT</i>},
   URL          = {http://www.ptidej.net/publications/documents/SERP4IoT20b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SERP4IoT20b.ppt.pdf},
   ABSTRACT     = {The video game industry is a multimillionaire market, 
      which makes solo indie developers millionaire in one day. However, 
      success in the game industry is not a coincidence. Video game 
      development is an unusual kind of software that mix multidisciplinary 
      teams: software engineers, designers, and artists. Also, for a video 
      game to become popular, it must be fun and polished: exhaustively 
      well tested. Testing in video game development encompasses different 
      types of tests at different moments of the development process. In 
      particular, assessing the players' gameplay in a test session can 
      drive the development drastically. The designers analyze the players' 
      actions and behaviour in the game. They can then decide if a 
      feature/level requires rework. They often spend many man/work hours 
      reworking a feature just because it is not engaging. As the designers 
      (usually) assess the gameplay session by hand, they cannot be sure 
      that a specific feature is engaging enough. They would benefit from 
      meaningful data that would help them better assess the gameplay and 
      take the decision to keep, rework, or remove a feature. Consequently, 
      we describe the need for an IoT framework to assess players' gameplay 
      using IoT sensors together with game devices which will produce a 
      rich output for the game designers.}
}

The video game industry is a multimillionaire market, which makes solo indie developers millionaire in one day. However, success in the game industry is not a coincidence. Video game development is an unusual kind of software that mix multidisciplinary teams: software engineers, designers, and artists. Also, for a video game to become popular, it must be fun and polished: exhaustively well tested. Testing in video game development encompasses different types of tests at different moments of the development process. In particular, assessing the players' gameplay in a test session can drive the development drastically. The designers analyze the players' actions and behaviour in the game. They can then decide if a feature/level requires rework. They often spend many man/work hours reworking a feature just because it is not engaging. As the designers (usually) assess the gameplay session by hand, they cannot be sure that a specific feature is engaging enough. They would benefit from meaningful data that would help them better assess the gameplay and take the decision to keep, rework, or remove a feature. Consequently, we describe the need for an IoT framework to assess players' gameplay using IoT sensors together with game devices which will produce a rich output for the game designers.

@INPROCEEDINGS{Politowski20-MSR-Data-VideoGamesDevelopmentProblems,
   AUTHOR       = {Cristiano Politowski and Fabio Petrillo and 
      Gabriel Cavalheiro Ullmann and de Andrade Werly, Josias and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 17<sup>th</sup> International Conference on Mining Software Repositories (MSR)},
   TITLE        = {Dataset of Video Game Development Problems},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Olga Baysal and Bogdan Vasilescu},
   MONTH        = {June},
   NOTE         = {Dataset. 5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {553--557},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <c>MSR</c>},
   URL          = {http://www.ptidej.net/publications/documents/MSR20.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MSR20.ppt.pdf},
   ABSTRACT     = {Different from traditional software development, there 
      is little information about the software-engineering process and 
      techniques in video-game development. One popular way to share 
      knowledge among the video-game developers' community is the 
      publishing of postmortems, which are documents summarizing what 
      happened during the video-game development project. However, these 
      documents are written without formal structure and often providing 
      disparate information. Through this paper, we provide developers and 
      researchers with grounded dataset describing software-engineering 
      problems in video-game development extracted from postmortems. We 
      created the dataset using an iterative method through which we 
      manually coded more than 200 postmortems spanning 20 years (1998 to 
      2018) and extracted 1,035 problems related to software engineering 
      while maintaining traceability links to the postmortems. We grouped 
      the problems in 20 different types. This dataset is useful to 
      understand the problems faced by developers during video-game 
      development, providing researchers and practitioners a starting point 
      to study video-game development in the context of software 
      engineering.}
}

Different from traditional software development, there is little information about the software-engineering process and techniques in video-game development. One popular way to share knowledge among the video-game developers' community is the publishing of postmortems, which are documents summarizing what happened during the video-game development project. However, these documents are written without formal structure and often providing disparate information. Through this paper, we provide developers and researchers with grounded dataset describing software-engineering problems in video-game development extracted from postmortems. We created the dataset using an iterative method through which we manually coded more than 200 postmortems spanning 20 years (1998 to 2018) and extracted 1,035 problems related to software engineering while maintaining traceability links to the postmortems. We grouped the problems in 20 different types. This dataset is useful to understand the problems faced by developers during video-game development, providing researchers and practitioners a starting point to study video-game development in the context of software engineering.

@INPROCEEDINGS{Tighilt20-EuroPLoP-MicroServicesAntiPatterns,
   AUTHOR       = {Rafik Tighilt and Manel Abdellatif and Naouel Moha and 
      Hafedh Mili and El Boussaidi, Ghizlane and Jean Privat and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 25<sup>th</sup> European Conference on Pattern Languages of Programs (EuroPLoP)},
   TITLE        = {On the Study of Microservice Antipatterns: a Catalog 
      Proposal},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Tiago Boldt Sousa},
   MONTH        = {July},
   NOTE         = {13 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>PLoP</c>},
   URL          = {http://www.ptidej.net/publications/documents/EuroPLoP20.doc.pdf},
   ABSTRACT     = {Microservice architecture has become popular in the last 
      few years as it allows the development of independent, highly 
      reusable, and fine grained services. However, a lack of understanding 
      of its core concepts and the absence of a ground-truth lead to design 
      and implementation decisions, which might be applied often and 
      introduce poorly designed solutions, called antipatterns. The 
      definition of microservice antipatterns is essential for improving 
      the design, maintenance, and evolution of microservice-based systems. 
      Moreover, the few existing specifications and definitions of 
      microservice antipatterns are scattered in the literature. 
      Consequently, we conducted a systematic literature review of 27 
      papers related to microservices and analyzed 67 open-source 
      microservice-based systems. Based on our analysis, we report in this 
      paper 16 microservice antipatterns. We concisely describe these 
      antipatterns, how they are implemented, and suggest refactoring 
      solutions to remove them.}
}

Microservice architecture has become popular in the last few years as it allows the development of independent, highly reusable, and fine grained services. However, a lack of understanding of its core concepts and the absence of a ground-truth lead to design and implementation decisions, which might be applied often and introduce poorly designed solutions, called antipatterns. The definition of microservice antipatterns is essential for improving the design, maintenance, and evolution of microservice-based systems. Moreover, the few existing specifications and definitions of microservice antipatterns are scattered in the literature. Consequently, we conducted a systematic literature review of 27 papers related to microservices and analyzed 67 open-source microservice-based systems. Based on our analysis, we report in this paper 16 microservice antipatterns. We concisely describe these antipatterns, how they are implemented, and suggest refactoring solutions to remove them.

@INPROCEEDINGS{Tighilt20-ServiceComputation-MicroServicesIdentification,
   AUTHOR       = {Rafik Tighilt and Naouel Moha and Manel Abdellatif and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 10<sup>th</sup> International Conference on Service Oriented Computing (Service Computation)},
   TITLE        = {Towards a Tool-based Approach for Microservice 
      Antipatterns Identification},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Arne Koschel and Eugen Borcoci and Annett Laube and 
      Andreas Hausotter and Paul Humphreys},
   MONTH        = {October},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--16},
   PUBLISHER    = {IARIA XPS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, 
      Venue: <c>Service Computation</c>},
   URL          = {http://www.ptidej.net/publications/documents/ServiceComputation20.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ServiceComputation20.ppt.pdf},
   ABSTRACT     = {Microservice architecture has become popular in the last 
      few years because it allows the development of independent, reusable, 
      and fine-grained services. However, a lack of understanding of its 
      core concepts and the absence of reference or consensual definitions 
      of its related concepts may lead to poorly designed solutions called 
      antipatterns. The presence of microservice antipatterns may hinder 
      the future maintenance and evolution of microservice-based systems. 
      Assessing the quality of design of such systems through the detection 
      of microservice antipatterns may ease their maintenance and 
      evolution. Several research works studied patterns and antipatterns 
      in the context of microservice-based systems. However, the automatic 
      identification of these patterns and antipatterns is still at its 
      infancy. We searched for re-engineering tools used to identify 
      antipatterns in microservice-based systems in both academia and 
      industry. The results of our search showed that there is no 
      fully-automated identification approach in the literature. In this 
      paper, we aim to reduce this gap by (1) introducing generic, 
      comprehensive, and consensual definitions of antipatterns in 
      microservice-based systems, and (2) presenting our approach to 
      automatically identify these antipatterns. Currently, this work is 
      still in progress and this paper aims to present the approach and the 
      metamodel used for future implementation.}
}

Microservice architecture has become popular in the last few years because it allows the development of independent, reusable, and fine-grained services. However, a lack of understanding of its core concepts and the absence of reference or consensual definitions of its related concepts may lead to poorly designed solutions called antipatterns. The presence of microservice antipatterns may hinder the future maintenance and evolution of microservice-based systems. Assessing the quality of design of such systems through the detection of microservice antipatterns may ease their maintenance and evolution. Several research works studied patterns and antipatterns in the context of microservice-based systems. However, the automatic identification of these patterns and antipatterns is still at its infancy. We searched for re-engineering tools used to identify antipatterns in microservice-based systems in both academia and industry. The results of our search showed that there is no fully-automated identification approach in the literature. In this paper, we aim to reduce this gap by (1) introducing generic, comprehensive, and consensual definitions of antipatterns in microservice-based systems, and (2) presenting our approach to automatically identify these antipatterns. Currently, this work is still in progress and this paper aims to present the approach and the metamodel used for future implementation.

@INPROCEEDINGS{Tiwari20-ENASE-CommitsDefectsQualityC,
   AUTHOR       = {Devansh Tiwari and Hironori Washizaki and 
      Yoshiaki Fukazawa and Tomoyuki Fukuoka and Junji Tamaki and 
      Nobuhiro Hosotani and Munetaka Kohama and Yann-Ga�l Gu�h�neuc and 
      Foutse Khomh},
   BOOKTITLE    = {Proceedings of the 15<sup>th</sup> International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE)},
   TITLE        = {Commit-Defect and Architectural Metrics based Quality 
      Assessment of C Language},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Raian Ali and Hermann Kaindl},
   MONTH        = {May},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {579--586},
   PUBLISHER    = {ScitePress},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <c>ENASE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ENASE20.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ENASE20.ppt.pdf},
   ABSTRACT     = {The foundation of any software system is its design and 
      architecture. Maintaining and improving the architecture and design 
      as systems grow are difficult tasks. Many studies on the architecture 
      and design of object-oriented systems exist but only few studies 
      pertain to the architecture and design of procedural systems. Herein 
      we study the quality of systems for the C language, and investigate 
      how dependencies and associated metrics among files, functions, and 
      modules are related to defects. We also investigate whether a set of 
      static, dependency, and social-network metrics are related to 
      problems in the architecture. Additionally, we examine the bug fixing 
      commits from the commit history and the relations among bug-fixing 
      commits and metrics. Thirteen open source systems from trending 
      GitHub projects are used for study. We found that files with a high 
      number of bug fixing commits are correlated to higher cycles and 
      centrality, indicating that key files of the architecture in C 
      systems are the same files causing issues in the development process. 
      We identify some version releases having huge impact on architecture 
      and files which could be considered at high risk and need more 
      attention.}
}

The foundation of any software system is its design and architecture. Maintaining and improving the architecture and design as systems grow are difficult tasks. Many studies on the architecture and design of object-oriented systems exist but only few studies pertain to the architecture and design of procedural systems. Herein we study the quality of systems for the C language, and investigate how dependencies and associated metrics among files, functions, and modules are related to defects. We also investigate whether a set of static, dependency, and social-network metrics are related to problems in the architecture. Additionally, we examine the bug fixing commits from the commit history and the relations among bug-fixing commits and metrics. Thirteen open source systems from trending GitHub projects are used for study. We found that files with a high number of bug fixing commits are correlated to higher cycles and centrality, indicating that key files of the architecture in C systems are the same files causing issues in the development process. We identify some version releases having huge impact on architecture and files which could be considered at high risk and need more attention.

@INPROCEEDINGS{Tiwari20-ENASE-CQuality,
   AUTHOR       = {Devansh Tiwari and Hironori Washizaki and 
      Yoshiaki Fukazawa and Tomoyuki Fukuoka and Junji Tamaki and 
      Nobuhiro Hosotani and Munetaka Kohama and Yann-Ga�l Gu�h�neuc and 
      Foutse Khomh},
   BOOKTITLE    = {Proceedings of the 15<sup>th</sup> International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE)},
   TITLE        = {Commit-Defect and Architectural Metrics-based Quality 
      Assessment of C language},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Raian Ali and Hermann Kaindl and Leszek A. Maciaszek},
   MONTH        = {May},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {579--586},
   PUBLISHER    = {SciTePress},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, Venue: <c>ENASE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ENASE20.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ENASE20.ppt.pdf},
   ABSTRACT     = {The foundation of any software system is its design and 
      architecture. Maintaining and improving the architecture and design 
      as systems grow are difficult tasks. Many studies on the architecture 
      and design of object-oriented systems exist but only few studies 
      pertain to the architecture and design of procedural systems. Herein 
      we study the quality of systems for the C language, and investigate 
      how dependencies and associated metrics among files, functions, and 
      modules are related to defects. We also investigate whether a set of 
      static, dependency, and social-network metrics are related to 
      problems in the architecture. Additionally, we examine the bug fixing 
      commits from the commit history and the relations among bug-fixing 
      commits and metrics. Thirteen open source systems from trending 
      GitHub projects are used for study. We found that files with a high 
      number of bug fixing commits are correlated to higher cycles and 
      centrality, indicating that key files of the architecture in C 
      systems are the same files causing issues in the development process. 
      We identify some version releases having huge impact on architecture 
      and files which could be considered at high risk and need more 
      attention.}
}

The foundation of any software system is its design and architecture. Maintaining and improving the architecture and design as systems grow are difficult tasks. Many studies on the architecture and design of object-oriented systems exist but only few studies pertain to the architecture and design of procedural systems. Herein we study the quality of systems for the C language, and investigate how dependencies and associated metrics among files, functions, and modules are related to defects. We also investigate whether a set of static, dependency, and social-network metrics are related to problems in the architecture. Additionally, we examine the bug fixing commits from the commit history and the relations among bug-fixing commits and metrics. Thirteen open source systems from trending GitHub projects are used for study. We found that files with a high number of bug fixing commits are correlated to higher cycles and centrality, indicating that key files of the architecture in C systems are the same files causing issues in the development process. We identify some version releases having huge impact on architecture and files which could be considered at high risk and need more attention.

@INPROCEEDINGS{Washizaki20-AsianPLoP-SEP4MLA,
   AUTHOR       = {Hironori Washizaki and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 9<sup>th</sup> Asian Conference on Pattern Languages of Programs (AsianPLoP)},
   TITLE        = {Software Engineering Patterns for Machine Learning 
      Applications (SEP4MLA)},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Yung-Pin Cheng and Takashi Iba and Wen-Chun Ni},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>PLoP</c>},
   URL          = {http://www.ptidej.net/publications/documents/AsianPLoP20.doc.pdf},
   ABSTRACT     = {To grasp the landscape of software engineering patterns 
      for machine learning (ML) applications, a systematic literature 
      review of both academic and gray literature is conducted to collect 
      good and bad software-engineering practices in the form of patterns 
      and anti-patterns for ML applications. From the 32 scholarly 
      documents and 48 gray documents identified, we extracted 12 ML 
      architecture patterns, 13 ML design patterns, and 8 ML anti-patterns. 
      From these 33 ML patterns, we describe three major ML architecture 
      patterns (``Data Lake'', ``Distinguish Business Logic from ML 
      Models'', and ``Microservice Architecture'') and one ML design 
      pattern (``ML Versioning'') in the standard pattern format so that 
      practitioners can (re)use them in their contexts.}
}

To grasp the landscape of software engineering patterns for machine learning (ML) applications, a systematic literature review of both academic and gray literature is conducted to collect good and bad software-engineering practices in the form of patterns and anti-patterns for ML applications. From the 32 scholarly documents and 48 gray documents identified, we extracted 12 ML architecture patterns, 13 ML design patterns, and 8 ML anti-patterns. From these 33 ML patterns, we describe three major ML architecture patterns (``Data Lake'', ``Distinguish Business Logic from ML Models'', and ``Microservice Architecture'') and one ML design pattern (``ML Versioning'') in the standard pattern format so that practitioners can (re)use them in their contexts.

@INPROCEEDINGS{Washizaki20-PLoP-SEP4MLAPart2,
   AUTHOR       = {Hironori Washizaki and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc and Hironori Takeuchi and Satoshi Okuda and 
      Naotake Natori and Naohisa Shioura},
   BOOKTITLE    = {Proceedings of the 27<sup>th</sup> Conference on Pattern Languages Of Programs (PLoP)},
   TITLE        = {Software Engineering Patterns for Machine Learning 
      Applications (SEP4MLA) - Part 2},
   YEAR         = {2020},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rebecca Wirfs-Brock},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>PLoP</c>},
   URL          = {http://www.ptidej.net/publications/documents/PLoP20.doc.pdf},
   ABSTRACT     = {Practitioners and researchers study best practices to 
      develop and maintain ML application systems and software to address 
      quality and constraint problems. Such practices are often formalized 
      as software patterns. We discovered software-engineering design 
      patterns for machine-learning applications by doing a thorough search 
      of available literature on the subject. From these ML patterns, we 
      describe three ML patterns (``Different Workloads in Different 
      Computing Environments'', ``Encapsulate ML Models Within Rule-base 
      Safeguards'', and ``Data Flows Up, Model Flows Down'') in the 
      standard pattern format so that practitioners can (re)use them in 
      their contexts.}
}

Practitioners and researchers study best practices to develop and maintain ML application systems and software to address quality and constraint problems. Such practices are often formalized as software patterns. We discovered software-engineering design patterns for machine-learning applications by doing a thorough search of available literature on the subject. From these ML patterns, we describe three ML patterns (``Different Workloads in Different Computing Environments'', ``Encapsulate ML Models Within Rule-base Safeguards'', and ``Data Flows Up, Model Flows Down'') in the standard pattern format so that practitioners can (re)use them in their contexts.

@MISC{Gueheneuc20-WebZine-EggebrechtWoC92,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {ao�t},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Actualit� : Les annonces de Lewis Eggebrecht au salon 
      World Of Commodore de Toronto (Traduction)},
   YEAR         = {2020},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/annonces_eggebrecht_woctoronto1992.php},
   ABSTRACT     = {Shawn Switenky a particip{\'e} au r{\'e}cent World Of 
      Commodore {\`a} Toronto et {\'e}tait votre reporteur pour 
      comp.sys.amiga.announce. Ce reportage est le r{\'e}sultat de ce 
      d{\'e}placement. C'est la premi{\`e}re de trois parties. Merci pour 
      votre travail, Shawn !}
}

Shawn Switenky a participé au récent World Of Commodore à Toronto et était votre reporteur pour comp.sys.amiga.announce. Ce reportage est le résultat de ce déplacement. C'est la première de trois parties. Merci pour votre travail, Shawn !

@MISC{Gueheneuc20-WebZine-InterviewDonDaglow,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {juillet},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Don Daglow (Traduction)},
   YEAR         = {2020},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwdaglow.php},
   ABSTRACT     = {Don Daglow est un v{\'e}t{\'e}ran d'entreprises aussi 
      diverses que Mattel Electronics (o{\`u} il a travaill{\'e} sur la 
      console Intellivision), Electronic Arts (o{\`u} il fut l'un des 
      premiers producteurs) et Broderbund (o{\`u} il dirigeait la division 
      logiciels de divertissement). Bien s{\^u}r, plus r{\'e}cemment, il a 
      dirig{\'e} le studio ind{\'e}pendant Stormfront Studios qui a 
      ferm{\'e} apr{\`e}s 20 ans d'existence en 2008 dans des circonstances 
      malheureuses. Dans une entrevue {\`a} Gamasutra r{\'e}alis{\'e}e 
      {\`a} cette {\'e}poque-l{\`a} et publi{\'e}e pour la premi{\`e}re 
      fois ici, Don Daglow revient sur son histoire dans l'industrie, 
      pr{\'e}sentant des d{\'e}tails sur le krash de l'industrie en 1983, 
      la console Intellivision IV jamais sortie, et plus encore. Pendant 
      l'entrevue, il donne {\'e}galement son point de vue sur l'{\'e}tat 
      actuel de l'industrie, y compris sur les jeux occasionnels ("casual 
      games") et PC..}
}

Don Daglow est un vétéran d'entreprises aussi diverses que Mattel Electronics (où il a travaillé sur la console Intellivision), Electronic Arts (où il fut l'un des premiers producteurs) et Broderbund (où il dirigeait la division logiciels de divertissement). Bien sûr, plus récemment, il a dirigé le studio indépendant Stormfront Studios qui a fermé après 20 ans d'existence en 2008 dans des circonstances malheureuses. Dans une entrevue à Gamasutra réalisée à cette époque-là et publiée pour la première fois ici, Don Daglow revient sur son histoire dans l'industrie, présentant des détails sur le krash de l'industrie en 1983, la console Intellivision IV jamais sortie, et plus encore. Pendant l'entrevue, il donne également son point de vue sur l'état actuel de l'industrie, y compris sur les jeux occasionnels ("casual games") et PC..

@MISC{Gueheneuc20-WebZine-BanquerouteICD,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {mai},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Point de vue : les probl�mes qui ont caus� la 
      banqueroute d'ICD (Traduction)},
   YEAR         = {2020},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/icd_problemes_banqueroute.php},
   ABSTRACT     = {Alors, qu'est-il arriv{\'e} {\`a} ICD Inc., les 
      cr{\'e}ateurs de sympathiques extensions pour Amiga 500, telles que 
      l'AdSpeed/IDE et le FlickerFree Video ? Apr{\`e}s y avoir 
      travaill{\'e} en tant que contr{\^o}leur qualit{\'e} et assistant 
      technique, j'ai {\'e}galement fait de la r{\'e}daction technique pour 
      des produits Amiga. J'ai connu ICD Inc. {\`a} son apog{\'e}e et {\`a} 
      son point le plus bas.}
}

Alors, qu'est-il arrivé à ICD Inc., les créateurs de sympathiques extensions pour Amiga 500, telles que l'AdSpeed/IDE et le FlickerFree Video ? Après y avoir travaillé en tant que contrôleur qualité et assistant technique, j'ai également fait de la rédaction technique pour des produits Amiga. J'ai connu ICD Inc. à son apogée et à son point le plus bas.

@MISC{Gueheneuc20-WebZine-GTA,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {septembre},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Point de vue : ma vraie histoire de Grand Theft Auto 
      (Traduction)},
   YEAR         = {2020},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/gta_vraiehistoire.php},
   ABSTRACT     = {Le Grand Theft Auto original est n{\'e} sous le nom de 
      ``Crime Inc.'' sur Amiga en 1991-1993. Il n'a pas fallu une grande 
      {\'e}quipe de programmeurs, de concepteurs et de graphistes pour 
      cr{\'e}er ce futur best-seller, il a suffi d'un programmeur et d'un 
      graphiste/concepteur pour r{\'e}aliser la vision originale de ce qui 
      allait devenir le pr{\'e}curseur de Grand Theft Auto.}
}

Le Grand Theft Auto original est né sous le nom de ``Crime Inc.'' sur Amiga en 1991-1993. Il n'a pas fallu une grande équipe de programmeurs, de concepteurs et de graphistes pour créer ce futur best-seller, il a suffi d'un programmeur et d'un graphiste/concepteur pour réaliser la vision originale de ce qui allait devenir le précurseur de Grand Theft Auto.

@INCOLLECTION{Khomh19-HoSE-ESE,
   AUTHOR       = {Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Handbook on Software Engineering (HoSE)},
   PUBLISHER    = {Springer},
   TITLE        = {Empirical Software Engineering},
   YEAR         = {2019},
   OPTADDRESS   = {},
   CHAPTER      = {7},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {Sungdeok Cha and Richard N. Taylor and Kyo C. Kang},
   MONTH        = {February},
   NOTE         = {35 pages.},
   OPTNUMBER    = {},
   PAGES        = {285--320},
   OPTSERIES    = {},
   OPTTYPE      = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, Venue: <b>HoSE</b>},
   URL          = {http://www.ptidej.net/publications/documents/HoSE19.doc.pdf},
   ABSTRACT     = {Software engineering as a discipline exists since the 
      1960's, when participants of the NATO Software Engineering Conference 
      in 1968 at Garmisch, Germany, recognised that there was a "software 
      crisis" due to the increased complexity of the systems and of the 
      software running (on) these systems. The software crisis led to the 
      acknowledgement that software engineering is more than computing 
      theories and efficiency of code and that it requires dedicated 
      research. Thus, this crisis was the starting point of software 
      engineering research. Software engineering research acknowledged 
      early that software engineering is fundamentally an empirical 
      discipline, thus further distinguishing computer science from 
      software engineering, because (1) software is immaterial and does not 
      obey physical laws and (2) software is written by people for people. 
      In this chapter, we first introduce the concepts and principles on 
      which empirical software engineering is based. Then, using these 
      concepts and principles, we describe seminal works that led to the 
      inception and popularisation of empirical software engineering 
      research. We use these seminal works to discuss some idioms, 
      patterns, and styles in empirical software engineering before 
      discussing some challenges that empirical software engineering must 
      overcome in the (near) future. Finally, we conclude and suggest 
      further readings and future directions.}
}

Software engineering as a discipline exists since the 1960's, when participants of the NATO Software Engineering Conference in 1968 at Garmisch, Germany, recognised that there was a "software crisis" due to the increased complexity of the systems and of the software running (on) these systems. The software crisis led to the acknowledgement that software engineering is more than computing theories and efficiency of code and that it requires dedicated research. Thus, this crisis was the starting point of software engineering research. Software engineering research acknowledged early that software engineering is fundamentally an empirical discipline, thus further distinguishing computer science from software engineering, because (1) software is immaterial and does not obey physical laws and (2) software is written by people for people. In this chapter, we first introduce the concepts and principles on which empirical software engineering is based. Then, using these concepts and principles, we describe seminal works that led to the inception and popularisation of empirical software engineering research. We use these seminal works to discuss some idioms, patterns, and styles in empirical software engineering before discussing some challenges that empirical software engineering must overcome in the (near) future. Finally, we conclude and suggest further readings and future directions.

@ARTICLE{Aly18-IoTJ-SLR,
   AUTHOR       = {Mohab Aly and Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Hironori Washizaki and Soumaya Yacout},
   JOURNAL      = {Internet of Things Journal (IoTJ)},
   TITLE        = {Is Fragmentation a Threat to the Success of the Internet 
      of Things?},
   YEAR         = {2019},
   MONTH        = {February},
   NOTE         = {15 pages.},
   NUMBER       = {1},
   PAGES        = {472--487},
   VOLUME       = {6},
   EDITOR       = {Xuemin Shen},
   KEYWORDS     = {Topic: <b>ESE for the IoT</b>, Venue: <b>IoTJ</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/IoTJ18.doc.pdf},
   ABSTRACT     = {Internet of Things (IoT) aims to bring connectivity to 
      almost every objects, i.e., things, found in the physical space. It 
      extends connectivity to everyday things, however, such increase in 
      the connectivity creates many prominent challenges. Context: 
      Generally, IoT opens the door for new applications for 
      machine-to-machine (M2M) and human-to-human communications. The 
      current trend of collaborating, distributed teams through the 
      Internet, mobile communications, and autonomous entities, e.g., 
      robots, is the first phase of the IoT to develop and deliver diverse 
      services and applications. However, such collaborations is threatened 
      by the fragmentation that we witness in the industry nowadays as it 
      brings difficulty to integrate the diverse technologies of the 
      various objects found in IoT systems. Diverse technologies induce 
      interoperability issues while designing and developing various 
      services and applications, hence, limiting the possibility of reusing 
      the data, more specifically, the software (including frameworks, 
      firmware, APIs, user interfaces) as well as of facing issues, like 
      security threats and bugs, when developing new services or 
      applications. Different aspects of handling data collection ranging 
      from discovering smart sensors for data collection, integrating and 
      applying reasoning on them must be available to provide 
      interoperability and flexibility to the diverse objects interacting 
      in the system. However, such approaches are bound to be challenged in 
      future IoT scenarios as they bring substantial performance 
      impairments in settings with the very large number of collaborating 
      devices and technologies. Objective: We raise the awareness of the 
      community about the lack of interoperability among technologies 
      developed for IoT and challenges that their integration poses. We 
      also provide guidelines for researchers and practitioners interested 
      in connecting IoT networks and devices to develop services and 
      applications. Method: We apply the methods advocated by the 
      Evidence-based Software Engineering paradigm (EBSE). This paradigm 
      and its core tool, the Systematic Literature Review (SLR), were 
      introduced to the sofware-engineering research community early 2004 
      to help researchers and industry systematically and objectively 
      gather and aggregate evidences about different topics. In this paper, 
      we conduct a SLR of both IoT interoperability issues and the 
      state-of-practice of IoT technologies in the industry, highlighting 
      the integration challenges related to the IoT that have significantly 
      shifted the landscape of Internet-based collaborative services and 
      applications nowadays. Results: Our SLR identifies a number of 
      studies from journals, conferences, and workshops with the highest 
      quality in the field. This SLR reports different trends, including 
      frameworks and technologies, for the IoT for better comprehension of 
      the paradigm and discusses the integration and interoperability 
      challenges across the different layers of this technology while 
      shedding light on the current IoT state-of-practice. It also 
      discusses some future research directions for the community.}
}

Internet of Things (IoT) aims to bring connectivity to almost every objects, i.e., things, found in the physical space. It extends connectivity to everyday things, however, such increase in the connectivity creates many prominent challenges. Context: Generally, IoT opens the door for new applications for machine-to-machine (M2M) and human-to-human communications. The current trend of collaborating, distributed teams through the Internet, mobile communications, and autonomous entities, e.g., robots, is the first phase of the IoT to develop and deliver diverse services and applications. However, such collaborations is threatened by the fragmentation that we witness in the industry nowadays as it brings difficulty to integrate the diverse technologies of the various objects found in IoT systems. Diverse technologies induce interoperability issues while designing and developing various services and applications, hence, limiting the possibility of reusing the data, more specifically, the software (including frameworks, firmware, APIs, user interfaces) as well as of facing issues, like security threats and bugs, when developing new services or applications. Different aspects of handling data collection ranging from discovering smart sensors for data collection, integrating and applying reasoning on them must be available to provide interoperability and flexibility to the diverse objects interacting in the system. However, such approaches are bound to be challenged in future IoT scenarios as they bring substantial performance impairments in settings with the very large number of collaborating devices and technologies. Objective: We raise the awareness of the community about the lack of interoperability among technologies developed for IoT and challenges that their integration poses. We also provide guidelines for researchers and practitioners interested in connecting IoT networks and devices to develop services and applications. Method: We apply the methods advocated by the Evidence-based Software Engineering paradigm (EBSE). This paradigm and its core tool, the Systematic Literature Review (SLR), were introduced to the sofware-engineering research community early 2004 to help researchers and industry systematically and objectively gather and aggregate evidences about different topics. In this paper, we conduct a SLR of both IoT interoperability issues and the state-of-practice of IoT technologies in the industry, highlighting the integration challenges related to the IoT that have significantly shifted the landscape of Internet-based collaborative services and applications nowadays. Results: Our SLR identifies a number of studies from journals, conferences, and workshops with the highest quality in the field. This SLR reports different trends, including frameworks and technologies, for the IoT for better comprehension of the paradigm and discusses the integration and interoperability challenges across the different layers of this technology while shedding light on the current IoT state-of-practice. It also discusses some future research directions for the community.

@ARTICLE{Brabra19-IST-SemanticDetectionCloudAPI,
   AUTHOR       = {Hayet Brabra and Achraf Mtibaa and Fabio Petrillo and 
      Philippe Merle and Layth Sliman and Naouel Moha and Walid Gaaloul and 
      Yann-Ga�l Gu�h�neuc and Boualem Benatallah and Fa�ez Gargouri},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {On the Semantic Detection of Cloud API (Anti)Patterns},
   YEAR         = {2019},
   MONTH        = {March},
   NOTE         = {17 pages.},
   NUMBER       = {3},
   PAGES        = {65--82},
   VOLUME       = {107},
   EDITOR       = {Claes Wohlin},
   KEYWORDS     = {Topic: <b>Design patterns</b>, 
      Topic: <b>Code and design smells</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST18.doc.pdf},
   ABSTRACT     = {\textit{Context.} Open standards are urgently needed for 
      enabling software interoperability in Cloud Computing. Open Cloud 
      Computing Interface (OCCI) provides a set of best design principles 
      to create interoperable REST management APIs. Although OCCI is the 
      only standard addressing the management of any kind of cloud 
      resources, it does not support a range of best principles related to 
      REST design. This often worsens REST API quality by decreasing their 
      understandability and reusability. \textit{Objective.} We aim at 
      assisting cloud developers to enhance their REST management APIs by 
      providing a compliance evaluation of OCCI and REST best principles 
      and a recommendation support to comply with these principles. 
      \textit{Method.} First, we leverage patterns and anti-patterns to 
      drive respectively the good and poor practices of OCCI and REST best 
      principles. Then, we propose a semantic-based approach for defining 
      and detecting REST and OCCI (anti)patterns and providing a set of 
      correction recommendations to comply with both REST and OCCI best 
      principles. We validated this approach by applying it on cloud REST 
      APIs and evaluating its accuracy, usefulness and extensibility. 
      \textit{Results.} We found that our approach accurately detects OCCI 
      and REST(anti)patterns and provides useful recommendations. According 
      to the compliance results, we reveal that there is no widespread 
      adoption of OCCI principles in existing APIs. In contrast, these APIs 
      have reached an acceptable level of maturity regarding REST 
      principles. \textit{Conclusion.} Our approach provides an effective 
      and extensible technique for defining and detecting OCCI and REST 
      (anti)patterns in Cloud REST APIs. Cloud software developers can 
      benefit from our approach and defined principles to accurately 
      evaluate their APIs from OCCI and REST perspectives. This contributes 
      in designing interoperable, understandable, and reusable Cloud 
      management APIs. Thank to the compliance analysis and the 
      recommendation support, we also contribute to improving these APIs, 
      which make them more straightforward.}
}

Context. Open standards are urgently needed for enabling software interoperability in Cloud Computing. Open Cloud Computing Interface (OCCI) provides a set of best design principles to create interoperable REST management APIs. Although OCCI is the only standard addressing the management of any kind of cloud resources, it does not support a range of best principles related to REST design. This often worsens REST API quality by decreasing their understandability and reusability. Objective. We aim at assisting cloud developers to enhance their REST management APIs by providing a compliance evaluation of OCCI and REST best principles and a recommendation support to comply with these principles. Method. First, we leverage patterns and anti-patterns to drive respectively the good and poor practices of OCCI and REST best principles. Then, we propose a semantic-based approach for defining and detecting REST and OCCI (anti)patterns and providing a set of correction recommendations to comply with both REST and OCCI best principles. We validated this approach by applying it on cloud REST APIs and evaluating its accuracy, usefulness and extensibility. Results. We found that our approach accurately detects OCCI and REST(anti)patterns and provides useful recommendations. According to the compliance results, we reveal that there is no widespread adoption of OCCI principles in existing APIs. In contrast, these APIs have reached an acceptable level of maturity regarding REST principles. Conclusion. Our approach provides an effective and extensible technique for defining and detecting OCCI and REST (anti)patterns in Cloud REST APIs. Cloud software developers can benefit from our approach and defined principles to accurately evaluate their APIs from OCCI and REST perspectives. This contributes in designing interoperable, understandable, and reusable Cloud management APIs. Thank to the compliance analysis and the recommendation support, we also contribute to improving these APIs, which make them more straightforward.

@ARTICLE{Palma18-TSE-UniDoSA,
   AUTHOR       = {Francis Palma and Naouel Moha and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {UniDoSA: The Unified Specification and Detection of 
      Service Antipatterns},
   YEAR         = {2019},
   MONTH        = {October},
   NOTE         = {31 pages.},
   NUMBER       = {10},
   PAGES        = {1024--1053},
   VOLUME       = {45},
   EDITOR       = {Nenad Medvidovic},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE18.doc.pdf},
   ABSTRACT     = {Service-based Systems (SBSs) are developed on top of 
      diverse Service-Oriented Architecture (SOA) technologies or 
      architectural styles. Like any other complex systems, SBSs face both 
      functional and non-functional changes at the design or 
      implementation-level. Such changes may degrade the design quality and 
      quality of service (QoS) of the services in SBSs by introducing poor 
      solutions: service antipatterns. The presence of service antipatterns 
      in SBSs may hinder the future maintenance and evolution of SBSs. 
      Assessing the quality of design and QoS of SBSs through the detection 
      of service antipatterns may ease their maintenance and evolution. 
      However, the current literature lacks a unified approach for 
      modelling and evaluating the design of SBSs in term of design quality 
      and QoS. To address this lack, this paper presents a meta-model 
      unifying the three main service technologies: REST, SCA, and SOAP. 
      Using the meta-model, it describes a unified approach, UniDoSA 
      (Unified Specification and Detection of Service Antipatterns), 
      supported by a framework, SOFA (Service Oriented Framework for 
      Antipatterns), for modelling and evaluating the design quality and 
      QoS of SBSs. We apply and validate UniDoSA on: (1) 18 RESTful APIs, 
      (2) two SCA systems with more than 150 services, and (3) more than 
      120 SOAP Web services. With a high precision and recall, the 
      detection results provide evidence of the presence of service 
      antipatterns in SBSs, which calls for future studies of their impact 
      on QoS}
}

Service-based Systems (SBSs) are developed on top of diverse Service-Oriented Architecture (SOA) technologies or architectural styles. Like any other complex systems, SBSs face both functional and non-functional changes at the design or implementation-level. Such changes may degrade the design quality and quality of service (QoS) of the services in SBSs by introducing poor solutions: service antipatterns. The presence of service antipatterns in SBSs may hinder the future maintenance and evolution of SBSs. Assessing the quality of design and QoS of SBSs through the detection of service antipatterns may ease their maintenance and evolution. However, the current literature lacks a unified approach for modelling and evaluating the design of SBSs in term of design quality and QoS. To address this lack, this paper presents a meta-model unifying the three main service technologies: REST, SCA, and SOAP. Using the meta-model, it describes a unified approach, UniDoSA (Unified Specification and Detection of Service Antipatterns), supported by a framework, SOFA (Service Oriented Framework for Antipatterns), for modelling and evaluating the design quality and QoS of SBSs. We apply and validate UniDoSA on: (1) 18 RESTful APIs, (2) two SCA systems with more than 150 services, and (3) more than 120 SOAP Web services. With a high precision and recall, the detection results provide evidence of the presence of service antipatterns in SBSs, which calls for future studies of their impact on QoS

@ARTICLE{Petrillo19-JSS-SwarmDebugging,
   AUTHOR       = {Fabio Petrillo and Yann-Ga�l Gu�h�neuc and 
      Marcelo Soares Pimenta and Carla Maria Dal Sasso Freitas and 
      Foutse Khomh},
   JOURNAL      = {Journal of Systems and Software (JSS)},
   TITLE        = {Swarm Debugging: the Collective Intelligence on 
      Interactive Debugging},
   YEAR         = {2019},
   MONTH        = {July},
   NOTE         = {22 pages.},
   OPTNUMBER    = {},
   PAGES        = {152--174},
   VOLUME       = {153},
   EDITOR       = {Paris Avgeriou and David Shepherd},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>JSS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/JSS19.doc.pdf},
   ABSTRACT     = {One of the most important tasks in software maintenance 
      is debugging. To start an interactive debugging session, developers 
      usually set breakpoints in an integrated development environment and 
      navigate through different paths in their debuggers. We started our 
      work by asking what debugging information is useful to share among 
      developers and study two pieces of information: breakpoints (and 
      their locations) and sessions (debugging paths). To answer our 
      question, we introduce the Swarm Debugging concept to frame the 
      sharing of debugging information, the Swarm Debugging Infrastructure 
      (SDI) with which practitioners and researchers can collect and share 
      data about developers' interactive debugging sessions, and the Swarm 
      Debugging Global View (GV) to display debugging paths. Using the SDI, 
      we conducted a large study with professional developers to understand 
      how developers set breakpoints. Using the GV, we also analyzed 
      professional developers in two studies and collected data about their 
      debugging sessions. Our observations and the answers to our research 
      questions suggest that sharing and visualizing debugging data can 
      support debugging activities.}
}

One of the most important tasks in software maintenance is debugging. To start an interactive debugging session, developers usually set breakpoints in an integrated development environment and navigate through different paths in their debuggers. We started our work by asking what debugging information is useful to share among developers and study two pieces of information: breakpoints (and their locations) and sessions (debugging paths). To answer our question, we introduce the Swarm Debugging concept to frame the sharing of debugging information, the Swarm Debugging Infrastructure (SDI) with which practitioners and researchers can collect and share data about developers' interactive debugging sessions, and the Swarm Debugging Global View (GV) to display debugging paths. Using the SDI, we conducted a large study with professional developers to understand how developers set breakpoints. Using the GV, we also analyzed professional developers in two studies and collected data about their debugging sessions. Our observations and the answers to our research questions suggest that sharing and visualizing debugging data can support debugging activities.

@ARTICLE{Sabir18-SPE-SLRSmellsOOandSO,
   AUTHOR       = {Fatima Sabir and Francis Palma and Ghulam Rasool and 
      Yann-Ga�l Gu�h�neuc and Naouel Moha},
   JOURNAL      = {Software: Practice and Experience (SPE)},
   TITLE        = {A Systematic Literature Review on the Detection of 
      Smells and their Evolution in Object-Oriented and Service-Oriented 
      Systems},
   YEAR         = {2019},
   MONTH        = {January},
   NOTE         = {36 pages.},
   NUMBER       = {1},
   PAGES        = {3--39},
   VOLUME       = {49},
   EDITOR       = {Rajkumar Buyya},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>SPE</b>},
   PUBLISHER    = {Wiley},
   URL          = {http://www.ptidej.net/publications/documents/SPE18.doc.pdf},
   ABSTRACT     = {This systematic literature review article investigates 
      the key techniques used to identify bad smells in different paradigms 
      of software engineering from object-oriented (OO) to service-oriented 
      (SO). We report, classify, and categorise bad smells and the 
      state-of-the-art detection techniques based on their key 
      characteristics. With this review, we want to identify commonalities 
      and differences in the treatment of bad smells in OO and SO systems. 
      Our research method relies on an automatic search from the relevant 
      digital libraries to find the studies published since January 2000 on 
      bad smells until December 2017. We have conducted a pilot and 
      author-based search to select the 78 most relevant studies after 
      applying inclusion and exclusion criteria. We evaluated the studies 
      based on the bad smells detection techniques and the evolution of 
      different methodologies from OO to SO. We have identified six 
      different studies in which linguistic source code analysis received 
      less attention from the researchers as compared to the static source 
      code analysis. The smells like Yoyo Problem, Un-named Coupling, 
      Intensive Coupling, and Interface Bloat received considerably less 
      attention in the literature. We also identified a catalogue of 30 
      smells that are infrequently reported for SO systems and require 
      further attention. Moreover, a suite of 20 smells reported for SO 
      systems can also be detected using static source code metrics in OO. 
      Finally, our review highlighted three major research trends that are 
      further sub-divided into 20 research patterns initiating the 
      detection of bad smells towards their correction.}
}

This systematic literature review article investigates the key techniques used to identify bad smells in different paradigms of software engineering from object-oriented (OO) to service-oriented (SO). We report, classify, and categorise bad smells and the state-of-the-art detection techniques based on their key characteristics. With this review, we want to identify commonalities and differences in the treatment of bad smells in OO and SO systems. Our research method relies on an automatic search from the relevant digital libraries to find the studies published since January 2000 on bad smells until December 2017. We have conducted a pilot and author-based search to select the 78 most relevant studies after applying inclusion and exclusion criteria. We evaluated the studies based on the bad smells detection techniques and the evolution of different methodologies from OO to SO. We have identified six different studies in which linguistic source code analysis received less attention from the researchers as compared to the static source code analysis. The smells like Yoyo Problem, Un-named Coupling, Intensive Coupling, and Interface Bloat received considerably less attention in the literature. We also identified a catalogue of 30 smells that are infrequently reported for SO systems and require further attention. Moreover, a suite of 20 smells reported for SO systems can also be detected using static source code metrics in OO. Finally, our review highlighted three major research trends that are further sub-divided into 20 research patterns initiating the detection of bad smells towards their correction.

@ARTICLE{Zolfagharinia19-EMSE-BuildInflation,
   AUTHOR       = {Mahdis Zolfagharinia and Bram Adams and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {A Study of Build Inflation in 30 Million CPAN Builds on 
      13 Perl Versions and 10 Operating Systems},
   YEAR         = {2019},
   MONTH        = {June},
   NOTE         = {38 pages.},
   NUMBER       = {6},
   PAGES        = {3933--3971},
   VOLUME       = {24},
   EDITOR       = {Robert Feldt and Thomas Zimmermann},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE19.doc.pdf},
   ABSTRACT     = {Continuous Integration (CI) is a cornerstone of modern 
      quality assurance, providing on-demand builds (compilation and tests) 
      of code changes or software releases. Yet the many existing CI 
      systems do not help developers in interpreting build results, in 
      particular when facing build inflation. Build inflation arises when 
      each code change has to be built on dozens of combinations 
      (configurations) of runtime environments (REs), operating systems 
      (OSes), and hardware architectures (HAs). A code change C1 sent to 
      the CI system may introduce programming faults that result in all 
      these builds to fail, while a change C2 introducing a new library 
      dependency might only lead one particular build configuration to 
      fail. Consequently, the one build failure due to C2 will be 
      ``hidden'' among the dozens of build failures due to C1 when the CI 
      system reports the results of the builds. We have named this 
      phenomenon build inflation, because it may bias the interpretation of 
      build results by developers by ``hiding'' certain types of faults. In 
      this paper, we study build inflation through a large-scale study of 
      the relationship between REs and OSes and build failures on 30 
      million builds of the CPAN repository on the CPAN Testers 
      package-level CI system. We show that the builds of Perl packages may 
      fail differently on different REs and OSes and any combination 
      thereof . Thus, we show that the results provided by CPAN Testers 
      require filtering and selection to identify real trends of build 
      failures among the many failures. Manual analysis of 791 build 
      failures shows that dependency faults (missing modules) and 
      programming faults (undefined values) are the main reasons for 
      failures, with dependency faults being easier to fix. We conclude 
      with recommendations for practitioners and researchers in 
      interpreting build results as well as for tool builders who should 
      improve he scheduling of builds and the reporting of build failures.}
}

Continuous Integration (CI) is a cornerstone of modern quality assurance, providing on-demand builds (compilation and tests) of code changes or software releases. Yet the many existing CI systems do not help developers in interpreting build results, in particular when facing build inflation. Build inflation arises when each code change has to be built on dozens of combinations (configurations) of runtime environments (REs), operating systems (OSes), and hardware architectures (HAs). A code change C1 sent to the CI system may introduce programming faults that result in all these builds to fail, while a change C2 introducing a new library dependency might only lead one particular build configuration to fail. Consequently, the one build failure due to C2 will be ``hidden'' among the dozens of build failures due to C1 when the CI system reports the results of the builds. We have named this phenomenon build inflation, because it may bias the interpretation of build results by developers by ``hiding'' certain types of faults. In this paper, we study build inflation through a large-scale study of the relationship between REs and OSes and build failures on 30 million builds of the CPAN repository on the CPAN Testers package-level CI system. We show that the builds of Perl packages may fail differently on different REs and OSes and any combination thereof . Thus, we show that the results provided by CPAN Testers require filtering and selection to identify real trends of build failures among the many failures. Manual analysis of 791 build failures shows that dependency faults (missing modules) and programming faults (undefined values) are the main reasons for failures, with dependency faults being easier to fix. We conclude with recommendations for practitioners and researchers in interpreting build results as well as for tool builders who should improve he scheduling of builds and the reporting of build failures.

@INPROCEEDINGS{Abidi19-EuroPLoP-SmellsforMLS,
   AUTHOR       = {Mouna Abidi and Manel Grichi and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 24<sup>th</sup> European Conference on Pattern Languages of Programs (EuroPLoP)},
   TITLE        = {Code Smells for Multi-language Systems},
   YEAR         = {2019},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Taichi Isaku},
   MONTH        = {July},
   NOTE         = {13 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--13},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>PLoP</c>},
   URL          = {http://www.ptidej.net/publications/documents/EuroPLoP19b.doc.pdf},
   ABSTRACT     = {Software quality becomes a necessity and no longer an 
      advantage. In fact, with the advancement of technologies, companies 
      must provide software with good quality. Many studies introduce the 
      use of design patterns as improving software quality and discuss the 
      presence of occurrences of design defects as decreasing software 
      quality. Code smells include low-level problems in source code, poor 
      coding decisions that are symptoms of the presence of anti-patterns 
      in the code. Most of the studies present in the literature discuss 
      the occurrences of design defects for mono-language systems. However, 
      nowadays most of the systems are developed using a combination of 
      several programming languages, in order to use particular features of 
      each of them. As the number of languages increases, so does the 
      number of design defects. They generally do not prevent the program 
      from functioning correctly, but they indicate a higher risk of future 
      bugs and makes the code less readable and harder to maintain. We 
      analysed open-source systems, developers' documentation, bug reports, 
      and programming language specifications and extracted bad practices 
      related to multi-language systems. We encoded these practices in the 
      form of code smells. We report in this paper 12 code smells.}
}

Software quality becomes a necessity and no longer an advantage. In fact, with the advancement of technologies, companies must provide software with good quality. Many studies introduce the use of design patterns as improving software quality and discuss the presence of occurrences of design defects as decreasing software quality. Code smells include low-level problems in source code, poor coding decisions that are symptoms of the presence of anti-patterns in the code. Most of the studies present in the literature discuss the occurrences of design defects for mono-language systems. However, nowadays most of the systems are developed using a combination of several programming languages, in order to use particular features of each of them. As the number of languages increases, so does the number of design defects. They generally do not prevent the program from functioning correctly, but they indicate a higher risk of future bugs and makes the code less readable and harder to maintain. We analysed open-source systems, developers' documentation, bug reports, and programming language specifications and extracted bad practices related to multi-language systems. We encoded these practices in the form of code smells. We report in this paper 12 code smells.

@INPROCEEDINGS{Abidi19-EuroPLoP-APsforMLS,
   AUTHOR       = {Mouna Abidi and Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 24<sup>th</sup> European Conference on Pattern Languages of Programs (EuroPLoP)},
   TITLE        = {Anti-patterns for Multi-language Systems},
   YEAR         = {2019},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Taichi Isaku},
   MONTH        = {July},
   NOTE         = {14 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--14},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>PLoP</c>},
   URL          = {http://www.ptidej.net/publications/documents/EuroPLoP19a.doc.pdf},
   ABSTRACT     = {Multi-language systems are common nowadays because most 
      of the systems are developed using components written in different 
      programming languages. These systems could arise from three different 
      reasons: (1) to leverage the strengths and take benefits of each 
      language, (2) to reduce the cost by reusing code written in other 
      languages, (3) to include and accommodate legacy code. However, they 
      also introduce additional challenges, including the increase in the 
      complexity and the need for proper interfaces and interactions 
      between the different languages. To address these challenges, the 
      software-engineering research community, as well as the industry, 
      should describe and provide common guidelines, idioms, and patterns 
      to support the development, maintenance, and evolution of these 
      systems. These patterns are an effective means of improving the 
      quality of multi-language systems. They capture good practices to 
      adopt and bad practices to avoid. In order to help to improve the 
      quality of multi-language systems, we analysed open-source systems, 
      developers' documentation, bug reports, and programming language 
      specifications to extract bad practices of multi-language systems 
      usage. We encoded and cataloged these practices in the form of design 
      anti-patterns. We report here six anti-patterns. These results could 
      help not only researchers but also professional developers 
      considering the use of more than one programming language.}
}

Multi-language systems are common nowadays because most of the systems are developed using components written in different programming languages. These systems could arise from three different reasons: (1) to leverage the strengths and take benefits of each language, (2) to reduce the cost by reusing code written in other languages, (3) to include and accommodate legacy code. However, they also introduce additional challenges, including the increase in the complexity and the need for proper interfaces and interactions between the different languages. To address these challenges, the software-engineering research community, as well as the industry, should describe and provide common guidelines, idioms, and patterns to support the development, maintenance, and evolution of these systems. These patterns are an effective means of improving the quality of multi-language systems. They capture good practices to adopt and bad practices to avoid. In order to help to improve the quality of multi-language systems, we analysed open-source systems, developers' documentation, bug reports, and programming language specifications to extract bad practices of multi-language systems usage. We encoded and cataloged these practices in the form of design anti-patterns. We report here six anti-patterns. These results could help not only researchers but also professional developers considering the use of more than one programming language.

@INPROCEEDINGS{Barbez19-ICSME-DLforAPs,
   AUTHOR       = {Antoine Barbez and Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 35<sup>nd</sup> International Conference on Software Maintenance and Evolution (ICSME)},
   TITLE        = {Deep Learning Anti-patterns from Code Metrics History},
   YEAR         = {2019},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Miryung Kim and �rp�d Besz�des},
   MONTH        = {September--October},
   NOTE         = {11 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {114--124},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSM</c>, Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM19.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM19.ppt.pdf},
   ABSTRACT     = {Anti-patterns are poor solutions to recurring design 
      problems. Number of empirical studies have highlighted the negative 
      impact of anti-patterns on software maintenance which motivated the 
      development of various detection techniques. Most of these approaches 
      rely on structural metrics of software systems to identify affected 
      components while others exploit historical information by analyzing 
      co-changes occurring between code components. By relying solely on 
      one aspect of software systems (i.e., structural or historical), 
      existing approaches miss some precious information which limits their 
      performances. In this paper, we propose CAME (Convolutional Analysis 
      of code Metrics Evolution), a deep-learning based approach that 
      relies on both structural and historical information to detect 
      anti-patterns. Our approach exploits historical values of structural 
      code metrics mined from version control systems and uses a 
      Convolutional Neural Network classifier to infer the presence of 
      anti-patterns from this information. We experiment our approach for 
      the widely known God Class anti-pattern and evaluate its performances 
      on three software systems. With the results of our study, we show 
      that: (1) using historical values of source code metrics allows to 
      increase the precision; (2) CAME outperforms existing static 
      machine-learning classifiers; and (3) CAME outperforms existing 
      detection tools.}
}

Anti-patterns are poor solutions to recurring design problems. Number of empirical studies have highlighted the negative impact of anti-patterns on software maintenance which motivated the development of various detection techniques. Most of these approaches rely on structural metrics of software systems to identify affected components while others exploit historical information by analyzing co-changes occurring between code components. By relying solely on one aspect of software systems (i.e., structural or historical), existing approaches miss some precious information which limits their performances. In this paper, we propose CAME (Convolutional Analysis of code Metrics Evolution), a deep-learning based approach that relies on both structural and historical information to detect anti-patterns. Our approach exploits historical values of structural code metrics mined from version control systems and uses a Convolutional Neural Network classifier to infer the presence of anti-patterns from this information. We experiment our approach for the widely known God Class anti-pattern and evaluate its performances on three software systems. With the results of our study, we show that: (1) using historical values of source code metrics allows to increase the precision; (2) CAME outperforms existing static machine-learning classifiers; and (3) CAME outperforms existing detection tools.

@INPROCEEDINGS{Belkhir19-MOBILESoft-RESTAPIAndroind,
   AUTHOR       = {Abdelkarim Belkhir and Manel Abdellatif and 
      Rafik Tighilt and Naouel Moha and Yann-Ga�l Gu�h�neuc and 
      �ric Beaudry},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> International Conference on Mobile Software Engineering and Systems (MOBILESoft)},
   TITLE        = {An Observational Study on the State of REST API Uses in 
      Android Mobile Applications},
   YEAR         = {2019},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Denys Poshyvanyk and Ivano Malavolta},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {66--75},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <c>MOBILESoft</c>},
   URL          = {http://www.ptidej.net/publications/documents/MOBILESoft19.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MOBILESoft19.ppt.pdf},
   ABSTRACT     = {REST is by far the most commonly-used style for 
      designing APIs, especially for mobile platforms. Indeed, REST APIs 
      are well suited for providing content to apps running on small 
      devices, like smart-phones and tablets. Several research works 
      studied REST APIs development practices for mobile apps. However, 
      little is known about how Android apps use/consume these APIs in 
      practice through HTTP client libraries. Consequently, we propose an 
      observational study on the state of the practice of REST APIs use in 
      Android mobile apps. We (1) build a catalogue of Android REST mobile 
      clients practices; (2) define each of these practices through a 
      number of heuristics based on their potential implementations in 
      Android apps, and (3) propose an automatic approach to detect these 
      practices. We analyze 1,595 REST mobile apps downloaded from the 
      Google Play Store and mine thousands of StackOverflow posts to study 
      REST APIs uses in Android apps. We observe that developers have 
      always used HttpURLConnection class for REST APIs implementation in 
      Android apps. However, since the apparition of REST third-party 
      libraries such as Okhttp, Retrofit and Google Volley, Android REST 
      clients have been increasingly relying on the facilities offered by 
      these libraries. Also, we observe that developers used to ignore some 
      good practices of REST APIs uses in Android apps. Such practices are 
      the use of HTTP third-party libraries, caching responses, timeout 
      management, and error handling. Moreover, we report that only two 
      good practices are widely considered by Android developers when 
      implementing their mobile apps. These practices are network 
      connectivity awareness and JSON vs. XML response parsing. We also 
      find that Retrofit is the most targeted third-party HTTP client 
      library by Android developers because of its ease of use and provided 
      features. Thus, we conclude that service providers must strive to 
      make their libraries as simple as possible while mobile-service 
      consumers should consider existing libraries to benefit from their 
      features, such as asynchronous requests, awareness to connectivity, 
      timeout management, and cached responses.}
}

REST is by far the most commonly-used style for designing APIs, especially for mobile platforms. Indeed, REST APIs are well suited for providing content to apps running on small devices, like smart-phones and tablets. Several research works studied REST APIs development practices for mobile apps. However, little is known about how Android apps use/consume these APIs in practice through HTTP client libraries. Consequently, we propose an observational study on the state of the practice of REST APIs use in Android mobile apps. We (1) build a catalogue of Android REST mobile clients practices; (2) define each of these practices through a number of heuristics based on their potential implementations in Android apps, and (3) propose an automatic approach to detect these practices. We analyze 1,595 REST mobile apps downloaded from the Google Play Store and mine thousands of StackOverflow posts to study REST APIs uses in Android apps. We observe that developers have always used HttpURLConnection class for REST APIs implementation in Android apps. However, since the apparition of REST third-party libraries such as Okhttp, Retrofit and Google Volley, Android REST clients have been increasingly relying on the facilities offered by these libraries. Also, we observe that developers used to ignore some good practices of REST APIs uses in Android apps. Such practices are the use of HTTP third-party libraries, caching responses, timeout management, and error handling. Moreover, we report that only two good practices are widely considered by Android developers when implementing their mobile apps. These practices are network connectivity awareness and JSON vs. XML response parsing. We also find that Retrofit is the most targeted third-party HTTP client library by Android developers because of its ease of use and provided features. Thus, we conclude that service providers must strive to make their libraries as simple as possible while mobile-service consumers should consider existing libraries to benefit from their features, such as asynchronous requests, awareness to connectivity, timeout management, and cached responses.

@INPROCEEDINGS{Grichi19-CASCON-StateofJNI,
   AUTHOR       = {Manel Grichi and Mouna Abidi and Yann-Ga�l Gu�h�neuc and 
      Foutse Khomh},
   BOOKTITLE    = {Proceedings of the 29<sup>th</sup> IBM Centers for Advanced Studies Conference (CASCON)},
   TITLE        = {State of Practices of Java Native Interface},
   YEAR         = {2019},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kostas Kontogiannis and Robert Enenkel},
   MONTH        = {October},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {274--283},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <i>CASCON</i>},
   ABSTRACT     = {The use of the Java Native Interface (JNI) allows taking 
      advantage of the existing libraries written in different programming 
      languages for code reuse, performance, and security. Despite the 
      importance of JNI in development, practices on its usages are not 
      well studied yet. In this paper, we investigated the usage of JNI in 
      100 open source systems collected from OpenHub and Github, around 8k 
      of source code files combined between Java and C/C++, including the 
      Java class libraries part of the JDK v9. We identified the state of 
      the practice in JNI systems by semi-automatically and manually 
      analyzing the source code. Our qualitative analysis shows eleven JNI 
      practices where they are mainly related to loading libraries, 
      implementing native methods, exception management, return types, and 
      local/global references management. Basing on our findings, we 
      provided some suggestions and recommendations to developers to 
      facilitate the debugging tasks of JNI in multi-language systems, 
      which can also help them to deal with the Java and C memory.}
}

The use of the Java Native Interface (JNI) allows taking advantage of the existing libraries written in different programming languages for code reuse, performance, and security. Despite the importance of JNI in development, practices on its usages are not well studied yet. In this paper, we investigated the usage of JNI in 100 open source systems collected from OpenHub and Github, around 8k of source code files combined between Java and C/C++, including the Java class libraries part of the JDK v9. We identified the state of the practice in JNI systems by semi-automatically and manually analyzing the source code. Our qualitative analysis shows eleven JNI practices where they are mainly related to loading libraries, implementing native methods, exception management, return types, and local/global references management. Basing on our findings, we provided some suggestions and recommendations to developers to facilitate the debugging tasks of JNI in multi-language systems, which can also help them to deal with the Java and C memory.

@INPROCEEDINGS{Tighilt19-CAL-MicroServicePatternsAntiPatterns,
   AUTHOR       = {Rafik Tighilt and Manel Abdellatif and Abu Saad, Nader and 
      Naouel Moha and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 12<sup>th</sup> Conf�rence Francophone sur les Architectures Logicielles (CAL)},
   TITLE        = {Collection and Identification of Microservices Patterns 
      and Antipatterns},
   YEAR         = {2019},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Djamel-Abdelhak Seriai},
   MONTH        = {October--November},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--8},
   OPTPUBLISHER = {},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <i>CAL</i>},
   URL          = {http://www.ptidej.net/publications/documents/CAL19.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CAL19.ppt.pdf},
   ABSTRACT     = {Microservices architectural style is becoming more and 
      more popular in academia and industry. However, a lack of 
      understanding of its core concepts and the absence of ground-truth 
      leads to a lot of misconceptions and development mistakes. In our 
      research work, we aim to clarify the academic knowledge on 
      microservices through the collection and the automatic identification 
      of microservices patterns and anti-patterns. To this end, we aim to 
      (1) introduce an exhaustive collection of microservices 
      (anti-)patterns, and (2) propose an automatic approach for the 
      identification of (anti-)patterns in microservice-based systems. The 
      continuous integration and continuous delivery for microservices can 
      introduce \textit{anti-patterns} that may affect the maintainability 
      of the system and decrease its quality. Thus, we searched for 
      re-engineering tools used to identify (anti-)patterns in 
      microservice-based systems. The results of our analysis showed that 
      there is no fully-automated identification approach in the 
      literature. This motivates us to propose (anti-)patterns for the 
      identification process as a first step and then investigate how we 
      can automatically identify them from the artifacts of 
      microservice-based systems.}
}

Microservices architectural style is becoming more and more popular in academia and industry. However, a lack of understanding of its core concepts and the absence of ground-truth leads to a lot of misconceptions and development mistakes. In our research work, we aim to clarify the academic knowledge on microservices through the collection and the automatic identification of microservices patterns and anti-patterns. To this end, we aim to (1) introduce an exhaustive collection of microservices (anti-)patterns, and (2) propose an automatic approach for the identification of (anti-)patterns in microservice-based systems. The continuous integration and continuous delivery for microservices can introduce anti-patterns that may affect the maintainability of the system and decrease its quality. Thus, we searched for re-engineering tools used to identify (anti-)patterns in microservice-based systems. The results of our analysis showed that there is no fully-automated identification approach in the literature. This motivates us to propose (anti-)patterns for the identification process as a first step and then investigate how we can automatically identify them from the artifacts of microservice-based systems.

@INPROCEEDINGS{Washizaki19-IWESEP-DesignPatternsforMLSystems,
   AUTHOR       = {Hironori Washizaki and Hiromu Uchida and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 10<sup>th</sup> International Workshop on Empirical Software Engineering in Practice (IWESEP)},
   TITLE        = {Studying Software Engineering Patterns for Designing 
      Machine Learning Systems},
   YEAR         = {2019},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Akinori Ihara and Marco Aur�lio Gerosa},
   MONTH        = {December},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {49--54},
   PUBLISHER    = {IEEE CS Society},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <i>IWESEP</i>},
   URL          = {http://www.ptidej.net/publications/documents/IWESEP19.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/IWESEP19.ppt.pdf},
   ABSTRACT     = {Machine-learning (ML) techniques are becoming more 
      prevalent. ML techniques rely on mathematics and software 
      engineering. Researchers and practitioners studying best practices 
      strive to design ML systems and software that address software 
      complexity and quality issues. Such design practices are often 
      formalized as architecture and design patterns by encapsulating 
      reusable solutions to common problems within given contexts. However, 
      a systematic study to collect, classify, and discuss these 
      software-engineering (SE) design patterns for ML techniques have yet 
      to be reported. Our research collects good/bad SE design patterns for 
      ML techniques to provide developers with a comprehensive 
      classification of such patterns. Herein we report the preliminary 
      results of a systematic-literature review (SLR) of good/bad design 
      patterns for ML.}
}

Machine-learning (ML) techniques are becoming more prevalent. ML techniques rely on mathematics and software engineering. Researchers and practitioners studying best practices strive to design ML systems and software that address software complexity and quality issues. Such design practices are often formalized as architecture and design patterns by encapsulating reusable solutions to common problems within given contexts. However, a systematic study to collect, classify, and discuss these software-engineering (SE) design patterns for ML techniques have yet to be reported. Our research collects good/bad SE design patterns for ML techniques to provide developers with a comprehensive classification of such patterns. Herein we report the preliminary results of a systematic-literature review (SLR) of good/bad design patterns for ML.

@ARTICLE{An17-SQJ-CrashInducingCommits,
   AUTHOR       = {Le An and Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Software Quality Journal (SQJ)},
   TITLE        = {An Empirical Study of Crash-inducing Commits in Mozilla 
      Firefox},
   YEAR         = {2018},
   MONTH        = {June},
   NOTE         = {33 pages.},
   NUMBER       = {2},
   PAGES        = {553--584},
   VOLUME       = {26},
   EDITOR       = {Rachel Harrison},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>SQJ</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/SQJ17a.doc.pdf},
   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.}
}

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{Hayes16-REEN-AnalystEffort,
   AUTHOR       = {Jane Huffman Hayes and Alexander Dekhtyar and 
      Jody Larsen and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Requirements Engineering (REEN)},
   TITLE        = {Effective Use of Analysts' Effort in Automated Tracing},
   YEAR         = {2018},
   MONTH        = {March},
   NOTE         = {26 pages.},
   NUMBER       = {1},
   PAGES        = {119--143},
   VOLUME       = {23},
   EDITOR       = {Pericles Loucopoulos},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <b>REEN</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/REEN16.doc.pdf},
   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.}
}

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.

@ARTICLE{Politowski18-IST-RecommendationVideoGames,
   AUTHOR       = {Cristiano Politowski and Lisandra M. Fontoura and 
      Fabio Petrillo and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {Learning from the Past: a Process Recommendation System 
      for Video Game Projects using Postmortems Experiences},
   YEAR         = {2018},
   MONTH        = {August},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   PAGES        = {103--118},
   VOLUME       = {100},
   EDITOR       = {Claes Wohlin},
   KEYWORDS     = {Topic: <b>Video game development</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST18.doc.pdf},
   ABSTRACT     = {\textit{Context:} The video game industry is a billion 
      dollar industry that faces problems in the way games are developed. 
      One method to address these problems is using developer aid tools, 
      such as Recommendation Systems. These tools assist developers by 
      generating recommendations to help them perform their tasks. 
      \textit{Objective:} This article describes a systematic approach to 
      recommend development processes for video game projects, using 
      postmortem knowledge extraction and a model of the context of the new 
      project, in which ``postmortems'' are articles written by video game 
      developers at the end of projects, summarizing the experience of 
      their game development team. This approach aims to provide 
      reflections about development processes used in the game industry as 
      well as guidance to developers to choose the most adequate process 
      according to the contexts they're in. \textit{Method:} Our approach 
      is divided in three separate phases: in the first phase, we manually 
      extracted the processes from the postmortems analysis; in the second 
      one, we created a video game context and algorithm rules for 
      recommendation; and finally in the third phase, we evaluated the 
      recommended processes by using quantitative and qualitative metrics, 
      game developers feedback, and a case study by interviewing a video 
      game development team. \textit{Contributions:} This article brings 
      three main contributions. The first describes a database of 
      developers' experiences extracted from postmortems in the form of 
      development processes. The second defines the main attributes that a 
      video game project contain, which it uses to define the contexts of 
      the project. The third describes and evaluates a recommendation 
      system for video game projects, which uses the contexts of the 
      projects to identify similar projects and suggest a set of activities 
      in the form of a process.}
}

Context: The video game industry is a billion dollar industry that faces problems in the way games are developed. One method to address these problems is using developer aid tools, such as Recommendation Systems. These tools assist developers by generating recommendations to help them perform their tasks. Objective: This article describes a systematic approach to recommend development processes for video game projects, using postmortem knowledge extraction and a model of the context of the new project, in which ``postmortems'' are articles written by video game developers at the end of projects, summarizing the experience of their game development team. This approach aims to provide reflections about development processes used in the game industry as well as guidance to developers to choose the most adequate process according to the contexts they're in. Method: Our approach is divided in three separate phases: in the first phase, we manually extracted the processes from the postmortems analysis; in the second one, we created a video game context and algorithm rules for recommendation; and finally in the third phase, we evaluated the recommended processes by using quantitative and qualitative metrics, game developers feedback, and a case study by interviewing a video game development team. Contributions: This article brings three main contributions. The first describes a database of developers' experiences extracted from postmortems in the form of development processes. The second defines the main attributes that a video game project contain, which it uses to define the contexts of the project. The third describes and evaluates a recommendation system for video game projects, which uses the contexts of the projects to identify similar projects and suggest a set of activities in the form of a process.

@ARTICLE{Saborido18-EMSE-AndroidMaps,
   AUTHOR       = {Rub�n Saborido and Rodrigo Morales and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   JOURNAL      = {Journal of Empirical Software Engineering (EMSE)},
   TITLE        = {Getting the Most from Map Data Structures in Android},
   YEAR         = {2018},
   MONTH        = {October},
   NOTE         = {35 pages.},
   NUMBER       = {5},
   PAGES        = {2829--2864},
   VOLUME       = {23},
   EDITOR       = {Robert Feldt and Thomas Zimmermann},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE18b.doc.pdf},
   ABSTRACT     = {A map is a data structure that is commonly used to store 
      data as key-value pairs and retrieve data as keys, values, or 
      key-value pairs. Although Java offers different map implementation 
      classes, Android SDK offers other implementations supposed to be more 
      efficient than HashMap: ArrayMap and SparseArray variants 
      (SparseArray, LongSparseArray, SparseIntArray, SparseLongArray, and 
      SparseBooleanArray). Yet, the performance of these implementations in 
      terms of CPU time, memory usage, and energy consumption is lacking in 
      the official Android documentation; although saving CPU, memory, and 
      energy is a major concern of users wanting to increase battery life. 
      Consequently, we study the use of map implementations by Android 
      developers in two ways. First, we perform an observational study of 
      5713 Android apps in GitHub. Second, we conduct a survey to assess 
      developers' perspective on Java and Android map implementations. 
      Then, we perform an experimental study comparing HashMap, ArrayMap, 
      and SparseArray variants map implementations in terms of CPU time, 
      memory usage, and energy consumption. We conclude with guidelines for 
      choosing among the map implementations: HashMap is preferable over 
      ArrayMap to improve energy efficiency of apps, and SparseArray 
      variants should be used instead of HashMap and ArrayMap when keys are 
      primitive types.}
}

A map is a data structure that is commonly used to store data as key-value pairs and retrieve data as keys, values, or key-value pairs. Although Java offers different map implementation classes, Android SDK offers other implementations supposed to be more efficient than HashMap: ArrayMap and SparseArray variants (SparseArray, LongSparseArray, SparseIntArray, SparseLongArray, and SparseBooleanArray). Yet, the performance of these implementations in terms of CPU time, memory usage, and energy consumption is lacking in the official Android documentation; although saving CPU, memory, and energy is a major concern of users wanting to increase battery life. Consequently, we study the use of map implementations by Android developers in two ways. First, we perform an observational study of 5713 Android apps in GitHub. Second, we conduct a survey to assess developers' perspective on Java and Android map implementations. Then, we perform an experimental study comparing HashMap, ArrayMap, and SparseArray variants map implementations in terms of CPU time, memory usage, and energy consumption. We conclude with guidelines for choosing among the map implementations: HashMap is preferable over ArrayMap to improve energy efficiency of apps, and SparseArray variants should be used instead of HashMap and ArrayMap when keys are primitive types.

@ARTICLE{Soh17-EMSE-MylynNoise,
   AUTHOR       = {Z�phyrin Soh and Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   JOURNAL      = {Journal of Empirical Software Engineering (EMSE)},
   TITLE        = {Noise in Mylyn Interaction Traces and Its Impact on 
      Developers and Recommendation Systems},
   YEAR         = {2018},
   MONTH        = {April},
   NOTE         = {49 pages.},
   NUMBER       = {2},
   PAGES        = {645--692},
   VOLUME       = {23},
   EDITOR       = {Robert Feldt and Thomas Zimmermann},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE17a.doc.pdf},
   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.}
}

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{Washizaki17-EMSE-PROMETA,
   AUTHOR       = {Hironori Washizaki and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Empirical Software Engineering (EMSE)},
   TITLE        = {ProMeTA: A Taxonomy for Program Metamodels in Program 
      Reverse Engineering},
   YEAR         = {2018},
   MONTH        = {August},
   NOTE         = {35 pages.},
   NUMBER       = {4},
   PAGES        = {2323--2358},
   VOLUME       = {23},
   EDITOR       = {Bram Adams and Denys Poshyvanyk},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE18a.doc.pdf},
   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. We confirmed that any 
      reverse engineering activity can be clearly described as a pattern 
      based on the framework from the viewpoint of program metamodels. Then 
      the 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 review (SLR) 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.}
}

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. We confirmed that any reverse engineering activity can be clearly described as a pattern based on the framework from the viewpoint of program metamodels. Then the 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 review (SLR) 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.

@INPROCEEDINGS{Abdellatif18-ICSOC-SOAMigrationIndustry,
   AUTHOR       = {Manel Abdellatif and Geoffrey Hecht and Hafedh Mili and 
      El Boussaidi, Ghizlane and Naouel Moha and Anas Shatnawi and 
      Jean Privat and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 16<sup>th</sup> International Conference on Service Oriented Computing (ICSOC)},
   TITLE        = {State of the Practice in Service Identification for SOA 
      Migration in Industry},
   YEAR         = {2018},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Claus Pahl and Maja Vukovic and Jianwei Yin},
   MONTH        = {November},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {634--650},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC18.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC18.ppt.pdf},
   ABSTRACT     = {The migration of legacy software systems to Service 
      Oriented Architectures (SOA) has become a mainstream trend for 
      modernizing enterprise software systems. A key step in SOA migration 
      is the identification of services in the target application, but it 
      is a challenging one to the extent that the potential services (1) 
      embody reusable functionalities, (2) can be developed in a 
      cost-effective manner, and (3) should be easy to maintain. In this 
      paper, we report on state of the practice of SOA migration in 
      industry. We surveyed 45 practitioners of legacy-to-SOA migration to 
      understand how migration, in general, and service identification 
      (SI), in particular are done. Key findings include: (1) reducing 
      maintenance costs is a key driver in SOA migration, (2) domain 
      knowledge and source code of legacy applications are most often used 
      respectively in a hybrid top-down and bottom-up approach for SI, (3) 
      industrial SI methods focus on domain services-as opposed to 
      technical services, (4) there is very little automation of SI in 
      industry, and (5) RESTful services and microservices are the most 
      frequent target architectures. We conclude with a set of 
      recommendations and best practices.}
}

The migration of legacy software systems to Service Oriented Architectures (SOA) has become a mainstream trend for modernizing enterprise software systems. A key step in SOA migration is the identification of services in the target application, but it is a challenging one to the extent that the potential services (1) embody reusable functionalities, (2) can be developed in a cost-effective manner, and (3) should be easy to maintain. In this paper, we report on state of the practice of SOA migration in industry. We surveyed 45 practitioners of legacy-to-SOA migration to understand how migration, in general, and service identification (SI), in particular are done. Key findings include: (1) reducing maintenance costs is a key driver in SOA migration, (2) domain knowledge and source code of legacy applications are most often used respectively in a hybrid top-down and bottom-up approach for SI, (3) industrial SI methods focus on domain services-as opposed to technical services, (4) there is very little automation of SI in industry, and (5) RESTful services and microservices are the most frequent target architectures. We conclude with a set of recommendations and best practices.

@INPROCEEDINGS{Hecht18-APSEC-CodifyingDependencies,
   AUTHOR       = {Geoffrey Hecht and Hafedh Mili and El Boussaidi, Ghizlane and 
      Anis Boubaker and Manel Abdellatif and Yann-Gael Gu�h�neuc and 
      Anas Shatnawi and Jean Privat and Naouel Moha},
   BOOKTITLE    = {Proceedings of the 25<sup>th</sup> Asia-Pacific Software Engineering Conference (APSEC)},
   TITLE        = {Codifying Hidden Dependencies in Legacy J2EE 
      Applications},
   YEAR         = {2018},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Hironori Washizaki and Hongyu Zhang},
   MONTH        = {December},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {305--314},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>APSEC</c>},
   URL          = {http://www.ptidej.net/publications/documents/APSEC18.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/APSEC18.ppt.pdf},
   ABSTRACT     = {J2EE applications tend to be multi-tier and 
      multilanguage applications. They rely on the J2EE platform and 
      containers that offer infrastructure and architectural services to 
      ensure distributed, secure, safe, and scalable executions. These 
      mechanisms hide many program dependencies, which helps development 
      but hinders maintenance, evolution, and reengineering of J2EE 
      applications. In this paper, we study (i) the J2EE specifications to 
      extract a declarative specification of the dependencies that are 
      inherent in the services offered and that are not visible in the user 
      code that uses them. Then, we introduce (ii) a codification of the 
      dependencies into rules, and (iii) a tool that supports the 
      specification of those dependencies and their detection in a J2EE 
      applications. We validate our approach and tool on a sample of 10 
      J2EE applications. We also compare our tool against JRipples, a 
      state-of-the-art tool for change-impact analysis tasks. Results show 
      that our tool adds, on average, 15\% more call dependencies, which 
      would have been missed otherwise. On change impact analysis tasks, 
      our tool outperforms JRipples in all 10 applications, especially for 
      the early iterations of change propagation exploration}
}

J2EE applications tend to be multi-tier and multilanguage applications. They rely on the J2EE platform and containers that offer infrastructure and architectural services to ensure distributed, secure, safe, and scalable executions. These mechanisms hide many program dependencies, which helps development but hinders maintenance, evolution, and reengineering of J2EE applications. In this paper, we study (i) the J2EE specifications to extract a declarative specification of the dependencies that are inherent in the services offered and that are not visible in the user code that uses them. Then, we introduce (ii) a codification of the dependencies into rules, and (iii) a tool that supports the specification of those dependencies and their detection in a J2EE applications. We validate our approach and tool on a sample of 10 J2EE applications. We also compare our tool against JRipples, a state-of-the-art tool for change-impact analysis tasks. Results show that our tool adds, on average, 15% more call dependencies, which would have been missed otherwise. On change impact analysis tasks, our tool outperforms JRipples in all 10 applications, especially for the early iterations of change propagation exploration

@INPROCEEDINGS{Khomh18-SANER-MissingTheories,
   AUTHOR       = {Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 25<sup>th</sup> International Conference on Software Analysis, Evolution, and Reengineering (SANER)},
   TITLE        = {Design Patterns Impact on Software Quality: Where are 
      the Theories?},
   YEAR         = {2018},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Massimiliano Di Penta and David C. Shepherd},
   MONTH        = {March},
   NOTE         = {11 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {15--25},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, 
      Topic: <b>Quality models</b>, Venue: <c>SANER</c>},
   URL          = {http://www.ptidej.net/publications/documents/SANER18.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SANER18.ppt.pdf},
   ABSTRACT     = {Software engineers are creators of habits. During 
      software development, they follow again and again the same patterns 
      when architecting, designing and implementing programs. Alexander 
      introduced such patterns in architecture in 1974 and, 20 years later, 
      they made their way in software development thanks to the work of 
      Gamma et al. Software design patterns were promoted to make the 
      design of programs more ``flexible, modular, reusable, and 
      understandable''. However, ten years later, these patterns, their 
      roles, and their impact on software quality were not fully 
      understood. We then set out to study the impact of design patterns on 
      different quality attributes and published a paper entitled ``Do 
      Design Patterns Impact Software Quality Positively?'' in the 
      proceedings of the 12<sup>{th}</sup> European Conference on Software 
      Maintenance and Reengineering (CSMR) in 2008. Ten years later, this 
      paper received the Most Influential Paper award at the 
      25<sup>{th}</sup> International Conference on Software Analysis, 
      Evolution, and Reengineering (SANER) in 2018. In this retrospective 
      paper for the award, we report and reflect on our and others' studies 
      on the impact of design patterns, discussing some key findings 
      reported about design patterns. We also take a step back from these 
      studies and re-examine the role that design patterns should play in 
      software development. Finally, we outline some avenues for future 
      research work on design patterns, e.g., the identification of the 
      patterns really used by developers, the theories explaining the 
      impact of patterns, or their use to raise the abstraction level of 
      programming languages.}
}

Software engineers are creators of habits. During software development, they follow again and again the same patterns when architecting, designing and implementing programs. Alexander introduced such patterns in architecture in 1974 and, 20 years later, they made their way in software development thanks to the work of Gamma et al. Software design patterns were promoted to make the design of programs more ``flexible, modular, reusable, and understandable''. However, ten years later, these patterns, their roles, and their impact on software quality were not fully understood. We then set out to study the impact of design patterns on different quality attributes and published a paper entitled ``Do Design Patterns Impact Software Quality Positively?'' in the proceedings of the 12^th European Conference on Software Maintenance and Reengineering (CSMR) in 2008. Ten years later, this paper received the Most Influential Paper award at the 25^th International Conference on Software Analysis, Evolution, and Reengineering (SANER) in 2018. In this retrospective paper for the award, we report and reflect on our and others' studies on the impact of design patterns, discussing some key findings reported about design patterns. We also take a step back from these studies and re-examine the role that design patterns should play in software development. Finally, we outline some avenues for future research work on design patterns, e.g., the identification of the patterns really used by developers, the theories explaining the impact of patterns, or their use to raise the abstraction level of programming languages.

@INPROCEEDINGS{Petrillo18-CLOSER-LexicalSemanticREST,
   AUTHOR       = {Fabio Petrillo and Philippe Merle and Francis Palma and 
      Naouel Moha and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 8<sup>th</sup> International Conference on Cloud Computing and Services Science (CLOSER)},
   TITLE        = {A Lexical and Semantical Analysis on REST Cloud 
      Computing APIs},
   YEAR         = {2018},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Donald Ferguson and V�ctor M�ndez Mu�oz and 
      Jorge S. Cardoso and Markus Helfert and Claus Pahl},
   MONTH        = {July},
   NOTE         = {24 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {308--332},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>CLOSER</c>},
   URL          = {http://www.ptidej.net/publications/documents/CLOSER18.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CLOSER18.ppt.pdf},
   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. Developers use REST APIs by invoking 
      these APIs by their names and, thus, the lexicons used in the APIs 
      are important to ease the developers' comprehension. In this paper, 
      we study the lexicons and the linguistic (anti)patterns from 16 
      providers of REST Cloud Computing APIs. We observe that, although the 
      16 REST APIs describe the same domain (Cloud computing), contrary to 
      what one might expect, their lexicons do not share a large number of 
      common terms and 90\% of the terms (3,561/3,947) are just used by one 
      provider. Thus, the APIs are lexically heterogeneous and there is not 
      a consensus on which terms to use in Cloud computing. Further, we 
      observe that the majority of the URIs, 54\%, follow the 
      Contextualised Resource Names pattern, which is considered a good 
      practice in REST API design. However, a majority of the URIs, 
      62.82\%, suffer from the Non-pertinent Documentation antipattern. 
      Thus, we present three main contributions: 1) a tooled approach, 
      called CloudLex, for extracting and analysing REST Cloud computing 
      lexicons; 2) our analysis of the terms used in 16 REST APIs in 59,677 
      term occurrences; 3) our analysis of the linguistic (anti)patters in 
      more than 23,000 URIs of the 142 services of the 16 Cloud providers. 
      We also show that CloudLex has an average precision of 84.82\%, 
      recall of 63.57\%, and F1-measure of 71.03\% on one complete API, 
      Docker Engine, which confirms the accuracy of our semantic analyses 
      for the detection of linguistic (anti)patterns.}
}

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. Developers use REST APIs by invoking these APIs by their names and, thus, the lexicons used in the APIs are important to ease the developers' comprehension. In this paper, we study the lexicons and the linguistic (anti)patterns from 16 providers of REST Cloud Computing APIs. We observe that, although the 16 REST APIs describe the same domain (Cloud computing), contrary to what one might expect, their lexicons do not share a large number of common terms and 90% of the terms (3,561/3,947) are just used by one provider. Thus, the APIs are lexically heterogeneous and there is not a consensus on which terms to use in Cloud computing. Further, we observe that the majority of the URIs, 54%, follow the Contextualised Resource Names pattern, which is considered a good practice in REST API design. However, a majority of the URIs, 62.82%, suffer from the Non-pertinent Documentation antipattern. Thus, we present three main contributions: 1) a tooled approach, called CloudLex, for extracting and analysing REST Cloud computing lexicons; 2) our analysis of the terms used in 16 REST APIs in 59,677 term occurrences; 3) our analysis of the linguistic (anti)patters in more than 23,000 URIs of the 142 services of the 16 Cloud providers. We also show that CloudLex has an average precision of 84.82%, recall of 63.57%, and F1-measure of 71.03% on one complete API, Docker Engine, which confirms the accuracy of our semantic analyses for the detection of linguistic (anti)patterns.

@INPROCEEDINGS{Politowski18-ESEM-RecommendationPostmortems,
   AUTHOR       = {Cristiano Politowski and Lisandra M. Fontoura and 
      Fabio Petrillo and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 12<sup>th</sup> International Symposium on Empirical Software Engineering and Measurement (ESEM)},
   TITLE        = {Learning from the Past: a Process Recommendation System 
      for Video Game Projects using Postmortems Experiences},
   YEAR         = {2018},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   OPTEDITOR    = {},
   MONTH        = {October},
   NOTE         = {Journal First Presentation. 2 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   OPTPUBLISHER = {},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Video game development</b>, 
      Venue: <c>ESEM</c>},
   URL          = {http://www.ptidej.net/publications/documents/ESEM18.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ESEM18.ppt.pdf},
   ABSTRACT     = {\textit{Context:} The video game industry is a billion 
      dollar industry that faces problems in the way games are developed. 
      One method to address these problems is using developer aid tools, 
      such as Recommendation Systems. These tools assist developers by 
      generating recommendations to help them perform their tasks. 
      \textit{Objective:} This article describes a systematic approach to 
      recommend development processes for video game projects, using 
      postmortem knowledge extraction and a model of the context of the new 
      project, in which ``postmortems'' are articles written by video game 
      developers at the end of projects, summarizing the experience of 
      their game development team. This approach aims to provide 
      reflections about development processes used in the game industry as 
      well as guidance to developers to choose the most adequate process 
      according to the contexts they're in. \textit{Method:} Our approach 
      is divided in three separate phases: in the first phase, we manually 
      extracted the processes from the postmortems analysis; in the second 
      one, we created a video game context and algorithm rules for 
      recommendation; and finally in the third phase, we evaluated the 
      recommended processes by using quantitative and qualitative metrics, 
      game developers feedback, and a case study by interviewing a video 
      game development team. \textit{Contributions:} This article brings 
      three main contributions. The first describes a database of 
      developers' experiences extracted from postmortems in the form of 
      development processes. The second defines the main attributes that a 
      video game project contain, which it uses to define the contexts of 
      the project. The third describes and evaluates a recommendation 
      system for video game projects, which uses the contexts of the 
      projects to identify similar projects and suggest a set of activities 
      in the form of a process.}
}

Context: The video game industry is a billion dollar industry that faces problems in the way games are developed. One method to address these problems is using developer aid tools, such as Recommendation Systems. These tools assist developers by generating recommendations to help them perform their tasks. Objective: This article describes a systematic approach to recommend development processes for video game projects, using postmortem knowledge extraction and a model of the context of the new project, in which ``postmortems'' are articles written by video game developers at the end of projects, summarizing the experience of their game development team. This approach aims to provide reflections about development processes used in the game industry as well as guidance to developers to choose the most adequate process according to the contexts they're in. Method: Our approach is divided in three separate phases: in the first phase, we manually extracted the processes from the postmortems analysis; in the second one, we created a video game context and algorithm rules for recommendation; and finally in the third phase, we evaluated the recommended processes by using quantitative and qualitative metrics, game developers feedback, and a case study by interviewing a video game development team. Contributions: This article brings three main contributions. The first describes a database of developers' experiences extracted from postmortems in the form of development processes. The second defines the main attributes that a video game project contain, which it uses to define the contexts of the project. The third describes and evaluates a recommendation system for video game projects, which uses the contexts of the projects to identify similar projects and suggest a set of activities in the form of a process.

@MISC{Gueheneuc18-WebZine-AmithlonCD,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {octobre},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {En pratique : cr�er un CD Amithlon � jour et amor�able 
      (Traduction)},
   YEAR         = {2018},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/amithlon_creer_cd_ajour_amorcable.php},
   ABSTRACT     = {Les {\'e}tapes pour cr{\'e}er un CD Amithlon {\`a} jour 
      et amor{\c{c}}able.}
}

Les étapes pour créer un CD Amithlon à jour et amorçable.

@MISC{Gueheneuc18-WebZine-InterviewWingard,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {octobre},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Jim Wingard (Traduction)},
   YEAR         = {2018},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwwingard.php},
   ABSTRACT     = {Publication d'une entrevue avec Jim Wingard, un 
      d{\'e}veloppeur AmigaDE qui poss{\`e}de sa propre entreprise de 
      logiciels, Omniscience. Omniscience a d{\'e}velopp{\'e} deux produits 
      AmigaDE : Lexical IQ et Omni-Structure.}
}

Publication d'une entrevue avec Jim Wingard, un développeur AmigaDE qui possède sa propre entreprise de logiciels, Omniscience. Omniscience a développé deux produits AmigaDE : Lexical IQ et Omni-Structure.

@MISC{Yamashita18-Demo-MSR,
   AUTHOR       = {Aiko Yamashita and Fabio Petrillo and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {May},
   NOTE         = {Data showcase at the 15<sup>th</sup> International Conference on Mining Software Repositories. 4 pages.},
   TITLE        = {Developer Interaction Traces backed by IDE Screen 
      Recordings from Think-aloud Sessions},
   YEAR         = {2018},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>MSR</c>},
   URL          = {http://www.ptidej.net/publications/documents/MSR18DataShowcase.doc.pdf},
   ABSTRACT     = {There are two well-known difficulties to test and 
      interpret methodologies for mining developer interaction traces: 
      first, the lack of enough large datasets needed by mining or machine 
      learning approaches to provide reliable results; and second, the lack 
      of ground truth or empirical evidence that can be used to triangulate 
      the results, or to verify their accuracy and correctness. Moreover, 
      relying solely on interaction traces limits our ability to take into 
      account contextual factors that can affect the applicability of 
      mining techniques in other contexts, as well hinders our ability to 
      fully understand the mechanics behind observed phenomena. The data 
      presented in this paper attempts to alleviate these challenges by 
      providing 600+ hours of developer interaction traces, from which 26+ 
      hours are backed with video recordings of the IDE screen and 
      developer's comments. This data set is relevant to researchers 
      interested in investigating program comprehension, and those who are 
      developing techniques for interaction traces analysis and mining.}
}

There are two well-known difficulties to test and interpret methodologies for mining developer interaction traces: first, the lack of enough large datasets needed by mining or machine learning approaches to provide reliable results; and second, the lack of ground truth or empirical evidence that can be used to triangulate the results, or to verify their accuracy and correctness. Moreover, relying solely on interaction traces limits our ability to take into account contextual factors that can affect the applicability of mining techniques in other contexts, as well hinders our ability to fully understand the mechanics behind observed phenomena. The data presented in this paper attempts to alleviate these challenges by providing 600+ hours of developer interaction traces, from which 26+ hours are backed with video recordings of the IDE screen and developer's comments. This data set is relevant to researchers interested in investigating program comprehension, and those who are developing techniques for interaction traces analysis and mining.

@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�l Gu�h�neuc},
   JOURNAL      = {Software Quality Journal (SQJ)},
   TITLE        = {Investigating the Relation between Lexical Smells and 
      Change- and Fault-proneness: An Empirical Study},
   YEAR         = {2017},
   MONTH        = {September},
   NOTE         = {30 pages.},
   NUMBER       = {3},
   PAGES        = {641--670},
   VOLUME       = {25},
   EDITOR       = {Rachel Harrison},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>SQJ</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/SQJ17b.doc.pdf},
   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.}
}

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�l Gu�h�neuc and 
      Kim Mens},
   JOURNAL      = {Journal of Systems and Software (JSS)},
   TITLE        = {Analyzing Software Evolution and Quality by Extracting 
      Asynchrony Change Patterns},
   YEAR         = {2017},
   MONTH        = {September},
   NOTE         = {12 pages.},
   OPTNUMBER    = {},
   PAGES        = {311--322},
   VOLUME       = {131},
   EDITOR       = {Paris Avgeriou and David Shepherd},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>JSS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/JSS17.doc.pdf},
   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.}
}

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�l Gu�h�neuc},
   JOURNAL      = {International Journal of Cooperative Information Systems (IJCIS)},
   TITLE        = {Semantic Analysis of RESTful APIs for the Detection of 
      Linguistic Patterns and Antipatterns},
   YEAR         = {2017},
   MONTH        = {June},
   NOTE         = {38 pages.},
   NUMBER       = {2},
   PAGES        = {1--37},
   VOLUME       = {26},
   EDITOR       = {Alistair Barros and Daniela Grigori and 
      Nanjangud Narendra},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <b>IJCIS</b>},
   PUBLISHER    = {World Scientific},
   URL          = {http://www.ptidej.net/publications/documents/IJCIS17.doc.pdf},
   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.}
}

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.

@ARTICLE{Sabane17-EMSE-FBCS,
   AUTHOR       = {Aminata Saban� and Yann-Ga�l Gu�h�neuc and 
      Venera Arnaoudova and Giuliano Antoniol},
   JOURNAL      = {Journal of Empirical Software Engineering (EMSE)},
   TITLE        = {Fragile Base-class Problem, Problem?},
   YEAR         = {2017},
   MONTH        = {October},
   NOTE         = {Special issue on negative results. 46 pages.},
   NUMBER       = {5},
   PAGES        = {2612--2657},
   VOLUME       = {22},
   EDITOR       = {Mika V. M�ntyl� and Magne Jorgensen and Paul Ralph and 
      Hakan Erdogmus},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE17b.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Cote17-DHC-TAVIE,
   AUTHOR       = {Jos� C�t� and Sylvie Cossette and Pilar Ramirez-Garcia and 
      Genevi�ve Rouleau and Patricia Auger and Fran�ois Boudreau and 
      Marie-Pierre Gagnon and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> UCL Centre for Behaviour Change Digital Health Conference (DHC)},
   TITLE        = {A Web-based Nursing Tailored Intervention to Support 
      Health Behaviour Change among People Living with HIV: Development and 
      Demonstration of TAVIE en sant�},
   YEAR         = {2017},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Susan Michie and Anne Blandford},
   MONTH        = {February},
   NOTE         = {Poster. 1 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {University College London Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <c>DHC</c>},
   PDF          = {http://www.ptidej.net/publications/documents/DHC17.ppt.pdf}
}

@INPROCEEDINGS{Jaafar17-QRS-CloneAntipatterns,
   AUTHOR       = {Fehmi Jaafar and Angela Lozano and Yann-Ga�l Gu�h�neuc and 
      Kim Mens},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> International Conference on Software Quality, Reliability, and Security (QRS)},
   TITLE        = {On the Analysis of Co-occurrence of Anti-Patterns and 
      Clones},
   YEAR         = {2017},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Manuel Nu�ez and Tadashi Dohi and Xiaoying Bai},
   MONTH        = {July},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {274--284},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <c>QRS</c>},
   URL          = {http://www.ptidej.net/publications/documents/QRS17b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/QRS17b.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Petrillo17-QRS-BreakpointToggling,
   AUTHOR       = {Fabio Petrillo and Hyan Mandian and Aiko Yamashita and 
      Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> International Conference on Software Quality, Reliability, and Security (QRS)},
   TITLE        = {How Do Developers Toggle Breakpoints? Observational 
      Studies},
   YEAR         = {2017},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Manuel Nu�ez and Tadashi Dohi and Xiaoying Bai},
   MONTH        = {July},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {285--295},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>QRS</c>},
   URL          = {http://www.ptidej.net/publications/documents/QRS17a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/QRS17a.ppt.pdf},
   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.}
}

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{Petrillo17-CLOSER-CloudLexicon,
   AUTHOR       = {Fabio Petrillo and Philippe Merle and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 7<sup>th</sup> International Conference on Cloud Computing and Services Science (CLOSER)},
   TITLE        = {Towards a REST Cloud Computing Lexicon},
   YEAR         = {2017},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Donald Ferguson and V�ctor M�ndez Mu�oz and 
      Jorge Cardoso},
   MONTH        = {April},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {348--355},
   PUBLISHER    = {SciTePress},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>CLOSER</c>},
   URL          = {http://www.ptidej.net/publications/documents/CLOSER17.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CLOSER17.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Saborido17-ICPC-AndroidAds,
   AUTHOR       = {Rub�n Saborido and Foutse Khomh and Giuliano Antoniol and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 25<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Comprehension of Ads-supported and Paid Android 
      Applications: Are They Different?},
   YEAR         = {2017},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {David Lo and Alexander Serebrenik},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {143--153},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC17.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC17.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Shatnawi17-MSR-JEEDependencies,
   AUTHOR       = {Anas Shatnawi and Hafedh Mili and El Boussaidi, Ghizlane and 
      Anis Boubaker and Yann-Ga�l Gu�h�neuc and Naouel Moha and Jean Privat and 
      Manel Abdellatif},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> International Conference on Mining Software Repositories (MSR)},
   TITLE        = {Analyzing Program Dependencies in Java EE Applications},
   YEAR         = {2017},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Lin Tan and Abram Hindle},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {64--74},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>MSR</c>},
   URL          = {http://www.ptidej.net/publications/documents/MSR17c.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MSR17c.ppt.pdf},
   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.}
}

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{Yamashota17-MSR-P-Seodin,
   AUTHOR       = {Aiko Yamashita and S. Amirhossein Abtahizadeh and 
      Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> International Conference on Mining Software Repositories (MSR)},
   TITLE        = {Software Evolution and Quality Data from Controlled, 
      Multiple, Industrial Case Studies},
   YEAR         = {2017},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Lin Tan and Abram Hindle},
   MONTH        = {May},
   NOTE         = {Short paper. 4 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {507--510},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>MSR</c>},
   URL          = {http://www.ptidej.net/publications/documents/MSR17a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MSR17a.ppt.pdf},
   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.}
}

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�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> International Conference on Mining Software Repositories (MSR)},
   TITLE        = {Do Not Trust Build Results at Face Value: An Empirical 
      Study of 30 Million CPAN Builds},
   YEAR         = {2017},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Lin Tan and Abram Hindle},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {312--322},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>MSR</c>},
   URL          = {http://www.ptidej.net/publications/documents/MSR17b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MSR17b.ppt.pdf},
   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.}
}

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.

@MISC{Gueheneuc17-WebZine-BaSS,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {octobre},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Test de Beneath A Steel Sky},
   YEAR         = {2017},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/beneathasteelsky.php},
   ABSTRACT     = {Beneath A Steel Sky est un jeu vid{\'e}o con{\c{c}}u 
      pour MS-DOS et Amiga. Il a {\'e}t{\'e} d{\'e}velopp{\'e} par 
      Revolution Software et publi{\'e} par Virgin Interactive en 1994. Il 
      s'agit d'un jeu d'aventure de science-fiction pointer-et-cliquer. 
      Situ{\'e} dans un futur dystopique divis{\'e} entre Gap et Union 
      City, il m{\`e}ne son h{\'e}ros, Robert Foster, des secteurs 
      industriels et r{\'e}sidentiels de Union City jusqu'aux anciens 
      tunnels du m{\'e}tro o{\`u} le mal se cache...}
}

Beneath A Steel Sky est un jeu vidéo conçu pour MS-DOS et Amiga. Il a été développé par Revolution Software et publié par Virgin Interactive en 1994. Il s'agit d'un jeu d'aventure de science-fiction pointer-et-cliquer. Situé dans un futur dystopique divisé entre Gap et Union City, il mène son héros, Robert Foster, des secteurs industriels et résidentiels de Union City jusqu'aux anciens tunnels du métro où le mal se cache...

@MISC{Sakti17-Demo-SBST,
   AUTHOR       = {Abdelilah Sakti and Gilles Pesant and 
      Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {May},
   NOTE         = {Tool demo at the 10<sup>th</sup> ICSE International Workshop on Search-Based Software Testing. 4 pages.},
   TITLE        = {JTExpert at the Fifth Unit Testing Tool Competition},
   YEAR         = {2017},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <i>SBST</i>},
   PAGES        = {43--46},
   URL          = {http://www.ptidej.net/publications/documents/SBST17ToolDemo.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SBST17ToolDemo.ppt.pdf},
   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.}
}

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.

@INCOLLECTION{Gueheneuc16-ISTGuestIntroductionForAPSEC14,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Gi-hwon Kwon and 
      Pornsiri Muenchaisri},
   BOOKTITLE    = {Information and Software Technology (IST)},
   PUBLISHER    = {Elsevier},
   TITLE        = {Guest Editorial: Special Section with the Extensions to 
      the Best Papers from APSEC'13 and APSEC'14},
   YEAR         = {2016},
   OPTADDRESS   = {},
   CHAPTER      = {1},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {Yann-Ga�l Gu�h�neuc and Gi-hwon Kwon and 
      Pornsiri Muenchaisri},
   MONTH        = {June},
   NOTE         = {2 pages.},
   OPTNUMBER    = {},
   PAGES        = {181--182},
   OPTSERIES    = {},
   OPTTYPE      = {},
   VOLUME       = {74},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>IST</b>},
   URL          = {http://www.ptidej.net/publications/documents/APSEC14IST16.doc.pdf}
}

@ARTICLE{Jaafar14-EMSE-PatternDependencies,
   AUTHOR       = {Fehmi Jaafar and Yann-Ga�l Gu�h�neuc and Sylvie Hamel and 
      Foutse Khomh and Mohammad Zulkernine},
   JOURNAL      = {Journal of Empirical Software Engineering (EMSE)},
   TITLE        = {Evaluating the Impact of Design Pattern and Anti-pattern 
      Dependencies on Changes and Faults},
   YEAR         = {2016},
   MONTH        = {February},
   NOTE         = {35 pages.},
   NUMBER       = {3},
   PAGES        = {896--931},
   VOLUME       = {21},
   EDITOR       = {Di Penta, Massimiliano and Rocco Oliveto and 
      Romain Robbes},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Topic: <b>Design patterns</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE16b.doc.pdf},
   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.}
}

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.

@ARTICLE{Li16-JSEP-ErrorLeakage,
   AUTHOR       = {Wenbin Li and Jane Huffman Hayes and Giulio Antoniol and 
      Yann-Ga�l Gu�h�neuc and Bram Adams},
   JOURNAL      = {Journal of Software: Evolution and Process (JSEP)},
   TITLE        = {Error Leakage and Wasted Time: Sensitivity and Effort 
      Analysis of a Requirements Consistency Checking Process},
   YEAR         = {2016},
   MONTH        = {October},
   NOTE         = {20 pages.},
   NUMBER       = {12},
   PAGES        = {1061--1080},
   VOLUME       = {28},
   EDITOR       = {Marouane Kessentini and Mel � Cinn�ide},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <b>JSME</b>, Venue: <b>JSEP</b>},
   PUBLISHER    = {Wiley},
   URL          = {http://www.ptidej.net/publications/documents/JSEP16.doc.pdf},
   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.}
}

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{Wu15-EMSE-APIChangeEcosystems,
   AUTHOR       = {Wei Wu and Foutse Khomh and Bram Adams and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   JOURNAL      = {Journal of Empirical Software Engineering (EMSE)},
   TITLE        = {An Exploratory Study of API Changes and Usages based on 
      Apache and Eclipse Ecosystems},
   YEAR         = {2016},
   MONTH        = {December},
   NOTE         = {47 pages.},
   NUMBER       = {6},
   PAGES        = {2366--2412},
   VOLUME       = {21},
   EDITOR       = {Lionel Briand and Thomas Zimmermann},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE16a.doc.pdf},
   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.}
}

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{Bani16-ICSOC-CloudPatternEnergy,
   AUTHOR       = {B�chir Bani and Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> International Conference on Service Oriented Computing (ICSOC)},
   TITLE        = {A Study of the Energy Consumption of Databases and Cloud 
      Patterns},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Michael Sheng and Eleni Stroulia and Samir Tata},
   MONTH        = {October},
   NOTE         = {Short paper. 8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {606--614},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC16b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC16b.ppt.pdf},
   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.}
}

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{Cote16-Sante-TAVIE,
   AUTHOR       = {Jos� C�t� and Pilar Ramirez-Garcia and Gaston Godin and 
      Yann-Ga�l Gu�h�neuc and Annick Hernandez and 
      Les concepteurs des interventions TAVIE, },
   BOOKTITLE    = {Actes du 1<sup>er</sup> Forum Franco--Qu�b�cois d'Innovation en Sant� (FFQIS)},
   TITLE        = {Concept et plateforme informatique TAVIE : d�ploiement 
      d'une pratique infirmi�re virtuelle au service de la gestion des 
      maladies chroniques},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   OPTEDITOR    = {},
   MONTH        = {octobre},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {Aviesan},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <i>FFQIS</i>}
}

@INPROCEEDINGS{Karasneh16-SANER-ModelsCodeAPs,
   AUTHOR       = {Bilal Karasneh and Michel R.V. Chaudron and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 23<sup>rd</sup> International Conference on Software Analysis, Evolution, and Reengineering (SANER)},
   TITLE        = {Studying the Relation between Anti-patterns in Models 
      and in Source Code},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Michele Lanza and Yasutaka Kamei},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {36--45},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>SANER</c>},
   URL          = {http://www.ptidej.net/publications/documents/SANER16b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SANER16b.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Louadah16-MODELSWARD-ICD,
   AUTHOR       = {Hassna Louadah and Roger Champagne and Yvan Labiche and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 4<sup>th</sup> International Conference on Model-Driven Engineering and Software Development (MODELSWARD)},
   TITLE        = {A Data Extraction Process for Avionics Systems' 
      Interface Specifications},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Bran Selic and Philippe Desfray},
   MONTH        = {February},
   NOTE         = {11 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {544--554},
   PUBLISHER    = {SciTePress},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <c>MODELSWARD</c>},
   URL          = {http://www.ptidej.net/publications/documents/MODELSWARD16.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MODELSWARD16.ppt.pdf},
   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.}
}

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{Petrillo16-ICSOC-CloudRestAPIs,
   AUTHOR       = {Fabio Petrillo and Philippe Merle and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> International Conference on Service Oriented Computing (ICSOC)},
   TITLE        = {Are REST APIs for Cloud Computing Well-Designed? An 
      Exploratory Study},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Michael Sheng and Eleni Stroulia and Samir Tata},
   MONTH        = {October},
   NOTE         = {13 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {157--170},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC16a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC16a.ppt.pdf},
   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.}
}

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{Petrillo16-QRS-InteractiveDebugging,
   AUTHOR       = {Fabio Petrillo and Z�phyrin Soh and Foutse Khomh and 
      Marcelo Soares Pimenta and Carla Maria Dal Sasso Freitas and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 24<sup>th</sup> International Conference on Software Quality, Reliability, and Security (QRS)},
   TITLE        = {Towards Understanding Interactive Debugging},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Yves Le Traon and Zhenyu Chen},
   MONTH        = {August},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {152--163},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>QRS</c>},
   URL          = {http://www.ptidej.net/publications/documents/QRS16.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/QRS16.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Petrillo16-ICPC-SwarmDebugging,
   AUTHOR       = {Fabio Petrillo and Z�phyrin Soh and Foutse Khomh and 
      Marcelo Soares Pimenta and Carla Maria Dal Sasso Freitas and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 24<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Understanding Interactive Debugging with Swarm Debug 
      Infrastructure},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Jonathan I. Maletic and Gabriele Bavota},
   MONTH        = {May},
   NOTE         = {Short Paper. 4 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--4},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC16.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC16.ppt.pdf},
   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}
}

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{Politowski16-GAS-SEProcessesGame,
   AUTHOR       = {Cristiano Politowski and Lisandra M. Fontoura and 
      Fabio Petrillo and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 5<sup>th</sup> ICSE International Workshop on Games and Software Engineering (GAS)},
   TITLE        = {Are the Old Days Gone? A Survey on Actual Software 
      Engineering Processes in Video Game Industry},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kendra Cooper},
   MONTH        = {May},
   NOTE         = {7 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {22--28},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <i>GAS</i>},
   URL          = {http://www.ptidej.net/publications/documents/GAS16.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/GAS16.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Soh16-SANER-Noises,
   AUTHOR       = {Z�phyrin Soh and Aiko Yamashita and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 23<sup>rd</sup> International Conference on Software Analysis, Evolution, and Reengineering (SANER)},
   TITLE        = {Do Code Smells Impact the Effort of Different 
      Maintenance Programming Activities?},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Michele Lanza and Yasutaka Kamei},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {393--402},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <c>SANER</c>},
   URL          = {http://www.ptidej.net/publications/documents/SANER16a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SANER16a.ppt.pdf},
   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.}
}

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{Washizaki16-ICSME-Metamodels,
   AUTHOR       = {Hironori Washizaki and Yann-Ga�l Gu�h�neuc and 
      Foutse Khomh},
   BOOKTITLE    = {Proceedings of the 32<sup>nd</sup> International Conference on Software Maintenance and Evolution (ICSME)},
   TITLE        = {A Taxonomy for Program Metamodels in Program Reverse 
      Engineering},
   YEAR         = {2016},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Bram Adams and Denys Poshyvanyk},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {44--55},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>ICSM</c>, 
      Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM16.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM16.ppt.pdf},
   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.}
}

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.

@MISC{Gueheneuc16-WebZine-BoingBall,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {juin},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Bidouille : fabriquer un bo�tier Boing Ball pour 
      AmigaOne XE (Traduction)},
   YEAR         = {2016},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/boitier_boingball_amigaone.php},
   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}.}
}

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�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {septembre},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Reportage : Australian Roadshow (Traduction)},
   YEAR         = {2016},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/australian_roadshow.php},
   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.}
}

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.

@MISC{Sakti16-Demo-SBST,
   AUTHOR       = {Abdelilah Sakti and Gilles Pesant and 
      Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {May},
   NOTE         = {Tool demo at the 9<sup>th</sup> ICSE International Workshop on Search-Based Software Testing. 4 pages.},
   TITLE        = {JTExpert at the Fourth Unit Testing Tool Competition},
   YEAR         = {2016},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <i>SBST</i>},
   PAGES        = {37--40},
   URL          = {http://www.ptidej.net/publications/documents/SBST16ToolDemo.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SBST16ToolDemo.ppt.pdf},
   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.}
}

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.

@INCOLLECTION{Gueheneuc15-EMSEGuestIntroductionForICSM13,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Tom Mens},
   BOOKTITLE    = {Journal of Empirical Software Engineering (EMSE)},
   PUBLISHER    = {Springer},
   TITLE        = {Guest Editorial: Introduction to the Special Issue on 
      Software Maintenance and Evolution Research},
   YEAR         = {2015},
   OPTADDRESS   = {},
   CHAPTER      = {1},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {Yann-Ga�l Gu�h�neuc and Tom Mens},
   MONTH        = {February},
   NOTE         = {4 pages.},
   OPTNUMBER    = {},
   PAGES        = {1193--1197},
   OPTSERIES    = {},
   OPTTYPE      = {},
   VOLUME       = {20},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>EMSE</b>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM13EMSE15.doc.pdf},
   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.}
}

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.

@ARTICLE{Ali14-EMSE-EyeTrackingTraceability,
   AUTHOR       = {Nasir Ali and Zohreh Sharafi and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {An Empirical Study on the Importance of Source Code 
      Entities for Requirements Traceability},
   YEAR         = {2015},
   MONTH        = {April},
   NOTE         = {37 pages.},
   NUMBER       = {2},
   PAGES        = {442--478},
   VOLUME       = {20},
   EDITOR       = {Victor R. Basili and Lionel C. Briand},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Topic: <b>Program comprehension</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE14a.doc.pdf},
   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.}
}

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{Cote15-BMC-RandomizedTrial,
   AUTHOR       = {Jos� C�t� and Sylvie Cossette and Pilar Ramirez-Garcia and 
      De Pokomandy, Alexandra and Catherine Worthington and 
      Marie-Pierre Gagnon and Patricia Auger and Fran�ois Boudreau and 
      Joyal Miranda and Yann-Ga�l Gu�h�neuc and C�cile Tremblay},
   JOURNAL      = {BMC Public Health (BMC)},
   TITLE        = {Evaluation of a Web-based Tailored Intervention (TAVIE 
      en sant�) to Support People Living with HIV in the Adoption of Health 
      Promoting Behaviours: an Online Randomized Controlled Trial Protocol},
   YEAR         = {2015},
   MONTH        = {October},
   OPTNOTE      = {},
   NUMBER       = {1042},
   OPTPAGES     = {},
   VOLUME       = {15},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <b>BMC</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/BMC15.doc.pdf},
   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.}
}

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.

@ARTICLE{Cote15-JMIR-VirtualIntervention,
   AUTHOR       = {Jos� C�t� and Gaston Godin and Pilar Ramirez-Garcia and 
      Genevi�ve Rouleau and Anne Bourbonnais and Yann-Ga�l Gu�h�neuc and 
      C�cile Tremblay and Joanne Otis},
   JOURNAL      = {Journal of Medical Internet Research (JMIR)},
   TITLE        = {Virtual Intervention to Support Self-Management of 
      Antiretroviral Therapy Among People Living With HIV},
   YEAR         = {2015},
   MONTH        = {January},
   OPTNOTE      = {},
   NUMBER       = {1},
   PAGES        = {e6},
   VOLUME       = {17},
   EDITOR       = {Gunther Eysenbach},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <b>JMIR</b>},
   PUBLISHER    = {JMIR Publications},
   URL          = {http://www.ptidej.net/publications/documents/JMIR15.doc.pdf},
   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.}
}

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

@ARTICLE{Sharafi15-IST-SLREyeTracking,
   AUTHOR       = {Zohreh Sharafi and Z�phyrin Soh and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Information and Software Technology (IST)},
   TITLE        = {A Systematic Literature Review on the Usage of 
      Eye-tracking in Software Engineering},
   YEAR         = {2015},
   MONTH        = {November},
   NOTE         = {28 pages.},
   OPTNUMBER    = {},
   PAGES        = {79--107},
   VOLUME       = {67},
   EDITOR       = {Guenther Ruhe and Guilherme Horta Travassos and 
      Laurie Williams},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST15.doc.pdf},
   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. }
}

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.

@ARTICLE{Wu14-EMSE-EyeTrackingTraceability,
   AUTHOR       = {Wei Wu and Adrien Serveaux and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {The Impact of Imperfect Change Rules on Framework API 
      Evolution Identification: An Empirical Study},
   YEAR         = {2015},
   MONTH        = {August},
   NOTE         = {32 pages.},
   NUMBER       = {4},
   PAGES        = {1126--1158},
   VOLUME       = {20},
   EDITOR       = {Victor R. Basili and Lionel C. Briand},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE14b.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Abtahizadeh15-IPCCC-GreenPatterns,
   AUTHOR       = {S. Amirhossein Abtahizadeh and Foutse Khomh and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 34<sup>th</sup> International Performance Computing and Communications Conference (IPCCC)},
   TITLE        = {How Green Are Cloud Patterns? A Case Study of Energy 
      Consumption},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kui Ren and Tommaso Melodia},
   MONTH        = {December},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--8},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Topic: <b>Quality models</b>, Venue: <c>IPCCC</c>},
   URL          = {http://www.ptidej.net/publications/documents/IPCCC15.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/IPCCC15.ppt.pdf},
   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.}
}

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{Cote15-Medicine20-VirtualIntervention,
   AUTHOR       = {Jos� C�t� and Gaston Godin and Pilar Ramirez-Garcia and 
      Genevi�ve Rouleau and Anne Bourbonnais and Yann-Ga�l Gu�h�neuc and 
      C�cile Tremblay and Joanne Otis},
   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)},
   TITLE        = {Virtual Intervention to Support Self-Management of 
      Antiretroviral Therapy Among People Living With HIV},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   OPTEDITOR    = {},
   MONTH        = {October},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {Medicine 2.0},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <c>Medicine 2.0</c>},
   PDF          = {http://www.ptidej.net/publications/documents/MEDICINE15.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Hayes15-RENext-InherentCharacteristics,
   AUTHOR       = {Jane Huffman Hayes and Giuliano Antoniol and Bram Adams and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 23<sup>rd</sup> International Requirements Engineering Conference (RE)},
   TITLE        = {Inherent Characteristics of Traceability Artifacts: Less 
      Is More},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Didar Zowghi and Vincenzo Gervasi},
   MONTH        = {August},
   NOTE         = {RE Next! 6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {196--201},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>RE</c>},
   URL          = {http://www.ptidej.net/publications/documents/RENext15.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/RENext15.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Hayes15-NasBASE-ErrorLeakageTraceability,
   AUTHOR       = {Jane Huffman Hayes and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol and Wenbin Li and Mirek Truszczynski},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> North American Search Based Software Engineering Symposium (NasBASE)},
   TITLE        = {Error Leakage and Wasted Time: Sensitivity Analysis of a 
      Requirements Consistency Checking Process},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Marouane Kessentini},
   MONTH        = {February},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1061--1080},
   PUBLISHER    = {Elsevier},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <i>NasBASE</i>},
   URL          = {http://www.ptidej.net/publications/documents/NasBASE15.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/NasBASE15.ppt.pdf},
   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.}
}

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-ICSOC-RESTLinguisticAPs,
   AUTHOR       = {Francis Palma and Javier Gonzalez-Huerta and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc and Guy Tremblay},
   BOOKTITLE    = {Proceedings of the 13<sup>th</sup> International Conference on Service Oriented Computing (ICSOC)},
   TITLE        = {Are RESTful APIs Well-designed? Detection of Their 
      Linguistic (Anti)Patterns},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Alistair Barros and Daniela Grigori and N.C. Narendra},
   MONTH        = {November},
   NOTE         = {16 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {171--187},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC15.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC15.ppt.pdf},
   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.}
}

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{Palma15-MCETech-AntiBusinessProcess,
   AUTHOR       = {Francis Palma and Naouel Moha and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> International Conference on eTechnologies (MCETECH)},
   TITLE        = {Specification and Detection of Business Process 
      Antipatterns},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Morad Benyoucef and Michael Weiss},
   MONTH        = {May},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {37--52},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <i>MCETECH</i>},
   URL          = {http://www.ptidej.net/publications/documents/MCETECH15.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MCETECH15.ppt.pdf},
   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\%.}
}

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

@INPROCEEDINGS{Rouleau15-ACFAS-VIHTAVIE,
   AUTHOR       = {Genevi�ve Rouleau and Jos� C�t� and Pilar Ramirez-Garcia and 
      Annick Hernandez and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {actes du 83<sup>e</sup> congr�s de l'ACFAS},
   TITLE        = {VIH-TAVIE et TAVIE en sant� : interventions infirmi�res 
      en cybersant� pour soutenir la prise des antir�troviraux et 
      l'adoption de comportements de sant� aupr�s d'une client�le VIH},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {C�line Audet and Claude La Charit�},
   MONTH        = {mai},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {ACFAS},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <i>ACFAS</i>},
   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.}
}

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�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 22<sup>nd</sup> Asia-Pacific Software Engineering Conference (APSEC)},
   TITLE        = {Eye-tracking Metrics in Software Engineering},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Jing Sun and Y. Raghu Reddy},
   MONTH        = {December},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {96--103},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <c>APSEC</c>},
   URL          = {http://www.ptidej.net/publications/documents/APSEC15.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/APSEC15.ppt.pdf},
   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.}
}

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�phyrin Soh and Thomas Drioul and Pierre-Antoine Rappe and 
      Foutse Khomh and Yann-Ga�l Gu�h�neuc and Naji Habra},
   BOOKTITLE    = {Proceedings of the 9<sup>th</sup> International Symposium of Empirical Software Engineering and Measurement (ESEM)},
   TITLE        = {Noises in Interaction Traces Data and their Impact on 
      Previous Research Studies},
   YEAR         = {2015},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Jeff Carver and Oscar Dieste},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--10},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ESEM</c>},
   URL          = {http://www.ptidej.net/publications/documents/ESEM15.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ESEM15.ppt.pdf},
   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.}
}

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.

@MISC{Gueheneuc15-WebZine-InterviewFleecyMoss,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {mai},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Fleecy Moss (Traduction)},
   YEAR         = {2015},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwmoss2.php},
   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.}
}

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�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {mars},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Gary Peake (Traduction)},
   YEAR         = {2015},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwpeake_082000.php},
   ABSTRACT     = {Gary Peake a {\'e}t{\'e} un pilier de l'Amiga depuis 
      toujours.}
}

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

@MISC{Gueheneuc15-WebZine-Multimedia,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {june},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {L'Amiga m�ne le bal dans les pr�sentations multim�dias 
      interactives (Traduction)},
   YEAR         = {2015},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/amiga_presentations_multimedias_interactives.php},
   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.}
}

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-DevCon92,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {janvier},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Reportage : DevCon Commodore 1992 au Royaume-Uni 
      (Traduction)},
   YEAR         = {2015},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/devcon1992_royaumeuni.php},
   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.}
}

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.

@MISC{Gueheneuc15-WebZine-LorenEyrich,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {f�vrier},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Reportage : Loren Eyrich voyage avec un Amiga 
      (Traduction)},
   YEAR         = {2015},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/loreneyrich_voyage_amiga.php},
   ABSTRACT     = {Loren Eyrich pr{\'e}f{\`e}re les routes "moins 
      fr{\'e}quent{\'e}es" au sens propre comme au figur{\'e}.}
}

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

@MISC{Gueheneuc15-WebZine-AmigaInNASchools,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {mars},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Reportage : l'Amiga dans les �coles nord-am�ricaines 
      (Traduction)},
   YEAR         = {2015},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/amiga_ecoles_americaines.php},
   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.}
}

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-FOTAQ,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {mars},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Test de Flight Of The Amazon Queen},
   YEAR         = {2015},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/flightoftheamazonqueen.php},
   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 !}
}

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{Sakti15-Demo-SBST,
   AUTHOR       = {Abdelilah Sakti and Gilles Pesant and 
      Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {May},
   NOTE         = {Tool demo at the 8<sup>th</sup> ICSE International Workshop on Search-Based Software Testing. 4 pages.},
   TITLE        = {JTExpert at the Third Unit Testing Tool Competition},
   YEAR         = {2015},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <i>SBST</i>},
   PAGES        = {52--55},
   URL          = {http://www.ptidej.net/publications/documents/SBST15ToolDemo.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SBST15ToolDemo.ppt.pdf},
   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.}
}

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.

@PROCEEDINGS{APSEC14,
   TITLE        = {Proceedings of the 21<sup>th</sup> Asia-Pacific Software 
      Engineering Conference},
   YEAR         = {2014},
   OPTADDRESS   = {},
   EDITOR       = {Yann-Ga�l Gu�h�neuc and Gi-hwon Kwon},
   MONTH        = {December},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {}
}

@INCOLLECTION{Khomh14-EMSL-PQMOD,
   AUTHOR       = {Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol and Di Penta, Massimiliano},
   BOOKTITLE    = {�volution et maintenance des syst�mes logiciels (EMSL)},
   PUBLISHER    = {�ditions Lavoisier},
   TITLE        = {Mod�les de qualit� et conception des programmes},
   YEAR         = {2014},
   OPTADDRESS   = {},
   CHAPTER      = {3},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {Abdelhak-Djamel Seriai},
   MONTH        = {avril},
   NOTE         = {Hermes Science. Trait� IC2, s�rie Informatique et Syst�mes d'Information. 32 pages.},
   OPTNUMBER    = {},
   PAGES        = {85--116},
   OPTSERIES    = {},
   OPTTYPE      = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, 
      Topic: <b>Design patterns</b>, Venue: <b>EMSL</b>},
   URL          = {http://www.ptidej.net/publications/documents/EMSL14.doc.pdf},
   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 QMOOD 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 DEQUALIT{\'E} et son instantiation, 
      PQMOD, 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 
      DEQUALIT{\'E} 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 DEQUALIT{\'E} 
      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} PQMOD. 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 PQMOD sur 
      trois programmes dont le code source est libre. Nous montrons ainsi 
      les bonnes performances de PQMOD, 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 PQMOD avec deux mod{\`e}les 
      pr{\'e}c{\'e}dents et montrons ainsi que PQMOD 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 DEQUALIT{\'E} 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 PQMOD, 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.}
}

\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 QMOOD 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 DEQUALITÉ et son instantiation, PQMOD, 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 DEQUALITÉ 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 DEQUALITÉ 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é PQMOD. 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 PQMOD sur trois programmes dont le code source est libre. Nous montrons ainsi les bonnes performances de PQMOD, 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 PQMOD avec deux modèles précédents et montrons ainsi que PQMOD 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 DEQUALITÉ 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 PQMOD, 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{Arnaoudova14-TSE-REPENT,
   AUTHOR       = {Venera Arnaoudova and Laleh Mousavi Eshkevari and 
      Di Penta, Massimiliano and Rocco Oliveto and Giuliano Antoniol and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {REPENT: Analyzing the Nature of Identifier Renamings},
   YEAR         = {2014},
   MONTH        = {May},
   NOTE         = {30 pages.},
   NUMBER       = {5},
   PAGES        = {502--532},
   VOLUME       = {40},
   EDITOR       = {Harald Gall},
   KEYWORDS     = {Topic: <b>Identifier analysis</b>, Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE14.doc.pdf},
   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.}
}

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.

@ARTICLE{Jaafar13-JSME-MacroCoChanges,
   AUTHOR       = {Fehmi Jaafar and Yann-Ga�l Gu�h�neuc and 
      Guiliano Antoniol and Sylvie Hamel},
   JOURNAL      = {Journal of Software Maintenance and Evolution: Research and Practice (JSME)},
   TITLE        = {Detecting Asynchrony and Dephase Change Patterns by 
      Mining Software Repositories},
   YEAR         = {2014},
   MONTH        = {January},
   NOTE         = {29 pages.},
   NUMBER       = {1},
   PAGES        = {77--106},
   VOLUME       = {26},
   EDITOR       = {Denys Poshyvanyk and Martin Pinzger},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>JSME</b>, 
      Venue: <b>JSEP</b>},
   PUBLISHER    = {Wiley},
   URL          = {http://www.ptidej.net/publications/documents/JSME13.doc.pdf}
}

@ARTICLE{Jaafar14-ECEASST-AntipatternRelationships,
   AUTHOR       = {Fehmi Jaafar and Yann-Ga�l Gu�h�neuc and Sylvie Hamel and 
      Foutse Khomh},
   JOURNAL      = {Electronic Communications of the EASST (ECEASST)},
   TITLE        = {Analysing Anti-patterns Static Relationships with Design 
      Patterns},
   YEAR         = {2014},
   MONTH        = {August},
   NOTE         = {26 pages.},
   OPTNUMBER    = {},
   OPTPAGES     = {},
   VOLUME       = {59},
   EDITOR       = {Aminata Saban� and Wei Wu and Tiziana Margaria and 
      Julia Padberg and Gabriele Taentzer},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <b>ECEASST</b>},
   PUBLISHER    = {European Association of Software Science and Technology},
   URL          = {http://www.ptidej.net/publications/documents/ECEASST14.doc.pdf},
   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.}
}

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.

@ARTICLE{Medini14-JSEP-SCAN,
   AUTHOR       = {Soumaya Medini and Venera Arnaoudova and 
      Di Penta, Massimiliano and Giulian Antoniol and Yann-Ga�l Gu�h�neuc and 
      Paolo Tonella},
   JOURNAL      = {Journal of Software: Evolution and Process (JSEP)},
   TITLE        = {SCAN: An Approach to Label and Relate Execution Trace 
      Segments},
   YEAR         = {2014},
   MONTH        = {November},
   NOTE         = {33 pages.},
   NUMBER       = {11},
   PAGES        = {962--995},
   VOLUME       = {26},
   EDITOR       = {Rocco Oliveto and Denys Poshyvanyk},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <b>JSME</b>, Venue: <b>JSEP</b>},
   PUBLISHER    = {Wiley},
   URL          = {http://www.ptidej.net/publications/documents/JSEP14.doc.pdf},
   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.}
}

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.

@ARTICLE{Palma14-IJCIS-SOAAntipatternsDetection,
   AUTHOR       = {Francis Palma and Mathieu Nayrolles and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc and Benoit Baudry and Jean-Marc J�z�quel},
   JOURNAL      = {International Journal of Cooperative Information Systems (IJCIS)},
   TITLE        = {SOA Antipatterns: An Approach for their Specification 
      and Detection},
   YEAR         = {2014},
   MONTH        = {March},
   NOTE         = {31 pages.},
   NUMBER       = {1},
   OPTPAGES     = {},
   VOLUME       = {23},
   EDITOR       = {Mike P. Papazoglou and Gunter Schlageter},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <b>IJCIS</b>},
   PUBLISHER    = {World Scientific Publishing},
   URL          = {http://www.ptidej.net/publications/documents/IJCIS14.doc.pdf},
   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\%.}
}

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

@ARTICLE{Sakti14-TSE-JTExpert,
   AUTHOR       = {Abdelilah Sakti and Gilles Pesant and 
      Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {Instance Generator and Problem Representation to Improve 
      Object Oriented Code Coverage},
   YEAR         = {2014},
   MONTH        = {October},
   NOTE         = {22 pages.},
   NUMBER       = {99},
   PAGES        = {1--22},
   VOLUME       = {40},
   EDITOR       = {Matthew B. Dwyer},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE14b.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Bavota14-CSMR-WCRE-ClassRefactoringNashEquilibria,
   AUTHOR       = {Gabriele Bavota and Rocco Oliveto and De Lucia, Andrea and 
      Andrian Marcus and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> CSMR-WCRE Software Evolution Week (CSMR-WCRE)},
   TITLE        = {In Medio Stat Virtus: Extract Class Refactoring through 
      Nash Equilibria},
   YEAR         = {2014},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Dave Binkley and Filippo Ricca},
   MONTH        = {February},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {214--223},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>CSMR-WCRE</c>, Venue: <c>CSMR</c>, Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR-WCRE14.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR-WCRE14.ppt.pdf},
   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.}
}

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{Jaafar14-QSIC-AntiPatternMutations,
   AUTHOR       = {Fehmi Jaafar and Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Mohammad Zulkernine},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> International Conference on Quality Software (QSIC)},
   TITLE        = {Anti-pattern Mutations and Fault-proneness},
   YEAR         = {2014},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Bruce McMillin},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {246--255},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>QSIC</c>},
   URL          = {http://www.ptidej.net/publications/documents/QSIC14.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/QSIC14.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Linares-Vasquez14-ICPC-DomainMatters,
   AUTHOR       = {Mario Linares-V�squez and Sam Klock and Collin McMillan and 
      Aminata Saban� and Denys Poshyvanyk and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 22<sup>nd</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Domain Matters: Bringing Further Evidence of the 
      Relationships among Anti-patterns, Application Domains, and 
      Quality-related Metrics in Java Mobile Apps},
   YEAR         = {2014},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Andrew Begel and Leon Moonen},
   MONTH        = {June},
   NOTE         = {11 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {232--243},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC14.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC14.ppt.pdf},
   ABSTRACT     = {Some previous work began studying the relationship 
      between application domains and quality, in particular through the 
      prevalence of Topic: <b>Code and design smells</b> (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.}
}

Some previous work began studying the relationship between application domains and quality, in particular through the prevalence of Topic: 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.

@INPROCEEDINGS{Lozano14-IWSC-ClonesMacroCochanges,
   AUTHOR       = {Angela Lozano and Fehmi Jaafar and Kim Mens and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 8<sup>th</sup> International Workshop on Software Clones (IWSC)},
   TITLE        = {Clones and Macro Co-changes},
   YEAR         = {2014},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Nils G�de and Yoshiki Higo},
   MONTH        = {February},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {Electronic Communications of the EASST},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <i>IWSC</i>},
   URL          = {http://www.ptidej.net/publications/documents/IWSC14.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/IWSC14.ppt.pdf},
   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.}
}

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{Palma14-SOCA-ServiceAntiPatternChangeProneness,
   AUTHOR       = {Francis Palma and Le An and Foutse Khomh and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 7<sup>th</sup> International Conference on Service-Oriented Computing and Applications (SOCA)},
   TITLE        = {Investigating the Change-Proneness of Service Patterns 
      and Antipatterns},
   YEAR         = {2014},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Christian Huemer},
   MONTH        = {November},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--8},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>SOCA</c>},
   URL          = {http://www.ptidej.net/publications/documents/SOCA14.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SOCA14.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Palma14-ICSOC-SOAAntiPatternsWebServices,
   AUTHOR       = {Francis Palma and Johann Dubois and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 12<sup>th</sup> International Conference on Service Oriented Computing (ICSOC)},
   TITLE        = {Detection of REST Patterns and Antipatterns: A 
      Heuristics-based Approach},
   YEAR         = {2014},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Xavier Franch and Aditya Ghose and Grace Lewis},
   MONTH        = {November},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {230--244},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC14.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC14.ppt.pdf},
   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.}
}

\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{Palma14-ECSA-SOAAntiPatternsWebServices,
   AUTHOR       = {Francis Palma and Naouel Moha and Guy Tremblay and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 8<sup>th</sup> European Conference on Software Architecture (ECSA)},
   TITLE        = {Specification and Detection of SOA Antipatterns in Web 
      Services},
   YEAR         = {2014},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Paris Avgeriou},
   MONTH        = {August},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {58--73},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ECSA</c>},
   URL          = {http://www.ptidej.net/publications/documents/ECSA14.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ECSA14.ppt.pdf},
   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\%.}
}

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

@MISC{Gueheneuc14-WebZine-ArtEffectTouchingUp,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {f�vrier},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {En pratique : Art Effect 4 - retoucher une image 
      (trottoir) (Traduction)},
   YEAR         = {2014},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/arteffect_retouches_trottoir.php},
   ABSTRACT     = {Dans ce tutoriel, vous allez retoucher un trottoir en 
      face d'un bar et le remplacer par une plage de galets.}
}

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�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {d�cembre},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Andrew Morris (Traduction)},
   YEAR         = {2014},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwmorris.php},
   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.}
}

À 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-AustralianRoadshow,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {janvier},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Bill McEwen et Dick Van Dyke (Traduction)},
   YEAR         = {2014},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwmcewen_vandyke.php},
   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.}
}

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.

@MISC{Gueheneuc14-WebZine-InterviewPlatt,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {octobre},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Randy Platt (Traduction)},
   YEAR         = {2014},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwplatt.php},
   ABSTRACT     = {Voici une entrevue avec Randy Platt, programmeur de jeux 
      vid{\'e}o chez Cinemaware (1987-1991).}
}

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

@MISC{Gueheneuc14-WebZine-InterviewMical,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {juillet},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Entrevue avec Robert J. Mical (Traduction)},
   YEAR         = {2014},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/itwmical.php},
   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.}
}

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-CES86,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {avril},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Reportage : Consumer Electronic Show Summer 1986 
      (Traduction)},
   YEAR         = {2014},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/ces_ete_1986.php},
   ABSTRACT     = {Retour sur le Consumer Electronic Show Summer 1986, un 
      salon informatique qui s'est tenu en juin 1986.}
}

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

@MISC{Wu14-Demo-SCAM-ACUA,
   AUTHOR       = {Wei Wu and Bram Adams and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   OPTHOWPUBLISHED = {},
   MONTH        = {September},
   NOTE         = {Tool demo at the 14<sup>th</sup> International Working Conference on Source Code Analysis and Manipulation. 6 pages.},
   TITLE        = {ACUA: API Change and Usage Auditor},
   YEAR         = {2014},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>SCAM</c>},
   URL          = {http://www.ptidej.net/publications/documents/SCAM14ToolDemo.doc.pdf},
   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.}
}

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.

@PROCEEDINGS{ICSM13,
   TITLE        = {Proceedings of the 29<sup>th</sup> International 
      Conference on Software Maintenance},
   YEAR         = {2013},
   OPTADDRESS   = {},
   EDITOR       = {Yann-Ga�l Gu�h�neuc and Tom Mens},
   MONTH        = {September},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {}
}

@ARTICLE{Ali13-TSE-Trustrace,
   AUTHOR       = {Nasir Ali and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {Trustrace: Mining Software Repositories to Improve the 
      Accuracy of Requirement Traceability Links},
   YEAR         = {2013},
   MONTH        = {May},
   NOTE         = {20 pages.},
   NUMBER       = {5},
   PAGES        = {725--741},
   VOLUME       = {39},
   EDITOR       = {Tetsuo Tamai},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE13a.doc.pdf},
   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.}
}

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{Guerrouj13-EMSE-TIDIER,
   AUTHOR       = {Latifa Guerrouj and Di Penta, Massimiliano and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {An Experimental Investigation on the Effects of Context 
      on Source Code Identifiers Splitting and Expansion},
   YEAR         = {2013},
   MONTH        = {July},
   NOTE         = {45 pages.},
   NUMBER       = {6},
   PAGES        = {1--48},
   VOLUME       = {19},
   EDITOR       = {Victor R. Basili and Lionel C. Briand},
   KEYWORDS     = {Topic: <b>Identifier analysis</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE13.doc.pdf},
   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.}
}

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.

@ARTICLE{Kpodjedo13-TSE-MADMatch,
   AUTHOR       = {S�gla Kpodjedo and Filippo Ricca and Philippe Galinier and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {MADMatch: Many-to-many Approximate Diagram Matching for 
      Design Comparison},
   YEAR         = {2013},
   MONTH        = {February},
   NOTE         = {23 pages.},
   NUMBER       = {8},
   PAGES        = {1090--1111},
   VOLUME       = {39},
   EDITOR       = {Martin Robillard},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE13b.doc.pdf},
   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.}
}

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.

@ARTICLE{Kpodjedo13-JSME-ETGMEvolution,
   AUTHOR       = {S�gla Kpodjedo and Filippo Ricca and Philippe Galinier and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Software Maintenance and Evolution: Research and Practice (JSME)},
   TITLE        = {Studying Software Evolution of Large Object-oriented 
      Software Systems using an ETGM Algorithm},
   YEAR         = {2013},
   MONTH        = {September},
   NOTE         = {28 pages.},
   NUMBER       = {2},
   PAGES        = {139--163},
   VOLUME       = {25},
   EDITOR       = {Gerardo Canfora and David Raffo and Darren Dalcher},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>JSME</b>, 
      Venue: <b>JSEP</b>},
   PUBLISHER    = {Wiley},
   URL          = {http://www.ptidej.net/publications/documents/JSME10.doc.pdf},
   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.}
}

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{Joyal13-JMIRResProtoc,
   AUTHOR       = {Joyal Miranda and Jos� C�t� and Gaston Godin and 
      Martin Blais and Joanne Otis and Yann-Ga�l Gu�h�neuc and Ghayas Fadel and 
      Luisa Barton and Shawn Fowler},
   JOURNAL      = {JMIR Research Protocols},
   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},
   YEAR         = {2013},
   MONTH        = {October},
   NOTE         = {8 pages.},
   NUMBER       = {2},
   PAGES        = {e39},
   VOLUME       = {2},
   EDITOR       = {Gunther Eysenbach},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <b>JMIR</b>},
   PUBLISHER    = {Journal of Medical Internet Research},
   URL          = {http://www.ptidej.net/publications/documents/JMIRResProtoc13.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Arnaoudova13-CSMR-LinguisticAntipatterns,
   AUTHOR       = {Venera Arnaoudova and Di Penta, Massimiliano and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 17<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {A New Family of Software Anti-Patterns: Linguistic 
      Anti-Patterns},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Anthony Cleve and Filippo Ricca},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {187--196},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Identifier analysis</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR13d.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR13d.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{DaSilvaJr13-PPAP-SecurityPatterns,
   AUTHOR       = {Da Silva, Luis Sergio and Yann-Ga�l Gu�h�neuc and 
      John Mullins},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> International Workshop on Patterns Promotion and Anti-patterns Prevention (PPAP)},
   TITLE        = {An Approach to Formalise Security Patterns},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Surafel Lemma Abebe and Venera Arnaoudova and 
      Laleh Mousavi Eshkevari and Aminata Saban� and Wei Wu},
   MONTH        = {March},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {�PM},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <i>PPAP</i>},
   URL          = {http://www.ptidej.net/publications/documents/PPAP13b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/PPAP13b.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Duclos13-CSMR-ACRE,
   AUTHOR       = {�tienne Duclos and Le Digabel, S�bastien and 
      Yann-Ga�l Gu�h�neuc and Bram Adams},
   BOOKTITLE    = {Proceedings of the 17<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {ACRE: An Automated Aspect Creator for Testing C++ 
      Applications},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Anthony Cleve and Filippo Ricca},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {121--130},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR13b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR13b.ppt.pdf},
   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.}
}

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{Jaafar13-PPAP-AntipatternDependencies,
   AUTHOR       = {Fehmi Jaafar and Yann-Ga�l Gu�h�neuc and Sylvie Hamel},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> International Workshop on Patterns Promotion and Anti-patterns Prevention (PPAP)},
   TITLE        = {Analysing Anti-patterns Static Relationships with Design 
      Patterns},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Surafel Lemma Abebe and Venera Arnaoudova and 
      Laleh Mousavi Eshkevari and Aminata Saban� and Wei Wu},
   MONTH        = {March},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {�PM},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Topic: <b>Design patterns</b>, Venue: <i>PPAP</i>},
   URL          = {http://www.ptidej.net/publications/documents/PPAP13a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/PPAP13a.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and Sylvie Hamel and 
      Foutse Khomh},
   BOOKTITLE    = {Proceedings of the 20<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {Mining the Relationship Between Anti-patterns 
      Dependencies and Fault-proneness},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rocco Oliveto and Romain Robbes},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE13c.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE13c.ppt.pdf},
   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.}
}

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{Jaafar13-CSMR-MacroCoChangeBugProneness,
   AUTHOR       = {Fehmi Jaafar and Salima Hassaine and Yann-Ga�l Gu�h�neuc and 
      Sylvie Hamel and Bram Adams},
   BOOKTITLE    = {Proceedings of the 17<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {On the Relationship Between Program Evolution and 
      Fault-proneness: An Empirical Study},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Anthony Cleve and Filippo Ricca},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {15--24},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR13c.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR13c.ppt.pdf},
   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.}
}

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{Palma13-MRIBP-BPELAntipatterns,
   AUTHOR       = {Francis Palma and Naouel Moha and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> Workshop on Methodologies for Robustness Injection into Business Processes (MRI-BP)},
   TITLE        = {Detection of Process Antipatterns: A BPEL Perspective},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Hafedh Mili and Yasmine Charif and Emily Liu},
   MONTH        = {September},
   NOTE         = {5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <i>MRI-BP</i>},
   URL          = {http://www.ptidej.net/publications/documents/MRIBP13.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MRIBP13.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Sabane13-CSMR-CostUnitTestAntipatterns,
   AUTHOR       = {Aminata Saban� and Di Penta, Massimiliano and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 17<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {A Study on the Relation Between Antipatterns and the 
      Cost of Class Unit Testing},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Anthony Cleve and Filippo Ricca},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {167--176},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR13a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR13a.ppt.pdf},
   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.}
}

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{Sakti13-CPAIOR-ConstraintFitness,
   AUTHOR       = {Abdelilah Sakti and Yann-Ga�l Gu�h�neuc and 
      Gilles Pesant},
   BOOKTITLE    = {Proceedings of the 10<sup>th</sup> International Conference on Integration of Artificial Intelligence and Operations Research in Constraint Programming (CPAIOR)},
   TITLE        = {Constraint-based Fitness Function for Search-Based 
      Software Testing},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Carla Gomes and Meinolf Sellmann},
   MONTH        = {May},
   NOTE         = {Short paper. 4 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {378--385},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, 
      Venue: <c>CPAIOR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CPAIOR13.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CPAIOR13.ppt.pdf},
   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.}
}

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{Sharafi13-ICPC-EfficiencyTextvsGraph,
   AUTHOR       = {Zohreh Sharafi and Alessandro Marchetto and Angelo Susi and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 21<sup>st</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {An Empirical Study on the Efficiency of Graphical vs. 
      Textual Representations in Requirements Comprehension},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Denys Poshyvanyk and Di Penta, Massimiliano},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC13.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC13.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Soh13-WCRE-MatchingEffortTasks,
   AUTHOR       = {Z�phyrin Soh and Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 20<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {Towards Understanding How Developers Spend Their Effort 
      During Maintenance Activities},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rocco Oliveto and Romain Robbes},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {152--161},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE13b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE13b.ppt.pdf},
   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.}
}

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�phyrin Soh and Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol and Bram Adams},
   BOOKTITLE    = {Proceedings of the 20<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {On the Effect of Program Exploration on Maintenance 
      Tasks},
   YEAR         = {2013},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rocco Oliveto and Romain Robbes},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {391--400},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE13a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE13a.ppt.pdf},
   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.}
}

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.

@TECHREPORT{Soh13-TR-MylynInteractionHistories,
   AUTHOR       = {Z�phyrin Soh and Yann-Ga�l Gu�h�neuc},
   INSTITUTION  = {�cole Polytechnique de Montr�al},
   TITLE        = {Towards the exploration strategies by mining Mylyn's 
      interaction histories},
   YEAR         = {2013},
   OPTADDRESS   = {},
   MONTH        = {February},
   NOTE         = {24 pages.},
   NUMBER       = {EPM-RT-2013-01},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+MylynIH+Mar13.doc.pdf},
   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.}
}

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.

@TECHREPORT{Wu13-TR-HALO,
   AUTHOR       = {Wei Wu and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol and 
      Miryung Kim},
   INSTITUTION  = {�cole Polytechnique de Montr�al},
   TITLE        = {Halo: A Multi-feature Two-pass Analysis to Identify 
      Framework API Evolution},
   YEAR         = {2013},
   OPTADDRESS   = {},
   MONTH        = {June},
   NOTE         = {24 pages.},
   NUMBER       = {EPM-RT-2013-05},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+HALO+June13.doc.pdf},
   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.}
}

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.

@MISC{Gueheneuc13-WebZine-Comparatifs,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {Mai},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Comparatifs : quelques correctifs AmigaOS 68k 
      (processeur et op�rations sur disque)},
   YEAR         = {2013},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/comparatifs_correctifs_amiga.php},
   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.}
}

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.

@MISC{Gueheneuc13-WebZine-ArtEffectWatermarks,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {ao�t},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {En pratique : Art Effect 4 - r�aliser des filigranes 
      (Traduction)},
   YEAR         = {2013},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/arteffect_filigranes.php},
   ABSTRACT     = {Dans ce tutoriel, vous allez apprendre comment faire des 
      filigranes.}
}

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

@MISC{Gueheneuc13-WebZine-GeekGadgetsInstallation,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {janvier},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Installation de Geek Gadgets sur AmigaOS 3.x},
   YEAR         = {2013},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/installation_geek_gadgets.php},
   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.}
}

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-LureOfTheTemptress,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {juillet},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Test de Lure Of The Temptress},
   YEAR         = {2013},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/lureofthetemptress.php},
   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...}
}

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{Wu13-CSER-MOFAE,
   AUTHOR       = {Wei Wu and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   OPTHOWPUBLISHED = {},
   MONTH        = {June},
   NOTE         = {Poster at the 2013 Spring Meeting of the Consortium for Software Engineering Research. 24 pages.},
   TITLE        = {MOFAE: Multi-objective Optimization Approach to 
      Framework API Evolution},
   YEAR         = {2013},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <i>CSER</i>},
   URL          = {http://www.ptidej.net/publications/documents/CSER13.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSER13.ppt.pdf},
   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.}
}

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.

@INCOLLECTION{Ali11-SST-FactorImpactingTraceability,
   AUTHOR       = {Nasir Ali and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Software and Systems Traceability (SST)},
   PUBLISHER    = {Springer},
   TITLE        = {Factors Impacting the Inputs of Traceability Recovery 
      Approaches},
   YEAR         = {2012},
   OPTADDRESS   = {},
   CHAPTER      = {7},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {Andrea Zisman and Jane Cleland-Huang},
   MONTH        = {September},
   NOTE         = {28 pages.},
   OPTNUMBER    = {},
   PAGES        = {99--127},
   OPTSERIES    = {},
   OPTTYPE      = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <b>SST</b>},
   URL          = {http://www.ptidej.net/publications/documents/SST11.doc.pdf},
   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.}
}

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.

@ARTICLE{Cote12-TRIALS-EvaluationHIV,
   AUTHOR       = {Jos� C�t� and Gaston Godin and Yann-Ga�l Gu�h�neuc and 
      Genevi�ve Rouleau and Pilar Ramirez-Garcia and Joanne Otis and 
      C�cile Tremblay and Ghayas Fadel},
   JOURNAL      = {Trials Journal (Trials)},
   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},
   YEAR         = {2012},
   MONTH        = {December},
   NOTE         = {27 pages.},
   NUMBER       = {1},
   OPTPAGES     = {},
   VOLUME       = {13},
   EDITOR       = {Doug Altman and Curt Furberg and Jeremy Grimshaw and 
      Peter Rothwell},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <b>Trials</b>},
   PUBLISHER    = {BioMed Central},
   URL          = {http://www.ptidej.net/publications/documents/Trials12.doc.pdf},
   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.}
}

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.

@ARTICLE{Cote12-Telemedecie-AcceptabilityFeasabilityStudy,
   AUTHOR       = {Jos� C�t� and Genevi�ve Rouleau and Gaston Godin and 
      Pilar Ramirez-Garcia and Yann-Ga�l Gu�h�neuc and Georgette Nahas and 
      C�cile Tremblay and Joanne Otis and Annick Hernandez},
   JOURNAL      = {Journal of Telemedecine and Telecare (JTT)},
   TITLE        = {Acceptability and Feasibility Study of a Virtual 
      Intervention to Help Persons Living with HIV Manage their Daily 
      Therapies},
   YEAR         = {2012},
   MONTH        = {October},
   NOTE         = {12 pages.},
   NUMBER       = {7},
   PAGES        = {409--421},
   VOLUME       = {18},
   EDITOR       = {Elizabeth Krupinski},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <b>JTT</b>},
   PUBLISHER    = {Royal Society of Medicine Press},
   URL          = {http://www.ptidej.net/publications/documents/JTT12.doc.pdf},
   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.}
}

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.

@ARTICLE{Khomh11-EMSE-AntiPatternsImpact,
   AUTHOR       = {Foutse Khomh and Di Penta, Massimiliano and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {An Exploratory Study of the Impact of Antipatterns on 
      Class Change- and Fault-Proneness},
   YEAR         = {2012},
   MONTH        = {June},
   NOTE         = {27 pages.},
   NUMBER       = {3},
   PAGES        = {243--275},
   VOLUME       = {17},
   EDITOR       = {Victor R. Basili and Lionel C. Briand},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE11b.doc.pdf},
   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 13 antipatterns in 54 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.}
}

\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 13 antipatterns in 54 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.

@ARTICLE{DeSmet11-SCP-Taupe,
   AUTHOR       = {de Smet, Beno�t and Lorent Lempereur and Zohreh Sharafi and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol and Naji Habra},
   JOURNAL      = {Science of Computer Programming (SCP)},
   TITLE        = {Taupe: Visualising and Analysing Eye-tracking Data},
   YEAR         = {2012},
   MONTH        = {February},
   NOTE         = {2<sup>nd</sup> special issue on Experimental Software and Toolkits. 20 pages.},
   OPTNUMBER    = {},
   PAGES        = {260--278},
   VOLUME       = {79},
   EDITOR       = {van den Brand, Mark},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>SCP</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/SCP11.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Abebe12-WCRE-LBS,
   AUTHOR       = {Surafel Lemma Abebe and Paolo Tonella and 
      Venera Arnaoudova and Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 19<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {Can Lexicon Bad Smells Improve Fault Prediction?},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rocco Oliveto and Denys Poshyvanyk},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {235--244},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE12d.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE12d.ppt.pdf},
   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.}
}

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{Ali12-SCAM-ImprovingBugLocationBCR,
   AUTHOR       = {Nasir Ali and Aminata Saban� and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 12<sup>th</sup> International Working Conference on Source Code Analysis and Manipulation (SCAM)},
   TITLE        = {Improving Bug Location Using Binary Class Relationships},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Mariano Ceccato and Zheng Li},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {174--183},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>, 
      Topic: <b>Requirements and features</b>, Venue: <c>SCAM</c>},
   URL          = {http://www.ptidej.net/publications/documents/SCAM12.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SCAM12.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 28<sup>th</sup> International Conference on Source Maintenance (ICSM)},
   TITLE        = {An Empirical Study on Requirements Traceability Using 
      Eye-Tracking},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Di Penta, Massimiliano and Jonathan I. Maletic},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {191--200},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Topic: <b>Program comprehension</b>, Venue: <c>ICSM</c>, 
      Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM12.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM12.ppt.pdf},
   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}$.}
}

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

@INPROCEEDINGS{Bhattacharya12-SSBSE-ThreadAlignment,
   AUTHOR       = {Neelesh Bhattacharya and El Mahi, Olfat and 
      Etienne Duclos and Giovanni Beltrame and Giuliano Antoniol and 
      Le Digabel, S�bastien and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 4<sup>th</sup> Symposium on Search Based Software Engineering (SSBSE)},
   TITLE        = {Optimizing Threads Schedule Alignments to Expose the 
      Interference Bug Pattern},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Gordon Fraser and de Souza, Jerffeson Teixeira},
   MONTH        = {September},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {90--104},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <c>SSBSE</c>},
   URL          = {http://www.ptidej.net/publications/documents/SSBSE12b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SSBSE12b.ppt.pdf},
   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.}
}

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{Cote12-Medicine20-VIHTAVIEVirtualNursing,
   AUTHOR       = {Jos� C�t� and Genevi�ve Rouleau and Yann-Ga�l Gu�h�neuc and 
      Gaston Godin and Pilar Ramirez-Garcia and Annick Hernandez and 
      G�raldine Martorella and Sylvie Cossette},
   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)},
   TITLE        = {Virtual Nursing Interventions: Tailored Real-Time 
      Support for People Living with a Chronic Health Problem},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   OPTEDITOR    = {},
   MONTH        = {September},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {Medicine 2.0},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <c>Medicine 2.0</c>},
   URL          = {http://www.medicine20congress.com/ocs/index.php/med/med2012/schedConf/presentations},
   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.}
}

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� C�t� and Genevi�ve Rouleau and Yann-Ga�l Gu�h�neuc and 
      Pilar Ramirez-Garcia and Gaston Godin and Joanne Otis and Riyas Fadel and 
      C�cile Tremblay},
   BOOKTITLE    = {Proceedings of the 21<sup>th</sup> Canadian Conference on HIV/Aids Research (CAHR)},
   TITLE        = {HIV-MEDIC Online: Evaluation of a Web-based Intervention 
      to Better Support People Living with HIV (PLHIV) for Taking Their 
      Antiretroviral Therapy},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Pierre C�t� and Jean-Pierre Routy},
   MONTH        = {April},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {Pulsus Group},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <i>CAHR</i>},
   URL          = {http://www.cahr-acrv.ca/english/resources/archive.html},
   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.}
}

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.

@INPROCEEDINGS{Cote12-Medicine20-VIHTAVIESelfManagement,
   AUTHOR       = {Jos� C�t� and Genevi�ve Rouleau and Pilar Ramirez-Garcia and 
      Yann-Ga�l Gu�h�neuc and Gaston Godin and Annick Hernandez},
   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)},
   TITLE        = {VIH-TAVIE: Tailored Virtual Support for Better 
      Self-Management of Antiretroviral Therapy},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   OPTEDITOR    = {},
   MONTH        = {September},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {Medicine 2.0},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <c>Medicine 2.0</c>},
   URL          = {https://www.medicine20congress.org/index.php/med/med2012/paper/view/1118},
   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.}
}

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.

@INPROCEEDINGS{DiPenta12-SEE-PASED,
   AUTHOR       = {Di Penta, Massimiliano and Giuliano Antoniol and 
      Daniel M. German and Yann-Ga�l Gu�h�neuc and Bram Adams},
   BOOKTITLE    = {Proceedings of the 34<sup>th</sup> International Conference on Software Engineering (ICSE)},
   TITLE        = {Five Days of Empirical Software Engineering: the PASED 
      Experience},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Jochen Ludewig and Hausi A. M�ller},
   MONTH        = {June},
   NOTE         = {Software Engineering Education Track. 4 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1255--1258},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Venue: <c>ICSE</c>},
   URL          = {http://www.ptidej.net/publications/documents/SEE12.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SEE12.ppt.pdf},
   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.}
}

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{Guerrouj12-WCRE-TRIS,
   AUTHOR       = {Latifa Guerrouj and Philippe Galinier and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol and Di Penta, Massimiliano},
   BOOKTITLE    = {Proceedings of the 19<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {TRIS: a Fast and Accurate Identifiers Splitting and 
      Expansion Algorithm},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rocco Oliveto and Denys Poshyvanyk},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {103--112},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Identifier analysis</b>, Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE12b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE12b.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Hassaine12-CSMR-ADvISE,
   AUTHOR       = {Salima Hassaine and Yann-Ga�l Gu�h�neuc and Sylvie Hamel and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 16<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {ADvISE: Architectural Decay In Software Evolution},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Tom Mens, Anthony Cleve, Rudolf Ferenc},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {267--276},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR12.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR12.ppt.pdf},
   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.}
}

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{Maiga12-WCRE-SMURF,
   AUTHOR       = {Abdou Maiga and Nasir Ali and Neelesh Bhattacharya and 
      Aminata Saban� and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol and 
      Esma Aimeur},
   BOOKTITLE    = {Proceedings of the 19<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {SMURF: A SVM-based Incremental Anti-pattern Detection 
      Approach},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rocco Oliveto and Denys Poshyvanyk},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {466--475},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE12a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE12a.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Maiga12-ASE-FeedbackAntipatterns,
   AUTHOR       = {Abddou Maiga and Nasir Ali and Neelesh Bhattacharya and 
      Aminata Saban� and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol and 
      Esma Aimeur},
   BOOKTITLE    = {Proceedings of the 27<sup>th</sup> Conference on Automated Software Engineering (ASE)},
   TITLE        = {Support Vector Machines for Anti-pattern Detection},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Tim Menzies and Motoshi Saeki},
   MONTH        = {September},
   NOTE         = {Short paper. 4 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {278--281},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <c>ASE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ASE12.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ASE12.ppt.pdf},
   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.}
}

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{Medini12-WCRE-SCAN,
   AUTHOR       = {Soumaya Medini and Giuliano Antoniol and 
      Yann-Ga�l Gu�h�neuc and Di Penta, Massimiliano and Paolo Tonella},
   BOOKTITLE    = {Proceedings of the 19<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {SCAN: an Approach to Label and Relate Execution Trace 
      Segments},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rocco Oliveto and Denys Poshyvanyk},
   MONTH        = {October},
   NOTE         = {Best paper. 10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {135--144},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE12c.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE12c.ppt.pdf},
   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.}
}

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{Moha12-ICSOC-DetectionSOAAntipatterns,
   AUTHOR       = {Naouel Moha and Francis Palma and Mathieu Nayrolles and 
      Benjamin Joyen Conseil and Yann-Ga�l Gu�h�neuc and Benoit Baudry and 
      Jean-Marc J�z�quel},
   BOOKTITLE    = {Proceedings of the 10<sup>th</sup> International Conference on Service Oriented Computing (ICSOC)},
   TITLE        = {Specification and Detection of SOA Antipatterns},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Chengfei Liu and Heiko Ludwig and Farouk Toumani},
   MONTH        = {November},
   NOTE         = {Runner-up best paper. 15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--16},
   PUBLISHER    = {Springer},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC12.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC12.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Palma12-RSSE-DPR,
   AUTHOR       = {Francis Palma and Hadi Farzin and Yann-Ga�l Gu�h�neuc and 
      Naouel Moha},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> International Workshop on Recommendation Systems for Software (RSSE)},
   TITLE        = {Recommendation System for Design Patterns in Software 
      Development: A DPR Overview},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Walid Maalej and Martin Robillard and Robert J. Walker and 
      Thomas Zimmermann},
   MONTH        = {June},
   NOTE         = {5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>RSSE</i>},
   URL          = {http://www.ptidej.net/publications/documents/RSSE12.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/RSSE12.ppt.pdf},
   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.}
}

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{Sakti12-SSBSE-BoostingSBTwithCBT,
   AUTHOR       = {Abdelilah Sakti and Yann-Ga�l Gu�h�neuc and 
      Gilles Pesant},
   BOOKTITLE    = {Proceedings of the 4<sup>th</sup> Symposium on Search Based Software Engineering (SSBSE)},
   TITLE        = {Boosting Search-Based Testing by using Constraint-based 
      Testing},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Gordon Fraser and de Souza, Jerffeson Teixeira},
   MONTH        = {September},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {213--227},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <c>SSBSE</c>},
   URL          = {http://www.ptidej.net/publications/documents/SSBSE12a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SSBSE12a.ppt.pdf},
   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.}
}

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{Sharafi12-ICPC-MenWomen,
   AUTHOR       = {Zohreh Sharafi and Z�phyrin Soh and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 20<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Women & Men -- Different but Equal: On the Impact of 
      Identifier Style on Source Code Reading},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {van Deursen, Arie and Michael W. Godfrey},
   MONTH        = {June},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {27--36},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC12b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC12b.ppt.pdf},
   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.}
}

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{Soh12-ICPC-StatusExpertise,
   AUTHOR       = {Z�phyrin Soh and Zohreh Sharafi and 
      van den Plas, Bertrand and Cepeda Porras, Gerardo and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 20<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Professional Status and Expertise for UML Class Diagram 
      Comprehension: An Empirical Study},
   YEAR         = {2012},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {van Deursen, Arie and Michael W. Godfrey},
   MONTH        = {June},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {163--172},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC12a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC12a.ppt.pdf},
   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.}
}

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.

@TECHREPORT{Duclos12-TR-ACRE,
   AUTHOR       = {Etienne Duclos and Yann-Ga�l Gu�h�neuc and 
      Le Digabel, S�bastien},
   INSTITUTION  = {Les cahiers du GERAD},
   TITLE        = {ACRE: An Automated Aspect Creator for Testing C++ 
      Applications},
   YEAR         = {2012},
   OPTADDRESS   = {},
   MONTH        = {June},
   NOTE         = {17 pages.},
   NUMBER       = {G-2012-19},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <c>CSMR</c>},
   URL          = {http://goo.gl/kO8zw},
   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.}
}

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.

@MISC{Gueheneuc12-WebZine-CompilePortTHTTPDAmiga,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {juillet},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Compiler/porter THTTPd sur AmigaOS 3.x},
   YEAR         = {2012},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/compiler_thttpd_amiga.php},
   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.}
}

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.

@MISC{Gueheneuc12-WebZine-TestTowerOfBabel,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {d�cembre},
   NOTE         = {Obligement, un magazine en ligne (webzine) d�di� au monde de l'Amiga.},
   TITLE        = {Test de Tower Of Babel},
   YEAR         = {2012},
   KEYWORDS     = {Topic: <b>Retrocomputing</b>, Venue: <c>Obligement</c>},
   URL          = {http://obligement.free.fr/articles/towerofbabel.php},
   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...}
}

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{Nayrolles12-Demo-ICSOC,
   AUTHOR       = {Mathieu Nayrolles and Francis Palma and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {November},
   NOTE         = {Tool demo at the 11<sup>th</sup> International Conference on Service Oriented Computing. 4 pages.},
   TITLE        = {Soda: A Tool Support for the Detection of SOA 
      Antipatterns},
   YEAR         = {2012},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSOC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSOC12ToolDemo.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSOC12ToolDemo.ppt.pdf},
   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.}
}

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.

@ARTICLE{Guerrouj11-JSME-TIDIER,
   AUTHOR       = {Latifa Guerrouj and Di Penta, Massimiliano and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Journal of Software Maintenance and Evolution: Research and Practice (JSME)},
   TITLE        = {TIDIER: An Identifier Splitting Approach using Speech 
      Recognition Techniques},
   YEAR         = {2011},
   MONTH        = {June},
   NOTE         = {24 pages.},
   NUMBER       = {6},
   PAGES        = {575--599},
   VOLUME       = {25},
   EDITOR       = {Rudolf Ferenc and Juan Carlos Due�as},
   KEYWORDS     = {Topic: <b>Identifier analysis</b>, Venue: <b>JSME</b>, 
      Venue: <b>JSEP</b>},
   PUBLISHER    = {Wiley},
   URL          = {http://www.ptidej.net/publications/documents/JSME11.doc.pdf},
   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.}
}

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.

@ARTICLE{Khomh11-JSS-GQMBayesianDesignSmells,
   AUTHOR       = {Foutse Khomh and St�phane Vaucher and 
      Yann-Ga�l Gu�h�neuc and Houari Sahraoui},
   JOURNAL      = {Journal of Software and Systems (JSS)},
   TITLE        = {A GQM-based Method and a Bayesian Approach for the 
      Detection of Code and Design Smells},
   YEAR         = {2011},
   MONTH        = {April},
   NOTE         = {35 pages.},
   NUMBER       = {4},
   PAGES        = {559--572},
   VOLUME       = {84},
   EDITOR       = {van Vliet, Hans},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>JSS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/JSS11.doc.pdf},
   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, GanttProject v1.10.2 and 
      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.}
}

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, GanttProject v1.10.2 and 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.

@ARTICLE{Kpodjedo11-EMSE-DesignEvolutionMetrics,
   AUTHOR       = {S�gla Kpodjedo and Filippo Ricca and Philippe Galinier and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {Design Evolution Metrics for Defect Prediction in Object 
      Oriented Systems},
   YEAR         = {2011},
   MONTH        = {February},
   NOTE         = {34 pages.},
   NUMBER       = {1},
   PAGES        = {141--175},
   VOLUME       = {16},
   EDITOR       = {Simon Poulding and Di Penta, Massimiliano},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE11a.doc.pdf},
   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.}
}

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{Abbes11-CSMR-AntipatternsImpactComprehension,
   AUTHOR       = {Marwen Abbes and Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 15<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {An Empirical Study of the Impact of Two Antipatterns, 
      Blob and Spaghetti Code, On Program Comprehension},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Yiannis Kanellopoulos and Tom Mens},
   MONTH        = {March},
   NOTE         = {Best paper. 10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {181--190},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Topic: <b>Program comprehension</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR11a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR11a.ppt.pdf},
   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.}
}

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-WCRE-Partitioning,
   AUTHOR       = {Nasir Ali and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 18<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {Requirements Traceability for Object Oriented Systems by 
      Partitioning Source Code},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Martin Pinzger and Denys Poshyvanyk},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {45--54},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE11b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE11b.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 19<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Trust-Based Requirements Traceability},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Susan E. Sim and Filippo Ricca},
   MONTH        = {June},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {111--120},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC11c.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC11c.ppt.pdf},
   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>{\textrm{VSM},~\textrm{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>{\textrm{VSM},~\textrm{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>{\textrm{VSM},~\textrm{Histrace}}</sup> 
      improves with statistical significance the precision of the 
      traceability links while also improving recall but without 
      statistical significance.}
}

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

@INPROCEEDINGS{Ali11-ICSM-Miniaturisation,
   AUTHOR       = {Nasir Ali and Wei Wu and Giuliano Antoniol and 
      Di Penta, Massimiliano and Yann-Ga�l Gu�h�neuc and Jane Huffman Hayes},
   BOOKTITLE    = {Proceedings of the 27<sup>th</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {MoMS: Multi-objective Miniaturization of Software},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {James R. Cordy and Paolo Tonella},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {153--162},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>ICSM</c>, Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM11a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM11a.ppt.pdf},
   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, MoMS, 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 MoMS supports optimized 
      miniaturization and helps reduce effort by 77\%, on average, over a 
      manual approach.}
}

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

@INPROCEEDINGS{Belderrar11-CSMR-SubgraphsEvolution,
   AUTHOR       = {Ahmed Belderrar and S�gla Kpodjedo and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol and Philippe Galinier},
   BOOKTITLE    = {Proceedings of the 15<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {Sub-graph Mining: Identifying Micro-architectures in 
      Evolving Object-oriented Software},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Yiannis Kanellopoulos and Tom Mens},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {171--180},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR11b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR11b.ppt.pdf},
   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.}
}

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{Bhattacharya11-SSBSE-DivideByZero,
   AUTHOR       = {Neelesh Bhattacharya and Abdelilah Sakti and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc and Gilles Pesant},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> International Symposium on Search-based Software Engineering (SSBSE)},
   TITLE        = {Divide-by-zero Exceptions Raising via Branch Coverage},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Myra Cohen and Mel � Cinn�ide},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {204--218},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <c>SSBSE</c>},
   URL          = {http://www.ptidej.net/publications/documents/SSBSE11a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SSBSE11a.ppt.pdf},
   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).}
}

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

@INPROCEEDINGS{Bhattacharya11-ICST-P-CSPGAComparisonTestGeneration,
   AUTHOR       = {Neelesh Bhattacharya and Abdelilah Sakti and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc and Gilles Pesant},
   BOOKTITLE    = {Proceedings of the 4<sup>th</sup> International Conference on Software Testing, Verification, and Validation (ICST)},
   TITLE        = {Performance Analysis of Metaheuristic and Constraint 
      Programming Approaches to Generate Structural Test Cases},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Fevzi Belli and Michael Linschulte},
   MONTH        = {March},
   NOTE         = {Poster. 2 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <c>ICST</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICST11.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICST11.ppt.pdf},
   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.}
}

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{Cote11-ISI-SuitablityFeasabilityVirtualNursing,
   AUTHOR       = {Jos� C�t� and Genevi�ve Rouleau and Yann-Ga�l Gu�h�neuc and 
      Gaston Godin and Pilar Ramirez-Garcia and Joanne Otis and 
      Georgette Nahas},
   BOOKTITLE    = {Actes du 1<sup>er</sup> symposium international sur la recherche en intervention en sciences infirmi�res : d�veloppement, �valuation et partage (ISI)},
   TITLE        = {Suitability and Feasability Study of a Virtual Nursing 
      Intervention to Help Person Living with HIV Manage their Daily 
      Therapies},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   OPTEDITOR    = {},
   MONTH        = {avril},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   OPTPUBLISHER = {},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <c>ISI</c>},
   URL          = {http://www.ncbi.nlm.nih.gov/pubmed/23034932}
}

@INPROCEEDINGS{Eshkevari11-MSR-IdentifierRenamingTaxonomy,
   AUTHOR       = {Laleh Mousavi Eshkevari and Venera Arnaoudova and 
      Di Penta, Massimiliano and Rocco Oliveto and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 8<sup>th</sup> Working Conference on Mining Software Repositories (MSR)},
   TITLE        = {An Exploratory Study of Identifier Renamings},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Tao Xie and Thomas Zimmermann},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {33--42},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, Venue: <c>MSR</c>},
   URL          = {http://www.ptidej.net/publications/documents/MSR11.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MSR11.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Hassaine11-ICSM-ChangeImpactSeismology,
   AUTHOR       = {Salima Hassaine and Ferdaous Boughanmi and 
      Yann-Ga�l Gu�h�neuc and Sylvie Hamel and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 27<sup>th</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {A Seismology-inspired Approach for Change Impact 
      Analysis},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {James R. Cordy and Paolo Tonella},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {53--62},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>ICSM</c>, 
      Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM11b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM11b.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and Sylvie Hamel and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 19<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Change Impact Analysis: An Earthquake Metaphor},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Susan E. Sim and Filippo Ricca},
   MONTH        = {June},
   NOTE         = {Poster. 2 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {209--210},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC11a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC11a.ppt.pdf},
   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.}
}

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{Jaafar11-WCRE-MacroCoChange,
   AUTHOR       = {Fehmi Jaafar and Yann-Ga�l Gu�h�neuc and Sylvie Hamel and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 18<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {An Exploratory Study of Macro Co-changes},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Martin Pinzger and Denys Poshyvanyk},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {325--334},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE11a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE11a.ppt.pdf},
   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, Macocha, to identify these concepts in large 
      programs. We apply Macocha 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 Macocha. We thus answer two research questions showing the 
      existence and usefulness of theses concepts and explaining scenarios 
      of hidden dependencies among artefacts.}
}

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, Macocha, to identify these concepts in large programs. We apply Macocha 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 Macocha. We thus answer two research questions showing the existence and usefulness of theses concepts and explaining scenarios of hidden dependencies among artefacts.

@INPROCEEDINGS{Medini11-SSBSE-FastConceptSplitting,
   AUTHOR       = {Soumaya Medini and Philippe Galinier and 
      Di Penta, Massimiliano and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> International Symposium on Search-based Software Engineering (SSBSE)},
   TITLE        = {A Fast Algorithm to Locate Concepts in Execution Traces},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Myra Cohen and Mel � Cinn�ide},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {252--266},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>SSBSE</c>},
   URL          = {http://www.ptidej.net/publications/documents/SSBSE11b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SSBSE11b.ppt.pdf},
   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.}
}

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{Sakti11-JFPC-CPTestGeneration,
   AUTHOR       = {Abdelilah Sakti and Yann-Ga�l Gu�h�neuc and 
      Gilles Pesant},
   BOOKTITLE    = {Actes des 7<sup>e</sup> Journ�es Francophones de Programmation par Contraintes (JFPC)},
   TITLE        = {CP-SST : approche bass�e sur la programmation par 
      contraintes pour le test structurel du logiciel},
   YEAR         = {2011},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Arnaud Lallouet},
   MONTH        = {juin},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {289--298},
   PUBLISHER    = {LIRIS},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Test case generation</b>, Venue: <i>JFPC</i>},
   URL          = {http://www.ptidej.net/publications/documents/JFPC11.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/JFPC11.ppt.pdf},
   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.}
}

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.

@BOOK{Gueheneuc-EUE-PhDThesis,
   PUBLISHER    = {�ditions universitaires europ�ennes},
   TITLE        = {Un cadre pour la tra�abilit� des motifs de conception},
   YEAR         = {2010},
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   ALTEDITOR    = {},
   OPTADDRESS   = {},
   OPTEDITION   = {},
   MONTH        = {June},
   NOTE         = {360 pages.},
   OPTNUMBER    = {},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   URL          = {http://www.yann-gael.gueheneuc.net/Work/PhDThesis/Documents/LongPhDThesisYannGaelGueheneuc.doc.zip},
   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.}
}

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.

@INCOLLECTION{Gueheneuc10-ESE-DesignPatterns,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Encyclopedia of Software Engineering (ESE)},
   PUBLISHER    = {Taylor and Francis Group},
   TITLE        = {Design Patterns: Empirical Studies on the Impact of 
      Design Patterns on Quality},
   YEAR         = {2010},
   OPTADDRESS   = {},
   CHAPTER      = {19},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {Phil Laplante},
   MONTH        = {September},
   NOTE         = {16 pages.},
   OPTNUMBER    = {},
   PAGES        = {204--219},
   OPTSERIES    = {},
   OPTTYPE      = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <b>ESE</b>},
   URL          = {http://www.ptidej.net/publications/documents/ESE10.doc.pdf},
   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.}
}

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.

@INCOLLECTION{Mens10-IEEESoftwareGuestIntroduction,
   AUTHOR       = {Tom Mens and Yann-Ga�l Gu�h�neuc and 
      Juan Fernandez-Ramil and Maja D'Hondt},
   BOOKTITLE    = {IEEE Software},
   PUBLISHER    = {IEEE CS Press},
   TITLE        = {Guest Editorial: Software Evolution},
   YEAR         = {2010},
   OPTADDRESS   = {},
   CHAPTER      = {1},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {Tom Mens and Yann-Ga�l Gu�h�neuc and 
      Juan Fernandez-Ramil and Maja D'Hondt},
   MONTH        = {July--August},
   NOTE         = {4 pages.},
   OPTNUMBER    = {},
   PAGES        = {22--25},
   OPTSERIES    = {},
   OPTTYPE      = {},
   VOLUME       = {27},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, 
      Venue: <b>Software</b>},
   URL          = {http://www.ptidej.net/publications/documents/IEEESoftware10.doc.pdf},
   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.}
}

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.

@ARTICLE{CepedaPorras10-EMSE-UMLNotations,
   AUTHOR       = {Cepeda Porras, Gerardo and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Empirical Software Engineering (EMSE)},
   TITLE        = {An Empirical Study on the Efficiency of Different Design 
      Pattern Representations in UML Class Diagrams},
   YEAR         = {2010},
   MONTH        = {February},
   NOTE         = {29 pages.},
   NUMBER       = {5},
   PAGES        = {493--522},
   VOLUME       = {15},
   EDITOR       = {Lionel Briand},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <b>EMSE</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/EMSE10.doc.pdf},
   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.}
}

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{Cote09-CIN-VirtualIntervention,
   AUTHOR       = {Jos� C�t� and Pilar Ramirez-Garcia and Genevi�ve Rouleau and 
      Diane Saulnier and Yann-Ga�l Gu�h�neuc and Annick Hernandez and 
      Gaston Godin},
   JOURNAL      = {Computers, Informatics, Nursing (CIN)},
   TITLE        = {A Nursing Virtual Intervention: Real-Time Support for 
      Managing Antiretroviral Therapy},
   YEAR         = {2010},
   MONTH        = {January--February},
   NOTE         = {22 pages.},
   NUMBER       = {1},
   PAGES        = {43--51},
   VOLUME       = {29},
   EDITOR       = {Leslie H. Nicoll},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <b>CIN</b>},
   PUBLISHER    = {Lippincott, Williams, and Wilkins},
   URL          = {http://www.ptidej.net/publications/documents/CIN09.doc.pdf},
   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.}
}

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.

@ARTICLE{Gueheneuc10-SQJ-MetricalPtidejSolver,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Jean-Yves Guyomarc'h and 
      Houari Sahraoui},
   JOURNAL      = {Software Quality Journal (SQJ)},
   TITLE        = {Improving Design Pattern Identification: a New Approach 
      and an Exploratory Study},
   YEAR         = {2010},
   MONTH        = {March},
   NOTE         = {21 pages.},
   NUMBER       = {1},
   PAGES        = {145--166},
   VOLUME       = {18},
   EDITOR       = {Rachel Harrison},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <b>SQJ</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/SQJ10.doc.pdf},
   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.}
}

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.

@ARTICLE{Kaczor09-IST-EfficientDPIdentification,
   AUTHOR       = {Olivier Kaczor and Yann-Ga�l Gu�h�neuc and Sylvie Hamel},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {Identification of Design Motifs with Pattern Matching 
      Algorithms},
   YEAR         = {2010},
   MONTH        = {February},
   NOTE         = {16 pages.},
   NUMBER       = {2},
   PAGES        = {152--168},
   VOLUME       = {52},
   EDITOR       = {Claes Wohlin},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST09.doc.pdf},
   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.}
}

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.

@ARTICLE{Moha09-TSE-DECOR,
   AUTHOR       = {Naouel Moha and Yann-Ga�l Gu�h�neuc and Laurence Duchien and 
      Le Meur, Anne-Fran�oise},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {DECOR: A Method for the Specification and Detection of 
      Topic: <b>Code and design smells</b>},
   YEAR         = {2010},
   MONTH        = {January--February},
   NOTE         = {16 pages.},
   NUMBER       = {1},
   PAGES        = {20--36},
   VOLUME       = {36},
   EDITOR       = {Mark Harman},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE09.doc.pdf},
   ABSTRACT     = {Topic: <b>Code and design smells</b> 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 Topic: <b>Code and design smells</b>: (1) DECOR, a 
      method that embodies and defines all the steps necessary for the 
      specification and detection of Topic: <b>Code and design smells</b>; 
      (2) DETEX a detection technique that instantiates this method; and 
      (3) an empirical validation in terms of precision and recall of 
      DETEX. The originality of DETEX 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 DETEX, 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 Xerces v2.7.0, and discuss the precision 
      of these algorithms on 11 open-source systems.}
}

Topic: 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 Topic: Code and design smells: (1) DECOR, a method that embodies and defines all the steps necessary for the specification and detection of Topic: Code and design smells; (2) DETEX a detection technique that instantiates this method; and (3) an empirical validation in terms of precision and recall of DETEX. The originality of DETEX 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 DETEX, 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 Xerces 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�l Gu�h�neuc and 
      Le Meur, Anne-Fran�oise and Laurence Duchien and Alban Tiberghien},
   JOURNAL      = {Formal Aspects of Computing (FAC)},
   TITLE        = {From a Domain Analysis to the Specification and 
      Detection of Topic: <b>Code and design smells</b>},
   YEAR         = {2010},
   MONTH        = {May},
   NOTE         = {23 pages.},
   NUMBER       = {3},
   PAGES        = {345--368},
   VOLUME       = {22},
   EDITOR       = {Jos� Luiz Fiadeiro},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <b>FAC</b>},
   PUBLISHER    = {Springer},
   URL          = {http://www.ptidej.net/publications/documents/FAC09.doc.pdf},
   ABSTRACT     = {Topic: <b>Code and design smells</b> 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.}
}

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

@ARTICLE{Sahraoui10-IST-ImpactMeasurementProgram,
   AUTHOR       = {Houari Sahraoui and Lionel C. Briand and 
      Yann-Ga�l Gu�h�neuc and Olivier Beaurepaire},
   JOURNAL      = {Information and Software Technology (IST)},
   TITLE        = {Investigating the Impact of a Measurement Program on 
      Software Quality},
   YEAR         = {2010},
   MONTH        = {September},
   NOTE         = {10 pages.},
   NUMBER       = {9},
   PAGES        = {923--933},
   VOLUME       = {52},
   EDITOR       = {Claes Wohlin},
   KEYWORDS     = {Topic: <b>Quality models</b>, Venue: <b>IST</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/IST10.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Arnaoudova10-ICSM-ERA-IdentifierEntropy,
   AUTHOR       = {Venera Arnaoudova and Laleh Mousavi Eshkevari and 
      Rocco Oliveto and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 26<sup>th</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {Physical and Conceptual Identifier Dispersion: Measures 
      and Relation to Fault Proneness},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rudolf Ferenc and Denys Poshyvanyk},
   MONTH        = {September},
   NOTE         = {Early Research Achievements Track. Best paper. 5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--5},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Identifier analysis</b>, Venue: <c>ICSM</c>, 
      Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM10a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM10a.ppt.pdf},
   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.}
}

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{Asadi10-SSBSE-ComparisonDistributedArchitectures,
   AUTHOR       = {Fatemeh Asadi and Giuliano Antoniol and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 2<sup>nd</sup> International Symposium on Search Based Software Engineering (SSBSE)},
   TITLE        = {Concept Location with Genetic Algorithms: A Comparison 
      of Four Distributed Architectures},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Lionel Briand},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {153--162},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>SSBSE</c>},
   URL          = {http://www.ptidej.net/publications/documents/SSBSE10.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/SSBSE10.ppt.pdf},
   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.}
}

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 Di Penta, Massimiliano and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {A Heuristic-based Approach to Identify Concepts in 
      Execution Traces},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rudolf Ferenc and Juan Carlos Due�as},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {31--40},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR10a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR10a.ppt.pdf},
   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.}
}

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 De Lucia, Andrea and 
      Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 26<sup>th</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {Playing with Refactoring: Identifying Extract Class 
      Opportunities through Game Theory},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rudolf Ferenc and Denys Poshyvanyk},
   MONTH        = {September},
   NOTE         = {Early Research Achievements Track. 5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--5},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICSM</c>, Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM10b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM10b.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Cote10-ACFAS-ModeVirtuel,
   AUTHOR       = {Jos� C�t� and Genevi�ve Rouleau and Diane Saulnier and 
      C�cile Tremblay and H�l�ne Morin and Pilar Ramirez-Garcia and 
      Yann-Ga�l Gu�h�neuc and Gaston Godin and Joanne Otis},
   BOOKTITLE    = {actes du 78<sup>e</sup> congr�s de l'ACFAS},
   TITLE        = {D�couvrir aujourd'hui, r�inventer demain ! Le mode 
      virtuel : une voie prometteuse pour le soutien des client�les dans 
      l'autogestion de leur condition de sant�},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Christine Thoer and Joseph Levy},
   MONTH        = {mai},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {ACFAS},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <i>ACFAS</i>},
   URL          = {http://www.ptidej.net/publications/documents/ACFAS10.doc.pdf},
   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.}
}

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       = {Di Penta, Massimiliano and Daniel M. German and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 32<sup>nd</sup> International Conference on Software Engineering (ICSE)},
   TITLE        = {An Exploratory Study of the Evolution of Software 
      Licensing},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Prem Devanbu and Sebastian Uchitel},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {145--154},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>ICSE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSE10a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSE10a.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Hassaine10-QUATIC-IDS,
   AUTHOR       = {Salima Hassaine and Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Sylvie Hamel},
   BOOKTITLE    = {Proceedings of the 7<sup>th</sup> International Conference on the Quality of Information and Communications Technology (QUATIC)},
   TITLE        = {IDS: An Immune-inspired Approach for the Detection of 
      Software Design Smells},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Mel � Cinn�ide},
   MONTH        = {September--October},
   NOTE         = {Quality in ICT Reengineering and Refactoring Track. 6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {343--348},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>QUATIC</c>},
   URL          = {http://www.ptidej.net/publications/documents/QUATIC10.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/QUATIC10.ppt.pdf},
   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.}
}

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{Kniesel10-CSMR-DPDX,
   AUTHOR       = {G�nter Kniesel and Alexander Binun and P�ter Hegedus and 
      Lajos Jeno F�l�p and Alexander Chatzigeorgiou and Yann-Ga�l Gu�h�neuc and 
      Nikolaos Tsantalis},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {DPDX -- A Common Exchange Format for Design Pattern 
      Detection Tools},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rudolf Ferenc and Juan Carlos Due�as},
   MONTH        = {March},
   NOTE         = {Short paper. 5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {232--235},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR10b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR10b.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Madani10-CSMR-IdentifiersSpeechRecognition,
   AUTHOR       = {Nioosha Madani and Latifa Guerrouj and 
      Di Penta, Massimiliano and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {Recognizing Words from Source Code Identifiers using 
      Speech Recognition Techniques},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rudolf Ferenc and Juan Carlos Due�as},
   MONTH        = {March},
   NOTE         = {Best paper. 10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {68--77},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Identifier analysis</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR10c.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR10c.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Oliveto10-CSMR-BSplineSmellDetection,
   AUTHOR       = {Rocco Oliveto and Foutse Khomh and Giuliano Antoniol and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> European Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {Numerical Signatures of Antipatterns: An Approach based 
      on B-Splines},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Rudolf Ferenc and Juan Carlos Due�as},
   MONTH        = {March},
   NOTE         = {Short paper. 5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {248--251},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR10d.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR10d.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Wu10-ICSE-AURA,
   AUTHOR       = {Wei Wu and Yann-Ga�l Gu�h�neuc and Giuliano Antoniol and 
      Miryung Kim},
   BOOKTITLE    = {Proceedings of the 32<sup>nd</sup> International Conference on Software Engineering (ICSE)},
   TITLE        = {AURA: A Hybrid Approach to Identify Framework Evolution},
   YEAR         = {2010},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Prem Devanbu and Sebastian Uchitel},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {325--334},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>ICSE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSE10b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSE10b.ppt.pdf},
   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.}
}

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.

@INCOLLECTION{Charest09-NETTechnology-PatternsHardware,
   AUTHOR       = {Luc Charest and Yann-Ga�l Gu�h�neuc and Yousra Tagmouti},
   BOOKTITLE    = {System Level Design with .Net Technology (NET)},
   PUBLISHER    = {CRC Press},
   TITLE        = {Translating Design Pattern Concepts to Hardware Concepts},
   YEAR         = {2009},
   OPTADDRESS   = {},
   CHAPTER      = {4},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   EDITOR       = {El Mostapha Aboulhamid and Fr�d�ric Rousseau},
   MONTH        = {September},
   NOTE         = {25 pages.},
   OPTNUMBER    = {},
   PAGES        = {93--118},
   OPTSERIES    = {},
   OPTTYPE      = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <b>NET</b>},
   URL          = {http://www.ptidej.net/publications/documents/NET09.doc.pdf},
   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.}
}

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.

@ARTICLE{Gueheneuc08-JSSCI-VisionTheory,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {International Journal of Software Science and Computational Intelligence (IJSSCI)},
   TITLE        = {A Theory of Program Comprehension---Joining Vision 
      Science and Program Comprehension},
   YEAR         = {2009},
   MONTH        = {April-June},
   NOTE         = {18 pages.},
   NUMBER       = {2},
   PAGES        = {54--72},
   VOLUME       = {1},
   EDITOR       = {Yingxu Wang},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <b>JSSCI</b>},
   PUBLISHER    = {IGI Global},
   URL          = {http://www.ptidej.net/publications/documents/JSSCI09.doc.pdf},
   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 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 
      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.}
}

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

@ARTICLE{KaYeeNg09-JSME-BehaviouralCreationalIdentification,
   AUTHOR       = {Janice Ka-Yee Ng and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   JOURNAL      = {Journal of Software Maintenance and Evolution: Research and Practice (JSME)},
   TITLE        = {Identification of Behavioral and Creational Design 
      Motifs through Dynamic Analysis},
   YEAR         = {2009},
   MONTH        = {November},
   NOTE         = {30 pages.},
   NUMBER       = {8},
   PAGES        = {597--627},
   VOLUME       = {22},
   EDITOR       = {Maria Tortorella and Aniello Cimitile},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <b>JSME</b>, 
      Venue: <b>JSEP</b>},
   PUBLISHER    = {Wiley},
   URL          = {http://www.ptidej.net/publications/documents/JSME09.doc.pdf},
   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.}
}

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{German09-MSR-CodeSiblings,
   AUTHOR       = {Daniel M. German and Di Penta, Massimiliano and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> Working Conference on Mining Software Repositories (MSR)},
   TITLE        = {Code Siblings: Technical and Legal Implications of 
      Copying Code between Systems},
   YEAR         = {2009},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Michael W. Godfrey and Jim Whitehead},
   MONTH        = {May},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {81--90},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>MSR</c>},
   URL          = {http://www.ptidej.net/publications/documents/MSR09.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/MSR09.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Jeanmart09-ESEM-VisitorImpact,
   AUTHOR       = {S�bastien Jeanmart and Yann-Ga�l Gu�h�neuc and 
      Houari Sahraoui and Naji Habra},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> International Symposium on Empirical Software Engineering and Measurement (ESEM)},
   TITLE        = {Impact of the Visitor Pattern on Program Comprehension 
      and Maintenance},
   YEAR         = {2009},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {James Miller and Rick Selby},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {69--78},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ESEM</c>},
   URL          = {http://www.ptidej.net/publications/documents/ESEM09.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ESEM09.ppt.pdf},
   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.}
}

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{Khomh09-WCRE-CodeSmellsChanges,
   AUTHOR       = {Foutse Khomh and Di Penta, Massimiliano and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 16<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {An Exploratory Study of the Impact of Code Smells on 
      Software Change-proneness},
   YEAR         = {2009},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Giuliano Antoniol and Andy Zaidman},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {75--84},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE09a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE09a.ppt.pdf},
   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 29 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.}
}

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

@INPROCEEDINGS{Khomh09-ICSM-DPRoles,
   AUTHOR       = {Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 25<sup>th</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {Playing Roles in Design Patterns: An Empirical 
      Descriptive and Analytic Study},
   YEAR         = {2009},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kostas Kontogiannis and Tao Xie},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {83--92},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>ICSM</c>, 
      Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM09.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM09.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Khomh09-QSIC-BayesianDD,
   AUTHOR       = {Foutse Khomh and St�phane Vaucher and 
      Yann-Ga�l Gu�h�neuc and Houari Sahraoui},
   BOOKTITLE    = {Proceedings of the 9<sup>th</sup> International Conference on Quality Software (QSIC)},
   TITLE        = {A Bayesian Approach for the Detection of Code and Design 
      Smells},
   YEAR         = {2009},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Choi Byoung-ju},
   MONTH        = {August},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {305--314},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>QSIC</c>},
   URL          = {http://www.ptidej.net/publications/documents/QSIC09.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/QSIC09.ppt.pdf},
   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, GanttProject v1.10.2 and 
      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.}
}

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, GanttProject v1.10.2 and 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.

@INPROCEEDINGS{Vaucher09-WCRE-CurePreventionSmells,
   AUTHOR       = {St�phane Vaucher and Foutse Khomh and Naouel Moha and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 16<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {Tracking Design Smells: Lessons from a Study of God 
      Classes},
   YEAR         = {2009},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Giuliano Antoniol and Andy Zaidman},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {145--154},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Topic: <b>Quality models</b>, Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE09b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE09b.ppt.pdf},
   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. 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.}
}

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

@TECHREPORT{Khomh09-TR-AntipatternsChangeability,
   AUTHOR       = {Foutse Khomh and Di Penta, Massimiliano and 
      Yann-Ga�l Gu�h�neuc and Guiliano Antoniol},
   INSTITUTION  = {�cole Polytechnique de Montr�al},
   TITLE        = {An Exploratory Study of the Impact of Antipatterns on 
      Software Changeability},
   YEAR         = {2009},
   OPTADDRESS   = {},
   MONTH        = {April},
   NOTE         = {15 pages.},
   NUMBER       = {EPM-RT-2009-02},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Topic: <b>Evolution patterns</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+Antipatterns+Changeability+April09.doc.pdf},
   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.}
}

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.

@TECHREPORT{Khomh09-TR-DesignPatternsRoles,
   AUTHOR       = {Foutse Khomh and Yann-Ga�l Gu�h�neuc and 
      Guiliano Antoniol},
   INSTITUTION  = {�cole Polytechnique de Montr�al},
   TITLE        = {An Empirical Descriptive and Analytic Study of Playing 
      Roles in Design Patterns},
   YEAR         = {2009},
   OPTADDRESS   = {},
   MONTH        = {April},
   NOTE         = {15 pages.},
   NUMBER       = {EPM-RT-2009-03},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, 
      Topic: <b>Evolution patterns</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+Design+Patterns+Roles+April09.doc.pdf},
   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.}
}

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-DEQUALITE,
   AUTHOR       = {Foutse Khomh and Naouel Moha and Yann-Ga�l Gu�h�neuc},
   INSTITUTION  = {�cole Polytechnique de Montr�al},
   TITLE        = {DEQUALITE : m�thode de construction de mod�les de 
      qualit� prenant en compte la conception des syst�mes},
   YEAR         = {2009},
   OPTADDRESS   = {},
   MONTH        = {avril},
   NOTE         = {31 pages.},
   NUMBER       = {EPM-RT-2009-04},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Quality models</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+DEQUALITE+April09.doc.pdf},
   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.}
}

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

@INCOLLECTION{Khosravi08-SQM-IssuesQualityModels,
   AUTHOR       = {Khashayar Khosravi and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Software Quality Metrics},
   PUBLISHER    = {ICFAI University Press},
   TITLE        = {On Issues with Software Quality Models},
   YEAR         = {2008},
   OPTADDRESS   = {},
   CHAPTER      = {11},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   OPTEDITOR    = {},
   MONTH        = {January},
   NOTE         = {28 pages.},
   OPTNUMBER    = {},
   PAGES        = {218--235},
   OPTSERIES    = {},
   OPTTYPE      = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, 
      Topic: <b>Design patterns</b>, Venue: <b>SQM</b>},
   URL          = {http://www.ptidej.net/publications/documents/SQM08.doc.pdf},
   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.}
}

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.

@ARTICLE{Gueheneuc07-TSE-MultiLayeredFramework,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {DeMIMA: A Multi-layered Framework for Design Pattern 
      Identification},
   YEAR         = {2008},
   MONTH        = {September},
   NOTE         = {18 pages.},
   NUMBER       = {5},
   PAGES        = {667--684},
   VOLUME       = {34},
   EDITOR       = {Sebastian Elbaum and David S. Rosenblum},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE08.doc.pdf},
   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.}
}

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{Antoniol08-CASCON-ClassificationofChangeReq,
   AUTHOR       = {Giuliano Antoniol and Kamel Ayari and 
      Di Penta, Massimiliano and Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 18<sup>th</sup> IBM Centers for Advanced Studies Conference (CASCON)},
   TITLE        = {Is It a Bug or an Enhancement? A Text-based Approach to 
      Classify Change Requests},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Mark Vigder and Marsha Chechik},
   MONTH        = {October},
   NOTE         = {Most Influential Paper Award at CASCON'18. 15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {23--37},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <i>CASCON</i>},
   URL          = {http://www.ptidej.net/publications/documents/CASCON08.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CASCON08.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and Di Penta, Massimiliano},
   BOOKTITLE    = {Proceedings of the 24<sup>th</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {Reuse or Rewrite: Combining Textual, Static, and Dynamic 
      Analyses to Assess the Cost of Keeping a System Up-to-date},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Hong Mei and Kenny Wong},
   MONTH        = {September--October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {147--156},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>ICSM</c>, Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM08a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM08a.ppt.pdf},
   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.}
}

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{Denier08-ICPC-Mendel,
   AUTHOR       = {Simon Denier and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 16<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Mendel: A Model, Metrics, and Rules to Understand Class 
      Hierarchies},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Ren� Krikhaar and Ralf L�mmel},
   MONTH        = {June},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {143--152},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC08a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC08a.ppt.pdf},
   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.}
}

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{DiPenta08-ICSM-DPRoles,
   AUTHOR       = {Di Penta, Massimiliano and Luigi Cerulo and 
      Yann-Ga�l Gu�h�neuc and Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 24<sup>th</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {An Empirical Study of the Relationships between Design 
      Pattern Roles and Class Change Proneness},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Hong Mei and Kenny Wong},
   MONTH        = {September--October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {217--226},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>ICSM</c>, 
      Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM08b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM08b.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Eaddy08-ICPC-Cerberus,
   AUTHOR       = {Marc Eaddy and Alfred V. Aho and Giuliano Antoniol and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 16<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Cerberus: Tracing Requirements to Source Code Using 
      Information Retrieval, Dynamic Analysis, and Program Analysis},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Ren� Krikhaar and Ralf L�mmel},
   MONTH        = {June},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {53--62},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC08b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC08b.ppt.pdf},
   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.}
}

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{Ghannem08-LMO-AnalyseLogiciels,
   AUTHOR       = {Adnane Ghannem and Salima Hassaine and 
      Yann-Ga�l Gu�h�neuc and Sylvie Hamel},
   BOOKTITLE    = {Actes du 14<sup>e</sup> colloque Langages et Mod�les � Objets (LMO)},
   TITLE        = {L'analyse de logiciels, phylog�nie et histoire},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Mireille Blay-Fornarino},
   MONTH        = {mars},
   NOTE         = {Poster. 2 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {�ditions C�padu�s},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>LMO</c>},
   URL          = {http://www.ptidej.net/publications/documents/LMO08b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/LMO08b.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Hayes08-WCRE-PREREQIR,
   AUTHOR       = {Jane Huffman Hayes and Giuliano Antoniol and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 15<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {Prereqir: Recovering Pre-Requirements via Cluster 
      Analysis},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Andy Zaidman and Di Penta, Massimilano and Ahmed Hassan},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {165--174},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE08.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE08.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Khomh08-CSMR-DPQuality,
   AUTHOR       = {Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 12<sup>th</sup> Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {Do Design Patterns Impact Software Quality Positively?},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Christos Tjortjis and Andreas Winter},
   MONTH        = {April},
   NOTE         = {Short Paper. 5 pages. Most Influential Paper Award.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {274--278},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR08.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR08.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Moha08-FASE-DDDomainAnalysis,
   AUTHOR       = {Naouel Moha and Yann-Ga�l Gu�h�neuc and 
      Le Meur, Anne-Fran�oise and Laurence Duchien},
   BOOKTITLE    = {Proceedings of the 11<sup>th</sup> International Conference on Fundamental Approaches to Software Engineering (FASE)},
   TITLE        = {A Domain Analysis to Specify Design Defects and Generate 
      Detection Algorithms},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Jos� Fiadeiro and Paola Inverardi},
   MONTH        = {March-April},
   NOTE         = {15 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {276--291},
   PUBLISHER    = {Springer-Verlag},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>FASE</c>},
   URL          = {http://www.ptidej.net/publications/documents/FASE08.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/FASE08.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Moha08-ICFCA-RefactoringsDesignDefects,
   AUTHOR       = {Naouel Moha and Amine Mohamed Rouane Hacene and 
      Petko Valtchev and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 4<sup>th</sup> International Conference on Formal Concept Analysis (ICFCA)},
   TITLE        = {Refactorings of Design Defects using Relational Concept 
      Analysis},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Raoul Medina and Sergei Obiedkov},
   MONTH        = {February},
   NOTE         = {18 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {289--304},
   PUBLISHER    = {Springer-Verlag},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>ICFCA</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICFCA08.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICFCA08.ppt.pdf},
   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.}
}

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�l Gu�h�neuc},
   BOOKTITLE    = {Actes du 14<sup>e</sup> colloque Langages et Mod�les � Objets (LMO)},
   TITLE        = {G�n�ration automatique d'algorithmes de d�tection des 
      d�fauts de conception},
   YEAR         = {2008},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Mireille Blay-Fornarino},
   MONTH        = {mars},
   NOTE         = {13 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {93--106},
   PUBLISHER    = {�ditions C�padu�s},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <c>LMO</c>},
   URL          = {http://www.ptidej.net/publications/documents/LMO08a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/LMO08a.ppt.pdf},
   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.}
}

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.

@TECHREPORT{Denier08-TR-DPStateOfTheArt,
   AUTHOR       = {Simon Denier and Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   INSTITUTION  = {DGIGL, �cole Polytechnique Montr�al},
   TITLE        = {Reverse-Engineering the Literature on Design Patterns 
      and Reverse-Engineering},
   YEAR         = {2008},
   OPTADDRESS   = {},
   MONTH        = {October},
   NOTE         = {18 pages.},
   NUMBER       = {EPM-RT-2008-09},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+DP+SotA+October09.doc.pdf},
   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.}
}

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.

@TECHREPORT{Khomh08-TR-EmpStudyDPQuality,
   AUTHOR       = {Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   INSTITUTION  = {University of Montreal},
   TITLE        = {An Empirical Study of Design Patterns and Software 
      Quality},
   YEAR         = {2008},
   OPTADDRESS   = {},
   MONTH        = {january},
   NOTE         = {44 pages.},
   NUMBER       = {1315},
   OPTTYPE      = {},
   EDITOR       = {of Montr�al, University},
   KEYWORDS     = {Topic: <b>Quality models</b>, 
      Topic: <b>Design patterns</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+DP+Quality+January08.doc.pdf},
   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.}
}

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.

@MISC{Moha08-Demo-SATToSE,
   AUTHOR       = {Naouel Moha and Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {February},
   NOTE         = {SATToSE: Seminar on Advanced Tools and Techniques for Software Evolution, Waulsort, Belgium.},
   TITLE        = {Ptidej and DECOR: Identification of Design Patterns and 
      Design Defects},
   YEAR         = {2008},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <i>SATToSE</i>},
   URL          = {http://www.ptidej.net/publications/documents/SATToSE08ToolDemo.ppt.pdf},
   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.}
}

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.

@ARTICLE{Poshyvanyk07-TSE-Promesir,
   AUTHOR       = {Denys Poshyvanyk and Yann-Ga�l Gu�h�neuc and 
      Andrian Marcus and Giuliano Antoniol and V�clav Rajlich},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {Feature Location using Probabilistic Ranking of Methods 
      based on Execution Scenarios and Information Retrieval},
   YEAR         = {2007},
   MONTH        = {June},
   NOTE         = {14 pages.},
   NUMBER       = {6},
   PAGES        = {420--432},
   VOLUME       = {33},
   EDITOR       = {Jeff Kramer},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE07.doc.pdf},
   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.}
}

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{Antoniol07-ICSM-LexiconEvolution,
   AUTHOR       = {Giuliano Antoniol and Yann-Ga�l Gu�h�neuc and 
      Ettore Merlo and Paolo Tonella},
   BOOKTITLE    = {Proceedings of the 23<sup>rd</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {Mining the Lexicon Used by Programmers during Software 
      Evolution},
   YEAR         = {2007},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Ladan Tahvildari and Gerardo Canfora},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {14--23},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Identifier analysis</b>, Venue: <c>ICSM</c>, 
      Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM07.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM07.ppt.pdf},
   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.}
}

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� C�t� and Pilar Ramirez-Garcia and Gaston Godin and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Actes du 2<sup>e</sup> Congr�s international sur la cha�ne des m�dicaments (CICM)},
   TITLE        = {G�rer sa m�dication antir�trovirale avec une assistance 
      en ligne... une approche en cours d'�valuation},
   YEAR         = {2007},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Bernard B�gaud and Pavel Hamet and Andr� Jacques and 
      Vittorio A. Sironi},
   MONTH        = {Octobre},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {Groupe d'�tude sur l'interdisciplinarit� et les repr�sentations sociales},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <c>CICM</c>}
}

@INPROCEEDINGS{Gueheneuc07-EPFPR-PMARt,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> EuroPLoP Focus Group on Pattern Repositories (EPFPR)},
   TITLE        = {PMARt: Pattern-like Micro Architecture Repository},
   YEAR         = {2007},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Michael Weiss and Aliaksandr Birukou and Paolo Giorgini},
   MONTH        = {July},
   NOTE         = {3 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>PLoP</c>},
   URL          = {http://www.ptidej.net/publications/documents/EuroPLoP07PRa.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Gueheneuc07-EPFPR-Recommander,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Rabih Mustapha},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> EuroPLoP Focus Group on Pattern Repositories (EPFPR)},
   TITLE        = {A Simple Recommender System for Design Patterns},
   YEAR         = {2007},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Michael Weiss and Aliaksandr Birukou and Paolo Giorgini},
   MONTH        = {July},
   NOTE         = {2 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>PLoP</c>},
   URL          = {http://www.ptidej.net/publications/documents/EuroPLoP07PRb.doc.pdf},
   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.}
}

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{Khomh07-QAOOSE-DPQuality,
   AUTHOR       = {Foutse Khomh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 11<sup>th</sup> ECOOP workshop on Quantitative Approaches in Object-Oriented Software Engineering (QAOOSE)},
   TITLE        = {Perception and Reality: What are Design Patterns Good 
      For?},
   YEAR         = {2007},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {e Abreu, Fernando Brito and Coral Calero and 
      Yann-Ga�l Gu�h�neuc and Christian Lange and Michele Lanza and 
      Houari A. Sahraoui},
   MONTH        = {July--August},
   NOTE         = {7 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {Springer-Verlag},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, 
      Topic: <b>Design patterns</b>, Venue: <i>QAOOSE</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP07QAOOSE.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ECOOP07QAOOSE.ppt.pdf},
   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.}
}

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{Moha07-WOOR-DesignDefects,
   AUTHOR       = {Naouel Moha and Yann-Ga�l Gu�h�neuc and Laurence Duchien and 
      Le Meur, Anne-Fran�oise},
   BOOKTITLE    = {Proceedings of the 8<sup>th</sup> ECOOP workshop on Object-Oriented Reengineering (WOOR)},
   TITLE        = {Discussion on the Results of the Detection of Design 
      Defects},
   YEAR         = {2007},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Serge Demeyer and Yann-Ga�l Gu�h�neuc and 
      Christian Lange and Kim Mens and Roel Wuyts and St�phane Ducasse},
   MONTH        = {July--August},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <i>WOOR</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP07WOOR.doc.pdf},
   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.}
}

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{KaYeeNg07-PCODA-DynamicDPDetection,
   AUTHOR       = {Janice Ka-Yee Ng and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> International Workshop on Program Comprehension through Dynamic Analysis (PCODA)},
   TITLE        = {Identification of Behavioral and Creational Design 
      Patterns through Dynamic Analysis},
   YEAR         = {2007},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Andy Zaidman and Abdelwahab Hamou-Lhadj and Orla Greevy},
   MONTH        = {October},
   NOTE         = {TUD-SERG-2007-022. 9 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {34--42},
   PUBLISHER    = {Delft University of Technology},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>PCODA</i>},
   URL          = {http://www.ptidej.net/publications/documents/PCODA07.doc.pdf},
   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.}
}

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{Gueheneuc07-Demo-GRASCOMP,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {March},
   NOTE         = {Tool demo at GRASCOMP Graduate School in Computing Science 2007 (COMP013).},
   TITLE        = {Design Pattern Identification in Ptidej},
   YEAR         = {2007},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>GRASCOMP</i>},
   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.}
}

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-WBTShowcase,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {May},
   NOTE         = {Tool demo at the 5<sup>th</sup> World's Best Technologies Showcase.},
   TITLE        = {Ptidej - A Tool Suite},
   YEAR         = {2007},
   KEYWORDS     = {Topic: <b>Design patterns</b>, 
      Topic: <b>Code and design smells</b>, Venue: <i>WBT Showcase</i>},
   PDF          = {http://www.ptidej.net/publications/documents/WBT07ToolDemo.ppt.pdf},
   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.}
}

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�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {October},
   NOTE         = {Tool demo at the 23<sup>rd</sup> International Conference on Software Maintenance.},
   TITLE        = {Ptidej: A Flexible Reverse Engineering Tool Suite},
   YEAR         = {2007},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>ICSM</c>, 
      Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM07ToolDemo.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM07ToolDemo.ppt.pdf},
   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.}
}

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{Moha07-Demo-OOPSLA,
   AUTHOR       = {Naouel Moha and Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {October},
   NOTE         = {Tool demo at the 21<sup>st</sup> International Conference on Object-Oriented Programming, Systems, Languages and Applications.},
   TITLE        = {Ptidej and DECOR: Identification of Design Patterns and 
      Design Defects},
   YEAR         = {2007},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>OOPSLA</c>},
   URL          = {http://www.ptidej.net/publications/documents/OOPSLA07ToolDemo.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/OOPSLA07ToolDemo.ppt.pdf},
   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.}
}

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-ASE,
   AUTHOR       = {Naouel Moha and Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {November},
   NOTE         = {Tool demo at the 22<sup>nd</sup> International Conference on Automated Software Engineering.},
   TITLE        = {Ptidej and DECOR: Identification of Design Patterns and 
      Design Defects},
   YEAR         = {2007},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <c>ASE</c>},
   PDF          = {http://www.ptidej.net/publications/documents/ASE07ToolDemo.ppt.pdf},
   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.}
}

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.

@INCOLLECTION{Gueheneuc05-OODK-DesignPatternLaws,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Jean-Yves Guyomarc'h and 
      Khashayar Khosravi and Houari Sahraoui},
   BOOKTITLE    = {Object-oriented Design Knowledge: Principles, Heuristics, Best Practices (OODK)},
   PUBLISHER    = {Idea Group},
   TITLE        = {Design Patterns as Laws of Quality},
   YEAR         = {2006},
   OPTADDRESS   = {},
   CHAPTER      = {5},
   OPTCROSSREF  = {},
   OPTEDITION   = {},
   OPTEDITOR    = {},
   MONTH        = {January},
   NOTE         = {35 pages.},
   OPTNUMBER    = {},
   PAGES        = {105--142},
   OPTSERIES    = {},
   OPTTYPE      = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, 
      Topic: <b>Design patterns</b>, Venue: <b>OODK</b>},
   URL          = {http://www.ptidej.net/publications/documents/OODK05.doc.pdf},
   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.}
}

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.

@ARTICLE{Antoniol06-TSE-FeatureIdentification,
   AUTHOR       = {Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Transactions on Software Engineering (TSE)},
   TITLE        = {Feature Identification: An Epidemiological Metaphor},
   YEAR         = {2006},
   MONTH        = {September},
   NOTE         = {15 pages.},
   NUMBER       = {9},
   PAGES        = {627--641},
   VOLUME       = {32},
   EDITOR       = {Tibor Gyim�thy and Vaclav Rajlich},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <b>TSE</b>},
   PUBLISHER    = {IEEE CS Press},
   URL          = {http://www.ptidej.net/publications/documents/TSE06.doc.pdf},
   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.}
}

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{Bouktif06-WCRE-MiningCVS,
   AUTHOR       = {Salah Bouktif and Yann-Ga�l Gu�h�neuc and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 13<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {Extracting Change-patterns from CVS Repositories},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Susan Elliott Sim and Di Penta, Massimiliano},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {221--230},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE06.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE06.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Cote06-WebSupportVIH,
   AUTHOR       = {Jos� C�t� and Pilar Ramirez-Garcia and 
      Yann-Ga�l Gu�h�neuc and Xintao Wang and Gaston Godin},
   BOOKTITLE    = {Proceedings of the 15<sup>th</sup> annual Canadian Conference on HIV/Aids Research (CAHR)},
   TITLE        = {Web support for person living with HIV for the immediate 
      management of the treatment},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Gaston Godin and Jean Guy Baril and Jean Pierre Routy},
   MONTH        = {May},
   OPTNOTE      = {},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   OPTPAGES     = {},
   PUBLISHER    = {Pulsus Group},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>VIHTAVIE</b>, Venue: <i>CAHR</i>},
   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.}
}

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�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 16<sup>th</sup> IBM Centers for Advanced Studies Conference (CASCON)},
   TITLE        = {Taupe: Towards Understanding Program Comprehension},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Hakan Erdogmus and Eleni Stroulia},
   MONTH        = {October},
   NOTE         = {13 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {1--13},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <i>CASCON</i>},
   URL          = {http://www.ptidej.net/publications/documents/CASCON06.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CASCON06.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Gueheneuc06-CSMR-REToolsTaxonomy,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Kim Mens and Roel Wuyts},
   BOOKTITLE    = {Proceedings of the 10<sup>th</sup> Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {A Comparative Framework for Design Recovery Tools},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {di Lucca, Giuseppe Antonio and Nicolas Gold},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {121--130},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR06b.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR06b.ppt.pdf},
   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.}
}

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{Kaczor06-CSMR-EfficientIdentification,
   AUTHOR       = {Olivier Kaczor and Yann-Ga�l Gu�h�neuc and Sylvie Hamel},
   BOOKTITLE    = {Proceedings of the 10<sup>th</sup> Conference on Software Maintenance and Reengineering (CSMR)},
   TITLE        = {Efficient Identification of Design Patterns with 
      Bit-vector Algorithm},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {di Lucca, Giuseppe Antonio and Nicolas Gold},
   MONTH        = {March},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {173--182},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>CSMR</c>},
   URL          = {http://www.ptidej.net/publications/documents/CSMR06a.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CSMR06a.ppt.pdf},
   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.}
}

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{Moha06-WOOR-Correction,
   AUTHOR       = {Naouel Moha and Saliha Bouden and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 7<sup>th</sup> ECOOP workshop on Object-Oriented Reengineering (WOOR)},
   TITLE        = {Correction of High-Level Design Defects with 
      Refactorings},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Serge Demeyer and St�phane Ducasse and 
      Yann-Ga�l Gu�h�neuc and Kim Mens and Roel Wuyts},
   MONTH        = {July},
   NOTE         = {4 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <i>WOOR</i>},
   URL          = {http://www.ptidej.net/publications/documents/WOOR06.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Moha06-ASE-P-DDMethod,
   AUTHOR       = {Naouel Moha and Yann-Ga�l Gu�h�neuc and Pierre Leduc},
   BOOKTITLE    = {Proceedings of the 21<sup>st</sup> Conference on Automated Software Engineering (ASE)},
   TITLE        = {Automatic Generation of Detection Algorithms for Design 
      Defects},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Sebastian Uchitel and Steve Easterbrook},
   MONTH        = {September},
   NOTE         = {Short paper. 4 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {297--300},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <c>ASE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ASE06.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ASE06.ppt.pdf},
   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.}
}

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{Moha06-LMO-DefautConception,
   AUTHOR       = {Naouel Moha and Duc-Loc Huynh and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Actes du 12<sup>e</sup> colloque Langages et Mod�les � Objets (LMO)},
   TITLE        = {Une taxonomie et un m�tamod�le pour la d�tection des 
      d�fauts de conception},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Roger Rousseau},
   MONTH        = {mars},
   NOTE         = {16 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {201--216},
   PUBLISHER    = {Herm�s Science Publications},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <c>LMO</c>},
   URL          = {http://www.ptidej.net/publications/documents/LMO06.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/LMO06.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and 
      Petko Valtchev and El Boussaidi, Ghizlane},
   BOOKTITLE    = {Proceedings of the 4<sup>th</sup> International Conference on Concept Lattices and their Applications (CLA)},
   TITLE        = {Using FCA to Suggest Refactorings to Correct Design 
      Defects},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Sadok Ben Yahia and Engelbert Mephu Nguifo},
   MONTH        = {September},
   NOTE         = {Short paper. 6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {297--302},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, Venue: <c>CLA</c>},
   URL          = {http://www.ptidej.net/publications/documents/CLA06.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CLA06.ppt.pdf},
   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.}
}

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{Poshyvanyk06-ICPC-LSIFeature,
   AUTHOR       = {Denys Poshyvanyk and Yann-Ga�l Gu�h�neuc and 
      Andrian Marcus and Giuliano Antoniol and V�clav Rajlich},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> International Conference on Program Comprehension (ICPC)},
   TITLE        = {Combining Probabilistic Ranking and Latent Semantic 
      Indexing for Feature Identification},
   YEAR         = {2006},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Jurgen Ebert and Panos Linos},
   MONTH        = {June},
   NOTE         = {Best paper. 10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {137--148},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>ICPC</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICPC06.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICPC06.ppt.pdf},
   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.}
}

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.

@MISC{Taupe,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {since June},
   NOTE         = {A tool to edit, visualise, and analyse the data collected by eye-trackers during experiments.},
   TITLE        = {Taupe},
   YEAR         = {2006},
   KEYWORDS     = {Topic: <b>Program comprehension</b>},
   URL          = {http://www.ptidej.net/research/programcomprehension/}
}

@MISC{Moha06-Demo-CASCON,
   AUTHOR       = {Naouel Moha and Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {October},
   NOTE         = {Tool demo at the 16<sup>th</sup> IBM Centers for Advanced Studies Conference.},
   TITLE        = {DECOR and Ptidej},
   YEAR         = {2006},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Topic: <b>Design patterns</b>, Venue: <i>CASCON</i>},
   PDF          = {http://www.ptidej.net/publications/documents/CASCON06ToolDemo.ppt.pdf},
   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.}
}

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.

@PROCEEDINGS{WOOR05,
   TITLE        = {Report of the 6<sup>th</sup> international Workshop on 
      Object-Oriented Reengineering (WOOR)},
   YEAR         = {2005},
   OPTADDRESS   = {},
   EDITOR       = {Serge Demeyer and Kim Mens and Roel Wuyts and 
      Yann-Ga�l Gu�h�neuc and Andy Zaidman and Neil Walkinshaw and 
      Ademar Aguiar and St�phane Ducasse},
   MONTH        = {July},
   NOTE         = {12 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PUBLISHER    = {Springer-Verlag},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP05WOORReader.doc.pdf}
}

@INPROCEEDINGS{Antoniol05-ICSM-FeatureIdentification,
   AUTHOR       = {Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 21<sup>st</sup> International Conference on Software Maintenance (ICSM)},
   TITLE        = {Feature Identification: A Novel Approach and a Case 
      Study},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Tibor Gyim�thy and Vaclav Rajlich},
   MONTH        = {September},
   NOTE         = {Best paper. 10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {357--366},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <c>ICSM</c>, Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM05.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ICSM05.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and 
      Ettore Merlo and Houari Sahraoui},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> ICSM workshop on Empirical Studies in Reverse Engineering (WESRE)},
   TITLE        = {Software Evolution: The Need for Empirical Evidence},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Paolo Tonella},
   MONTH        = {September},
   NOTE         = {2 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Evolution patterns</b>, Venue: <i>WESRE</i>},
   URL          = {http://www.ptidej.net/publications/documents/WESRE05.doc.pdf},
   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.}
}

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�l Gu�h�neuc and Houari Sahraoui},
   BOOKTITLE    = {Proceedings of the 3<sup>rd</sup> ASE Workshop on Traceability in Emerging Forms of Software Engineering (TEFSE)},
   TITLE        = {Feature Traceability in Object Oriented Software},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Jonathan I. Maletic and Giuliano Antonio and 
      Jane Cleland-Huang and Jane Huffman Hayes},
   MONTH        = {November},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {73--78},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Requirements and features</b>, 
      Venue: <i>TEFSE</i>},
   URL          = {http://www.ptidej.net/publications/documents/TEFSE05.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/TEFSE05.ppt.pdf},
   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.}
}

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{Guyomarch05-QAOOSE-AspectQuality,
   AUTHOR       = {Jean-Yves Guyomarc'h and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 9<sup>th</sup> ECOOP workshop on Quantitative Approaches in Object-Oriented Software Engineering (QAOOSE)},
   TITLE        = {On the Impact of Aspect-Oriented Programming on 
      Object-Oriented Metrics},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {e Abreu, Fernando Brito and Coral Calero and 
      Michele Lanza and Geert Poels and Houari A. Sahraoui},
   MONTH        = {July},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {42--47},
   PUBLISHER    = {Springer-Verlag},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, Venue: <i>QAOOSE</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP05QAOOSEa.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ECOOP05QAOOSEa.ppt.pdf},
   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.}
}

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{Gueheneuc05-BSUP-Ptidej,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> ECOOP workshop on Building a System using Patterns (BSUP)},
   TITLE        = {Ptidej: Promoting Patterns with Patterns},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Mohamed E. Fayad},
   MONTH        = {July},
   NOTE         = {9 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {Springer-Verlag},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>BSUP</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP05BSUP.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ECOOP05BSUP.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Gueheneuc05-IWDPTP-ExperimentalSetting,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Stefan Monnier and 
      Giuliano Antoniol},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> ICSM workshop in Design Pattern Theory and Practice (IWDPTP)},
   TITLE        = {Evaluating the Use of Design Patterns during Program 
      Comprehension -- Experimental Setting},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Giuliano Antoniol and Yann-Ga�l Gu�h�neuc},
   MONTH        = {September},
   NOTE         = {In the pre-proceedings. 6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>, 
      Venue: <i>IWDPTP</i>},
   URL          = {http://www.ptidej.net/publications/documents/IWDPTP05.doc.pdf},
   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.}
}

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�l Gu�h�neuc and Houari Sahraoui},
   BOOKTITLE    = {Actes du 11<sup>e</sup> colloque Langages et Mod�les � Objets (LMO)},
   TITLE        = {Des signatures num�riques pour am�liorer la recherche 
      structurelle de patrons},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Marianne Huchard and St�phane Ducasse and 
      Oscar Nierstrasz},
   MONTH        = {mars},
   NOTE         = {16 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {97--112},
   PUBLISHER    = {Herm�s Science Publications},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>LMO</c>},
   URL          = {http://www.ptidej.net/publications/documents/LMO05.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/LMO05.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and Tewfik Ziadi},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> ECOOP workshop on Object-Oriented Reengineering (WOOR)},
   TITLE        = {Automated Reverse-Engineering of UML v2.0 Dynamic Models},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Serge Demeyer and St�phane Ducasse and Kim Mens and 
      Roel Wuyts},
   MONTH        = {July},
   NOTE         = {5 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>WOOR</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP05WOORb.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Khosravi05-QAOOSE-QualityIssues,
   AUTHOR       = {Khashayar Khosravi and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 9<sup>th</sup> ECOOP workshop on Quantitative Approaches in Object-Oriented Software Engineering (QAOOSE)},
   TITLE        = {Open Issues with Quality Models},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {e Abreu, Fernando Brito and Coral Calero and 
      Michele Lanza and Geert Poels and Houari A. Sahraoui},
   MONTH        = {July},
   NOTE         = {14 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {Springer-Verlag},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, 
      Topic: <b>Design patterns</b>, Venue: <i>QAOOSE</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP05QAOOSEb.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ECOOP05QAOOSEb.ppt.pdf},
   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.}
}

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�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 6<sup>th</sup> ECOOP workshop on Object-Oriented Reengineering (WOOR)},
   TITLE        = {On the Automatic Detection and Correction of Design 
      Defects},
   YEAR         = {2005},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Serge Demeyer and Kim Mens and Roel Wuyts and 
      St�phane Ducasse},
   MONTH        = {July},
   NOTE         = {7 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <i>WOOR</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP05WOORa.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ECOOP05WOORa.ppt.pdf},
   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.}
}

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.

@TECHREPORT{Gueheneuc05-TR-VisionComprehension,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   INSTITUTION  = {University of Montreal},
   TITLE        = {A Theory of Program Comprehension -- Joining Vision 
      Science and Program Comprehension},
   YEAR         = {2005},
   OPTADDRESS   = {},
   MONTH        = {December},
   NOTE         = {26 pages.},
   NUMBER       = {1267},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Program comprehension</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+Vision+Comprehension+December05.doc.pdf},
   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.}
}

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�l Gu�h�neuc and Jean-Yves Guyomarc'h and 
      Duc-Loc Huynh and Olivier Kaczor and Naouel Moha and Samah Rached},
   OPTHOWPUBLISHED = {},
   MONTH        = {October},
   NOTE         = {Tool demo at the 15<sup>th</sup> IBM Centers for Advanced Studies Conference.},
   TITLE        = {Ptidej - A Tool Suite},
   YEAR         = {2005},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>CASCON</i>},
   PDF          = {http://www.ptidej.net/publications/documents/CASCON05ToolDemo.ppt.pdf},
   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.}
}

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{Gueheneuc04-CASCON-PreciseClassDiagrams,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 14<sup>th</sup> IBM Centers for Advanced Studies Conference (CASCON)},
   TITLE        = {A Reverse Engineering Tool for Precise Class Diagrams},
   YEAR         = {2004},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Janice Singer and Hanan Lutfiyya},
   MONTH        = {October},
   NOTE         = {14 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {28--41},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>, 
      Venue: <i>CASCON</i>},
   URL          = {http://www.ptidej.net/publications/documents/CASCON04.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/CASCON04.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Gueheneuc04-APSEC-SystematicUML,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 11<sup>th</sup> Asia-Pacific Software Engineering Conference (APSEC)},
   TITLE        = {A Systematic Study of UML Class Diagram Constituents for 
      their Abstract and Precise Recovery},
   YEAR         = {2004},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Doo-Hwan Bae and William C. Chu},
   MONTH        = {November-December},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {265--274},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>, 
      Venue: <c>APSEC</c>},
   URL          = {http://www.ptidej.net/publications/documents/APSEC04.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/APSEC04.ppt.pdf},
   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.}
}

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�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 20<sup>th</sup> International Conference and Software Maintenance (ICSM)},
   TITLE        = {Abstract and Precise Recovery of UML Class Diagram 
      Constituents},
   YEAR         = {2004},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Mark Harman and Bogdan Korel},
   MONTH        = {September},
   NOTE         = {Poster. 1 page.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {523},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>, 
      Venue: <c>ICSM</c>, Venue: <c>ICSME</c>},
   URL          = {http://www.ptidej.net/publications/documents/ICSM04.doc.pdf},
   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.}
}

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-OOPSLA-RecoveringBCR,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Herv� Albin-Amiot},
   BOOKTITLE    = {Proceedings of the 19<sup>th</sup> Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA)},
   TITLE        = {Recovering Binary Class Relationships: Putting Icing on 
      the UML Cake},
   YEAR         = {2004},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Doug C. Schmidt},
   MONTH        = {October},
   NOTE         = {14 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {301--314},
   PUBLISHER    = {ACM Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>, 
      Venue: <c>OOPSLA</c>},
   URL          = {http://www.ptidej.net/publications/documents/OOPSLA04.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/OOPSLA04.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and Houari Sahraoui and Farouk Zaidi},
   BOOKTITLE    = {Proceedings of the 11<sup>th</sup> Working Conference on Reverse Engineering (WCRE)},
   TITLE        = {Fingerprinting Design Patterns},
   YEAR         = {2004},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Eleni Stroulia and de Lucia, Andrea},
   MONTH        = {November},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {172--181},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>WCRE</c>},
   URL          = {http://www.ptidej.net/publications/documents/WCRE04.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/WCRE04.ppt.pdf},
   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.}
}

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{Khosravi04-TR-DPQualityModel,
   AUTHOR       = {Khashayar Khosravi and Yann-Ga�l Gu�h�neuc},
   INSTITUTION  = {University of Montreal},
   TITLE        = {A Quality Model for Design Patterns},
   YEAR         = {2004},
   OPTADDRESS   = {},
   MONTH        = {September},
   NOTE         = {94 pages.},
   NUMBER       = {1249},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Quality models</b>, 
      Topic: <b>Design patterns</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+Quality+Models+September04.doc.pdf},
   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.}
}

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.

@MISC{PMARt,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {since November},
   NOTE         = {A database of occurrences of patterns in object-oriented programs.},
   TITLE        = {PMARt},
   YEAR         = {2004},
   KEYWORDS     = {Topic: <b>Design patterns</b>},
   URL          = {http://www.ptidej.net/research/designpatterns/}
}

@PHDTHESIS{Gueheneuc03-PhD,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   SCHOOL       = {�cole des Mines de Nantes et Universit� de Nantes},
   TITLE        = {Un cadre pour la tra�abilit� des motifs de conception},
   YEAR         = {2003},
   OPTADDRESS   = {},
   MONTH        = {juin},
   NOTE         = {350 pages.},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, 
      Topic: <b>Binary class relations</b>},
   URL          = {http://www.yann-gael.gueheneuc.net/Work/PhDThesis/},
   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{}.}
}

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.

@ARTICLE{Farias03-ENTCS-CoherenceProtocols,
   AUTHOR       = {Andr�s Far�as and Yann-Ga�l Gu�h�neuc},
   JOURNAL      = {Electronic Notes in Theoretical Computer Science (ENTCS)},
   TITLE        = {On the Coherence of Component Protocols},
   YEAR         = {2003},
   MONTH        = {April},
   NOTE         = {12 pages.},
   NUMBER       = {5},
   PAGES        = {42--53},
   VOLUME       = {82},
   EDITOR       = {Uwe Assmann and Elke Pulvermueller and Isabelle Borne and 
      Noury Bouraqadi and Pierre Cointe},
   KEYWORDS     = {Venue: <b>ENTCS</b>},
   PUBLISHER    = {Elsevier},
   URL          = {http://www.ptidej.net/publications/documents/ETAPS03SC.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{Gueheneuc03-ASE-P-AAC,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Herv� Albin-Amiot},
   BOOKTITLE    = {Proceedings of the 18<sup>th</sup> Conference on Automated Software Engineering (ASE)},
   TITLE        = {A Pragmatic Study of Binary Class Relationships},
   YEAR         = {2003},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {John Grundy and John Penix},
   MONTH        = {September},
   NOTE         = {Short paper. 4 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {277--280},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>, Venue: <c>ASE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ASE03.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ASE03.ppt.pdf},
   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.}
}

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�l Gu�h�neuc and Herv� Albin-Amiot and 
      Pierre Cointe},
   BOOKTITLE    = {Journ�e GDR ALP-OCM},
   TITLE        = {PatternsBox--Ptidej, int�gration de deux outils de 
      conception et de r�tro-conception � Eclipse},
   YEAR         = {2003},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Jacques Malenfant},
   MONTH        = {f�vrier},
   NOTE         = {6 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, 
      Venue: <i>GDR ALP-OCM</i>},
   URL          = {http://www.ptidej.net/publications/documents/Projet+GDRALP+OCM03.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/Projet+GDRALP+OCM03.ppt.pdf},
   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 Gamma et 
      al.) facilite, d'une part, la conception et la documentation et, 
      d'autre part, la compr{\'e}hension et l'am{\'e}lioration de ces 
      programmes. Nous avons d{\'e}velopp{\'e} {\`a} l'occasion de nos 
      travaux de th{\`e}se de doctorat, \PatternsBox{} et Ptidej{}, 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{}, 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{}.}
}

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 Gamma et al.) facilite, d'une part, la conception et la documentation et, d'autre part, la compréhension et l'amélioration de ces programmes. Nous avons développé à l'occasion de nos travaux de thèse de doctorat, ¶atternsBox et Ptidej, 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, 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.

@TECHREPORT{Baroni03-TR-DPFormalization,
   AUTHOR       = {Aline L�cia Baroni and Yann-Ga�l Gu�h�neuc and 
      Herv� Albin-Amiot},
   INSTITUTION  = {Computer Science Department, �cole des Mines de Nantes},
   TITLE        = {Design Patterns Formalization},
   YEAR         = {2003},
   OPTADDRESS   = {},
   MONTH        = {June},
   NOTE         = {59 pages.},
   NUMBER       = {03/03/INFO},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+Metamodeling+June03.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{AlbinAmiot02-JCOM-Couple,
   AUTHOR       = {Herv� Albin-Amiot and Pierre Cointe and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Journ�e sur le projet COM},
   TITLE        = {Un m�ta-mod�le pour coupler application et d�tection des 
      design patterns},
   YEAR         = {2002},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Anne-Marie Kempf},
   MONTH        = {f�vrier},
   NOTE         = {17 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>JCOM</i>},
   URL          = {http://www.ptidej.net/publications/documents/JCOM02.ppt.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/JCOM02.ppt.pdf},
   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.}
}

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

@INPROCEEDINGS{AlbinAmiot02-LMO-MetaModele,
   AUTHOR       = {Herv� Albin-Amiot and Pierre Cointe and 
      Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Actes du 8<sup>e</sup> colloque Langages et Mod�les � Objets (LMO)},
   TITLE        = {Un m�ta-mod�le pour coupler application et d�tection des 
      design patterns},
   YEAR         = {2002},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Michel Dao and Marianne Huchard},
   MONTH        = {janvier},
   NOTE         = {18 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {41--58},
   PUBLISHER    = {Herm�s Science Publications},
   SERIES       = {RSTI -- L'objet},
   VOLUME       = {8, num�ro 1-2/2002},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>LMO</c>},
   URL          = {http://www.ptidej.net/publications/documents/LMO02.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/LMO02.ppt.pdf},
   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.}
}

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{Farias02-WBS-ProtocolsEJB,
   AUTHOR       = {Andr�s Far�as and Yann-Ga�l Gu�h�neuc and Mario S�dholt},
   BOOKTITLE    = {Proceedings of the 11<sup>th</sup> OOPSLA workshop on Behavioral Semantics: Serving the Customer (Behavioural Semantics)},
   TITLE        = {Integrating Behavioral Protocols in Enterprise Java 
      Beans},
   YEAR         = {2002},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kenneth Baclawski and Haim Kilov},
   MONTH        = {October},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   ORGANIZATION = {College of Computer Science},
   PAGES        = {80--89},
   PUBLISHER    = {Northeastern University},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Venue: <i>WBS</i>},
   URL          = {http://www.ptidej.net/publications/documents/OOPSLA02BehavioralSemantics.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/OOPSLA02BehavioralSemantics.ppt.pdf},
   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.}
}

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�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> ASE workshop on Declarative Meta-Prorgramming (WDMP)},
   TITLE        = {Three Musketeers to the Rescue -- Meta-Modelling, Logic 
      Programming, and Explanation-based Constraint Programming for Pattern 
      Description and Detection},
   YEAR         = {2002},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Kris De Volder and Kim Mens and Tom Mens and Roel Wuyts},
   MONTH        = {September},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {Computer Science Department, University of British Columbia},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>WDMP</i>},
   URL          = {http://www.ptidej.net/publications/documents/ASE02DMP.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ASE02DMP.ppt.pdf},
   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}
}

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

@INPROCEEDINGS{Gueheneuc02-ASE-Caffeine,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and R�mi Douence and 
      Narendra Jussien},
   BOOKTITLE    = {Proceedings of the 17<sup>th</sup> Conference on Automated Software Engineering (ASE)},
   TITLE        = {No Java Without Caffeine -- A Tool for Dynamic Analysis 
      of Java Programs},
   YEAR         = {2002},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Wolfgang Emmerich and Dave Wile},
   MONTH        = {September},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {117--126},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>, Venue: <c>ASE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ASE02.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ASE02.ppt.pdf},
   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.}
}

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-GapLanguages,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Herv� Albin-Amiot and 
      R�mi Douence and Pierre Cointe},
   INSTITUTION  = {Computer Science Department, �cole des Mines de Nantes},
   TITLE        = {Bridging the Gap Between Modeling and Programming 
      Languages},
   YEAR         = {2002},
   OPTADDRESS   = {},
   MONTH        = {July},
   NOTE         = {56 pages.},
   NUMBER       = {02/09/INFO},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+AAC+July02.doc.pdf},
   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.}
}

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.

@TECHREPORT{Gueheneuc02-TR-Caffeine,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and R�mi Douence and 
      Narendra Jussien},
   INSTITUTION  = {Computer Science Department, �cole des Mines de Nantes},
   TITLE        = {No Java Without Caffeine -- A Tool for Dynamic Analysis 
      of Java Programs},
   YEAR         = {2002},
   OPTADDRESS   = {},
   MONTH        = {May},
   NOTE         = {16 pages.},
   NUMBER       = {02/07/INFO},
   OPTTYPE      = {},
   KEYWORDS     = {Topic: <b>Binary class relations</b>},
   URL          = {http://www.ptidej.net/publications/documents/Research+report+Caffeine+May02.doc.pdf},
   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.}
}

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.

@MISC{Caffeine,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc},
   OPTHOWPUBLISHED = {},
   MONTH        = {since May},
   NOTE         = {A tool to analyse Java programs dynamically.},
   TITLE        = {Caffeine},
   YEAR         = {2002},
   KEYWORDS     = {Topic: <b>Design patterns</b>},
   URL          = {http://www.ptidej.net}
}

@INPROCEEDINGS{AlbinAmiot01-ASE-BitsPieces,
   AUTHOR       = {Herv� Albin-Amiot and Pierre Cointe and 
      Yann-Ga�l Gu�h�neuc and Narendra Jussien},
   BOOKTITLE    = {Proceedings of the 16<sup>th</sup> Conference on Automated Software Engineering (ASE)},
   TITLE        = {Instantiating and Detecting Design Patterns: Putting 
      Bits and Pieces Together},
   YEAR         = {2001},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Debra Richardson and Martin Feather and Michael Goedicke},
   MONTH        = {November},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {166--173},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <c>ASE</c>},
   URL          = {http://www.ptidej.net/publications/documents/ASE01.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ASE01.ppt.pdf},
   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.}
}

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-WGP-Generative,
   AUTHOR       = {Herv� Albin-Amiot and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> OOPSLA workshop on Generative Programming (GP)},
   TITLE        = {Design Patterns Application: Pure-generative Approach 
      vs. Conservative-generative Approach},
   YEAR         = {2001},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Krzysztof Czarnecki},
   MONTH        = {October},
   NOTE         = {3 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>WGP</i>},
   URL          = {http://www.ptidej.net/publications/documents/OOPSLA01GP.doc.pdf},
   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.}
}

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.

@INPROCEEDINGS{AlbinAmiot01-WPHDOOS-RoundTrip,
   AUTHOR       = {Herv� Albin-Amiot and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 11<sup>th</sup> ECOOP workshop for Ph.D. Students in Object-Oriented Systems (PHDOOS)},
   TITLE        = {Design Patterns: A Round-Trip},
   YEAR         = {2001},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Gilles Ardourel and Michael Haupt and 
      Jose Luis Herrero Agustin and Rainer Ruggaber and Charles Suscheck},
   MONTH        = {June},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {N/A},
   PUBLISHER    = {N/A},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>PHDOOS</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP01PHDOOS.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ECOOP01PHDOOS.ppt.pdf},
   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.}
}

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� Albin-Amiot and Yann-Ga�l Gu�h�neuc},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> ECOOP workshop on Automating Object-Oriented Software Development Methods (AOOSDM)},
   TITLE        = {Meta-Modeling Design Patterns: Application to Pattern 
      Detection and Code Synthesis},
   YEAR         = {2001},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {van den Broek, Pim and Pavel Hruby and Motoshi Saeki and 
      Gerson Suny� and Bedir Tekinerdogan},
   MONTH        = {October},
   NOTE         = {TR-CTIT-01-35. 8 pages.},
   OPTNUMBER    = {},
   ORGANIZATION = {Centre for Telematics and Information Technology},
   PAGES        = {20--27},
   PUBLISHER    = {University of Twente},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>AOOSDM</i>},
   URL          = {http://www.ptidej.net/publications/documents/ECOOP01AOOSDM.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/ECOOP01AOOSDM.ppt.pdf},
   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.}
}

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{Gueheneuc01-TOOLSUSA-DesignDefects,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Herv� Albin-Amiot},
   BOOKTITLE    = {Proceedings of the 39<sup>th</sup> Conference on the Technology of Object-Oriented Languages and Systems (TOOLS USA)},
   TITLE        = {Using Design Patterns and Constraints to Automate the 
      Detection and Correction of Inter-Class Design Defects},
   YEAR         = {2001},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Quioyun Li and Richard Riehle and Gilda Pour and 
      Bertrand Meyer},
   MONTH        = {July},
   NOTE         = {10 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {296--305},
   PUBLISHER    = {IEEE CS Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Code and design smells</b>, 
      Venue: <c>TOOLS USA</c>},
   URL          = {http://www.ptidej.net/publications/documents/TOOLSUSA01.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/TOOLSUSA01.ppt.pdf},
   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.}
}

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-JNPC-Explications,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Narendra Jussien},
   BOOKTITLE    = {Actes des 7<sup>e</sup> Journ�es Nationales sur la r�solution de Probl�mes NP-Complets (JNPC)},
   TITLE        = {Quelques explications pour les patrons -- Une 
      application de la PPC avec explications pour l'identification de 
      patrons de conception},
   YEAR         = {2001},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Bertrand Neveu},
   MONTH        = {juin},
   NOTE         = {12 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {111--122},
   PUBLISHER    = {ONERA},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>JNPC</i>},
   URL          = {http://www.ptidej.net/publications/documents/JNPC01.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/JNPC01.ppt.pdf},
   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.}
}

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.

@INPROCEEDINGS{Gueheneuc01-WMSPC-Explanations,
   AUTHOR       = {Yann-Ga�l Gu�h�neuc and Narendra Jussien},
   BOOKTITLE    = {Proceedings of the 1<sup>st</sup> IJCAI Workshop on Modeling and Solving Problems with Constraints (WMSPC)},
   TITLE        = {Using Explanations for Design-Patterns Identification},
   YEAR         = {2001},
   OPTADDRESS   = {},
   OPTCROSSREF  = {},
   EDITOR       = {Christian Bessi�re},
   MONTH        = {August},
   NOTE         = {8 pages.},
   OPTNUMBER    = {},
   OPTORGANIZATION = {},
   PAGES        = {57--64},
   PUBLISHER    = {AAAI Press},
   OPTSERIES    = {},
   OPTVOLUME    = {},
   KEYWORDS     = {Topic: <b>Design patterns</b>, Venue: <i>WMSPC</i>},
   URL          = {http://www.ptidej.net/publications/documents/IJCAI01MSPC.doc.pdf},
   PDF          = {http://www.ptidej.net/publications/documents/IJCAI01MSPC.ppt.pdf},
   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.}
}

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.