@article{Alikhanifard:TOSEM:2024:RefactoringMiner3.0,
	author = {Alikhanifard, Pouria and Tsantalis, Nikolaos},
	title = {A Novel Refactoring and Semantic Aware Abstract Syntax Tree Differencing Tool and a Benchmark for Evaluating the Accuracy of Diff Tools},
	year = {2025},
	issue_date = {February 2025},
	publisher = {Association for Computing Machinery},
	address = {New York, NY, USA},
	volume = {34},
	number = {2},
	issn = {1049-331X},
	--url = {https://doi.org/10.1145/3696002},
	doi = {10.1145/3696002},
	abstract = {Software undergoes constant changes to support new requirements, address bugs, enhance performance, and ensure maintainability. Thus, developers spend a great portion of their workday trying to understand and review the code changes of their teammates. Abstract Syntax Tree (AST) diff tools were developed to overcome the limitations of line-based diff tools, which are used by the majority of developers. Despite the notable improvements brought by AST diff tools in understanding complex changes, they still suffer from serious limitations, such as (1) lacking multi-mapping support, (2) matching semantically incompatible AST nodes, (3) ignoring language clues to guide the matching process, (4) lacking refactoring awareness, and (5) lacking commit-level diff support. We propose a novel AST diff tool based on RefactoringMiner that resolves all aforementioned limitations. First, we improved RefactoringMiner to increase its statement mapping accuracy, and then we developed an algorithm that generates AST diff for a given commit or pull request based on the refactoring instances and pairs of matched program element declarations provided by RefactoringMiner. To evaluate the accuracy of our tool and compare it with the state-of-the-art tools, we created the first benchmark of AST node mappings, including 800 bug-fixing commits and 188 refactoring commits. Our evaluation showed that our tool achieved a considerably higher precision and recall, especially for refactoring commits, with an execution time that is comparable with that of the faster tools.},
	journal = {ACM Transactions on Software Engineering and Methodology},
	month = jan,
	articleno = {40},
	numpages = {63},
	keywords = {Source code differencing, Abstract Syntax Trees, Benchmark},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/TOSEM_2024.pdf},
}

Software undergoes constant changes to support new requirements, address bugs, enhance performance, and ensure maintainability. Thus, developers spend a great portion of their workday trying to understand and review the code changes of their teammates. Abstract Syntax Tree (AST) diff tools were developed to overcome the limitations of line-based diff tools, which are used by the majority of developers. Despite the notable improvements brought by AST diff tools in understanding complex changes, they still suffer from serious limitations, such as (1) lacking multi-mapping support, (2) matching semantically incompatible AST nodes, (3) ignoring language clues to guide the matching process, (4) lacking refactoring awareness, and (5) lacking commit-level diff support. We propose a novel AST diff tool based on RefactoringMiner that resolves all aforementioned limitations. First, we improved RefactoringMiner to increase its statement mapping accuracy, and then we developed an algorithm that generates AST diff for a given commit or pull request based on the refactoring instances and pairs of matched program element declarations provided by RefactoringMiner. To evaluate the accuracy of our tool and compare it with the state-of-the-art tools, we created the first benchmark of AST node mappings, including 800 bug-fixing commits and 188 refactoring commits. Our evaluation showed that our tool achieved a considerably higher precision and recall, especially for refactoring commits, with an execution time that is comparable with that of the faster tools.

@article{Coelho:EMSE:2024,
  author = {Coelho, Flávia and Tsantalis, Nikolaos and Massoni, Tiago and Alves, Everton L. G.},
  journal = {Empirical Software Engineering},
  title = {A Qualitative Study on Refactorings Induced by Code Review},
  year = {2025},
  volume = {30}, 
  number = {17},
  doi = {10.1007/s10664-024-10560-7},
  url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/EMSE_2024a.pdf},
}

@article{Shao:EMSE:2024,
  author = {Shao, Hanying and Ding, Zishuo and Shang, Weiyi and Yang, Jinqiu and Tsantalis, Nikolaos},
  journal = {Empirical Software Engineering},
  title = {Towards Effectively Testing Machine Translation Systems from White-Box Perspectives},
  year = {2025},
  volume = {30}, 
  number = {13},
  doi = {10.1007/s10664-024-10549-2},
  url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/EMSE_2024b.pdf},
}

@article{Hasan:TSE:2024:CodeTracker2.0,
	author={Hasan, Mohammed Tayeeb and Tsantalis, Nikolaos and Alikhanifard, Pouria},
	journal={IEEE Transactions on Software Engineering}, 
	title={Refactoring-aware Block Tracking in Commit History}, 
	year={2024},
	volume={50},
	number={12},
	pages={3330-3350},
	doi={10.1109/TSE.2024.3484586},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/TSE_2024.pdf},
}

@article{Jafari:TSE:2021,
	author={Javan Jafari, Abbas and Costa, Diego Elias and Abdalkareem, Rabe and Shihab, Emad and Tsantalis, Nikolaos},
	journal={IEEE Transactions on Software Engineering}, 
	title={Dependency Smells in JavaScript Projects}, 
	year={2022},
	volume={48},
	number={10},
	pages={3790-3807},
	doi={10.1109/TSE.2021.3106247},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/TSE_2021.pdf},
	bibbase_note = {<span style="color: blue"><strong>Journal-first paper at ICSE 2022</strong></span>},
}

@article{Tsantalis:TSE:2020:RefactoringMiner2.0,
	author={Tsantalis, Nikolaos and Ketkar, Ameya and Dig, Danny},
	title={RefactoringMiner 2.0},
	journal={IEEE Transactions on Software Engineering},
	year={2022},
	volume={48},
	number={3},
	pages={930-950},
	doi={10.1109/TSE.2020.3007722},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/TSE_2020.pdf},
}

