all.bib

@phdthesis{Khatchadourian2011,
  author = {Khatchadourian, Raffi},
  title = {Techniques for Automated Software Evolution},
  school = {Ohio State University},
  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},
  title = {Traceability Framework: From Requirements Through Architecture and Design},
  institution = {European Network of Excellence on Aspect-Oriented Software Development},
  year = {2008},
  number = {AOSD-Europe Deliverable D126, AOSD-Europe-ULANC-43},
  month = jul,
  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},
  title = {Software support for the traceability framework, including extension of current configuration management and product line evolution model},
  institution = {Aspect-Oriented, Model-Driven Product Line Engineering},
  year = {2008},
  number = {AMPLE D4.2},
  month = oct,
  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},
  title = {Overall Aspect-Oriented Analysis and Design Approach},
  institution = {European Network of Excellence on Aspect-Oriented Software Development},
  year = {2008},
  number = {AOSD-Europe Deliverable D132, AOSD-Europe-ULANC-49},
  month = sep,
  url = {https://pdfs.semanticscholar.org/b81f/e142b291ccfe3b9d1f4135abcbe2ee1344b6.pdf}
}
@techreport{Rashid2008,
  author = {Rashid, Safoora Omer and Chitchyan, Ruzanna and Rashid, Awais and Khatchadourian, Raffi and Greenwood, Phil},
  title = {Approach for Change Impact Analysis of Aspectual Requirements},
  institution = {European Network of Excellence on Aspect-Oriented Software Development},
  year = {2008},
  number = {AOSD-Europe Deliverable D110, AOSD-Europe-ULANC-40},
  month = jan,
  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},
  title = {Pointcut Rejuvenation: Recovering Pointcut Expressions in Evolving Aspect-Oriented Software},
  journal = {{IEEE} Transactions on Software Engineering},
  year = {2012},
  volume = {38},
  number = {3},
  pages = {642--657},
  month = may,
  issn = {0098-5589},
  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},
  title = {Detecting Broken Pointcuts Using Structural Commonality and Degree of Interest},
  journal = {Science of Computer Programming},
  year = {2017},
  volume = {150},
  pages = {56--74},
  month = dec,
  issn = {0167-6423},
  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},
  title = {Contributing Factors to Pointcut Fragility},
  booktitle = {Workshop on Assessment of Contemporary Modularization Techniques},
  year = {2009},
  series = {ACoM '09},
  pages = {19--24},
  month = oct,
  publisher = {ACM},
  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},
  title = {Controlling Use Of Shared Content Items Based On Client Device},
  month = jan,
  year = {2016},
  note = {US Patent 20,160,019,375; US Patent App. 14/634,405},
  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},
  title = {Towards Safe Refactoring for Intelligent Parallelization of {Java} 8 Streams},
  booktitle = {International Conference on Software Engineering: Companion Proceedings},
  year = {2018},
  series = {ICSE '18},
  pages = {206--207},
  address = {New York, NY, USA},
  month = may,
  organization = {ACM/IEEE},
  publisher = {ACM},
  isbn = {978-1-4503-5663-3},
  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},
  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},
  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 = {http://khatchad.commons.gc.cuny.edu/files/2015/08/paper.pdf}
}
@inproceedings{Khatchadourian2009,
  author = {Khatchadourian, Raffi and Greenwood, Phil and Rashid, Awais and Xu, Guoqing},
  title = {Pointcut Rejuvenation: Recovering Pointcut Expressions in Evolving Aspect-Oriented Software},
  booktitle = {International Conference on Automated Software Engineering},
  year = {2009},
  series = {ASE '09},
  pages = {575--579},
  address = {Washington, DC, USA},
  month = nov,
  publisher = {IEEE/ACM},
  note = {(71/222; 32\% acceptance rate).},
  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},
  title = {Automated Refactoring of Legacy {Java} Software to Enumerated Types},
  booktitle = {International Conference on Software Maintenance},
  year = {2007},
  series = {ICSM '07},
  pages = {224--233},
  month = oct,
  publisher = {IEEE},
  note = {(46/214; 21\% acceptance rate).},
  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},
  title = {Automated Refactoring of Legacy {Java} Software to Default Methods},
  booktitle = {International Conference on Software Engineering},
  year = {2017},
  series = {ICSE '17},
  pages = {82--93},
  address = {Piscataway, NJ, USA},
  month = may,
  organization = {ACM/IEEE},
  publisher = {IEEE Press},
  note = {(68/398; 17\% acceptance rate)},
  isbn = {978-1-5386-3868-2},
  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},
  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},
  title = {Proactive Empirical Assessment of New Language Feature Adoption via Automated Refactoring: The Case of {Java} 8 Default Methods},
  booktitle = {International Conference on the Art, Science, and Engineering of Programming},
  year = {2018},
  volume = {2},
  number = {3},
  series = {Programming '18},
  pages = {6:1--6:30},
  month = mar,
  publisher = {AOSA},
  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},
  title = {Porting the {NetBeans} {Java} 8 Enhanced for Loop Lambda Expression Refactoring to {Eclipse}},
  booktitle = {Companion Proceedings of the 2015 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity},
  year = {2015},
  series = {SPLASH Companion 2015},
  pages = {58--59},
  address = {New York, NY, USA},
  month = oct,
  publisher = {ACM},
  isbn = {978-1-4503-3722-9},
  acmid = {2817277},
  doi = {10.1145/2814189.2817277},
  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},
  title = {Defaultification Refactoring: A Tool for Automatically Converting {Java} Methods to Default},
  booktitle = {International Conference on Automated Software Engineering},
  year = {2017},
  series = {ASE '17},
  pages = {984--989},
  address = {Piscataway, NJ, USA},
  month = oct,
  organization = {ACM/IEEE},
  publisher = {IEEE Press},
  note = {(20/32; 63\% acceptance rate).},
  isbn = {978-1-5386-2684-9},
  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},
  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},
  title = {Fraglight: Shedding Light on Broken Pointcuts in Evolving Aspect-oriented Software},
  booktitle = {Companion Proceedings of the 2015 {ACM} {SIGPLAN} International Conference on Systems, Programming, Languages and Applications: Software for Humanity},
  year = {2015},
  series = {SPLASH Companion 2015},
  pages = {17--18},
  address = {New York, NY, USA},
  month = oct,
  publisher = {ACM},
  isbn = {978-1-4503-3722-9},
  acmid = {2814195},
  doi = {10.1145/2814189.2814195},
  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 = {http://websupport1.citytech.cuny.edu/Faculty/rkhatchadourian/media/splashcomp15demo-demoid6-p-72a7a4c-26095-preprint.pdf}
}
@inproceedings{Khatchadourian2010,
  author = {Khatchadourian, Raffi and Muskalla, Benjamin},
  title = {Enumeration Refactoring: A Tool for Automatically Converting {Java} Constants to Enumerated Types},
  booktitle = {International Conference on Automated Software Engineering},
  year = {2010},
  series = {ASE '10},
  pages = {181--182},
  address = {New York, NY, USA},
  month = sep,
  publisher = {IEEE/ACM},
  note = {(18/45; 40\% acceptance rate).},
  isbn = {978-1-4503-0116-9},
  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},
  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}
}
@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},
  title = {Towards Improving Interface Modularity in Legacy {Java} Software Through Automated Refactoring},
  booktitle = {Companion Proceedings of the International Conference on Modularity},
  year = {2016},
  series = {MODULARITY Companion 2016},
  pages = {104--106},
  address = {New York, NY, USA},
  month = mar,
  publisher = {ACM},
  isbn = {978-1-4503-4033-5},
  acmid = {2892681},
  doi = {10.1145/2892664.2892681},
  keywords = {default methods, interfaces, java, refactoring},
  location = {M\&\#225;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 = {http://websupport1.citytech.cuny.edu/Faculty/rkhatchadourian/media/Towards%20Improving%20Interface%20Modularity%20in%20Legacy%20Java%20Software%20through%20Automated%20Refactoring.pdf}
}
@inproceedings{Soundarajan2009,
  author = {Soundarajan, Neelam and Khatchadourian, Raffi},
  title = {Specifying Reusable Aspects},
  booktitle = {Asian Workshop on Aspect-Oriented and Modular Software Development},
  year = {2009},
  series = {AOAsia '09},
  month = nov,
  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},
  title = {Enforcing Behavioral Constraints in Evolving Aspect-Oriented Programs},
  booktitle = {Workshop on Foundations of Aspect-oriented Languages},
  year = {2008},
  series = {FOAL '08},
  pages = {19--28},
  address = {New York, NY, USA},
  month = apr,
  publisher = {ACM},
  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},
  title = {On the Assessment of Pointcut Design in Evolving Aspect-Oriented Software},
  booktitle = {Workshop on Assessment of Contemporary Modularization Techniques},
  year = {2008},
  series = {ACoM '08},
  pages = {9--10},
  month = oct,
  organization = {Lancaster University},
  publisher = {ACM},
  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},
  title = {Going Big: A Large-scale Study on What Big Data Developers Ask},
  booktitle = {Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering},
  year = {2019},
  series = {ESEC/FSE 2019},
  pages = {432--442},
  address = {New York, NY, USA},
  month = aug,
  organization = {ACM},
  publisher = {ACM},
  note = {(74/303; 24.4\% acceptance rate).},
  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}
}
@article{Bagherzadeh2021,
  author = {Mehdi Bagherzadeh and Syed Ahmed and Srilakshmi Sripathi and Raffi Khatchadourian},
  journal = {In submission to Information and Software Technology},
  title = {Interests, Difficulties, Sentiments, and Tool Usages of Concurrency Developers: {A} Large-Scale Study on {Stack Overflow}},
  year = {2021},
  month = sep,
  archiveprefix = {arXiv},
  eprint = {2109.03138},
  numpages = {34},
  owner = {Raffi Khatchadourian},
  primaryclass = {cs.SE},
  timestamp = {2020-10-21}
}
@inproceedings{Soundarajan2011,
  author = {Soundarajan, Neelam and Bronish, Derek and Khatchadourian, Raffi},
  title = {Formalizing Reusable Aspect-Oriented Concurrency Control},
  booktitle = {International Conference on Software Engineering {\&} Knowledge Engineering},
  year = {2011},
  series = {SEKE '11},
  pages = {111--114},
  month = jul,
  publisher = {Knowledge Systems Institute Graduate School},
  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 = {http://web.cse.ohio-state.edu/~neelam/papers/seke11.pdf}
}
@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},
  title = {Reasoning about the Behavior of Aspect-Oriented Programs},
  booktitle = {International Conference on Software Engineering and Applications},
  year = {2007},
  editor = {Smith, J.},
  series = {SEA '07},
  pages = {198--202},
  address = {USA},
  month = nov,
  organization = {IASTED},
  publisher = {ACTA Press},
  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},
  title = {Rely-Guarantee Approach to Reasoning about Aspect-Oriented Programs},
  booktitle = {Workshop on Software Engineering Properties of Languages and Aspect Technologies},
  year = {2007},
  series = {SPLAT '07},
  pages = {5--es},
  address = {New York, NY, USA},
  month = mar,
  publisher = {ACM},
  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://www.slideshare.net/khatchad/an-empirical-study-of-refactorings-and-technical-debt-in-machine-learning-systems},
  timestamp = {2021-05-18},
  url = {https://academicworks.cuny.edu/hc_pubs/671}
}
@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{Tang2021,
  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 = {2021},
  issn = {0167-6423},
  month = oct,
  pages = {102724},
  abstract = {Logging---used for system events and security breaches to 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 $\sim$3 million lines of code and $\sim$4K log statements. Our tool successfully analyzes 99.26\% of logging statements, increases log level distributions by $\sim$20\%, identifies logs manually modified with a recall of $\sim$80\% and a level-direction match rate of $\sim$87\%, and increases the focus of logs in bug fix contexts $\sim$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.},
  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},
  keywords = {logging, software evolution, software repository mining, software transformation, source code analysis, degree of interest},
  numpages = {39},
  owner = {Raffi Khatchadourian},
  primaryclass = {cs.SE},
  publisher = {Elsevier {BV}},
  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}
}
@comment{{jabref-meta: databaseType:bibtex;}}

This file was generated by bibtex2html 1.99.