@phdthesis{Khatchadourian2011,
author = {Khatchadourian, Raffi},
school = {Ohio State University},
title = {Techniques for Automated Software Evolution},
year = {2011},
address = {247 University Hall, 230 North Oval Mall, Columbus, OH, USA 43210},
month = apr,
url = {http://rave.ohiolink.edu/etdc/view?acc_num=osu1304885155}
}
@techreport{Pinto2008,
author = {Pinto, M\'onica and Fuentes, Lidia and Chitchyan, Ruzanna and Rashid, Awais and Jackson, Andrew and Clarke, Siobh\'an and Shishkov, Boris and Tekinerdogan, Bedir and Aksit, Mehmet and Greenwood, Phil and Khatchadourian, Raffi},
institution = {European Network of Excellence on Aspect-Oriented Software Development},
title = {Traceability Framework: From Requirements Through Architecture and Design},
year = {2008},
month = jul,
number = {AOSD-Europe Deliverable D126, AOSD-Europe-ULANC-43},
url = {http://pdfs.semanticscholar.org/fd2e/816a96da3f8b33b6c492f1d01a9142108f6c.pdf}
}
@techreport{Royer2008,
author = {Royer, Jean-Claude and Noppen, Joost and Anquetil, Nicolas and Rummler, Andreas and Mitschke, Ralf and Sousa, Andr\'e and Kulesza, Uira and Khatchadourian, Raffi and Greenwood, Phil and Rashid, Awais and Galvao, Ism\^{e}nia},
institution = {Aspect-Oriented, Model-Driven Product Line Engineering},
title = {Software support for the traceability framework, including extension of current configuration management and product line evolution model},
year = {2008},
month = oct,
number = {AMPLE D4.2},
url = {https://pdfs.semanticscholar.org/e3ff/583cb585cb515381f9078509164431ec8b50.pdf}
}
@techreport{Khatchadourian2008d,
author = {Khatchadourian, Raffi and Chitchyan, Ruzanna and Greenwood, Phil and Rashid, Awais and Valenzuela, Juan A. and Fern\'andez, Luis M. and Pinto, M\'onica and Fuentes, Lidia and Jackson, Andrew and Clarke, Siobh\'an},
institution = {European Network of Excellence on Aspect-Oriented Software Development},
title = {Overall Aspect-Oriented Analysis and Design Approach},
year = {2008},
month = sep,
number = {AOSD-Europe Deliverable D132, AOSD-Europe-ULANC-49}
}
@techreport{Rashid2008,
author = {Rashid, Safoora Omer and Chitchyan, Ruzanna and Rashid, Awais and Khatchadourian, Raffi and Greenwood, Phil},
institution = {European Network of Excellence on Aspect-Oriented Software Development},
title = {Approach for Change Impact Analysis of Aspectual Requirements},
year = {2008},
month = jan,
number = {AOSD-Europe Deliverable D110, AOSD-Europe-ULANC-40},
timestamp = {2018.05.08},
url = {https://pdfs.semanticscholar.org/2535/4e106f7be34cd161538fe9b6491a9b254ca6.pdf}
}
@article{Khatchadourian2012,
author = {Raffi Khatchadourian and Phil Greenwood and Awais Rashid and Guoqing Xu},
journal = {{IEEE} Transactions on Software Engineering},
title = {Pointcut Rejuvenation: Recovering Pointcut Expressions in Evolving Aspect-Oriented Software},
year = {2012},
issn = {0098-5589},
month = may,
number = {3},
pages = {642--657},
volume = {38},
abstract = {Pointcut fragility is a well-documented problem in Aspect-Oriented Programming; changes to the base code can lead to join points incorrectly falling in or out of the scope of pointcuts. In this paper, we present an automated approach that limits fragility problems by providing mechanical assistance in pointcut maintenance. The approach is based on harnessing arbitrarily deep structural commonalities between program elements corresponding to join points selected by a pointcut. The extracted patterns are then applied to later versions to offer suggestions of new join points that may require inclusion. To illustrate that the motivation behind our proposal is well founded, we first empirically establish that join points captured by a single pointcut typically portray a significant amount of unique structural commonality by analyzing patterns extracted from 23 AspectJ programs. Then, we demonstrate the usefulness of our technique by rejuvenating pointcuts in multiple versions of three of these programs. The results show that our parameterized heuristic algorithm was able to accurately and automatically infer the majority of new join points in subsequent software versions that were not captured by the original pointcuts.},
doi = {10.1109/TSE.2011.21},
keywords = {aspect-oriented programming;AspectJ programs;aspect-oriented programming;aspect-oriented software;deep structural commonalities harnessing;join points;parameterized heuristic algorithm;pattern analysis;pointcut expression recovery;pointcut fragility;pointcut maintenance;pointcut rejuvenation;program elements;Fuels;Observers;Programming;Proposals;Robustness;Software;Software engineering;Software development environments;software maintenance;software tools.},
owner = {Raffi Khatchadourian},
publisher = {Institute of Electrical and Electronics Engineers ({IEEE})},
timestamp = {2019.01.08},
url = {http://academicworks.cuny.edu/hc_pubs/474}
}
@article{Khatchadourian2017,
author = {Raffi Khatchadourian and Awais Rashid and Hidehiko Masuhara and Takuya Watanabe},
journal = {Science of Computer Programming},
title = {Detecting Broken Pointcuts Using Structural Commonality and Degree of Interest},
year = {2017},
issn = {0167-6423},
month = dec,
pages = {56--74},
volume = {150},
abstract = {Pointcut fragility is a well-documented problem in Aspect-Oriented Programming; changes to the base-code can lead to join points incorrectly falling in or out of the scope of pointcuts. Deciding which pointcuts have broken due to base-code changes is a daunting venture, especially in large and complex systems. We present an automated approach that recommends pointcuts that are likely to require modification due to a particular base-code change, as well as ones that do not. Our hypothesis is that join points selected by a pointcut exhibit common structural characteristics. Patterns describing such commonality are used to recommend pointcuts that have potentially broken with a degree of confidence as the developer is typing. The approach is implemented as an extension to the popular Mylyn Eclipse IDE plug-in, which maintains focused contexts of entities relevant to the task at hand using a Degree of Interest (DOI) model. We show that it is accurate in revealing broken pointcuts by applying it to multiple versions of several open source projects and evaluating the quality of the recommendations produced against actual modifications. We found that our tool made broken pointcuts 2.14 times more interesting in the DOI model than unbroken ones, with a p-value under 0.1, indicating a significant difference in final DOI value between the two kinds of pointcuts (i.e., broken and unbroken).},
doi = {10.1016/j.scico.2017.06.011},
keywords = {Software development environments, Software maintenance, Software tools},
owner = {rk1424},
publisher = {Elsevier {BV}},
timestamp = {2017.10.16},
url = {http://academicworks.cuny.edu/hc_pubs/300}
}
@inproceedings{Greenwood2009,
author = {Greenwood, Phil and Rashid, Awais and Khatchadourian, Raffi},
booktitle = {Workshop on Assessment of Contemporary Modularization Techniques},
title = {Contributing Factors to Pointcut Fragility},
year = {2009},
month = oct,
pages = {19--24},
publisher = {ACM},
series = {ACoM '09},
location = {Orlando, Florida, USA},
owner = {Raffi Khatchadourian},
timestamp = {2020-04-01},
url = {https://academicworks.cuny.edu/hc_pubs/618/}
}
@misc{Fasoli2016,
author = {Fasoli, Gianpaolo and Farrugia, Augustin and Govind, Apoorva and Khatchadourian, Raffi},
month = jan,
note = {US Patent 20,160,019,375; US Patent App. 14/634,405},
title = {Controlling Use Of Shared Content Items Based On Client Device},
year = {2016},
number = {20160019375},
owner = {Raffi Khatchadourian},
timestamp = {2017.07.24},
url = {https://www.google.com/patents/US20160019375}
}
@article{Khatchadourian2017c,
author = {Raffi Khatchadourian},
journal = {Automated Software Engineering},
title = {Automated refactoring of legacy {Java} software to enumerated types},
year = {2017},
issn = {0928-8910},
month = dec,
number = {4},
pages = {757--787},
volume = {24},
abstract = {Modern Java languages introduce several new features that offer significant improvements over older Java technology. In this article we consider the new enum construct, which provides language support for enumerated types. Prior to recent Java languages, programmers needed to employ various patterns (e.g., the weak enum pattern) to compensate for the absence of enumerated types in Java. Unfortunately, these compensation patterns lack several highly-desirable properties of the enum construct, most notably, type safety. We present a novel fully-automated approach for transforming legacy Java code to use the new enumeration construct. This semantics-preserving approach increases type safety, produces code that is easier to comprehend, removes unnecessary complexity, and eliminates brittleness problems due to separate compilation. At the core of the proposed approach is an interprocedural type inferencing algorithm which tracks the flow of enumerated values. The algorithm was implemented as an open source, publicly available Eclipse plug-in and evaluated experimentally on 17 large Java benchmarks. Our results indicate that analysis cost is practical and the algorithm can successfully refactor a substantial number of fields to enumerated types. This work is a significant step towards providing automated tool support for migrating legacy Java software to modern Java technologies.},
day = {01},
doi = {10.1007/s10515-016-0208-8},
keywords = {software environments, software maintenance, software tools, enumerated types, java, automated refactoring},
owner = {Raffi Khatchadourian},
publisher = {Springer US},
timestamp = {2018-07-10},
url = {http://academicworks.cuny.edu/hc_pubs/273}
}
@inproceedings{Tang2018,
author = {Tang, Yiming and Khatchadourian, Raffi and Bagherzadeh, Mehdi and Ahmed, Syed},
booktitle = {International Conference on Software Engineering: Companion Proceedings},
title = {Towards Safe Refactoring for Intelligent Parallelization of {Java} 8 Streams},
year = {2018},
address = {New York, NY, USA},
month = may,
organization = {ACM/IEEE},
pages = {206--207},
publisher = {ACM},
series = {ICSE '18},
abstract = {The Java 8 Stream API sets forth a promising new programming model that incorporates functional-like, MapReduce-style features into a mainstream programming language. However, using streams correctly and efficiently may involve subtle considerations. In this poster, we present our ongoing work and preliminary results towards an automated refactoring approach that assists developers in writing optimal stream code. The approach, based on ordering and typestate analysis, determines when it is safe and advantageous to convert streams to parallel and optimize parallel streams.},
acmid = {3195098},
doi = {10.1145/3183440.3195098},
isbn = {978-1-4503-5663-3},
keywords = {Java 8, parallelization, refactoring, streams, typestate analysis},
location = {Gothenburg, Sweden},
numpages = {2},
owner = {Raffi Khatchadourian},
poster = {http://academicworks.cuny.edu/hc_pubs/394},
timestamp = {2018-07-15},
url = {http://academicworks.cuny.edu/hc_pubs/355}
}
@inproceedings{Khatchadourian2015a,
author = {Khatchadourian, Raffi and Rashid, Awais and Masuhara, Hidehiko and Watanabe, Takuya},
booktitle = {International Conference on Automated Software Engineering},
title = {Detecting Broken Pointcuts using Structural Commonality and Degree of Interest},
year = {2015},
address = {New York, NY, USA},
month = nov,
note = {(77/326; 23.6\% acceptance rate).},
pages = {641--646},
publisher = {IEEE/ACM},
series = {ASE '15},
abstract = {Pointcut fragility is a well-documented problem in Aspect-Oriented Programming, changes to the base-code can lead to join points incorrectly falling in or out of the scope of pointcuts. Deciding which pointcuts have broken due to base-code changes is a daunting venture, especially in large and complex systems. We present an automated approach that recommends pointcuts that are likely to require modification due to a particular base-code change, as well as ones that do not. Our hypothesis is that join points selected by a pointcut exhibit common structural characteristics. Patterns describing such commonality are used to recommend pointcuts that have potentially broken to the developer. The approach is implemented as an extension to the popular Mylyn Eclipse IDE plug-in, which maintains focused contexts of entities relevant to the task at hand using a Degree of Interest (DOI) model.},
doi = {10.1109/ase.2015.80},
keywords = {aspect-oriented programming, program debugging, DOI model, Mylyn Eclipse IDE plug-in, broken pointcut detection, degree of interest model, pointcut fragility, structural characteristics, structural commonality, Java, Programming, Software, Software engineering, Aspect-Oriented programming, software evolution},
location = {Lincoln, NE, USA},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/detecting-broken-pointcuts-using-structural-commonality-and-degree-of-interest},
timestamp = {2020-10-01},
url = {https://academicworks.cuny.edu/hc_pubs/703}
}
@inproceedings{Khatchadourian2009,
author = {Khatchadourian, Raffi and Greenwood, Phil and Rashid, Awais and Xu, Guoqing},
booktitle = {International Conference on Automated Software Engineering},
title = {Pointcut Rejuvenation: Recovering Pointcut Expressions in Evolving Aspect-Oriented Software},
year = {2009},
address = {Washington, DC, USA},
month = nov,
note = {(71/222; 32\% acceptance rate).},
pages = {575--579},
publisher = {IEEE/ACM},
series = {ASE '09},
acmid = {1747559},
doi = {10.1109/ASE.2009.37},
isbn = {978-0-7695-3891-4},
keywords = {Software development environments, Software maintenance, Software tools},
location = {Auckland, New Zealand},
numpages = {5},
owner = {Raffi Khatchadourian},
slides = {http://www.slideshare.net/khatchad/pointcut-rejuvenation-talk},
timestamp = {2020-03-19},
url = {https://academicworks.cuny.edu/hc_pubs/615}
}
@inproceedings{Khatchadourian2007a,
author = {Khatchadourian, Raffi and Sawin, Jason and Rountev, Atanas},
booktitle = {International Conference on Software Maintenance},
title = {Automated Refactoring of Legacy {Java} Software to Enumerated Types},
year = {2007},
month = oct,
note = {(46/214; 21\% acceptance rate).},
pages = {224--233},
publisher = {IEEE},
series = {ICSM '07},
doi = {10.1109/ICSM.2007.4362635},
issn = {1063-6773},
keywords = {Java;programming language semantics;software maintenance;Java 1.5;Java technology;enum construct;legacy Java code;legacy Java software;semantics-preserving approach;Algorithm design and analysis;Application software;Costs;Inference algorithms;Java;Programming profession;Robustness;Safety;Software maintenance;Software tools},
location = {Paris, France},
owner = {Raffi Khatchadourian},
slides = {http://www.slideshare.net/khatchad/automated-refactoring-of-legacy-java-software-to-enumerated-types-43326611},
timestamp = {2020-10-01},
url = {https://academicworks.cuny.edu/hc_pubs/623}
}
@inproceedings{Khatchadourian2017a,
author = {Khatchadourian, Raffi and Masuhara, Hidehiko},
booktitle = {International Conference on Software Engineering},
title = {Automated Refactoring of Legacy {Java} Software to Default Methods},
year = {2017},
address = {Piscataway, NJ, USA},
month = may,
note = {(68/398; 17\% acceptance rate)},
organization = {ACM/IEEE},
pages = {82--93},
publisher = {IEEE Press},
series = {ICSE '17},
abstract = {Java 8 default methods, which allow interfaces to contain (instance) method implementations, are useful for the skeletal implementation software design pattern. However, it is not easy to transform existing software to exploit default methods as it requires analyzing complex type hierarchies, resolving multiple implementation inheritance issues, reconciling differences between class and interface methods, and analyzing tie-breakers (dispatch precedence) with overriding class methods to preserve type-correctness and confirm semantics preservation. In this paper, we present an efficient, fully-automated, type constraint-based refactoring approach that assists developers in taking advantage of enhanced interfaces for their legacy Java software. The approach features an extensive rule set that covers various corner-cases where default methods cannot be used. To demonstrate applicability, we implemented our approach as an Eclipse plug-in and applied it to 19 real-world Java projects, as well as submitted pull requests to popular GitHub repositories. The indication is that it is useful in migrating skeletal implementation methods to interfaces as default methods, sheds light onto the pattern's usage, and provides insight to language designers on how this new construct applies to existing software.},
acmid = {3097379},
doi = {10.1109/ICSE.2017.16},
isbn = {978-1-5386-3868-2},
keywords = {Java, default methods, interfaces, refactoring},
location = {Buenos Aires, Argentina},
numpages = {12},
owner = {Raffi Khatchadourian},
slides = {http://www.slideshare.net/khatchad/automated-refactoring-of-legacy-java-software-to-default-methods-talk-at-icse-2017},
timestamp = {2018-07-25},
url = {http://academicworks.cuny.edu/hc_pubs/287}
}
@inproceedings{Khatchadourian2018,
author = {Khatchadourian, Raffi and Masuhara, Hidehiko},
booktitle = {International Conference on the Art, Science, and Engineering of Programming},
title = {Proactive Empirical Assessment of New Language Feature Adoption via Automated Refactoring: The Case of {Java} 8 Default Methods},
year = {2018},
month = mar,
number = {3},
pages = {6:1--6:30},
publisher = {AOSA},
series = {Programming '18},
volume = {2},
abstract = {Programming languages and platforms improve over time, sometimes resulting in new language features that offer many benefits. However, despite these benefits, developers may not always be willing to adopt them in their projects for various reasons. In this paper, we describe an empirical study where we assess the adoption of a particular new language feature. Studying how developers use (or do not use) new language features is important in programming language research and engineering because it gives designers insight into the usability of the language to create meaning programs in that language. This knowledge, in turn, can drive future innovations in the area. Here, we explore Java 8 default methods, which allow interfaces to contain (instance) method implementations.
Default methods can ease interface evolution, make certain ubiquitous design patterns redundant, and improve both modularity and maintainability. A focus of this work is to discover, through a scientific approach and a novel technique, situations where developers found these constructs useful and where they did not, and the reasons for each. Although several studies center around assessing new language features, to the best of our knowledge, this kind of construct has not been previously considered.
Despite their benefits, we found that developers did not adopt default methods in all situations. Our study consisted of submitting pull requests introducing the language feature to 19 real-world, open source Java projects without altering original program semantics. This novel assessment technique is proactive in that the adoption was driven by an automatic refactoring approach rather than waiting for developers to discover and integrate the feature themselves. In this way, we set forth best practices and patterns of using the language feature effectively earlier rather than later and are able to possibly guide (near) future language evolution. We foresee this technique to be useful in assessing other new language features, design patterns, and other programming idioms.},
articleno = {6},
doi = {10.22152/programming-journal.org/2018/2/6},
issn = {2473-7321},
keywords = {java, default methods, skeletal implementation pattern, empirical study},
location = {Nice, France},
numpages = {30},
owner = {Raffi Khatchadourian},
slides = {http://www.slideshare.net/khatchad/proactive-empirical-assessment-of-new-language-feature-adoption-via-automated-refactoring-the-case-of-java-8-default-methods-93663832},
timestamp = {2018-07-25},
url = {https://academicworks.cuny.edu/hc_pubs/354}
}
@inproceedings{Arefin2015,
author = {Arefin, Md. and Khatchadourian, Raffi},
booktitle = {Companion Proceedings of the 2015 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity},
title = {Porting the {NetBeans} {Java} 8 Enhanced for Loop Lambda Expression Refactoring to {Eclipse}},
year = {2015},
address = {New York, NY, USA},
month = oct,
pages = {58--59},
publisher = {ACM},
series = {SPLASH Companion 2015},
acmid = {2817277},
doi = {10.1145/2814189.2817277},
isbn = {978-1-4503-3722-9},
keywords = {Java 8, lambda expressions, refactoring},
location = {Pittsburgh, PA, USA},
numpages = {2},
owner = {Raffi Khatchadourian},
poster = {https://academicworks.cuny.edu/hc_pubs/426},
timestamp = {2018-07-25},
url = {https://academicworks.cuny.edu/hc_pubs/427}
}
@inproceedings{Khatchadourian2017b,
author = {Khatchadourian, Raffi and Masuhara, Hidehiko},
booktitle = {International Conference on Automated Software Engineering},
title = {Defaultification Refactoring: A Tool for Automatically Converting {Java} Methods to Default},
year = {2017},
address = {Piscataway, NJ, USA},
month = oct,
note = {(20/32; 63\% acceptance rate).},
organization = {ACM/IEEE},
pages = {984--989},
publisher = {IEEE Press},
series = {ASE '17},
abstract = {Enabling interfaces to declare (instance) method implementations, Java 8 default methods can be used as a substitute for the ubiquitous skeletal implementation software design pattern. Performing this transformation on legacy software manually, though, may be non-trivial. The refactoring requires analyzing complex type hierarchies, resolving multiple implementation inheritance issues, reconciling differences between class and interface methods, and analyzing tie-breakers (dispatch precedence) with overriding class methods. All of this is necessary to preserve type-correctness and confirm semantics preservation. We demonstrate an automated refactoring tool called MIGRATE Skeletal Implementation to Interface for transforming legacy Java code to use the new default construct. The tool, implemented as an Eclipse plug-in, is driven by an efficient, fully-automated, type constraint-based refactoring approach. It features an extensive rule set covering various corner-cases where default methods cannot be used. The resulting code is semantically equivalent to the original, more succinct, easier to comprehend, less complex, and exhibits increased modularity. A demonstration can be found at http://youtu.be/YZHIy0yePh8.},
acmid = {3155691},
doi = {10.1109/ASE.2017.8115716},
isbn = {978-1-5386-2684-9},
keywords = {automated, default methods, evolution, integrated development environments, interfaces, java, refactoring, type constraints},
location = {Urbana-Champaign, IL, USA},
numpages = {6},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/defaultification-refactoring-a-tool-for-automatically-converting-java-methods-to-default},
timestamp = {2018-07-25},
tool = {https://github.com/ponder-lab/Migrate-Skeletal-Implementation-to-Interface-Refactoring},
url = {http://academicworks.cuny.edu/hc_pubs/329}
}
@inproceedings{Khatchadourian2015,
author = {Raffi Khatchadourian and Awais Rashid and Hidehiko Masuhara and Takuya Watanabe},
booktitle = {Companion Proceedings of the International Conference on Systems, Programming, Languages and Applications: Software for Humanity},
title = {Fraglight: Shedding Light on Broken Pointcuts in Evolving Aspect-oriented Software},
year = {2015},
address = {New York, NY, USA},
month = oct,
organization = {{ACM} {SIGPLAN}},
pages = {17--18},
publisher = {ACM},
series = {SPLASH Companion 2015},
abstract = {Pointcut fragility is a well-documented problem in Aspect-Oriented Programming; changes to the base-code can lead to join points incorrectly falling in or out of the scope of pointcuts. Deciding which pointcuts have broken due to base-code changes is a daunting venture, especially in large and complex systems. We demonstrate an automated tool called FRAGLIGHT that recommends a set of pointcuts that are likely to require modification due to a particular base-code change. The underlying approach is rooted in harnessing unique and arbitrarily deep structural commonality between program elements corresponding to join points selected by a pointcut in a particular software version. Patterns describing such commonality are used to recommend pointcuts that have potentially broken with a degree of confidence as the developer is typing. Our tool is implemented as an extension to the Mylyn Eclipse IDE plug-in, which maintains focused contexts of entities relevant to a task.},
acmid = {2814195},
doi = {10.1145/2814189.2814195},
isbn = {978-1-4503-3722-9},
keywords = {Aspect-Oriented programming, software evolution},
location = {Pittsburgh, PA, USA},
numpages = {2},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/fraglight-shedding-light-on-broken-pointcuts-in-evolving-aspectoriented-software-demo},
timestamp = {2018-07-25},
tool = {https://github.com/ponder-lab/fraglight},
url = {https://academicworks.cuny.edu/hc_pubs/704}
}
@inproceedings{Khatchadourian2010,
author = {Khatchadourian, Raffi and Muskalla, Benjamin},
booktitle = {International Conference on Automated Software Engineering},
title = {Enumeration Refactoring: A Tool for Automatically Converting {Java} Constants to Enumerated Types},
year = {2010},
address = {New York, NY, USA},
month = sep,
note = {(18/45; 40\% acceptance rate).},
pages = {181--182},
publisher = {IEEE/ACM},
series = {ASE '10},
abstract = {Java 5 introduces several new features that offer significant improvements over older Java technology. We consider the new enum construct, which provides language support for enumerated types. Before Java 5, programmers needed to employ various patterns to compensate for the absence of enumerated types in Java. Unfortunately, these compensation patterns lack several highly desirable properties of the enum construct, most notably, type-safety. We demonstrate an automated refactoring tool called Convert Constants to Enum for transforming legacy Java code to use the new enumeration construct. An interprocedural type inferencing algorithm that tracks the flow of enumerated values drives the approach, and the tool is implemented as a seamless extension to existing refactoring support in Eclipse. The resulting code is semantically equivalent to the original, increasingly type-safe, easier to comprehend, less complex, and supports separate compilation.},
acmid = {1859036},
doi = {10.1145/1858996.1859036},
isbn = {978-1-4503-0116-9},
keywords = {automated refactoring, enumerated types, java},
location = {Antwerp, Belgium},
numpages = {2},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/enumeration-refactoring-a-tool-for-automatically-converting-java-constants-to-enumerated-types},
timestamp = {2018-07-25},
tool = {https://github.com/ponder-lab/Constants-to-Enum-Eclipse-Plugin},
url = {https://academicworks.cuny.edu/hc_pubs/701}
}
@inproceedings{Khatchadourian2008b,
author = {Raffi Khatchadourian and Awais Rashid},
booktitle = {International Working Conference on Source Code Analysis and Manipulation},
title = {Rejuvenate Pointcut: A Tool for Pointcut Expression Recovery in Evolving Aspect-Oriented Software},
year = {2008},
month = sep,
pages = {261--262},
publisher = {IEEE},
series = {IEEE SCAM '08},
abstract = {Aspect-oriented programming (AOP) strives to localize the scattered and tangled implementations of crosscutting concerns (CCCs) by allowing developers to declare that certain actions (advice) should be taken at specific points (join points) during the execution of software where a CCC (an aspect) is applicable. However, it is non-trivial to construct optimal pointcut expressions (a collection of join points) that capture the true intentions of the programmer and, upon evolution, maintain these intentions. We demonstrate an AspectJ source-level inferencing tool called rejuvenate pointcut which helps developers maintain pointcut expressions over the lifetime of a software product. A key insight into the tool's construction is that the problem of maintaining pointcut expressions bears strong similarity to the requirements traceability problem in software engineering; hence, the underlying algorithm was devised by adapting existing approaches for requirements traceability to pointcut maintenance. The Eclipse IDE-based tool identifies intention graph patterns pertaining to a pointcut and, based on these patterns, uncovers other potential join points that may fall within the scope of the pointcut with a given confidence. This work represents a significant step towards providing tool-supported maintainability for evolving aspect-oriented software.},
doi = {10.1109/SCAM.2008.32},
keywords = {formal specification;object-oriented programming;software maintenance;software tools;AspectJ;Eclipse IDE-based tool;aspect-oriented programming;aspect-oriented software;crosscutting concern;pointcut expression recovery;pointcut maintenance;rejuvenate pointcut;requirements traceability;software engineering;software product;Inference algorithms;Joining processes;Programming profession;Scattering;Software algorithms;Software engineering;Software maintenance;Software tools;aspect-oriented programming;inferencing;refactoring;source code analysis},
location = {Beijing, China},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/scam08},
timestamp = {2020-04-01},
tool = {https://github.com/ponder-lab/Rejuvenate-Pointcut},
url = {https://academicworks.cuny.edu/hc_pubs/620/}
}
@inproceedings{Khatchadourian2016,
author = {Khatchadourian, Raffi and Moore, Olivia and Masuhara, Hidehiko},
booktitle = {Companion Proceedings of the International Conference on Modularity},
title = {Towards Improving Interface Modularity in Legacy {Java} Software through Automated Refactoring},
year = {2016},
address = {New York, NY, USA},
month = mar,
pages = {104--106},
publisher = {ACM},
series = {MODULARITY Companion '16},
abstract = {The skeletal implementation pattern is a software design pattern consisting of defining an abstract class that provides a partial interface implementation. However, since Java allows only single class inheritance, if implementers decide to extend a skeletal implementation, they will not be allowed to extend any other class. Also, discovering the skeletal implementation may require a global analysis. Java 8 enhanced interfaces alleviate these problems by allowing interfaces to contain (default) method implementations, which implementers inherit. Java classes are then free to extend a different class, and a separate abstract class is no longer needed; developers considering implementing an interface need only examine the interface itself. We argue that both these benefits improve software modularity, and discuss our ongoing work in developing an automated refactoring tool that would assist developers in taking advantage of the enhanced interface feature for their legacy Java software.},
acmid = {2892681},
doi = {10.1145/2892664.2892681},
isbn = {978-1-4503-4033-5},
keywords = {interfaces, java, refactoring, default methods},
location = {M\'{a}laga, Spain},
numpages = {3},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/towards-improving-interface-modularity-in-legacy-java-software-through-automated-refactoring-59573828},
timestamp = {2018-07-25},
url = {https://academicworks.cuny.edu/hc_pubs/702}
}
@inproceedings{Soundarajan2009,
author = {Soundarajan, Neelam and Khatchadourian, Raffi},
booktitle = {Asian Workshop on Aspect-Oriented and Modular Software Development},
title = {Specifying Reusable Aspects},
year = {2009},
month = nov,
series = {AOAsia '09},
location = {Auckland, New Zealand},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/specifying-reusable-aspects},
timestamp = {2020-06-03},
url = {http://academicworks.cuny.edu/hc_pubs/630}
}
@inproceedings{Khatchadourian2008a,
author = {Khatchadourian, Raffi and Dovland, Johan and Soundarajan, Neelam},
booktitle = {Workshop on Foundations of Aspect-oriented Languages},
title = {Enforcing Behavioral Constraints in Evolving Aspect-Oriented Programs},
year = {2008},
address = {New York, NY, USA},
month = apr,
pages = {19--28},
publisher = {ACM},
series = {FOAL '08},
abstract = {Reasoning, specification, and verification of Aspect-Oriented (AO) programs presents unique challenges especially as such programs evolve over time. Components, base-code and aspects alike, may be easily added, removed, interchanged, or presently unavailable at unpredictable frequencies. Consequently, modular reasoning of such programs is highly attractive as it enables tractable evolution, otherwise necessitating that the entire program be reexamined each time a component is changed. It is well known, however, that modular reasoning about AO programs is difficult. In this paper, we present our ongoing work in constructing a relyguarantee style reasoning system for the Aspect-Oriented Programming (AOP) paradigm, adopting a trace-based approach to deal with the plug-n-play nature inherent to these programs, thus easing AOP evolution.},
acmid = {1394499},
doi = {10.1145/1394496.1394499},
isbn = {978-1-60558-110-1},
keywords = {reasoning, aspect-oriented programming, verification, software evolution},
location = {Brussels, Belgium},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/enforcing-behavioral-constraints-in-evolving-aspectoriented-programs},
timestamp = {2020-04-01},
url = {https://academicworks.cuny.edu/hc_pubs/622/}
}
@inproceedings{Khatchadourian2008,
author = {Khatchadourian, Raffi and Greenwood, Phil and Rashid, Awais},
booktitle = {Workshop on Assessment of Contemporary Modularization Techniques},
title = {On the Assessment of Pointcut Design in Evolving Aspect-Oriented Software},
year = {2008},
month = oct,
organization = {Lancaster University},
pages = {9--10},
publisher = {ACM},
series = {ACoM '08},
location = {Nashville, Tennessee, USA},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/on-the-assessment-of-pointcut-design-in-evolving-aspectoriented-software},
timestamp = {2020-04-01},
url = {https://academicworks.cuny.edu/hc_pubs/619/}
}
@inproceedings{Khatchadourian2018b,
author = {Raffi Khatchadourian and Yiming Tang and Mehdi Bagherzadeh and Syed Ahmed},
booktitle = {International Working Conference on Source Code Analysis and Manipulation},
title = {A Tool for Optimizing {Java} 8 Stream Software via Automated Refactoring},
year = {2018},
month = sep,
note = {Engineering track. (9/17; 53\% acceptance rate). \textbf{Distinguished Paper Award}~\faTrophy.},
organization = {IEEE},
pages = {34--39},
publisher = {IEEE Press},
series = {IEEE SCAM '18},
abstract = {Streaming APIs are pervasive in mainstream Object-Oriented languages and platforms. For example, the Java 8 Stream API allows for functional-like, MapReduce-style operations in processing both finite, e.g., collections, and infinite data structures. However, using this API efficiently involves subtle considerations like determining when it is best for stream operations to run in parallel, when running operations in parallel can be less efficient, and when it is safe to run in parallel due to possible lambda expression side-effects. In this paper, we describe the engineering aspects of an open source automated refactoring tool called Optimize Streams that assists developers in writing optimal stream software in a semantics-preserving fashion. Based on a novel ordering and typestate analysis, the tool is implemented as a plug-in to the popular Eclipse IDE, using both the WALA and SAFE frameworks. The tool was evaluated on 11 Java projects consisting of ~642 thousand lines of code, where we found that 36.31\% of candidate streams were refactorable, and an average speedup of 1.55 on a performance suite was observed. We also describe experiences gained from integrating three very different static analysis frameworks to provide developers with an easy-to-use interface for optimizing their stream code to its full potential.},
doi = {10.1109/SCAM.2018.00011},
issn = {2470-6892},
keywords = {refactoring, automatic parallelization, typestate analysis, ordering, Java 8, streams, eclipse, WALA, SAFE},
location = {Madrid, Spain},
numpages = {6},
owner = {Raffi Khatchadourian},
slides = {http://www.slideshare.net/khatchad/a-tool-for-optimizing-java-8-stream-softwarevia-automated-refactoring},
timestamp = {2018-11-15},
tool = {https://github.com/ponder-lab/Optimize-Java-8-Streams-Refactoring},
url = {http://academicworks.cuny.edu/hc_pubs/429}
}
@inproceedings{Khatchadourian2019,
author = {Raffi Khatchadourian and Yiming Tang and Mehdi Bagherzadeh and Syed Ahmed},
booktitle = {International Conference on Software Engineering},
title = {Safe Automated Refactoring for Intelligent Parallelization of {Java} 8 Streams},
year = {2019},
address = {Piscataway, NJ, USA},
month = may,
note = {(109/529; 20.6\% acceptance rate)},
organization = {ACM/IEEE},
pages = {619--630},
publisher = {{IEEE}},
series = {ICSE '19},
abstract = {Streaming APIs are becoming more pervasive in mainstream Object-Oriented programming languages. For example, the Stream API introduced in Java 8 allows for functional-like, MapReduce-style operations in processing both finite and infinite data structures. However, using this API efficiently involves subtle considerations like determining when it is best for stream operations to run in parallel, when running operations in parallel can be less efficient, and when it is safe to run in parallel due to possible lambda expression side-effects. In this paper, we present an automated refactoring approach that assists developers in writing efficient stream code in a semantics-preserving fashion. The approach, based on a novel data ordering and typestate analysis, consists of preconditions for automatically determining when it is safe and possibly advantageous to convert sequential streams to parallel and unorder or de-parallelize already parallel streams. The approach was implemented as a plug-in to the Eclipse IDE, uses the WALA and SAFE analysis frameworks, and was evaluated on 11 Java projects consisting of $\sim$642 thousand lines of code. We found that 36.31\% of candidate streams were refactorable, and an average speedup of 3.49 on performance tests was observed. The results indicate that the approach is useful in optimizing stream code to their full potential.},
acmid = {3339586},
data = {http://doi.org/10.5281/zenodo.1419201},
doi = {10.1109/icse.2019.00072},
keywords = {Java 8, automatic parallelization, refactoring, static analysis, streams, typestate analysis},
location = {Montr\'eal, QC, Canada},
numpages = {12},
owner = {Raffi Khatchadourian},
slides = {http://www.slideshare.net/khatchad/safe-automated-refactoring-for-intelligent-parallelization-of-java-8-streams},
timestamp = {2019.06.13},
tool = {http://github.com/ponder-lab/Optimize-Java-8-Streams-Refactoring},
url = {http://academicworks.cuny.edu/hc_pubs/489}
}
@inproceedings{Bagherzadeh2019,
author = {Bagherzadeh, Mehdi and Khatchadourian, Raffi},
booktitle = {Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering},
title = {Going Big: A Large-scale Study on What Big Data Developers Ask},
year = {2019},
address = {New York, NY, USA},
month = aug,
note = {(74/303; 24.4\% acceptance rate).},
organization = {ACM},
pages = {432--442},
publisher = {ACM},
series = {ESEC/FSE '19},
abstract = {Software developers are increasingly required to write big data code. However, they find big data software development challenging. To help these developers it is necessary to understand big data topics that they are interested in and the difficulty of finding answers for questions in these topics. In this work, we conduct a large-scale study on Stackoverflow to understand the interest and difficulties of big data developers. To conduct the study, we develop a set of big data tags to extract big data posts from Stackoverflow; use topic modeling to group these posts into big data topics; group similar topics into categories to construct a topic hierarchy; analyze popularity and difficulty of topics and their correlations; and discuss implications of our findings for practice, research and education of big data software development and investigate their coincidence with the findings of previous work.},
acmid = {3338939},
doi = {10.1145/3338906.3338939},
isbn = {978-1-4503-5572-8},
keywords = {Big data topic difficulty, Big data topic hierarchy, Big data topic popularity, Big data topics, Stackoverflow},
location = {Tallinn, Estonia},
numpages = {11},
owner = {Raffi Khatchadourian},
timestamp = {2019-06-10},
url = {http://academicworks.cuny.edu/hc_pubs/524}
}
@inproceedings{Soundarajan2011,
author = {Soundarajan, Neelam and Bronish, Derek and Khatchadourian, Raffi},
booktitle = {International Conference on Software Engineering {\&} Knowledge Engineering},
title = {Formalizing Reusable Aspect-Oriented Concurrency Control},
year = {2011},
month = jul,
pages = {111--114},
publisher = {Knowledge Systems Institute Graduate School},
series = {SEKE '11},
bibsource = {dblp computer science bibliography, https://dblp.org},
biburl = {https://dblp.org/rec/bib/conf/seke/SoundarajanBK11},
isbn = {1-891706-29-2},
location = {Miami, Floirda, USA},
owner = {Raffi Khatchadourian},
timestamp = {2017.07.21},
url = {https://academicworks.cuny.edu/hc_pubs/705}
}
@inproceedings{Khatchadourian2020,
author = {Khatchadourian, Raffi and Tang, Yiming and Bagherzadeh, Mehdi and Ray, Baishakhi},
booktitle = {Fundamental Approaches to Software Engineering},
title = {An Empirical Study on the Use and Misuse of {Java} 8 Streams},
year = {2020},
address = {Cham},
editor = {Wehrheim, Heike and Cabot, Jordi},
month = apr,
note = {(23/81; 28\% acceptance rate). \textbf{EAPLS Best Paper Award}~\faTrophy.},
organization = {ETAPS},
pages = {97--118},
publisher = {Springer International Publishing},
series = {FASE '20},
abstract = {Streaming APIs allow for big data processing of native data structures by providing MapReduce-like operations over these structures. However, unlike traditional big data systems, these data structures typically reside in shared memory accessed by multiple cores. Although popular, this emerging hybrid paradigm opens the door to possibly detrimental behavior, such as thread contention and bugs related to non-execution and non-determinism. This study explores the use and misuse of a popular streaming API, namely, Java 8 Streams. The focus is on how developers decide whether or not to run these operations sequentially or in parallel and bugs both specific and tangential to this paradigm. Our study involved analyzing 34 Java projects and 5:53 million lines of code, along with 719 manually examined code patches. Various automated, including interprocedural static analysis, and manual methodologies were employed. The results indicate that streams are pervasive, parallelization is not widely used, and performance is a crosscutting concern that accounted for the majority of fixes. We also present coincidences that both confirm and contradict the results of related studies. The study advances our understanding of streams, as well as benefits practitioners, programming language and API designers, tool developers, and educators alike.},
data = {http://doi.org/10.5281/zenodo.3677449},
doi = {10.1007/978-3-030-45234-6_5},
isbn = {978-3-030-45234-6},
keywords = {empirical studies, functional programming, Java 8, streams, multi-paradigm programming, static analysis},
numpages = {22},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/an-empirical-study-on-the-use-and-misuse-of-java-8-streams-231309312},
timestamp = {2021-01-12},
url = {http://academicworks.cuny.edu/hc_pubs/610}
}
@inproceedings{Soundarajan2007,
author = {Soundarajan, Neelam and Khatchadourian, Raffi and Dovland, Johan},
booktitle = {International Conference on Software Engineering and Applications},
title = {Reasoning about the Behavior of Aspect-Oriented Programs},
year = {2007},
address = {USA},
editor = {Smith, J.},
month = nov,
organization = {IASTED},
pages = {198--202},
publisher = {ACTA Press},
series = {SEA '07},
abstract = {Aspect-oriented programming (AOP) has become increasingly popular over the last few years. At the same time, reasoning about the behavior of these programs poses serious challenges. In this paper, we present a rely-guaranteeapproach to such reasoning. The rely-guarantee approach has proven useful in reasoning about concurrent and distributed programs. We show that some of the key problems encountered in reasoning about aspect-oriented programs are similar to those encountered in reasoning about concurrent programs; and that the rely-guarantee approach, appropriately modified, helps address these problems. We illustrate our approach with a simple example.},
isbn = {9780889867062},
keywords = {behavioral reasoning, aspect-oriented programs},
location = {Cambridge, Massachusetts},
numpages = {5},
owner = {Raffi Khatchadourian},
timestamp = {2020-03-19},
url = {https://academicworks.cuny.edu/hc_pubs/617}
}
@inproceedings{Khatchadourian2007,
author = {Khatchadourian, Raffi and Soundarajan, Neelam},
booktitle = {Workshop on Software Engineering Properties of Languages and Aspect Technologies},
title = {Rely-Guarantee Approach to Reasoning about Aspect-Oriented Programs},
year = {2007},
address = {New York, NY, USA},
month = mar,
pages = {5--es},
publisher = {ACM},
series = {SPLAT '07},
abstract = {Over the last few years, the question of reasoning about aspect-oriented programs has been addressed by a number of authors. In this paper, we present a rely-guarantee approach to such reasoning. The rely-guarantee approach has proven extremely successful in reasoning about concurrent and distributed programs. We show that some of the key problems encountered in reasoning about aspectoriented programs are similar to those encountered in reasoning about concurrent programs; and that the rely-guarantee approach, appropriately modified, helps address these problems. We illustrate our approach with a simple example.},
acmid = {1233848},
articleno = {5},
doi = {10.1145/1233843.1233848},
isbn = {978-1-59593-656-1},
keywords = {aspect-oriented software, rely-guarantee, modular verification},
location = {Vancouver, British Columbia, Canada},
numpages = {6},
owner = {Raffi Khatchadourian},
slides = {https://www.slideshare.net/khatchad/relyguarantee-approach-to-reasoning-about-aspectoriented-programs},
timestamp = {2020-03-19},
url = {https://academicworks.cuny.edu/hc_pubs/616}
}
@article{Khatchadourian2020a,
author = {Raffi Khatchadourian and Yiming Tang and Mehdi Bagherzadeh},
journal = {Science of Computer Programming},
title = {Safe automated refactoring for intelligent parallelization of {Java} 8 streams},
year = {2020},
issn = {0167-6423},
month = sep,
pages = {102476},
volume = {195},
abstract = {Streaming APIs are becoming more pervasive in mainstream Object-Oriented programming languages and platforms. For example, the Stream API introduced in Java 8 allows for functional-like, MapReduce-style operations in processing both finite, e.g., collections, and infinite data structures. However, using this API efficiently involves subtle considerations such as determining when it is best for stream operations to run in parallel, when running operations in parallel can be less efficient, and when it is safe to run in parallel due to possible lambda expression side-effects. In this paper, we present an automated refactoring approach that assists developers in writing efficient stream code in a semantics-preserving fashion. The approach, based on a novel data ordering and typestate analysis, consists of preconditions and transformations for automatically determining when it is safe and possibly advantageous to convert sequential streams to parallel and unorder or de-parallelize already parallel streams. The approach was implemented as a plug-in to the popular Eclipse IDE, uses the WALA and SAFE analysis frameworks, and was evaluated on 18 Java projects consisting of ~1.65M lines of code. We found that 116 of 419 candidate streams (27.68\%) were refactorable, and an average speedup of 3.49 on performance tests was observed. The results indicate that the approach is useful in optimizing stream code to their full potential.},
doi = {10.1016/j.scico.2020.102476},
keywords = {Automated refactoring, Automatic parallelization, Typestate analysis, Java 8, Streams},
numpages = {47},
owner = {Raffi Khatchadourian},
publisher = {Elsevier {BV}},
timestamp = {2020-10-21},
url = {http://academicworks.cuny.edu/hc_pubs/632}
}
@inproceedings{Tang2021a,
author = {Tang, Yiming and Khatchadourian, Raffi and Bagherzadeh, Mehdi and Singh, Rhia and Stewart, Ajani and Raja, Anita},
booktitle = {International Conference on Software Engineering},
title = {An Empirical Study of Refactorings and Technical Debt in {Machine Learning} Systems},
year = {2021},
month = may,
note = {(138/615; 22\% acceptance rate).},
organization = {{IEEE}/{ACM}},
pages = {238--250},
publisher = {{IEEE}},
series = {ICSE '21},
abstract = {Machine Learning (ML), including Deep Learning (DL), systems, i.e., those with ML capabilities, are pervasive in today's data-driven society. Such systems are complex; they are comprised of ML models and many subsystems that support learning processes. As with other complex systems, ML systems are prone to classic technical debt issues, especially when such systems are long-lived, but they also exhibit debt specific to these systems. Unfortunately, there is a gap of knowledge in how ML systems actually evolve and are maintained. In this paper, we fill this gap by studying refactorings, i.e., source-to-source semantics-preserving program transformations, performed in real-world, open-source software, and the technical debt issues they alleviate. We analyzed 26 projects, consisting of 4.2 MLOC, along with 327 manually examined code patches. The results indicate that developers refactor these systems for a variety of reasons, both specific and tangential to ML, some refactorings correspond to established technical debt categories, while others do not, and code duplication is a major crosscutting theme that particularly involved ML configuration and model code, which was also the most refactored. We also introduce 14 and 7 new ML-specific refactorings and technical debt categories, respectively, and put forth several recommendations, best practices, and anti-patterns. The results can potentially assist practitioners, tool developers, and educators in facilitating long-term ML system usefulness.},
data = {https://doi.org/10.5281/zenodo.3841195},
doi = {10.1109/ICSE43902.2021.00033},
issn = {1558-1225},
keywords = {empirical studies, refactoring, machine learning systems, technical debt, software repository mining},
location = {Madrid, Spain},
numpages = {13},
owner = {Raffi Khatchadourian},
slides = {https://academicworks.cuny.edu/hc_pubs/766},
timestamp = {2021-05-18},
url = {https://academicworks.cuny.edu/hc_pubs/671},
video = {https://youtu.be/M3hMTBvIaho}
}
@article{Bagherzadeh2020,
author = {Bagherzadeh, Mehdi and Fireman, Nicholas and Shawesh, Anas and Khatchadourian, Raffi},
journal = {Proc. ACM Program. Lang.},
title = {Actor Concurrency Bugs: A Comprehensive Study on Symptoms, Root Causes, {API} Usages, and Differences},
year = {2020},
month = nov,
note = {(109/302; 36\% acceptance rate).},
number = {OOPSLA},
pages = {1--32},
volume = {4},
abstract = {Actor concurrency is becoming increasingly important in the development of real-world software systems. Although actor concurrency may be less susceptible to some multithreaded concurrency bugs, such as low-level data races and deadlocks, it comes with its own bugs that may be different. However, the fundamental characteristics of actor concurrency bugs, including their symptoms, root causes, API usages, examples, and differences when they come from different sources are still largely unknown. Actor software development can significantly benefit from a comprehensive qualitative and quantitative understanding of these characteristics, which is the focus of this work, to foster better API documentation, development practices, testing, debugging, repairing, and verification frameworks. To conduct this study, we take the following major steps. First, we construct a set of 186 real-world Akka actor bugs from Stack Overflow and GitHub via manual analysis of 3,924 Stack Overflow questions, answers, and comments and 3,315 GitHub commits, messages, original and modified code snippets, issues, and pull requests. Second, we manually study these actor bugs and their fixes to understand and classify their symptoms, root causes, and API usages. Third, we study the differences between the commonalities and distributions of symptoms, root causes, and API usages of our Stack Overflow and GitHub actor bugs. Fourth, we discuss real-world examples of our actor bugs with these symptoms and root causes. Finally, we investigate the relation of our findings with those of previous work and discuss their implications. A few findings of our study are: (1) symptoms of our actor bugs can be classified into five categories, with Error as the most common symptom and Incorrect Exceptions as the least common, (2) root causes of our actor bugs can be classified into ten categories, with Logic as the most common root cause and Untyped Communication as the least common, (3) a small number of Akka API packages are responsible for most of API usages by our actor bugs, and (4) our Stack Overflow and GitHub actor bugs can differ significantly in commonalities and distributions of their symptoms, root causes, and API usages. While some of our findings agree with those of previous work, others sharply contrast.},
address = {New York, NY, USA},
articleno = {214},
booktitle = {International Conference on Object-Oriented Programming, Systems, Languages, and Applications},
doi = {10.1145/3428282},
issue_date = {November 2020},
keywords = {Actor bug API usages, Actor bug root causes, Actor bug differences, GitHub, Akka actor bugs, Stack Overflow, Actor bug symptoms},
location = {Chicago, IL, USA},
numpages = {32},
organization = {ACM SIGPLAN},
owner = {Raffi Khatchadourian},
publisher = {ACM},
series = {OOPSLA '20},
slides = {https://www.slideshare.net/khatchad/actor-concurrency-bugs-a-comprehensive-study-on-symptoms-root-causes-api-usages-and-differences},
timestamp = {2020-11-16},
url = {https://academicworks.cuny.edu/hc_pubs/664}
}
@mastersthesis{Spektor2020,
author = {Allan Spektor},
school = {City University of New York (CUNY) Hunter College},
title = {Two Techniques For Automated Logging Statement Evolution},
year = {2020},
address = {695 Park Avenue, New York, NY 10065},
month = jul,
abstract = {This thesis presents and explores two techniques for automated logging statement evolution. The first technique reinvigorates logging statement levels to reduce information overload using degree of interest obtained via software repository mining. The second technique converts legacy method calls to deferred execution to achieve performance gains, eliminating unnecessary evaluation overhead.},
owner = {Raffi Khatchadourian},
timestamp = {2020-12-07},
url = {https://academicworks.cuny.edu/hc_sas_etds/631}
}
@phdthesis{Tang2021b,
author = {Yiming Tang},
school = {City University of New York (CUNY) Graduate Center},
title = {Towards Automated Software Evolution of Data-intensive Applications},
year = {2021},
address = {365 5th Ave, New York, NY 10016},
month = jun,
abstract = {Recent years have witnessed an explosion of work on Big Data. Data-intensive applications analyze and produce large volumes of data typically terabyte and petabyte in size. Many techniques for facilitating data processing are integrated into data-intensive applications. API is a software interface that allows two applications to communicate with each other. Streaming APIs are widely used in today's Object-Oriented programming development that can support parallel processing. In this dissertation, an approach that automatically suggests stream code run in parallel or sequentially is proposed. However, using streams efficiently and properly needs many subtle considerations. The use and misuse patterns for stream codes are proposed in this dissertation. Modern software, especially for highly transactional software systems, generates vast logging information every day. The huge amount of information prevents developers from receiving useful information effectively. Log-level could be used to filter run-time information. This dissertation proposes an automated evolution approach for alleviating logging information overload by rejuvenating log levels according to developers' interests. Machine Learning (ML) systems are pervasive in today's software society. They are always complex and can process large volumes of data. Due to the complexity of ML systems, they are prone to classic technical debt issues, but how ML systems evolve is still a puzzling problem. This dissertation introduces ML-specific refactoring and technical debt for solving this problem.},
owner = {Raffi Khatchadourian},
timestamp = {2021-06-17},
url = {https://academicworks.cuny.edu/gc_etds/4406}
}
@article{Tang2022,
author = {Yiming Tang and Allan Spektor and Raffi Khatchadourian and Mehdi Bagherzadeh},
journal = {Science of Computer Programming},
title = {Automated Evolution of Feature Logging Statement Levels Using {Git} Histories and Degree of Interest},
year = {2022},
issn = {0167-6423},
month = feb,
note = {Presented at the {IEEE} International Conference on Software Analysis, Evolution and Reengineering (SANER '22) journal-first track.},
number = {C},
pages = {102724},
volume = {214},
abstract = {Logging---used for system events and security breaches to describe more informational yet essential aspects of software features---is pervasive. Given the high transactionality of today's software, logging effectiveness can be reduced by information overload. Log levels help alleviate this problem by correlating a priority to logs that can be later filtered. As software evolves, however, levels of logs documenting surrounding feature implementations may also require modification as features once deemed important may have decreased in urgency and vice-versa. We present an automated approach that assists developers in evolving levels of such (feature) logs. The approach, based on mining Git histories and manipulating a degree of interest (DOI) model, transforms source code to revitalize feature log levels based on the "interestingness" of the surrounding code. Built upon JGit and Mylyn, the approach is implemented as an Eclipse IDE plug-in and evaluated on 18 Java projects with ~3 million lines of code and ~4K log statements. Our tool successfully analyzes 99.22\% of logging statements, increases log level distributions by ~20\%, and increases the focus of logs in bug fix contexts ~83\% of the time. Moreover, pull (patch) requests were integrated into large and popular open-source projects. The results indicate that the approach is promising in assisting developers in evolving feature log levels.},
address = {USA},
archiveprefix = {arXiv},
data = {https://doi.org/10.5281/zenodo.3698983},
doi = {10.1016/j.scico.2021.102724},
eprint = {2104.07736},
eprintclass = {cs.SE},
eprinttype = {arXiv},
issue_date = {Feb 2022},
keywords = {logging, software evolution, software repository mining, software transformation, source code analysis, degree of interest},
numpages = {16},
owner = {Raffi Khatchadourian},
primaryclass = {cs.SE},
publisher = {Elsevier North-Holland, Inc.},
slides = {http://www.slideshare.net/khatchad/automated-evolution-of-feature-logging-statement-levels-using-git-histories-and-degree-of-interest},
timestamp = {2021-04-19},
tool = {http://github.com/ponder-lab/Logging-Level-Evolution-Plugin},
url = {http://academicworks.cuny.edu/gc_pubs/686},
video = {https://youtu.be/9tN5nOPqCds}
}
@inproceedings{Tang2022a,
author = {Yiming Tang and Allan Spektor and Raffi Khatchadourian and Mehdi Bagherzadeh},
booktitle = {International Conference on Software Engineering: Companion Proceedings},
title = {A Tool for Rejuvenating Feature Logging Levels via {Git} Histories and Degree of Interest},
year = {2022},
month = may,
note = {(49/98; 50\% acceptance rate).},
organization = {IEEE/ACM},
pages = {21--25},
publisher = {IEEE},
series = {ICSE-Companion '22},
abstract = {Logging is a significant programming practice. Due to the highly transactional nature of modern software applications, massive amount of logs are generated every day, which may overwhelm developers. Logging information overload can be dangerous to software applications. Using log levels, developers can print the useful information while hiding the verbose logs during software runtime. As software evolves, the log levels of logging statements associated with the surrounding software feature implementation may also need to be altered. Maintaining log levels necessitates a significant amount of manual effort. In this paper, we demonstrate an automated approach that can rejuvenate feature log levels by matching the interest level of developers in the surrounding features. The approach is implemented as an open-source Eclipse plugin, using two external plug-ins (JGit and Mylyn). It was tested on 18 open-source Java projects consisting of ~3 million lines of code and ~4K log statements. Our tool successfully analyzes 99.22\% of logging statements, increases log level distributions by ~20\%, and increases the focus of logs in bug fix contexts ~83\% of the time. For further details, interested readers can watch our demonstration video (https://www.youtube.com/watch?v=qIULoAXoDv4).},
archiveprefix = {arXiv},
doi = {10.1109/ICSE-Companion55297.2022.9793736},
eprint = {2112.02758},
issn = {2574-1926},
numpages = {5},
owner = {Raffi Khatchadourian},
primaryclass = {cs.SE},
slides = {https://www.slideshare.net/khatchad/a-tool-for-rejuvenating-feature-logging-levels-via-git-histories-and-degree-of-interest},
tool = {http://github.com/ponder-lab/Logging-Level-Evolution-Plugin},
url = {https://academicworks.cuny.edu/hc_pubs/693},
video = {https://youtu.be/qIULoAXoDv4}
}
@inproceedings{Takeuchi2021,
author = {Fumi Takeuchi and Hidehiko Masuhara and Raffi Khatchadourian and Youyou Cong},
booktitle = {Annual Conference of the Japanese Society for Software Science and Technology},
title = {Towards an Automated Code Rewriting Tool for Alleviating Concurrency Problems in the {Go} Programming Language},
year = {2021},
editor = {Takeo Imai},
month = sep,
note = {Poster presentation.},
organization = {JSSST},
series = {JSSST '21},
date = {2021-09-01},
owner = {Raffi Khatchadourian},
timestamp = {2021-11-26},
url = {http://jssst2021.wordpress.com/program}
}
@inproceedings{CastroVelez2022,
author = {Castro V\'{e}lez, Tatiana and Raffi Khatchadourian and Mehdi Bagherzadeh and Anita Raja},
booktitle = {International Conference on Mining Software Repositories},
title = {Challenges in Migrating Imperative {Deep Learning} Programs to Graph Execution: An Empirical Study},
year = {2022},
address = {New York, NY, USA},
month = may,
note = {(45/138; 32.6\% acceptance rate).},
organization = {IEEE/ACM},
pages = {469--481},
publisher = {{ACM}},
series = {MSR '22},
abstract = {Efficiency is essential to support responsiveness w.r.t. ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code that supports symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development tends to produce DL code that is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, less error-prone imperative DL frameworks encouraging eager execution have emerged at the expense of run-time performance. While hybrid approaches aim for the "best of both worlds," the challenges in applying them in the real world are largely unknown. We conduct a data-driven analysis of challenges---and resultant bugs---involved in writing reliable yet performant imperative DL code by studying 250 open-source projects, consisting of 19.7 MLOC, along with 470 and 446 manually examined code patches and bug reports, respectively. The results indicate that hybridization: (i) is prone to API misuse, (ii) can result in performance degradation---the opposite of its intention, and (iii) has limited application due to execution mode incompatibility. We put forth several recommendations, best practices, and anti-patterns for effectively hybridizing imperative DL code, potentially benefiting DL practitioners, API designers, tool developers, and educators.},
archiveprefix = {arXiv},
collection = {MSR '22},
data = {https://doi.org/10.5281/zenodo.5601987},
doi = {10.1145/3524842.3528455},
eprint = {2201.09953},
isbn = {9781450393034},
issn = {2574-3864},
keywords = {deep learning, empirical studies, graph-based execution, hybrid programming paradigms, imperative programs, software evolution},
location = {Pittsburgh, PA, USA},
numpages = {13},
owner = {Raffi Khatchadourian},
poster = {http://academicworks.cuny.edu/hc_pubs/833},
primaryclass = {cs.SE},
slides = {https://www.slideshare.net/khatchad/challenges-in-migrating-imperative-deep-learning-programs-to-graph-execution-an-empirical-study},
url = {http://academicworks.cuny.edu/hc_pubs/698},
video = {https://youtu.be/t49W_JmoNk4}
}
@misc{Bagherzadeh2021,
author = {Bagherzadeh, Mehdi and Ahmed, Syed and Sripathi, Srilakshmi and Khatchadourian, Raffi},
month = sep,
title = {Interests, Difficulties, Sentiments, and Tool Usages of Concurrency Developers: A Large-Scale Study on Stack Overflow},
year = {2021},
abstract = {Context: Software developers are increasingly facing the challenges of writing code that is not only concurrent but also correct.
Objective: To help these developers, it is necessary to understand concurrency topics they are interested in, their difficulty in finding answers for questions in these topics, their sentiment for these topics, and how they use concurrency tools and techniques to guarantee correctness.
Method: We conduct a large-scale study on the entirety of Stack Overflow to understand interests, difficulties, sentiment, and tool usages of concurrency developers. We discuss the implications of our findings for the practice, research, and education of concurrent software development, and investigate the relation of our findings with the findings of the previous work.
Results: A few findings of our study are: (1) questions that concurrency developers ask can be grouped into a hierarchy with 27 concurrency topics under 8 major categories, (2) thread safety is among the most popular concurrency topics and client-server concurrency is among the least popular, (3) irreproducible behavior is among the most difficult topics and memory consistency is among the least difficult, (4) data scraping is among the most positive concurrency topics and irreproducible behavior is among the most negative, (5) root cause identification has the most number of questions for usage of data race tools and alternative use has the least.
Conclusion: The results of our study can not only help concurrency developers but also concurrency educators and researchers to better decide where to focus their efforts, by trading off one concurrency topic against another.},
archiveprefix = {arXiv},
copyright = {Creative Commons Attribution 4.0 International},
doi = {10.48550/ARXIV.2109.03138},
eprint = {2109.03138},
keywords = {Software Engineering (cs.SE), FOS: Computer and information sciences, D.1.3},
primaryclass = {cs.SE},
publisher = {arXiv},
url = {https://arxiv.org/abs/2109.03138}
}
@techreport{Paing2022,
author = {Ye Paing and Castro V\'{e}lez, Tatiana and Raffi Khatchadourian},
institution = {City University of New York (CUNY) Hunter College},
title = {{QuerTCI}: A Tool Integrating {GitHub} Issue Querying with Comment Classification},
year = {2022},
address = {695 Park Ave, New York, NY 10065 United States},
month = jul,
number = {707},
abstract = {Empirical Software Engineering (ESE) researchers study (open-source) project issues and the comments and threads within to discover---among others---challenges developers face when incorporating new technologies, platforms, and programming language constructs. However, such threads accumulate, becoming unwieldy and hindering any insight researchers may gain. While existing approaches alleviate this burden by classifying issue thread comments, there is a gap between searching popular open-source software repositories (e.g., those on GitHub) for issues containing particular keywords and feeding the results into a classification model. This paper demonstrates a research infrastructure tool called QuerTCI that bridges this gap by integrating the GitHub issue comment search API with the classification models found in existing approaches. Using queries, ESE researchers can retrieve GitHub issues containing particular keywords, e.g., those related to a specific programming language construct, and, subsequently, classify the discussions occurring in those issues. We hope ESE researchers can use our tool to uncover challenges related to particular technologies using specific keywords through popular open-source repositories more seamlessly than previously possible. A tool demonstration video may be found at: https://youtu.be/fADKSxn0QUk.},
accessdate = {2022-02-18},
archiveprefix = {arXiv},
data = {https://doi.org/10.5281/zenodo.6115403},
eprint = {2202.08761},
keywords = {software repository mining, GitHub, issue comments, classification},
numpages = {4},
owner = {Raffi Khatchadourian},
primaryclass = {cs.SE},
school = {City University of New York (CUNY) Hunter College},
timestamp = {2022-07-19},
tool = {https://doi.org/10.5281/zenodo.4637636},
url = {https://academicworks.cuny.edu/hc_pubs/707},
video = {https://youtu.be/fADKSxn0QUk}
}
@inproceedings{MoradiMoghadam2023,
author = {Moradi Moghadam, Mohsen and Bagherzadeh, Mehdi and Khatchadourian, Raffi and Bagheri, Hamid},
booktitle = {Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering},
title = {$\mu${A}kka: Mutation Testing for Actor Concurrency in {Akka} Using Real-World Bugs},
year = {2023},
address = {New York, NY, USA},
month = nov,
note = {(60/473; 12.68\% acceptance rate for papers accepted with no major revisions).},
organization = {ACM},
pages = {262--274},
publisher = {ACM},
series = {ESEC/FSE '23},
abstract = {Actor concurrency is becoming increasingly important in the real world and mission-critical software. This requires these applications to be free from actor bugs, that occur in the real world, and have tests that are effective in finding these bugs. Mutation testing is a well-established technique that transforms an application to induce its likely bugs and evaluate the effectiveness of its tests in finding these bugs. Mutation testing is available for a broad spectrum of applications and their bugs, ranging from web to mobile to machine learning, and is used at scale in companies like Google and Facebook. However, there still is no mutation testing for actor concurrency that uses real-world actor bugs. In this paper, we propose ?Akka, a framework for mutation testing of Akka actor concurrency using real actor bugs. Akka is a popular industrial-strength implementation of actor concurrency. To design, implement, and evaluate ?Akka, we take the following major steps: (1) manually analyze a recent set of 186 real Akka bugs from Stack Overflow and GitHub to understand their causes; (2) design a set of 32 mutation operators, with 138 source code changes in Akka API, to emulate these causes and induce their bugs; (3) implement these operators in an Eclipse plugin for Java Akka; (4) use the plugin to generate 11.7k mutants of 10 real GitHub applications, with 446.4k lines of code and 7.9k tests; (5) run these tests on these mutants to measure the quality of mutants and effectiveness of tests; (6) use PIT to generate 26.2k mutants to compare ?Akka and PIT mutant quality and test effectiveness. PIT is a popular mutation testing tool with traditional operators; (7) manually analyze the bug coverage and overlap of ?Akka, PIT, and actor operators in a previous work; and (8) discuss a few implications of our findings. Among others, we find that ?Akka mutants are higher quality, cover more bugs, and tests are less effective in detecting them.},
collection = {ESEC/FSE '23},
doi = {10.1145/3611643.3616362},
isbn = {9798400703270},
keywords = {?Akka, Test effectiveness, Mutation testing, Mutation opertors, Mutant quality, Akka, Actor concurrency},
location = {San Francisco, CA, USA},
numpages = {13},
owner = {Raffi Khatchadourian},
timestamp = {2023-01-27},
url = {https://academicworks.cuny.edu/hc_pubs/814}
}
@inproceedings{FumiTakeuchi2022,
author = {Fumi Takeuchi and Hidehiko Masuhara and Raffi Khatchadourian and Youyou Cong and Keisuke Ishibashi},
booktitle = {Annual Conference of the Japanese Society for Software Science and Technology},
title = {How many mutex bugs can a simple analysis find in {Go} programs?},
year = {2022},
month = sep,
series = {JSSST '22},
abstract = {In open source software, it is known that there are many concurrency bugs. A previous study in Go revealed that a considerable number of such bugs are simple (for example, 9\% of the bugs are the ones that forget to unlock a mutex,) through a manual program investigation. This paper tries to detect such bugs by applying a simple analysis in order to see how far such a tool can match the manual analysis. We built a simple intraprocedural control flow analysis in Go, and evaluated its performance with respect to the open source programs with concurrency bugs reported in the previous study. Consequently, as for quality, the recall is good at 88\% and the precision is poor at 60\%, and as for analysis time, it can be finished within practical amount of time (for example, 1 second per 5000 LoC).},
modificationdate = {2022-09-15T15:27:11},
url = {https://jssst.or.jp/files/user/taikai/2022/papers/23-L.pdf}
}
@mastersthesis{Zneit2022,
author = {Manal Zneit},
school = {City University of New York (CUNY) Hunter College},
title = {A Tool-Supported Metamodel for Program Bug Fix Analysis in Empirical Software Engineering},
year = {2022},
address = {695 Park Avenue, New York, NY 10065},
month = aug,
abstract = {This thesis describes a software modeling approach aimed at addressing empirical studies in software engineering. We build a metamodel that provides an overview of the taxonomy of program bugfixes in deep learning programs. For modeling purposes, we present a prototype tool that is an implementation of the model-driven techniques presented.},
owner = {Raffi Khatchadourian},
timestamp = {2022-10-04},
url = {https://academicworks.cuny.edu/hc_sas_etds/923}
}
@inproceedings{Khatchadourian2023,
author = {Raffi Khatchadourian and Castro V\'{e}lez, Tatiana and Mehdi Bagherzadeh and Nan Jia and Anita Raja},
booktitle = {International Conference on Automated Software Engineering},
title = {Towards Safe Automated Refactoring of Imperative {Deep Learning} Programs to Graph Execution},
year = {2023},
month = sep,
note = {NIER track. (25/70; 35.7\% acceptance rate).},
pages = {1800--1802},
publisher = {IEEE},
series = {ASE '23},
abstract = {Efficiency is essential to support responsiveness w.r.t. ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code---supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged at the expense of run-time performance. Though hybrid approaches aim for the "best of both worlds," using them effectively requires subtle considerations to make code amenable to safe, accurate, and efficient graph execution. We present our ongoing work on automated refactoring that assists developers in specifying whether and how their otherwise eagerly-executed imperative DL code could be reliably and efficiently executed as graphs while preserving semantics. The approach, based on a novel imperative tensor analysis, will automatically determine when it is safe and potentially advantageous to migrate imperative DL code to graph execution and modify decorator parameters or eagerly executing code already running as graphs. The approach is being implemented as a PyDev Eclipse IDE plug-in and uses the WALA Ariadne analysis framework. We discuss our ongoing work towards optimizing imperative DL code to its full potential.},
archiveprefix = {arXiv},
doi = {10.1109/ASE56229.2023.00187},
issn = {2643-1572},
keywords = {Deep learning;Codes;Tensors;Semantics;Artificial neural networks;Reliability;Software engineering;deep learning;refactoring;graph execution},
location = {Kirchberg, Luxembourg},
numpages = {3},
owner = {Raffi Khatchadourian},
primaryclass = {cs.SE},
slides = {http://academicworks.cuny.edu/hc_pubs/815},
timestamp = {2023-05-31},
url = {https://academicworks.cuny.edu/hc_pubs/813}
}
@inproceedings{Jia2024,
author = {Nan Jia and Anita Raja and Raffi Khatchadourian},
booktitle = {Workshop on Artificial Intelligence Safety at the International Joint Conference on Artificial Intelligence},
title = {{ReLESS}: A Framework for Assessing Safety in {Deep Learning} Systems},
year = {2024},
month = aug,
note = {\textbf{Best Paper Award}~\faTrophy~nominee.},
organization = {IJCAI},
series = {AISafety '24 at IJCAI '24},
abstract = {Traditionally, software refactoring helps to improve a system's internal structure and enhance its non-functional features, such as reliability and run-time performance, while preserving external behavior including original program semantics. However, in the context of learning-enabled software systems (LESS), e.g., Machine Learning (ML) systems, it is unclear which portions of a software's semantics require preservation at the development phase. This is mainly because (a) the behavior of the LESS is not defined until run-time; and (b) the inherently iterative and non-deterministic nature of ML algorithms. Consequently, there is a knowledge gap in what refactoring truly means in the context of LESS as such systems have no guarantee of a predetermined correct answer. We thus conjecture that to construct robust and safe LESS, it is imperative to understand the flexibility of refactoring LESS compared to traditional software and to measure it. In this paper, we introduce a novel conceptual framework named ReLESS for evaluating refactorings for supervised learning by (i) exploring the transformation methodologies taken by state-of-the-art LESS refactorings that focus on singular metrics, (ii) reviewing informal notions of semantics preservation and the level at which they occur (source code vs. trained model), and (iii) empirically comparing and contrasting existing LESS refactorings in the context of image classification problems. This framework will set the foundation to not only formalize a standard definition of semantics preservation in LESS but also combine four metrics: accuracy, run-time performance, robustness, and interpretability as a multi-objective optimization function, instead of a single-objective function used in existing works, to assess LESS refactorings. In the future, our work could seek reliable LESS refactorings that generalize over diverse systems.},
url = {https://ceur-ws.org/Vol-3856/paper-9.pdf}
}
@inproceedings{Moghadam2025,
author = {Mohsen Moradi Moghadam and Mehdi Bagherzadeh and Raffi Khatchadourian and Hua Ming},
booktitle = {submission to the International Conference on the Foundations of Software Engineering},
title = {What Do Real-World {ML} Developers Test for? {A} Large-Scale Study on {GitHub}},
year = {2025},
month = jun,
organization = {ACM},
publisher = {ACM},
series = {FSE '25},
location = {Trondheim, Norway},
owner = {Raffi Khatchadourian},
timestamp = {2024-09-17}
}
@inproceedings{Khatchadourian2025,
author = {Raffi Khatchadourian and Castro V\'{e}lez, Tatiana and Mehdi Bagherzadeh and Nan Jia and Anita Raja},
booktitle = {submission to the International Conference on the Foundations of Software Engineering},
title = {Safe Automated Refactoring for Efficient Migration of Imperative {Deep Learning} Programs to Graph Execution},
year = {2025},
month = jun,
organization = {ACM},
publisher = {ACM},
series = {FSE '25},
location = {Trondheim, Norway},
owner = {Raffi Khatchadourian},
timestamp = {2024-09-17}
}
@inproceedings{Khatchadourian2025a,
author = {Raffi Khatchadourian and Castro V\'{e}lez, Tatiana and Mehdi Bagherzadeh and Nan Jia and Anita Raja},
booktitle = {Fundamental Approaches to Software Engineering},
title = {Hybridize Functions: A Tool for Automatically Refactoring Imperative {Deep Learning} Programs to Graph Execution},
year = {2025},
month = may,
note = {To appear. (11/31; 35\% acceptance rate).},
organization = {ETAPS},
series = {FASE '25},
abstract = {Efficiency is essential to support responsiveness w.r.t. ever-growing datasets, especially for Deep Learning (DL) systems. DL frameworks have traditionally embraced deferred execution-style DL code---supporting symbolic, graph-based Deep Neural Network (DNN) computation. While scalable, such development is error-prone, non-intuitive, and difficult to debug. Consequently, more natural, imperative DL frameworks encouraging eager execution have emerged but at the expense of run-time performance. Though hybrid approaches aim for the ``best of both worlds,'' using them effectively requires subtle considerations to make code amenable to safe, accurate, and efficient graph execution---avoiding performance bottlenecks and semantically inequivalent results. We discuss the engineering aspects of a refactoring tool that automatically determines when it is safe and potentially advantageous to migrate imperative DL code to graph execution and vice-versa.},
creationdate = {2024-12-20T17:56:28},
keywords = {deep learning,refactoring,imperative programs,graphs},
modificationdate = {2024-12-20T17:56:28},
owner = {Raffi Khatchadourian},
tool = {https://github.com/ponder-lab/Hybridize-Functions-Refactoring},
url = {https://etaps.org/2025/conferences/fase}
}
@comment{{jabref-meta: databaseType:bibtex;}}
This file was generated by bibtex2html 1.99.