@inproceedings{Jodavi:FSE:2022,
	author = {Jodavi, Mehran and Tsantalis, Nikolaos},
	title = {Accurate Method and Variable Tracking in Commit History},
	year = {2022},
	isbn = {9781450394130},
	publisher = {Association for Computing Machinery},
	address = {New York, NY, USA},
	--url = {https://doi.org/10.1145/3540250.3549079},
	doi = {10.1145/3540250.3549079},
	booktitle = {Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering},
	pages = {183–195},
	numpages = {13},
	keywords = {commit change history, refactoring-aware source code tracking},
	location = {Singapore, Singapore},
	--series = {ESEC/FSE 2022},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/FSE_2022.pdf},
	url_Link={https://github.com/jodavimehran/code-tracker},
}

@inproceedings{Ketkar:ICSE:2022,
	author = {Ketkar, Ameya and Smirnov, Oleg and Tsantalis, Nikolaos and Dig, Danny and Bryksin, Timofey},
	title = {Inferring and Applying Type Changes},
	year = {2022},
	booktitle = {Proceedings of the 44th International Conference on Software Engineering},
	--series = {ICSE 2022},
	doi = {10.1145/3510003.3510115},
	publisher = {Association for Computing Machinery},
	address = {New York, NY, USA},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2022.pdf},
	url_Link={https://github.com/JetBrains-Research/data-driven-type-migration},
}

@inproceedings{IntelliTC:ICSE:2022,
	author = {Oleg Smirnov and Ameya Ketkar and Timofey Bryksin and Nikolaos Tsantalis and Danny Dig},
	booktitle = {2022 IEEE/ACM 44th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion)},
	title = {IntelliTC: Automating Type Changes in IntelliJ IDEA},
	year = {2022},
	issn = {2574-1926},
	pages = {115-119},
	keywords = {java;codes;video on demand;inspection;user experience;software;history},
	doi = {10.1109/ICSE-Companion55297.2022.9793766},
	--url = {https://doi.ieeecomputersociety.org/10.1109/ICSE-Companion55297.2022.9793766},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	month = {may},
	url_Paper = {https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2022a.pdf},
	url_Link = {https://www.youtube.com/watch?v=pdcfvADA1PY},
}

@inproceedings{Coelho:ESEM:2021,
	author = {Coelho, Fl\'{a}via and Tsantalis, Nikolaos and Massoni, Tiago and Alves, Everton L. G.},
	title = {An Empirical Study on Refactoring-Inducing Pull Requests},
	year = {2021},
	isbn = {9781450386654},
	publisher = {Association for Computing Machinery},
	address = {New York, NY, USA},
	--url = {https://doi.org/10.1145/3475716.3475785},
	doi = {10.1145/3475716.3475785},
	booktitle = {Proceedings of the 15th ACM / IEEE International Symposium on Empirical Software Engineering and Measurement},
	articleno = {9},
	numpages = {12},
	keywords = {code review mining, empirical study, refactoring-inducing pull request},
	location = {Bari, Italy},
	--series = {ESEM '21},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/ESEM_2021.pdf},
	url_link={https://github.com/flaviacoelho/riprs-reproduction-kit},
}

@inproceedings{Kim:ICSE:2021,
	author = {Kim, Dong Jae and Tsantalis, Nikolaos and Chen, Tse-Hsun (Peter) and Yang, Jinqiu},
	title = {Studying Test Annotation Maintenance in the Wild},
	year = {2021},
	booktitle = {Proceedings of the 43rd International Conference on Software Engineering},
	--series = {ICSE 2021},
	pages = {62-73},
	keywords = {java;annotations;fixtures;taxonomy;maintenance engineering;tools;testing},
	doi = {10.1109/ICSE43902.2021.00019},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2021.pdf},
}

@inproceedings{PyRef:SCAM:2021,
	author = {Hassan Atwi and Bin Lin and Nikolaos Tsantalis and Yutaro Kashiwa and Yasutaka Kamei and Naoyasu Ubayashi and Gabriele Bavota and Michele Lanza},
	booktitle = {Proceedings of the IEEE 21st International Working Conference on Source Code Analysis and Manipulation},
	title = {PyRef: Refactoring Detection in Python Projects},
	--series = {SCAM '21},
	year = {2021},
	pages = {136-141},
	keywords = {java;codes;conferences;tools;programming;maintenance engineering;software systems},
	doi = {10.1109/SCAM52516.2021.00025},
	--url = {https://doi.ieeecomputersociety.org/10.1109/SCAM52516.2021.00025},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	month = {sep},
	url_Paper = {https://users.encs.concordia.ca/~nikolaos/publications/SCAM_2021.pdf},
}

@inproceedings{Ketkar:FSE:2020,
	author = {Ketkar, Ameya and Tsantalis, Nikolaos and Dig, Danny},
	title = {Understanding Type Changes in Java},
	year = {2020},
	isbn = {9781450370431},
	publisher = {Association for Computing Machinery},
	address = {New York, NY, USA},
	--url = {https://doi.org/10.1145/3368089.3409725},
	doi = {10.1145/3368089.3409725},
	booktitle = {Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering},
	pages = {629–641},
	numpages = {13},
	keywords = {Type Change Adaptations, Git, Empirical Study, Type Migration, Type Change Mining, Type Change Patterns, Commit},
	location = {Virtual Event, USA},
	--series = {ESEC/FSE 2020},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/FSE_2020.pdf},
}

@article{Afjehei:EMSE:2019,
	author="Afjehei, Sara Seif and Chen, Tse-Hsun and Tsantalis, Nikolaos",
	title="iPerfDetector: Characterizing and detecting performance anti-patterns in iOS applications",
	journal="Empirical Software Engineering",
	year="2019",
	month="Dec",
	day="01",
	volume="24",
	number="6",
	pages="3484--3513",
	abstract="Performance issues in mobile applications (i.e., apps) often have a direct impact on the user experience. However, due to limited testing resources and fast-paced software development cycles, many performance issues remain undiscovered when the apps are released. As found by a prior study, these performance issues are one of the most common complaints that app users have. Unfortunately, there is a limited support to help developers avoid or detect performance issues in mobile apps. In this paper, we conduct an empirical study on performance issues in iOS apps written in Swift language. To the best of our knowledge, this is the first study on performance issues of apps on the iOS platform. We manually studied 225 performance issues that are collected from four open source iOS apps. We found that most performance issues in iOS apps are related to inefficient UI design, memory issues, and inefficient thread handling. We also manually uncovered four performance anti-patterns that recurred in the studied issue reports. To help developers avoid these performance anti-patterns in the code, we implemented a static analysis tool called iPerfDetector. We evaluated iPerfDetector on eight open source and three commercial apps. iPerfDetector successfully detected 34 performance anti-pattern instances in the studied apps, where 31 of them are already confirmed and accepted by developers as potential performance issues. Our case study on the performance impact of the anti-patterns shows that fixing the anti-pattern may improve the performance (i.e., response time, GPU, or CPU) of the workload by up to 80{\%}.",
	issn="1573-7616",
	doi="10.1007/s10664-019-09703-y",
	--url="https://doi.org/10.1007/s10664-019-09703-y",
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/EMSE_2019.pdf},
	url_Link={https://github.com/saraseif/iPerfDetector},
}

Performance issues in mobile applications (i.e., apps) often have a direct impact on the user experience. However, due to limited testing resources and fast-paced software development cycles, many performance issues remain undiscovered when the apps are released. As found by a prior study, these performance issues are one of the most common complaints that app users have. Unfortunately, there is a limited support to help developers avoid or detect performance issues in mobile apps. In this paper, we conduct an empirical study on performance issues in iOS apps written in Swift language. To the best of our knowledge, this is the first study on performance issues of apps on the iOS platform. We manually studied 225 performance issues that are collected from four open source iOS apps. We found that most performance issues in iOS apps are related to inefficient UI design, memory issues, and inefficient thread handling. We also manually uncovered four performance anti-patterns that recurred in the studied issue reports. To help developers avoid these performance anti-patterns in the code, we implemented a static analysis tool called iPerfDetector. We evaluated iPerfDetector on eight open source and three commercial apps. iPerfDetector successfully detected 34 performance anti-pattern instances in the studied apps, where 31 of them are already confirmed and accepted by developers as potential performance issues. Our case study on the performance impact of the anti-patterns shows that fixing the anti-pattern may improve the performance (i.e., response time, GPU, or CPU) of the workload by up to 80%.

@inproceedings{Mahmoudi:SANER:2019,
	author={Mahmoudi, Mehran and Nadi, Sarah and Tsantalis, Nikolaos},
	booktitle={Proceedings of the IEEE 26th International Conference on Software Analysis, Evolution and Reengineering},
	title={Are Refactorings to Blame? An Empirical Study of Refactorings in Merge Conflicts},
	year={2019},
	--series={SANER '19},
	pages={151-162},
	keywords={Merging;Tools;Java;Task analysis;Open source software;Control systems;refactoring;git;merge conflict;software evolution},
	doi={10.1109/SANER.2019.8668012},
	ISSN={1534-5351},
	month={Feb},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/SANER_2019.pdf},
	url_Slides={https://users.encs.concordia.ca/~nikolaos/publications/SANER_2019.pptx},
	url_link={https://github.com/ualberta-smr/RefactoringsInMergeCommits},
}

@inproceedings{Sierra:SANER:2019, 
	author={Giancarlo Sierra and Ahmad Tahmid and Emad Shihab and Nikolaos Tsantalis}, 
	booktitle={Proceedings of the IEEE 26th International Conference on Software Analysis, Evolution and Reengineering}, 
	title={Is Self-Admitted Technical Debt a Good Indicator of Architectural Divergences?}, 
	year={2019},  
	pages={534-543}, 
	doi={10.1109/SANER.2019.8667999}, 
	ISSN={1534-5351}, 
	month={Feb},
	url_Paper={https://users.encs.concordia.ca/~nikolaos/publications/SANER_2019a.pdf},
}

@article{Hassani:EMSE:2018,
	author={Hassani, Mehran and Shang, Weiyi and Shihab, Emad and Tsantalis, Nikolaos},
	journal={Empirical Software Engineering},
	title={Studying and Detecting Log-Related Issues},
	year={2018},
	month=dec,
	volume={23},
	number={6},
	pages={3248--3280},
	abstract={Logs capture valuable information throughout the execution of software systems. The rich knowledge conveyed in logs is highly leveraged by researchers and practitioners in performing various tasks, both in software development and its operation. Log-related issues, such as missing or having outdated information, may have a large impact on the users who depend on these logs. In this paper, we first perform an empirical study on log-related issues in two large-scale, open source software systems. We find that the files with log-related issues have undergone statistically significantly more frequent prior changes, and bug fixes. We also find that developers fixing these log-related issues are often not the ones who introduced the logging statement nor the owner of the method containing the logging statement. Maintaining logs is more challenging without clear experts. Finally, we find that most of the defective logging statements remain unreported for a long period (median 320 days). Once reported, the issues are fixed quickly (median five days). Our empirical findings suggest the need for automated tools that can detect log-related issues promptly. We conducted a manual study and identified seven root-causes of the log-related issues. Based on these root causes, we developed an automated tool that detects four evident types of log-related issues. Our tool can detect 75 existing inappropriate logging statements reported in 40 log-related issues. We also reported new issues found by our tool to developers and 38 previously unknown issues in the latest release of the subject systems were accepted by developers.},
	issn={1573-7616},
	doi={10.1007/s10664-018-9603-z},
	--url={https://doi.org/10.1007/s10664-018-9603-z},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/EMSE_2018.pdf},
	bibbase_note = {<span style="color: blue"><strong>Journal-first paper at ESEC/FSE 2018</strong></span>},
}

Logs capture valuable information throughout the execution of software systems. The rich knowledge conveyed in logs is highly leveraged by researchers and practitioners in performing various tasks, both in software development and its operation. Log-related issues, such as missing or having outdated information, may have a large impact on the users who depend on these logs. In this paper, we first perform an empirical study on log-related issues in two large-scale, open source software systems. We find that the files with log-related issues have undergone statistically significantly more frequent prior changes, and bug fixes. We also find that developers fixing these log-related issues are often not the ones who introduced the logging statement nor the owner of the method containing the logging statement. Maintaining logs is more challenging without clear experts. Finally, we find that most of the defective logging statements remain unreported for a long period (median 320 days). Once reported, the issues are fixed quickly (median five days). Our empirical findings suggest the need for automated tools that can detect log-related issues promptly. We conducted a manual study and identified seven root-causes of the log-related issues. Based on these root causes, we developed an automated tool that detects four evident types of log-related issues. Our tool can detect 75 existing inappropriate logging statements reported in 40 log-related issues. We also reported new issues found by our tool to developers and 38 previously unknown issues in the latest release of the subject systems were accepted by developers.

@inproceedings{Tsantalis:2018:AER:3180155.3180206,
	author = {Tsantalis, Nikolaos and Mansouri, Matin and Eshkevari, Laleh M. and Mazinanian, Davood and Dig, Danny},
	title = {Accurate and Efficient Refactoring Detection in Commit History},
	booktitle = {Proceedings of the 40th International Conference on Software Engineering},
	--series = {ICSE '18},
	year = {2018},
	isbn = {978-1-4503-5638-1},
	location = {Gothenburg, Sweden},
	pages = {483--494},
	numpages = {12},
	--url = {http://doi.acm.org/10.1145/3180155.3180206},
	doi = {10.1145/3180155.3180206},
	acmid = {3180206},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {Git, Oracle, abstract syntax tree, accuracy, commit, refactoring},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2018.pdf},
	url_Slides ={https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2018.pptx},
	url_link = {http://refactoring.encs.concordia.ca/oracle/},
}

@inproceedings{Tsantalis:MIP:2018,
	author={Tsantalis, Nikolaos and Chaikalis, Theodoros and Chatzigeorgiou, Alexander},
	booktitle={Proceedings of the IEEE 25th International Conference on Software Analysis, Evolution and Reengineering},
	title={Ten years of JDeodorant: Lessons learned from the hunt for smells},
	--series={SANER '18},
	year={2018},
	pages={4-14},
	keywords={Feature extraction;Google;History;Measurement;Open source software;Tools;Code Smells;Object-Oriented Software;Refactoring},
	doi={10.1109/SANER.2018.8330192},
	month={March},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/SANER_MIP_2018.pdf},
	bibbase_note = {<span style="color: blue"><strong>Most Influential Paper Retrospective</strong></span>},
}

@article{MKTD:OOPSLA:2017,
	author = {Mazinanian, Davood and Ketkar, Ameya and Tsantalis, Nikolaos and Dig, Danny},
	title = {Understanding the Use of Lambda Expressions in Java},
	journal = {Proceedings of the ACM on Programming Languages},
	issue_date = {October 2017},
	volume = {1},
	number = {OOPSLA},
	month = oct,
	year = {2017},
	issn = {2475-1421},
	pages = {85:1--85:31},
	articleno = {85},
	numpages = {31},
	--url = {http://doi.acm.org/10.1145/3133909},
	doi = {10.1145/3133909},
	acmid = {3133909},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {Empirical Studies, Functional Programming, Java 8, Lambda Expressions,
	Multi-paradigm Programming, The Firehouse Interview Method},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/OOPSLA_2017.pdf},
	url_link = {http://dmazinanian.me/journal-papers/oopsla/2017/07/04/oopsla17.html},
	bibbase_note = {<span style="color: blue"><strong>ACM SIGPLAN Distinguished Artifact Award</strong></span>},
}

@article{Maldonado:TSE:2017,
	author={Maldonado, Everton da Silva and Shihab, Emad and Tsantalis, Nikolaos}, 
	journal={IEEE Transactions on Software Engineering},
	title={Using Natural Language Processing to Automatically Detect Self-Admitted Technical Debt},
	year={2017},
	volume={43},
	number={11},
	pages={1044-1062},
	keywords={Entropy, Java, Manuals, Natural language processing, Software, Structured Query Language, Unified modeling language, Technical debt, empirical study, source code comments},
	doi={10.1109/TSE.2017.2654244},
	ISSN={0098-5589},
	month=nov,
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/TSE_2017.pdf},
	url_Link ={https://github.com/maldonado/tse.satd.data},
	bibbase_note = {<span style="color: blue"><strong>Featured article of the November 2017 issue</strong></span>},
}

@inproceedings{Tsantalis:ICSE:2017,
	author = {Tsantalis, Nikolaos and Mazinanian, Davood and Rostami, Shahriar},
	title = {Clone Refactoring with Lambda Expressions},
	booktitle = {Proceedings of the 39th International Conference on Software Engineering},
	--series = {ICSE '17},
	year = {2017},
	isbn = {978-1-5386-3868-2},
	location = {Buenos Aires, Argentina},
	pages = {60--70},
	numpages = {11},
	--url = {https://doi.org/10.1109/ICSE.2017.14},
	doi = {10.1109/ICSE.2017.14},
	acmid = {3097377},
	publisher = {IEEE Press},
	address = {Piscataway, NJ, USA},
	keywords = {code duplication, lambda expressions, refactoring},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2017.pdf},
	url_link = {ICSE_2017/},
	bibbase_note = {<span style="color: blue"><strong>ACM SIGSOFT Distinguished Paper Award</strong></span>},
}

@inproceedings{Eshkevari:2017:JCJ:3098344.3098367,
	author = {Eshkevari, Laleh and Mazinanian, Davood and Rostami, Shahriar and Tsantalis, Nikolaos},
	title = {JSDeodorant: Class-awareness for JavaScript Programs},
	booktitle = {Proceedings of the 39th International Conference on Software Engineering Companion},
	--series = {ICSE-C '17},
	year = {2017},
	isbn = {978-1-5386-1589-8},
	location = {Buenos Aires, Argentina},
	pages = {71--74},
	numpages = {4},
	--url = {https://doi.org/10.1109/ICSE-C.2017.6},
	doi = {10.1109/ICSE-C.2017.6},
	acmid = {3098367},
	publisher = {IEEE Press},
	address = {Piscataway, NJ, USA},
	url_Paper = {https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2017a.pdf},
	url_Link = {https://www.youtube.com/watch?v=k4U2LwkL6JU},
}

@inproceedings{Mazinanian:ICSE:2017:CSSDev,
	author = {Mazinanian, Davood and Tsantalis, Nikolaos},
	booktitle = {Proceedings of the 39th International Conference on Software Engineering Companion},
	title = {CSSDev: Refactoring Duplication in Cascading Style Sheets},
	--series = {ICSE-C '17},
	year = {2017},
	pages = {63-66},
	numpages = {4},
	doi = {10.1109/ICSE-C.2017.7},
	month = {May},
	url_Paper = {https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2017b.pdf},
	url_Link = {https://www.youtube.com/watch?v=lu3oITi1XrQ},
}

@inproceedings{Mazinanian:ASE:2016,
	author = {Mazinanian, Davood and Tsantalis, Nikolaos},
	title = {Migrating Cascading Style Sheets to Preprocessors by Introducing Mixins},
	booktitle = {Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering},
	--series = {ASE 2016},
	year = {2016},
	isbn = {978-1-4503-3845-5},
	location = {Singapore, Singapore},
	pages = {672--683},
	numpages = {12},
	--url = {http://doi.acm.org/10.1145/2970276.2970348},
	doi = {10.1145/2970276.2970348},
	acmid = {2970348},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {Cascading style sheets, duplication, migration, refactoring},
	url_Paper = {https://users.encs.concordia.ca/~nikolaos/publications/ASE_2016.pdf},
	url_link = {http://dmazinanian.me/publications/ASE'16/},
	abstract = {Cascading Style Sheets (CSS) is the standard language for styling web documents and is extensively used in the industry. However, CSS lacks constructs that would allow code reuse (e.g., functions). Consequently, maintaining CSS code is often a cumbersome and error-prone task. Preprocessors (e.g., Less and Sass) have been introduced to fill this gap, by extending CSS with the missing constructs. Despite the clear maintainability benefits coming from the use of prepro-cessors, there is currently no support for migrating legacy CSS code to preprocessors. In this paper, we propose a technique for automatically detecting duplicated style declarations in CSS code that can be migrated to preproces-sor functions (i.e., mixins). Our technique can parameter-ize differences in the style values of duplicated declarations, and ensure that the migration will not change the presentation semantics of the web documents. The evaluation has shown that our technique is able to detect 98% of the mix-ins that professional developers introduced in websites and Style Sheet libraries, and can safely migrate real CSS code.},
	bibbase_note = {<span style="color: blue"><strong>Invited to Special Issue of the Automated Software Engineering Journal</strong></span>},
}

Cascading Style Sheets (CSS) is the standard language for styling web documents and is extensively used in the industry. However, CSS lacks constructs that would allow code reuse (e.g., functions). Consequently, maintaining CSS code is often a cumbersome and error-prone task. Preprocessors (e.g., Less and Sass) have been introduced to fill this gap, by extending CSS with the missing constructs. Despite the clear maintainability benefits coming from the use of prepro-cessors, there is currently no support for migrating legacy CSS code to preprocessors. In this paper, we propose a technique for automatically detecting duplicated style declarations in CSS code that can be migrated to preproces-sor functions (i.e., mixins). Our technique can parameter-ize differences in the style values of duplicated declarations, and ensure that the migration will not change the presentation semantics of the web documents. The evaluation has shown that our technique is able to detect 98% of the mix-ins that professional developers introduced in websites and Style Sheet libraries, and can safely migrate real CSS code.

@inproceedings{Silva:FSE:2016,
	author = {Silva, Danilo and Tsantalis, Nikolaos and Valente, Marco Tulio},
	title = {Why We Refactor? Confessions of GitHub Contributors},
	booktitle = {Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering},
	--series = {FSE 2016},
	year = {2016},
	isbn = {978-1-4503-4218-6},
	location = {Seattle, WA, USA},
	pages = {858--870},
	numpages = {13},
	--url = {http://doi.acm.org/10.1145/2950290.2950305},
	doi = {10.1145/2950290.2950305},
	acmid = {2950305},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {GitHub, Refactoring, code smells, software evolution},
	url_Paper = {https://users.encs.concordia.ca/~nikolaos/publications/FSE_2016.pdf},
	url_Link = {http://aserg-ufmg.github.io/why-we-refactor},
	bibbase_note = {<span style="color: blue"><strong>ACM SIGSOFT Distinguished Paper Award</strong></span> and <span style="color: blue"><strong>ACM SIGSOFT Distinguished Artifact Award</strong></span>},
	abstract = {Refactoring is a widespread practice that helps developers to improve the maintainability and readability of their code. However, there is a limited number of studies empirically investigating the actual motivations behind specific refactoring operations applied by developers. To fill this gap, we monitored Java projects hosted on GitHub to detect recently applied refactorings, and asked the developers to explain the reasons behind their decision to refactor the code. By applying thematic analysis on the collected responses, we compiled a catalogue of 44 distinct motivations for 12 well-known refactoring types. We found that refactoring activity is mainly driven by changes in the requirements and much less by code smells. Extract Method is the most versatile refactoring operation serving 11 different purposes. Finally, we found evidence that the IDE used by the developers affects the adoption of automated refactoring tools.},
}

Refactoring is a widespread practice that helps developers to improve the maintainability and readability of their code. However, there is a limited number of studies empirically investigating the actual motivations behind specific refactoring operations applied by developers. To fill this gap, we monitored Java projects hosted on GitHub to detect recently applied refactorings, and asked the developers to explain the reasons behind their decision to refactor the code. By applying thematic analysis on the collected responses, we compiled a catalogue of 44 distinct motivations for 12 well-known refactoring types. We found that refactoring activity is mainly driven by changes in the requirements and much less by code smells. Extract Method is the most versatile refactoring operation serving 11 different purposes. Finally, we found evidence that the IDE used by the developers affects the adoption of automated refactoring tools.

@inproceedings{Mazinanian:SANER:2016,
	author = {Mazinanian, Davood and Tsantalis, Nikolaos},
	title = {An empirical study on the use of CSS preprocessors},
	booktitle = {Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering},
	--series = {SANER '16},
	year = {2016},
	location = {Osaka, Japan},
	pages = {168--178},
	numpages = {11},
	--url = {http://dx.doi.org/10.1109/SANER.2016.18},
	doi = {10.1109/SANER.2016.18},
	url_Paper = {https://users.encs.concordia.ca/~nikolaos/publications/SANER_2016.pdf},
	url_Slides = {http://www.slideshare.net/tsantalis/an-empirical-study-on-the-use-of-css-preprocessors},
	bibbase_note = {<span style="color: blue"><strong>Best Paper Candidate Award</strong></span>},
	abstract = {Cascading Style Sheets (CSS) is the standard language for styling structured documents, such as HTML. However, CSS lacks most of the traditional programming constructs, including variables and functions, which enable code reuse and structured programming. Alternatively, CSS Preprocessors (e.g., LESS, SASS) have been introduced as superset languages to extend CSS by supporting those missing constructs. While these languages are being widely used by developers, we do not have sufficient knowledge about how developers take advantage of the features they provide. Gaining this knowledge is crucial for providing better tool support to the developer community by devising techniques for the automatic migration of existing CSS code to take advantage of CSS Preprocessor language features, designing refactoring recommendation systems for existing Preprocessor code, and giving insights to the Preprocessor language designers for improving language usability. In this paper, we have empirically investigated the CSS Preprocessor codebase of 150 websites regarding four preprocessor features, namely variables, nested selectors, mixins and extend constructs, and report the discovered usage patterns for each feature. We also discuss how the gained knowledge can be put into practice towards improving the development and maintenance of CSS preprocessor code.},
}

Cascading Style Sheets (CSS) is the standard language for styling structured documents, such as HTML. However, CSS lacks most of the traditional programming constructs, including variables and functions, which enable code reuse and structured programming. Alternatively, CSS Preprocessors (e.g., LESS, SASS) have been introduced as superset languages to extend CSS by supporting those missing constructs. While these languages are being widely used by developers, we do not have sufficient knowledge about how developers take advantage of the features they provide. Gaining this knowledge is crucial for providing better tool support to the developer community by devising techniques for the automatic migration of existing CSS code to take advantage of CSS Preprocessor language features, designing refactoring recommendation systems for existing Preprocessor code, and giving insights to the Preprocessor language designers for improving language usability. In this paper, we have empirically investigated the CSS Preprocessor codebase of 150 websites regarding four preprocessor features, namely variables, nested selectors, mixins and extend constructs, and report the discovered usage patterns for each feature. We also discuss how the gained knowledge can be put into practice towards improving the development and maintenance of CSS preprocessor code.

@inproceedings{Rostami:ICSME:2016,
	author = {Rostami, Shahriar and Eshkevari, Laleh and Mazinanian, Davood and Tsantalis, Nikolaos},
	title = {Detecting Function Constructors in JavaScript},
	booktitle = {Proceedings of the 32nd IEEE International Conference on Software Maintenance and Evolution},
	--series = {ICSME '16},
	year = {2016},
	pages = {488-492},
	doi = {10.1109/ICSME.2016.29},
	location = {Raleigh, North Carolina, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICSME_2016.pdf},
	url_Link = {https://github.com/sshishe/jsdeodorant},
}

@inproceedings{Mazinanian:2016:JCR:2889160.2889168,
	author = {Mazinanian, Davood and Tsantalis, Nikolaos and Stein, Raphael and Valenta, Zackary},
	title = {JDeodorant: Clone Refactoring},
	booktitle = {Proceedings of the 38th International Conference on Software Engineering Companion},
	--series = {ICSE '16},
	year = {2016},
	isbn = {978-1-4503-4205-6},
	location = {Austin, Texas},
	pages = {613--616},
	numpages = {4},
	--url = {http://doi.acm.org/10.1145/2889160.2889168},
	doi = {10.1145/2889160.2889168},
	acmid = {2889168},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {code duplication, refactorability analysis, refactoring},
	url_Paper = {https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2016.pdf},
	url_Link = {https://www.youtube.com/watch?v=K_xAEqIEJ-4},
}

@article{Tsantalis:TSE:2015,
	author={Tsantalis, Nikolaos and Mazinanian, Davood and Krishnan, Giri P.}, 
	journal={IEEE Transactions on Software Engineering}, 
	title={Assessing the Refactorability of Software Clones}, 
	year={2015}, 
	volume={41}, 
	number={11}, 
	pages={1055-1090}, 
	--url={http://dx.doi.org/10.1109/TSE.2015.2448531},
	doi={10.1109/TSE.2015.2448531}, 
	ISSN={0098-5589}, 
	month=nov,
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/TSE_2015.pdf},
	url_Link ={TSE_2015/},
	bibbase_note = {<span style="color: blue"><strong>Featured article of the November 2015 issue</strong></span>},
	abstract = {The presence of duplicated code in software systems is significant and several studies have shown that clones can be potentially harmful with respect to the maintainability and evolution of the source code. Despite the significance of the problem, there is still limited support for eliminating software clones through refactoring, because the unification and merging of duplicated code is a very challenging problem, especially when software clones have gone through several modifications after their initial introduction. In this work, we propose an approach for automatically assessing whether a pair of clones can be safely refactored without changing the behavior of the program. In particular, our approach examines if the differences present between the clones can be safely parameterized without causing any side-effects. The evaluation results have shown that the clones assessed as refactorable by our approach can be indeed refactored without causing any compile errors or test failures. Additionally, the computational cost of the proposed approach is negligible (less than a second) in the vast majority of the examined cases. Finally, we perform a large-scale empirical study on over a million clone pairs detected by four different clone detection tools in nine open-source projects to investigate how refactorability is affected by different clone properties and tool configuration options. Among the highlights of our conclusions, we found that a) clones in production code tend to be more refactorable than clones in test code, b) clones with a close relative location (i.e., same method, type, or file) tend to be more refactorable than clones in distant locations (i.e., same hierarchy, or unrelated types), c) Type-1 clones tend to be more refactorable than the other clone types, and d) clones with a small size tend to be more refactorable than clones with a larger size.},
}

The presence of duplicated code in software systems is significant and several studies have shown that clones can be potentially harmful with respect to the maintainability and evolution of the source code. Despite the significance of the problem, there is still limited support for eliminating software clones through refactoring, because the unification and merging of duplicated code is a very challenging problem, especially when software clones have gone through several modifications after their initial introduction. In this work, we propose an approach for automatically assessing whether a pair of clones can be safely refactored without changing the behavior of the program. In particular, our approach examines if the differences present between the clones can be safely parameterized without causing any side-effects. The evaluation results have shown that the clones assessed as refactorable by our approach can be indeed refactored without causing any compile errors or test failures. Additionally, the computational cost of the proposed approach is negligible (less than a second) in the vast majority of the examined cases. Finally, we perform a large-scale empirical study on over a million clone pairs detected by four different clone detection tools in nine open-source projects to investigate how refactorability is affected by different clone properties and tool configuration options. Among the highlights of our conclusions, we found that a) clones in production code tend to be more refactorable than clones in test code, b) clones with a close relative location (i.e., same method, type, or file) tend to be more refactorable than clones in distant locations (i.e., same hierarchy, or unrelated types), c) Type-1 clones tend to be more refactorable than the other clone types, and d) clones with a small size tend to be more refactorable than clones with a larger size.

@inproceedings{Mazinanian:2014:DRO:2635868.2635879,
	author = {Mazinanian, Davood and Tsantalis, Nikolaos and Mesbah, Ali},
	title = {Discovering Refactoring Opportunities in Cascading Style Sheets},
	booktitle = {Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering},
	--series = {FSE '14},
	year = {2014},
	isbn = {978-1-4503-3056-5},
	location = {Hong Kong, China},
	pages = {496--506},
	numpages = {11},
	--url = {http://doi.acm.org/10.1145/2635868.2635879},
	doi = {10.1145/2635868.2635879},
	acmid = {2635879},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {Cascading style sheets, duplication, refactoring},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/FSE_2014.pdf},
}

@inproceedings{Krishnan:2014:6747160, 
	author={Krishnan, Giri P. and Tsantalis, Nikolaos}, 
	booktitle={Proceedings of the IEEE Conference on Software Maintenance, Reengineering and Reverse Engineering}, 
	title={Unification and refactoring of clones}, 
	year={2014}, 
	pages={104-113}, 
	doi={10.1109/CSMR-WCRE.2014.6747160},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/CSMR-WCRE_2014.pdf},
}

@inproceedings{Bavota:2014:RRB:2642937.2642948,
	author = {Bavota, Gabriele and Panichella, Sebastiano and Tsantalis, Nikolaos and Di Penta, Massimiliano and
	          Oliveto, Rocco and Canfora, Gerardo},
	title = {Recommending Refactorings Based on Team Co-maintenance Patterns},
	booktitle = {Proceedings of the 29th ACM/IEEE International Conference on Automated Software Engineering},
	--series = {ASE '14},
	year = {2014},
	isbn = {978-1-4503-3013-8},
	location = {Vasteras, Sweden},
	pages = {337--342},
	numpages = {6},
	--url = {http://doi.acm.org/10.1145/2642937.2642948},
	doi = {10.1145/2642937.2642948},
	acmid = {2642948},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {developers, refactoring, teams},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ASE_2014.pdf},
}

@incollection{Mikhaiel:2013,
	year={2013},
	isbn={978-3-642-35991-0},
	booktitle={Generative and Transformational Techniques in Software Engineering IV},
	volume={7680},
	series={Lecture Notes in Computer Science},
	editor={L\"{a}mmel, Ralf and Saraiva, Jo\~{a}o and Visser, Joost},
	doi={10.1007/978-3-642-35992-7_4},
	title={Differencing UML Models: A Domain-Specific vs. a Domain-Agnostic Method},
	--url={http://dx.doi.org/10.1007/978-3-642-35992-7_4},
	publisher={Springer Berlin Heidelberg},
	keywords={UML, software differencing, software evolution},
	author={Mikhaiel, Rimon and Tsantalis, Nikolaos and Negara, Natalia and Stroulia, Eleni and Xing, Zhenchang},
	pages={159-196},
	language={English},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/GTTSE_2013.pdf},
}

@inproceedings{Tsantalis:2013:MES:2555523.2555539,
	author = {Tsantalis, Nikolaos and Guana, Victor and Stroulia, Eleni and Hindle, Abram},
	title = {A Multidimensional Empirical Study on Refactoring Activity},
	booktitle = {Proceedings of the 2013 Conference of the Center for Advanced Studies on Collaborative Research},
	--series = {CASCON '13},
	year = {2013},
	location = {Ontario, Canada},
	pages = {132--146},
	numpages = {15},
	url = {http://dl.acm.org/citation.cfm?id=2555523.2555539},
	acmid = {2555539},
	--doi = {doi.acm.org/10.1145/2555523.2555539},
	publisher = {IBM Corp.},
	address = {Riverton, NJ, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/CASCON_2013.pdf},
}

@inproceedings{Negara:2013:6498464, 
	author={Negara, N. and Tsantalis, N. and Stroulia, E.}, 
	booktitle={Proceedings of the 17th European Conference on Software Maintenance and Reengineering}, 
	title={Feature Detection in Ajax-Enabled Web Applications}, 
	year={2013}, 
	pages={154-163}, 
	doi={10.1109/CSMR.2013.25}, 
	ISSN={1534-5351},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/CSMR_2013.pdf},
}

@inproceedings{Krishnan:2013:RCO:2550526.2550590,
	author = {Krishnan, Giri Panamoottil and Tsantalis, Nikolaos},
	title = {Refactoring Clones: An Optimization Problem},
	booktitle = {Proceedings of the 29th IEEE International Conference on Software Maintenance},
	--series = {ICSM '13},
	year = {2013},
	isbn = {978-0-7695-4981-1},
	pages = {360--363},
	numpages = {4},
	--url = {http://dx.doi.org/10.1109/ICSM.2013.47},
	doi = {10.1109/ICSM.2013.47},
	acmid = {2550590},
	publisher = {IEEE Computer Society},
	address = {Washington, DC, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICSM_2013.pdf},
}

@inproceedings{Tsantalis:2013:RCN:2662708.2662712,
	author = {Tsantalis, Nikolaos and Krishnan, Giri Panamoottil},
	title = {Refactoring Clones: A New Perspective},
	booktitle = {Proceedings of the 7th International Workshop on Software Clones},
	--series = {IWSC '13},
	year = {2013},
	isbn = {978-1-4673-6445-4},
	location = {San Francisco, California},
	pages = {12--13},
	numpages = {2},
	url = {http://dl.acm.org/citation.cfm?id=2662708.2662712},
	--doi = {doi.acm.org/10.1145/2662708.2662712},
	acmid = {2662712},
	publisher = {IEEE Press},
	address = {Piscataway, NJ, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/IWSC_2013.pdf},
}

@article{Fokaefs:2012:IAE:2330373.2330432,
	author = {Fokaefs, Marios and Tsantalis, Nikolaos and Stroulia, Eleni and Chatzigeorgiou, Alexander},
	title = {Identification and Application of Extract Class Refactorings in Object-oriented Systems},
	journal = {Journal of Systems and Software},
	issue_date = {October, 2012},
	volume = {85},
	number = {10},
	month = oct,
	year = {2012},
	issn = {0164-1212},
	pages = {2241--2260},
	numpages = {20},
	--url = {http://dx.doi.org/10.1016/j.jss.2012.04.013},
	doi = {10.1016/j.jss.2012.04.013},
	acmid = {2330432},
	publisher = {Elsevier Science Inc.},
	address = {New York, NY, USA},
	keywords = {clustering, object-oriented programming, refactoring, software reengineering},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/JSS_2012.pdf},
}

@article{Tsantalis:2011:IEM:2010601.2010870,
	author = {Tsantalis, Nikolaos and Chatzigeorgiou, Alexander},
	title = {Identification of Extract Method Refactoring Opportunities for the Decomposition of Methods},
	journal = {Journal of Systems and Software},
	issue_date = {October, 2011},
	volume = {84},
	number = {10},
	month = oct,
	year = {2011},
	issn = {0164-1212},
	pages = {1757--1782},
	numpages = {26},
	--url = {http://dx.doi.org/10.1016/j.jss.2011.05.016},
	doi = {10.1016/j.jss.2011.05.016},
	acmid = {2010870},
	publisher = {Elsevier Science Inc.},
	address = {New York, NY, USA},
	keywords = {Extract Method refactoring, module decomposition, program slicing},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/JSS_2011.pdf},
}

@inproceedings{Fokaefs:2011:ESW:2058528.2059963,
	author = {Fokaefs, Marios and Mikhaiel, Rimon and Tsantalis, Nikolaos and Stroulia, Eleni and Lau, Alex},
	title = {An Empirical Study on Web Service Evolution},
	booktitle = {Proceedings of the 2011 IEEE International Conference on Web Services},
	--series = {ICWS '11},
	year = {2011},
	isbn = {978-0-7695-4463-2},
	pages = {49--56},
	numpages = {8},
	--url = {http://dx.doi.org/10.1109/ICWS.2011.114},
	doi = {10.1109/ICWS.2011.114},
	acmid = {2059963},
	publisher = {IEEE Computer Society},
	address = {Washington, DC, USA},
	keywords = {service evolution, tree-edit distance, WSDL, clustering},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICWS_2011.pdf},
}

@inproceedings{Tsantalis:2011:5741256, 
	author={Tsantalis, N. and Chatzigeorgiou, A.}, 
	booktitle={Proceedings of the 15th European Conference on Software Maintenance and Reengineering}, 
	title={Ranking Refactoring Suggestions Based on Historical Volatility}, 
	year={2011}, 
	pages={25-34}, 
	doi={10.1109/CSMR.2011.7}, 
	ISSN={1534-5351},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/CSMR_2011.pdf},
}

@inproceedings{Tsantalis:2011:WGD:2117694.2119680,
	author = {Tsantalis, Nikolaos and Negara, Natalia and Stroulia, Eleni},
	title = {Webdiff: A Generic Differencing Service for Software Artifacts},
	booktitle = {Proceedings of the 27th IEEE International Conference on Software Maintenance},
	--series = {ICSM '11},
	year = {2011},
	isbn = {978-1-4577-0663-9},
	pages = {586--589},
	numpages = {4},
	--url = {http://dx.doi.org/10.1109/ICSM.2011.6080836},
	doi = {10.1109/ICSM.2011.6080836},
	acmid = {2119680},
	publisher = {IEEE Computer Society},
	address = {Washington, DC, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICSM_2011.pdf},
}

@inproceedings{Fokaefs:2011:JIA:1985793.1985989,
	author = {Fokaefs, Marios and Tsantalis, Nikolaos and Stroulia, Eleni and Chatzigeorgiou, Alexander},
	title = {JDeodorant: Identification and Application of Extract Class Refactorings},
	booktitle = {Proceedings of the 33rd International Conference on Software Engineering},
	--series = {ICSE '11},
	year = {2011},
	isbn = {978-1-4503-0445-0},
	location = {Waikiki, Honolulu, HI, USA},
	pages = {1037--1039},
	numpages = {3},
	--url = {http://doi.acm.org/10.1145/1985793.1985989},
	doi = {10.1145/1985793.1985989},
	acmid = {1985989},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {clustering, object-oriented programming, refactoring, software reengineering},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICSE_2011.pdf},
}

@article{Tsantalis:2010:IRO:1739313.1739401,
	author = {Tsantalis, Nikolaos and Chatzigeorgiou, Alexander},
	title = {Identification of Refactoring Opportunities Introducing Polymorphism},
	journal = {Journal of Systems and Software},
	issue_date = {March, 2010},
	volume = {83},
	number = {3},
	month = mar,
	year = {2010},
	issn = {0164-1212},
	pages = {391--404},
	numpages = {14},
	--url = {http://dx.doi.org/10.1016/j.jss.2009.09.017},
	doi = {10.1016/j.jss.2009.09.017},
	acmid = {1739401},
	publisher = {Elsevier Science Inc.},
	address = {New York, NY, USA},
	keywords = {object-oriented design, polymorphism, refactoring, State/Strategy design pattern},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/JSS_2010.pdf},
}

@inproceedings{Kniesel:2010, 
	author={Kniesel, G. and Binun, A. and Heged\H{u}s, P. and F\"{u}l\"{o}p, L.J. and Chatzigeorgiou, A. and
	        Gu\'{e}h\'{e}neuc, Y. and Tsantalis, N.}, 
	booktitle={Proceedings of the 14th European Conference on Software Maintenance and Reengineering}, 
	title={DPDX--Towards a Common Result Exchange Format for Design Pattern Detection Tools}, 
	year={2010}, 
	pages={232-235}, 
	doi={10.1109/CSMR.2010.40}, 
	ISSN={1534-5351},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/CSMR_2010.pdf},
}

@phdthesis{Tsantalis:2010,
	author = {Nikolaos Tsantalis}, 
	title = {Evaluation and Improvement of Software Architecture:
	Identification of Design Problems in Object-Oriented Systems and Resolution through Refactorings},
	school = {Department of Applied Informatics, University of Macedonia},
	year = 2010,
	address = {Thessaloniki, Greece},
	month = aug,
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/PhD_Thesis.pdf},
}

@article{Tsantalis:2009:IMM:1591905.1592367,
	author = {Tsantalis, Nikolaos and Chatzigeorgiou, Alexander},
	title = {Identification of Move Method Refactoring Opportunities},
	journal = {IEEE Transactions on Software Engineering},
	issue_date = {May 2009},
	volume = {35},
	number = {3},
	month = may,
	year = {2009},
	issn = {0098-5589},
	pages = {347--367},
	numpages = {21},
	--url = {http://dx.doi.org/10.1109/TSE.2009.1},
	doi = {10.1109/TSE.2009.1},
	acmid = {1592367},
	publisher = {IEEE Press},
	address = {Piscataway, NJ, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/TSE_2009.pdf},
}

@inproceedings{Fokaefs:2009:5306332, 
	author={Fokaefs, M. and Tsantalis, N. and Chatzigeorgiou, A. and Sander, J.}, 
	booktitle={Proceedings of the 25th IEEE International Conference on Software Maintenance}, 
	title={Decomposing object-oriented class modules using an agglomerative clustering technique}, 
	year={2009}, 
	pages={93-101}, 
	doi={10.1109/ICSM.2009.5306332}, 
	ISSN={1063-6773},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICSM_2009.pdf},
}

@inproceedings{Tsantalis:2009:4812745, 
	author={Tsantalis, N. and Chatzigeorgiou, A.}, 
	booktitle={Proceedings of the 13th European Conference on Software Maintenance and Reengineering}, 
	title={Identification of Extract Method Refactoring Opportunities}, 
	year={2009}, 
	pages={119-128}, 
	doi={10.1109/CSMR.2009.23}, 
	ISSN={1534-5351},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/CSMR_2009.pdf},
}

@article{10.1109/TDSC.2007.70240,
	author = {Spyros T. Halkidis and Nikolaos Tsantalis and Alexander Chatzigeorgiou and George Stephanides},
	title = {Architectural Risk Analysis of Software Systems Based on Security Patterns},
	journal = {IEEE Transactions on Dependable and Secure Computing},
	volume = {5},
	number = {3},
	issn = {1545-5971},
	year = {2008},
	pages = {129-142},
	doi = {10.1109/TDSC.2007.70240},
	--url = {http://doi.ieeecomputersociety.org/10.1109/TDSC.2007.70240},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	bibbase_note = {<span style="color: blue"><strong>Featured article of the July-September 2008 issue</strong></span>},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/TDSC_2008.pdf},
}

@article{Chatzigeorgiou:2008:ESS:1383659.1383847,
	author = {Chatzigeorgiou, Alexander and Tsantalis, Nikolaos and Deligiannis, Ignatios},
	title = {An Empirical Study on Students' Ability to Comprehend Design Patterns},
	journal = {Comput. Educ.},
	issue_date = {November, 2008},
	volume = {51},
	number = {3},
	month = nov,
	year = {2008},
	issn = {0360-1315},
	pages = {1007--1016},
	numpages = {10},
	--url = {http://dx.doi.org/10.1016/j.compedu.2007.10.003},
	doi = {10.1016/j.compedu.2007.10.003},
	acmid = {1383847},
	publisher = {Elsevier Science Ltd.},
	address = {Oxford, UK},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/CompEdu_2008.pdf},
}

@inproceedings{Tsantalis:2008:JIR:1545010.1545391,
	author = {Tsantalis, Nikolaos and Chaikalis, Theodoros and Chatzigeorgiou, Alexander},
	title = {JDeodorant: Identification and Removal of Type-Checking Bad Smells},
	booktitle = {Proceedings of the 12th European Conference on Software Maintenance and Reengineering},
	--series = {CSMR '08},
	year = {2008},
	isbn = {978-1-4244-2157-2},
	pages = {329--331},
	numpages = {3},
	--url = {http://dx.doi.org/10.1109/CSMR.2008.4493342},
	doi = {10.1109/CSMR.2008.4493342},
	acmid = {1545391},
	publisher = {IEEE Computer Society},
	address = {Washington, DC, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/CSMR_2008.pdf},
}

@inproceedings{Fokaefs:2007:4362679, 
	author={Fokaefs, M. and Tsantalis, N. and Chatzigeorgiou, A.}, 
	booktitle={Proceedings of the 23rd IEEE International Conference on Software Maintenance}, 
	title={JDeodorant: Identification and Removal of Feature Envy Bad Smells}, 
	year={2007}, 
	pages={519-520}, 
	doi={10.1109/ICSM.2007.4362679}, 
	ISSN={1063-6773},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/ICSM_2007.pdf},
}

@article{Tsantalis:2006:DPD:1248727.1248777,
	author = {Tsantalis, Nikolaos and Chatzigeorgiou, Alexander and Stephanides, George and Halkidis, Spyros T.},
	title = {Design Pattern Detection Using Similarity Scoring},
	journal = {IEEE Transactions on Software Engineering},
	issue_date = {November 2006},
	volume = {32},
	number = {11},
	month = nov,
	year = {2006},
	issn = {0098-5589},
	pages = {896--909},
	numpages = {14},
	--url = {http://dx.doi.org/10.1109/TSE.2006.112},
	doi = {10.1109/TSE.2006.112},
	acmid = {1248777},
	publisher = {IEEE Press},
	address = {Piscataway, NJ, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/TSE_2006.pdf},
}

@inproceedings{Chatzigeorgiou:2006:AGT:1137661.1137669,
	author = {Chatzigeorgiou, Alexander and Tsantalis, Nikolaos and Stephanides, George},
	title = {Application of Graph Theory to OO Software Engineering},
	booktitle = {Proceedings of the 2006 International Workshop on Workshop on Interdisciplinary Software Engineering Research},
	--series = {WISER '06},
	year = {2006},
	isbn = {1-59593-409-X},
	location = {Shanghai, China},
	pages = {29--36},
	numpages = {8},
	--url = {http://doi.acm.org/10.1145/1137661.1137669},
	doi = {10.1145/1137661.1137669},
	acmid = {1137669},
	publisher = {ACM},
	address = {New York, NY, USA},
	keywords = {"God" classes, clustering, design pattern detection, graph theory, scale-free},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/WISER_2006.pdf},
}

@article{Tsantalis:2005:PPC:1083823.1084002,
	author = {Tsantalis, Nikolaos and Chatzigeorgiou, Alexander and Stephanides, George},
	title = {Predicting the Probability of Change in Object-Oriented Systems},
	journal = {IEEE Transactions on Software Engineering},
	issue_date = {July 2005},
	volume = {31},
	number = {7},
	month = jul,
	year = {2005},
	issn = {0098-5589},
	pages = {601--614},
	numpages = {14},
	--url = {http://dx.doi.org/10.1109/TSE.2005.83},
	doi = {10.1109/TSE.2005.83},
	acmid = {1084002},
	publisher = {IEEE Press},
	address = {Piscataway, NJ, USA},
	url_Paper ={https://users.encs.concordia.ca/~nikolaos/publications/TSE_2005.pdf},
}