@INPROCEEDINGS {10647203,
author = {Y. Gueheneuc and S. Humayoun and R. Morales and R. Saborido},
booktitle = {2024 IEEE/ACM 6th International Workshop on Software Engineering Research & Practices for the IoT (SERP4IoT)},
title = {Message from the Chairs; SERP4IoT'24},
year = {2024},
volume = {},
issn = {},
pages = {vii-vii},
abstract = {SERP4IoT'24, the sixth edition of the International Workshop on Software Engineering Research & Practices for the Internet of Things, took place on April 20th, 2024. It was held in conjunction with the 46th ACM/IEEE International Conference on Software Engineering (ICSE'24), which was located in Lisbon, Portugal.},
keywords = {},
doi = {},
url = {https://doi.ieeecomputersociety.org/},
publisher = {IEEE Computer Society},
address = {Los Alamitos, CA, USA},
month = {apr}
}

SERP4IoT'24, the sixth edition of the International Workshop on Software Engineering Research & Practices for the Internet of Things, took place on April 20th, 2024. It was held in conjunction with the 46th ACM/IEEE International Conference on Software Engineering (ICSE'24), which was located in Lisbon, Portugal.

@INPROCEEDINGS {10190475,
author = {},
booktitle = {2023 IEEE/ACM 5th International Workshop on Software Engineering Research and Practices for the IoT (SERP4IoT)},
title = {Message from the Chairs},
year = {2023},
volume = {},
issn = {},
pages = {7-7},
abstract = {},
keywords = {},
doi = {10.1109/SERP4IoT59158.2023.00005},
url = {https://doi.ieeecomputersociety.org/10.1109/SERP4IoT59158.2023.00005},
publisher = {IEEE Computer Society},
address = {Los Alamitos, CA, USA},
month = {may}
}

@article{10.1145/3485952.3485959,
author = {Gu\'{e}h\'{e}neuc, Yann-Ga\"{e}l and Humayoun, Shah Rukh and Morales, Rodrigo and Saborido, Rub\'{e}n},
title = {SERP4IoT'21 Workshop Report},
year = {2021},
issue_date = {October 2021},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
volume = {46},
number = {4},
issn = {0163-5948},
url = {https://doi.org/10.1145/3485952.3485959},
doi = {10.1145/3485952.3485959},
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, nd solutions for, and share experiences with the development, release, and testing of robust software for IoT systems.},
journal = {SIGSOFT Softw. Eng. Notes},
month = {oct},
pages = {26–27},
numpages = {2}
}

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, nd solutions for, and share experiences with the development, release, and testing of robust software for IoT systems.

@INPROCEEDINGS{9202613,
  author={L. {Etaiwi} and S. {Hamel} and Y. -G. {Guéhéneuc} and W. {Flageol} and R. {Morales}},
  booktitle={2020 IEEE 44th Annual Computers, Software, and Applications Conference (COMPSAC)}, 
  title={Order in Chaos: Prioritizing Mobile App Reviews using Consensus Algorithms}, 
  year={2020},
  volume={},
  number={},
  pages={912-920},
  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.},
  keywords={Android (operating system);feature extraction;mobile computing;smart phones;software engineering;text analysis;mobile app reviews;consensus algorithm;app developers;user reviews;app evolution;Android apps;app quality;topic extraction;topic analysis;Feature extraction;Computer bugs;Correlation;Google;Software;Androids;Humanoid robots;Consensus algorithms, Rankings, Review prioritization, User reviews, Software evolution},
  doi={10.1109/COMPSAC48688.2020.0-151},
  ISSN={0730-3157},
  month={July},}

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.

@ARTICLE{9219255,  author={R. {Morales} and R. {Saborido} and S. R. {Humayoun} and Y. -G. {Guéhéneuc}},  journal={IEEE Internet of Things Journal},   title={Guest Editorial Special Issue on Software Engineering Research and Practices for the Internet of Things},   year={2020},  volume={7},  number={10},  pages={10089-10090},
doi={10.1109/JIOT.2020.3026565},
url_Paper = {https://moar82.github.io/preprint/jiot-morales-3026565-proof.pdf},
url={https://ieeexplore.ieee.org/document/9219255}
,}

@Article{emse2020refturing,
author="R. Morales and F. Khomh and G. Antoniol",
title="RePOR: Mimiking humans on refactoring tasks. Are we there yet?",
journal="Empirical Software Engineering",
year={2020},
volume={25}, 
number={4}, 
pages={2960-2996}, 
abstract="Refactoring is a maintenance activity that aims to improve design quality while preserving the behavior of a system. Several (semi)automated approaches have been proposed to support developers in this maintenance activity, based on the correction of anti-patterns, which are “poor” solutions to recurring design problems. However, little quantitative evidence exists about the impact of automatically refactored code on program comprehension, and in which context automated refactoring can be as effective as manual refactoring. Leveraging RePOR, an automated refactoring approach based on partial order reduction techniques, we performed an empirical study to investigate whether automated refactoring code structure affects the understandability of systems during comprehension tasks. (1) We surveyed 80 developers, asking them to identify from a set of 20 refactoring changes if they were generated by developers or by a tool, and to rate the refactoring changes according to their design quality; (2) we asked 30 developers to complete code comprehension tasks on 10 systems that were refactored by either a freelancer or an automated refactoring tool. To make comparison fair, for a subset of refactoring actions that introduce new code entities, only synthetic identifiers were presented to practitioners. We measured developers’ performance using the NASA task load index for their effort, the time that they spent performing the tasks, and their percentages of correct answers. Our findings, despite current technology limitations, show that it is reasonable to expect refactoring tools to match developer code. Indeed, results show that for 3 out of the 5 anti-pattern types studied, developers could not recognize the origin of the refactoring (i.e., whether it was performed by a human or an automatic tool). We also observed that developers do not prefer human refactorings over automated refactorings, except when refactoring Blob classes; and that there is no statistically significant difference between the impact on code understandability of human refactorings and automated refactorings. We conclude that automated refactorings can be as effective as manual refactorings. However, for complex anti-patterns types like the Blob, the perceived quality achieved by developers is slightly higher",
issn={1573-7616},
doi={10.1007/s10664-020-09826-7},
url_Paper = {https://moar82.github.io/preprint/refturing-EMSE-D-19-00094R1.pdf},
url={-},}

Refactoring is a maintenance activity that aims to improve design quality while preserving the behavior of a system. Several (semi)automated approaches have been proposed to support developers in this maintenance activity, based on the correction of anti-patterns, which are “poor” solutions to recurring design problems. However, little quantitative evidence exists about the impact of automatically refactored code on program comprehension, and in which context automated refactoring can be as effective as manual refactoring. Leveraging RePOR, an automated refactoring approach based on partial order reduction techniques, we performed an empirical study to investigate whether automated refactoring code structure affects the understandability of systems during comprehension tasks. (1) We surveyed 80 developers, asking them to identify from a set of 20 refactoring changes if they were generated by developers or by a tool, and to rate the refactoring changes according to their design quality; (2) we asked 30 developers to complete code comprehension tasks on 10 systems that were refactored by either a freelancer or an automated refactoring tool. To make comparison fair, for a subset of refactoring actions that introduce new code entities, only synthetic identifiers were presented to practitioners. We measured developers’ performance using the NASA task load index for their effort, the time that they spent performing the tasks, and their percentages of correct answers. Our findings, despite current technology limitations, show that it is reasonable to expect refactoring tools to match developer code. Indeed, results show that for 3 out of the 5 anti-pattern types studied, developers could not recognize the origin of the refactoring (i.e., whether it was performed by a human or an automatic tool). We also observed that developers do not prefer human refactorings over automated refactorings, except when refactoring Blob classes; and that there is no statistically significant difference between the impact on code understandability of human refactorings and automated refactorings. We conclude that automated refactorings can be as effective as manual refactorings. However, for complex anti-patterns types like the Blob, the perceived quality achieved by developers is slightly higher

@ARTICLE{8966499momit,
author={R. {Morales} and R. {Saborido} and Y. {Gu{\'e}h{\'e}neuc}},
journal={IEEE Transactions on Software Engineering}, 
title={MoMIT: Porting a JavaScript Interpreter on a Quarter Coin}, 
year={2020}, 
volume={}, 
number={}, 
pages={}, 
keywords={Internet of Things;Software Miniaturization;Multiobjective optimization;embedded devices;JavaScript;Evolutionary algorithms}, 
doi={10.1109/TSE.2020.2968061}, 
ISSN={0098-5589}, 
url_Paper = {MoMIT__Porting_a_JavaScript_Interpreter_on_a_Quarter_Coin.pdf},
month={},
url ={https://doi.org/10.1109/TSE.2020.2968061},}

@INPROCEEDINGS{8900776,
author={D. {Dig} and R. {Morales} and R. {Saborido} and S. {Humayoun} and Y. {Dubinsky} and Y. {Gu{\'e}h{\'e}neuc}},
booktitle={2019 IEEE/ACM 1st International Workshop on Software Engineering Research Practices for the Internet of Things (SERP4IoT)},
title={SERP4IoT 2019 Organizing Committee},
year={2019},
volume={},
number={},
pages={9-9},
keywords={},
doi={10.1109/SERP4IoT.2019.00006},
ISSN={null},
month={May},}

@INPROCEEDINGS{8453062,
author={R. {Morales} and R. {Saborido} F. {Khomh} and F. {Chicano} and G. {Antoniol}},
booktitle={2018 IEEE/ACM 40th International Conference on Software Engineering (ICSE)},
title={EARMO: An Energy-Aware Refactoring Approach for Mobile Apps},
year={2018},
volume={},
number={},
pages={59-59},
abstract={With millions of smartphones sold every year, the development of mobile apps has grown substantially. The battery power limitation of mobile devices has push developers and researchers to search for methods to improve the energy efficiency of mobile apps. We propose a multiobjective refactoring approach to automatically improve the architecture of mobile apps, while controlling for energy efficiency. In this extended abstract we briefly summarize our work.},
keywords={Energy efficiency;Software engineering;Batteries;Energy measurement;Mobile handsets;Energy consumption;Software;Refactoring;Anti-patterns;Mobile apps;Energy consumption},
doi={10.1145/3180155.3182524},
ISSN={1558-1225},
month={May},}

With millions of smartphones sold every year, the development of mobile apps has grown substantially. The battery power limitation of mobile devices has push developers and researchers to search for methods to improve the energy efficiency of mobile apps. We propose a multiobjective refactoring approach to automatically improve the architecture of mobile apps, while controlling for energy efficiency. In this extended abstract we briefly summarize our work.

@article{Morales2018symred,
title = "Efficient Refactoring Scheduling based on Partial order Reduction ",
author = "Rodrigo Morales and Francisco Chicano  and Foutse Khomh and Giuliano Antoniol",
journal = "Journal of Systems and Software ",
volume = "145",
number = "",
pages = "25-51",
year = "2018",
note = "",
issn = "0164-1212",
abstract = {Anti-patterns are poor solutions to design problems that make software systems hard to understand and to extend. Components involved in anti-patterns are reported to be consistently related to high changes and faults rates. Developers are advised to perform refactoring to remove anti-patterns, and consequently improve software design quality and reliability. However, since the number of anti-patterns in a system can be very large, the process of manual refactoring can be overwhelming. To assist a software engineer who has to perform this task, we propose a novel approach RePOR (Refactoring approach based on Partial Order Reduction). We perform a case study with five open source systems to assess the performance of RePOR against two well-known metaheuristics (Genetic Algorithm, and Ant Colony Optimization), one conflict-aware refactoring approach and, a new approach based on sampling (Sway). Results show that RePOR can correct a median of 73% of anti-patterns (10% more than existing approaches) with a significant reduction in effort (measured by the number of refactorings applied) ranging from 69% to 85%, and a reduction of execution time ranging between 50% and 87%, in comparison to existing approaches.},
keywords = {Software Refactoring, Refactoring Schedule, Anti-patterns, Design Quality, Ant Colony Optimization, Genetic Algorithm},
doi = "https://doi.org/10.1016/j.jss.2018.07.076",
url_Paper = {Morales-JSS-symred.pdf},
url ={https://doi.org/10.1016/j.jss.2018.07.076} }

Anti-patterns are poor solutions to design problems that make software systems hard to understand and to extend. Components involved in anti-patterns are reported to be consistently related to high changes and faults rates. Developers are advised to perform refactoring to remove anti-patterns, and consequently improve software design quality and reliability. However, since the number of anti-patterns in a system can be very large, the process of manual refactoring can be overwhelming. To assist a software engineer who has to perform this task, we propose a novel approach RePOR (Refactoring approach based on Partial Order Reduction). We perform a case study with five open source systems to assess the performance of RePOR against two well-known metaheuristics (Genetic Algorithm, and Ant Colony Optimization), one conflict-aware refactoring approach and, a new approach based on sampling (Sway). Results show that RePOR can correct a median of 73% of anti-patterns (10% more than existing approaches) with a significant reduction in effort (measured by the number of refactorings applied) ranging from 69% to 85%, and a reduction of execution time ranging between 50% and 87%, in comparison to existing approaches.

@Article{Saborido2018,
author="Saborido, Rub{\'e}n
and Morales, Rodrigo
and Khomh, Foutse
and Gu{\'e}h{\'e}neuc, Yann-Ga{\"e}l
and Antoniol, Giuliano",
title="Getting the most from map data structures in Android",
journal="Empirical Software Engineering",
year="2018",
volume={23}, 
number={5}, 
pages={2829-2864}, 
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.",
issn={1573-7616},
doi={"10.1007/s10664-018-9607-8},
url_Paper = {map-data-structures.pdf},
url={https://doi.org/10.1007/s10664-018-9607-8}
}

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{Morales2017,
author="Morales, Rodrigo
and Chicano, Francisco
and Khomh, Foutse
and Antoniol, Giuliano",
title="Exact search-space size for the refactoring scheduling problem",
journal="Automated Software Engineering",
year="2018",
abstract="Ouni et al. ``Maintainability defects detection and correction: a multi-objective approach'' proposed a search-based approach for generating optimal refactoring sequences. They estimated the size of the search space for the refactoring scheduling problem using a formulation that is incorrect; the search space is estimated to be too much larger than it is. We provide in this paper the exact expression for computing the number of possible refactoring sequences of a software system. This could be useful for researchers and practitioners interested in developing new approaches to automate refactoring.",
issn="0928-8910",
pages = {195--200}, 
number = {2}, 
volume = {25}, 
doi="10.1007/s10515-017-0213-6",
url_Paper =    {http://rdcu.be/paOV},
url="https://doi.org/10.1007/s10515-017-0213-6"
}

Ouni et al. ``Maintainability defects detection and correction: a multi-objective approach'' proposed a search-based approach for generating optimal refactoring sequences. They estimated the size of the search space for the refactoring scheduling problem using a formulation that is incorrect; the search space is estimated to be too much larger than it is. We provide in this paper the exact expression for computing the number of possible refactoring sequences of a software system. This could be useful for researchers and practitioners interested in developing new approaches to automate refactoring.

@phdthesis{Morales2017Phd,
    title    = {Automated Improvement of Software Design by Search-Based Refactoring},
    school   = {Ecole Polytechnique de Montreal},
    author   = {Morales, Rodrigo},
    year     = {2017}, 
    url_Paper = {RMorales_thesis.pdf},
    url={https://publications.polymtl.ca/2878/},
    note     = {Received Best thesis award 2017 from DGIGL at Polytechnique},
}

@ARTICLE{8052533EARMO, 
author={R. Morales and R. Saborido and F. Khomh and F. Chicano and G. Antoniol}, 
journal={IEEE Transactions on Software Engineering}, 
title={EARMO: An Energy-Aware Refactoring Approach for Mobile Apps}, 
year={2017}, 
volume={44}, 
number={12}, 
pages={1176-1206}, 
keywords={Anti-patterns;Energy consumption;Mobile apps;Refactoring;Search-based Software Engineering;Software maintenance}, 
doi={10.1109/TSE.2017.2757486}, 
ISSN={0098-5589}, 
url_Paper =    {http://swat.polymtl.ca/~foutsekh/docs/EARMO-TSE.pdf},
month={12},}

@article{Morales2017236,
title = "On the use of developers’ context for automatic refactoring of software anti-patterns ",
journal = "Journal of Systems and Software ",
volume = "128",
number = "",
pages = "236 - 251",
year = "2017",
note = "",
issn = "0164-1212",
doi = "https://doi.org/10.1016/j.jss.2016.05.042",
url_Paper = {http://swat.polymtl.ca/~foutsekh/docs/Morales-JSS.pdf},
url = "http://www.sciencedirect.com/science/article/pii/S0164121216300632",
author = "Rodrigo Morales and Zéphyrin Soh and Foutse Khomh and Giuliano Antoniol and Francisco Chicano",
keywords = "Software maintenance",
keywords = "Automatic refactoring",
keywords = "Task context",
keywords = "Interaction traces",
keywords = "Anti-patterns",
keywords = "Metaheuristics ",
abstract = "Abstract Anti-patterns are poor solutions to design problems that make software systems hard to understand and extend. Entities involved in anti-patterns are reported to be consistently related to high change and fault rates. Refactorings, which are behavior preserving changes are often performed to remove anti-patterns from software systems. Developers are advised to interleave refactoring activities with their regular coding tasks to remove anti-patterns, and consequently improve software design quality. However, because the number of anti-patterns in a software system can be very large, and their interactions can require a solution in a set of conflicting objectives, the process of manual refactoring can be overwhelming. To automate this process, previous works have modeled anti-patterns refactoring as a batch process where a program provides a solution for the total number of classes in a system, and the developer has to examine a long list of refactorings, which is not feasible in most situations. Moreover, these proposed solutions often require that developers modify classes on which they never worked before (i.e., classes on which they have little or no knowledge). To improve on these limitations, this paper proposes an automated refactoring approach, ReCon (Refactoring approach based on task Context), that leverages information about a developer’s task (i.e., the list of code entities relevant to the developer’s task) and metaheuristics techniques to compute the best sequence of refactorings that affects only entities in the developer’s context. We mine 1705 task contexts (collected using the Eclipse plug-in Mylyn) and 1013 code snapshots from three open-source software projects (Mylyn, PDE, Eclipse Platform) to assess the performance of our proposed approach. Results show that ReCon can remove more than 50% of anti-patterns in a software system, using fewer resources than the traditional approaches from the literature. "
}

Abstract Anti-patterns are poor solutions to design problems that make software systems hard to understand and extend. Entities involved in anti-patterns are reported to be consistently related to high change and fault rates. Refactorings, which are behavior preserving changes are often performed to remove anti-patterns from software systems. Developers are advised to interleave refactoring activities with their regular coding tasks to remove anti-patterns, and consequently improve software design quality. However, because the number of anti-patterns in a software system can be very large, and their interactions can require a solution in a set of conflicting objectives, the process of manual refactoring can be overwhelming. To automate this process, previous works have modeled anti-patterns refactoring as a batch process where a program provides a solution for the total number of classes in a system, and the developer has to examine a long list of refactorings, which is not feasible in most situations. Moreover, these proposed solutions often require that developers modify classes on which they never worked before (i.e., classes on which they have little or no knowledge). To improve on these limitations, this paper proposes an automated refactoring approach, ReCon (Refactoring approach based on task Context), that leverages information about a developer’s task (i.e., the list of code entities relevant to the developer’s task) and metaheuristics techniques to compute the best sequence of refactorings that affects only entities in the developer’s context. We mine 1705 task contexts (collected using the Eclipse plug-in Mylyn) and 1013 code snapshots from three open-source software projects (Mylyn, PDE, Eclipse Platform) to assess the performance of our proposed approach. Results show that ReCon can remove more than 50% of anti-patterns in a software system, using fewer resources than the traditional approaches from the literature.

@inproceedings{Morales2016SanerTesting,
   author = {Morales, Rodrigo and Sabane, Aminata and Musavi, Pooya and Khomh, Foutse and Chicano, Francisco. and Antoniol, Giuliano.},
   title = {Finding the Best Compromise Between Design Quality and Testing Effort During Refactoring},
   booktitle = {2016 IEEE 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER)},
   volume = {1},
	 year={2016},
   pages = {24-35},
   keywords = {genetic algorithms
program testing
search problems
software maintenance
software quality
MOCell
NSGA-II
SPEA2
design quality
manual refactoring
novel search-based multiobjective approach
open-source systems
semantic-preserving-code transformations
single anti-patterns correction
software development
testing effort
Anti-patterns
Refactoring
Search-based software engineering},
   DOI = {10.1109/SANER.2016.23},
   url_Paper ={http://swat.polymtl.ca/rmorales/preprint/Morales-saner16.pdf},
   type = {Conference Proceedings}
   
}

@INPROCEEDINGS{7081827, 
author={R. Morales and S. McIntosh and F. Khomh}, 
booktitle={2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER)}, 
title={Do code review practices impact design quality? A case study of the Qt, VTK, and ITK projects}, 
year={2015}, 
volume={}, 
number={}, 
pages={171-180}, 
keywords={object-oriented programming;software quality;ITK project;Qt project;VTK project;code review practice;modern code review;open source project;post-release bugs;software components;software design quality;software release quality;software system;Analytical models;Complexity theory;Correlation;Measurement;Software design;Software systems}, 
doi={10.1109/SANER.2015.7081827}, 
url_Paper={http://swat.polymtl.ca/data/SANER15/Morales-saner15.pdf},
ISSN={1534-5351}, 
month={March},}

@INPROCEEDINGS{7081891, 
author={R. Morales}, 
booktitle={2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER)}, 
title={Towards a framework for automatic correction of anti-patterns}, 
year={2015}, 
volume={}, 
number={}, 
pages={603-604}, 
keywords={software maintenance;software quality;antipattern detection;automated refactoring;automatic antipattern correction;automatic antipattern removal;metaheuristics;software design quality;software evolution;software maintenance;Correlation;Measurement;Software engineering;Software maintenance;Software systems;Space exploration}, 
doi={10.1109/SANER.2015.7081891}, 
url_Paper ={http://swat.polymtl.ca/rmorales/preprint/phdSaner.pdf},
ISSN={1534-5351}, 
month={March},}

@article{moralesupiita2005,
author = {Morales, Rodrigo},
year = {2008},
month = {09},
pages = {-2},
title = {Programación de guantes de datos y ambientes virtuales},
volume = {13},
journal = {Boletin electronico UPIITA},
doi = {},
url_Paper = {https://moar82.github.io/myPapers/constanciaUPiita.jpg},
}

@MastersThesis{Morales2007Msc,
    title    = {Interfaz Para El Aprendizaje De La Realidad Virtual Haciendo Uso De Un Guante De Datos},
    school   = {CIDETEC Instituto Politecnico Nacional,  Mexico},
    author   = {Morales, Rodrigo},
    year     = {2007}, 
    url_Paper = {https://moar82.github.io/myPapers/master_tesis _morales.pdf},
    url={-},
    note     = {-},
}

@article{lozada2005,
author = {Herrera Lozada, Juan and Zarate, Israel and Morales, Rodrigo},
year = {2005},
month = {01},
pages = {23-29},
title = {Programación de Sistemas de Cómputo Móviles},
volume = {31},
journal = {Polibits},
doi = {10.17562/PB-31-4},
url_Paper = {https://moar82.github.io/myPapers/polibits.jpg},
}