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{Khatchadourian2008c,
  author = {Khatchadourian, Raffi and Greenwood, Phil and Rashid, Awais and Xu, Guoqing},
  title = {Pointcut Rejuvenation: Recovering Pointcut Expressions in Evolving Aspect-Oriented Software},
  institution = {Lancaster University},
  year = {2008},
  number = {COMP-001-2008, Revised March 2009, May 2009},
  address = {Lancaster, UK},
  month = aug,
  url = {http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.151.7274&rep=rep1&type=pdf}
}
@techreport{Khatchadourian2007b,
  author = {Khatchadourian, Raffi and Sawin, Jason and Rountev, Atanas},
  title = {Automated Refactoring of Legacy {Java} Software to Enumerated Types},
  institution = {Ohio State University},
  year = {2007},
  number = {OSU-CISRC-4/07-TR26},
  month = apr,
  url = {http://web.cse.ohio-state.edu/~rountev/presto/pubs/tr26.pdf}
}
@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://www.citeulike.org/user/khatchad/article/4993367}
}
@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 = {http://www.citeulike.org/user/khatchad/article/4993335}
}
@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 = {http://www.citeulike.org/user/khatchad/article/4993356}
}
@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 = {2017.07.10},
  url = {http://www.ics.uci.edu/~guoqingx/papers/khatchadourian-tse12.pdf}
}
@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 = {2017.07.21},
  url = {http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.157.2718}
}
@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},
  title = {Automated refactoring of legacy {Java} software to enumerated types},
  journal = {Automated Software Engineering},
  year = {2017},
  volume = {24},
  number = {4},
  pages = {757--787},
  month = dec,
  issn = {0928-8910},
  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},
  title = {Detecting Broken Pointcuts using Structural Commonality and Degree of Interest},
  booktitle = {International Conference on Automated Software Engineering},
  year = {2015},
  series = {ASE 2015},
  pages = {641--646},
  address = {New York, NY, USA},
  month = nov,
  publisher = {IEEE/ACM},
  note = {(77/326; 23.6\% acceptance rate).},
  doi = {10.1109/ase.2015.80},
  keywords = {aspect-oriented programming, program debugging, DOI model, Mylyn Eclipse IDE plug-in, aspect-oriented programming, 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 = {2018-07-25},
  url = {http://khatchad.commons.gc.cuny.edu/files/2015/08/paper.pdf}
}
@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},
  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.},
  keywords = {Aspect-oriented programs, Behavioral reasoning},
  location = {Cambridge, MA, USA},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.07.21},
  url = {http://web.cse.ohio-state.edu/~neelam/papers/sea072.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).},
  isbn = {978-0-7695-3891-4},
  acmid = {1747559},
  doi = {10.1109/ASE.2009.37},
  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 = {2018-07-25},
  url = {http://www.ics.uci.edu/~guoqingx/papers/khatchadourian-ase09.pdf}
}
@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},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.07.21},
  url = {http://web.cse.ohio-state.edu/~neelam/papers/seke11.pdf}
}
@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 2007},
  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 = {2018-07-25},
  url = {http://web.cse.ohio-state.edu/~rountev/presto/pubs/icsm07.pdf}
}
@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},
  title = {Rejuvenate Pointcut: A Tool for Pointcut Expression Recovery in Evolving Aspect-Oriented Software},
  booktitle = {International Working Conference on Source Code Analysis and Manipulation},
  year = {2008},
  series = {SCAM '08},
  pages = {261--262},
  month = sep,
  publisher = {IEEE},
  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 = {2018-07-25},
  tool = {https://github.com/ponder-lab/Rejuvenate-Pointcut},
  url = {http://www.ieee-scam.org/2008/papers/Khatchadourian.pdf}
}
@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 = {2018-07-25},
  url = {http://web.cse.ohio-state.edu/~neelam/papers/nfm2010.pdf}
}
@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},
  isbn = {978-1-60558-110-1},
  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},
  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 = {2018-07-25}
}
@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},
  address = {New York, NY, USA},
  month = mar,
  publisher = {ACM},
  isbn = {978-1-59593-656-1},
  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},
  keywords = {aspect-oriented software, modular verification, rely-guarantee},
  location = {Vancouver, British Columbia, Canada},
  owner = {Raffi Khatchadourian},
  slides = {https://www.slideshare.net/khatchad/relyguarantee-approach-to-reasoning-about-aspectoriented-programs},
  timestamp = {2018-07-25}
}
@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 = {2018-07-25},
  url = {http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.151.7754}
}
@inproceedings{Khatchadourian2018b,
  author = {Raffi Khatchadourian and Yiming Tang and Mehdi Bagherzadeh and Syed Ahmed},
  title = {A Tool for Optimizing {Java} 8 Stream Software via Automated Refactoring},
  booktitle = {International Working Conference on Source Code Analysis and Manipulation},
  year = {2018},
  series = {SCAM '18},
  pages = {34--39},
  month = sep,
  organization = {IEEE},
  publisher = {IEEE Press},
  note = {Engineering Track. (9/17; 53\% acceptance rate). \textbf{Distinguished Paper Award}.},
  slides = {http://www.slideshare.net/khatchad/a-tool-for-optimizing-java-8-stream-softwarevia-automated-refactoring},
  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},
  timestamp = {2018-11-15},
  tool = {https://github.com/ponder-lab/Optimize-Java-8-Streams-Refactoring},
  url = {http://academicworks.cuny.edu/hc_pubs/429}
}
@inproceedings{Bagherzadeh2019,
  author = {Mehdi Bagherzadeh and Syed Ahmed and Raffi Khatchadourian and Yiming Tang},
  title = {Sentiment and Concurrency: A Large-scale Study on {Stack Overflow}},
  booktitle = {submission to the International Conference on Software Engineering},
  year = {2019},
  series = {ICSE '19},
  month = may,
  organization = {ACM/IEEE},
  publisher = {ACM},
  note = {New Ideas and Emerging Results Track.},
  location = {Montr\'eal, QC, Canada},
  numpages = {4},
  owner = {Raffi Khatchadourian},
  timestamp = {2018.10.02}
}
@inproceedings{Khatchadourian2019,
  author = {Raffi Khatchadourian and Yiming Tang and Mehdi Bagherzadeh and Syed Ahmed},
  title = {Safe Automated Refactoring for Intelligent Parallelization of {Java} 8 Streams},
  booktitle = {International Conference on Software Engineering},
  year = {2019},
  series = {ICSE '19},
  month = may,
  organization = {ACM/IEEE},
  publisher = {ACM},
  note = {Technical Track. (109/529; 20.6\% acceptance rate). To appear.},
  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.},
  location = {Montr\'eal, QC, Canada},
  numpages = {12},
  owner = {Raffi Khatchadourian},
  timestamp = {2018-12-13},
  tool = {https://github.com/ponder-lab/Optimize-Java-8-Streams-Refactoring},
  url = {https://2019.icse-conferences.org/event/icse-2019-technical-papers-safe-automated-refactoring-for-intelligent-parallelization-of-java-8-streams}
}
@comment{{jabref-meta: databaseType:bibtex;}}

This file was generated by bibtex2html 1.98.