all.bib

@article{Khatchadourian2016,
  author = {Raffi Khatchadourian},
  title = {Automated refactoring of legacy {Java} software to enumerated types},
  journal = {Automated Software Engineering},
  year = {2016},
  pages = {1--31},
  month = dec,
  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.},
  doi = {10.1007/s10515-016-0208-8},
  keywords = {software environments,software maintenance,software tools,enumerated types,java,automated refactoring},
  owner = {Raffi Khatchadourian},
  publisher = {Springer Nature},
  timestamp = {2017.07.10},
  url = {http://rdcu.be/nJcI}
}
@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,
  url = {http://scc-aosd.lancs.ac.uk/deliverables/d110.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 = {Khatchadourian, Raffi and Rashid, Awais and Masuhara, Hidehiko and Watanabe, Takuya},
  title = {Detecting Broken Pointcuts Using Structural Commonality and Degree of Interest},
  journal = {Science of Computer Programming},
  year = {2017},
  month = jun,
  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 = {Raffi Khatchadourian},
  publisher = {Elsevier {BV}},
  timestamp = {2017.07.10},
  url = {http://academicworks.cuny.edu/hc_pubs/300}
}
@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},
  timestamp = {2017.07.21},
  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).},
  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},
  timestamp = {2017.07.21},
  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},
  timestamp = {2017.07.21},
  url = {http://web.cse.ohio-state.edu/~rountev/presto/pubs/icsm07.pdf}
}
@inproceedings{Khatchadourian2016a,
  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},
  acmid = {2892681},
  doi = {10.1145/2892664.2892681},
  isbn = {978-1-4503-4033-5},
  keywords = {default methods, interfaces, java, refactoring},
  location = {M\&\#225;laga, Spain},
  numpages = {3},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.07.21},
  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},
  timestamp = {2017.07.21},
  url = {http://web.cse.ohio-state.edu/~neelam/papers/nfm2010.pdf}
}
@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},
  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, modular verification, rely-guarantee},
  location = {Vancouver, British Columbia, Canada},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.07.21}
}
@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},
  timestamp = {2017.07.21},
  url = {http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.151.7754}
}
@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},
  timestamp = {2017.07.21}
}
@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}
}
@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\% tool demonstration acceptance rate).},
  abstract = {Java 5 introduces several new features that offer significant improvements over older Java technology. We consider the new enum construct, which provides language support for enumerated types. Before Java 5, programmers needed to employ various patterns to compensate for the absence of enumerated types in Java. Unfortunately, these compensation patterns lack several highly desirable properties of the enum construct, most notably, type-safety. We demonstrate an automated refactoring tool called Convert Constants to Enum for transforming legacy Java code to use the new enumeration construct. An interprocedural type inferencing algorithm that tracks the flow of enumerated values drives the approach, and the tool is implemented as a seamless extension to existing refactoring support in Eclipse. The resulting code is semantically equivalent to the original, increasingly type-safe, easier to comprehend, less complex, and supports separate compilation.},
  acmid = {1859036},
  doi = {10.1145/1858996.1859036},
  isbn = {978-1-4503-0116-9},
  keywords = {automated refactoring, enumerated types, java},
  location = {Antwerp, Belgium},
  numpages = {2},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.07.24}
}
@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},
  acmid = {2814195},
  doi = {10.1145/2814189.2814195},
  isbn = {978-1-4503-3722-9},
  keywords = {Aspect-Oriented programming, software evolution},
  location = {Pittsburgh, PA, USA},
  numpages = {2},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.07.24},
  url = {http://websupport1.citytech.cuny.edu/Faculty/rkhatchadourian/media/splashcomp15demo-demoid6-p-72a7a4c-26095-preprint.pdf}
}
@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},
  timestamp = {2017.07.25},
  url = {http://www.ieee-scam.org/2008/papers/Khatchadourian.pdf}
}
@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},
  month = oct,
  organization = {ACM/IEEE},
  note = {To appear.},
  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 because 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. 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 that 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 video demonstration can be found at http://youtu.be/YZHIy0yePh8.},
  keywords = {refactoring, java, interfaces, default methods, type constraints, eclipse},
  location = {Urbana-Champaign, Illinois, USA},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.07.31},
  url = {http://youtu.be/YZHIy0yePh8}
}
@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}
}
@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},
  acmid = {2817277},
  doi = {10.1145/2814189.2817277},
  isbn = {978-1-4503-3722-9},
  keywords = {Java 8, lambda expressions, refactoring},
  location = {Pittsburgh, PA, USA},
  numpages = {2},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.07.25},
  url = {http://websupport1.citytech.cuny.edu/Faculty/rkhatchadourian/media/splashcomp15posters-postersid13-p-72a7a4c-26095-preprint.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)},
  abstract = {Java 8 default methods, which allow interfaces to contain (instance) method implementations, are useful for the skeletal implementation software design pattern. However, it is not easy to transform existing software to exploit default methods as it requires analyzing complex type hierarchies, resolving multiple implementation inheritance issues, reconciling differences between class and interface methods, and analyzing tie-breakers (dispatch precedence) with overriding class methods to preserve type-correctness and confirm semantics preservation. In this paper, we present an efficient, fully-automated, type constraint-based refactoring approach that assists developers in taking advantage of enhanced interfaces for their legacy Java software. The approach features an extensive rule set that covers various corner-cases where default methods cannot be used. To demonstrate applicability, we implemented our approach as an Eclipse plug-in and applied it to 19 real-world Java projects, as well as submitted pull requests to popular GitHub repositories. The indication is that it is useful in migrating skeletal implementation methods to interfaces as default methods, sheds light onto the pattern's usage, and provides insight to language designers on how this new construct applies to existing software.},
  acmid = {3097379},
  doi = {10.1109/ICSE.2017.16},
  isbn = {978-1-5386-3868-2},
  keywords = {Java, default methods, interfaces, refactoring},
  location = {Buenos Aires, Argentina},
  numpages = {12},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.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 = {submission to the International Conference on the Art, Science, and Engineering of Programming},
  year = {2018},
  series = {Programming '18},
  month = apr,
  publisher = {AOSA},
  location = {Nice, France},
  owner = {Raffi Khatchadourian},
  timestamp = {2017.08.03}
}
@comment{{jabref-meta: databaseType:bibtex;}}

This file was generated by bibtex2html 1.98.