Raffi Khatchadourian’s Profile Faculty Toggle navigation

Point­cut fragility is a well-doc­u­mented prob­lem in As­pect-Ori­ented Pro­gram­ming; changes to the base-code can lead to join points in­cor­rectly falling in or out of the scope of point­cuts. De­cid­ing which point­cuts have bro­ken be­cause of changes made to the base-code is a daunt­ing task, es­pe­cially in large and com­plex sys­tems. This pro­ject rep­re­sents an au­to­mated ap­proach that rec­om­mends a set of point­cuts that are likely to re­quire mod­i­fi­ca­tion due to a par­tic­u­lar change in the base-code. Our hy­poth­e­sis is that join points cap­tured by a point­cut ex­hibit a vary­ing de­gree of com­mon struc­tural char­ac­ter­is­tics on mul­ti­ple lev­els. We use pat­terns de­scrib­ing such com­mon­al­ity to rec­om­mend point­cuts that have po­ten­tially bro­ken to the de­vel­oper, as well as point the de­vel­oper in a di­rec­tion in which the point­cut should be al­tered. We im­ple­mented our ap­proach as an ex­ten­sion to the pop­u­lar Mylyn Eclipse IDE plu­gin, which main­tains fo­cused con­texts of en­ti­ties rel­e­vant to the cur­rent task. We show that this ap­proach is use­ful in re­veal­ing bro­ken point­cuts by ap­ply­ing it to mul­ti­ple ver­sions of sev­eral open source pro­jects and eval­u­at­ing the ac­cu­racy of the rec­om­men­da­tions pro­duced against ac­tual mod­i­fi­ca­tions made on these sys­tems.

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 because of changes made to the base-code is a daunting task, especially in large and complex systems. This project represents an automated approach that recommends a set of pointcuts that are likely to require modification due to a particular change in the base-code. Our hypothesis is that join points captured by a pointcut exhibit a varying degree of common structural characteristics on multiple levels. We use patterns describing such commonality to recommend pointcuts that have potentially broken to the developer, as well as point the developer in a direction in which the pointcut should be altered. We implemented our approach as an extension to the popular Mylyn Eclipse IDE plugin, which maintains focused contexts of entities relevant to the current task. We show that this approach is useful in revealing broken pointcuts by applying it to multiple versions of several open source projects and evaluating the accuracy of the recommendations produced against actual modifications made on these systems.

Java 8 is one of the largest up­grades to the pop­u­lar lan­guage and frame­work in over a decade. It of­fers sev­eral new, key fea­tures that can help make pro­grams eas­ier to read, write, and main­tain, es­pe­cially in re­gards to col­lec­tions. These fea­tures in­clude Lambda Ex­pres­sions, the Stream API, and en­hanced in­ter­faces, many of which help bridge the gap be­tween func­tional and im­per­a­tive pro­gram­ming par­a­digms and allow for suc­cinct con­cur­rency im­ple­men­ta­tions. We in­ves­ti­gate sev­eral open is­sues re­lated to au­to­mat­i­cally mi­grat­ing (refac­tor­ing) legacy Java soft­ware to use en­hanced in­ter­faces cor­rectly, ef­fi­ciently, and as com­pletely as pos­si­ble. Our goal is to help de­vel­op­ers to max­i­mally un­der­stand and adopt this new fea­ture thus im­prov­ing their soft­ware.

Java 8 is one of the largest upgrades to the popular language and framework in over a decade. It offers several new, key features that can help make programs easier to read, write, and maintain, especially in regards to collections. These features include Lambda Expressions, the Stream API, and enhanced interfaces, many of which help bridge the gap between functional and imperative programming paradigms and allow for succinct concurrency implementations. We investigate several open issues related to automatically migrating (refactoring) legacy Java software to use enhanced interfaces correctly, efficiently, and as completely as possible. Our goal is to help developers to maximally understand and adopt this new feature thus improving their software.

Java 8 is one of the largest up­grades to the pop­u­lar lan­guage and frame­work in over a decade. There are sev­eral new key fea­tures of Java 8 that can help make pro­grams eas­ier to read, write, and main­tain. Java 8 comes with many fea­tures, es­pe­cially re­lated to col­lec­tion li­braries. These in­clude such new fea­tures as Lambda Ex­pres­sions, the Stream API, en­hanced in­ter­faces, and more. While JDT Core/UI has in­cor­po­rated many Java 8 quick fixes and refac­tor­ings, there are still many fea­tures left to be done. For ex­am­ple, Net­Beans has a refac­tor­ing that con­verts loops to Lambda ex­pres­sions. This pro­ject is for ex­plor­ing the port­ing of the such con­ver­sion mech­a­nism in Net­Beans to Eclipse. These may be man­i­fested as refac­tor­ing and/or “quick fixes.” This pro­ject is open source. Please see the site link for down­loads.

Java 8 is one of the largest upgrades to the popular language and framework in over a decade. There are several new key features of Java 8 that can help make programs easier to read, write, and maintain. Java 8 comes with many features, especially related to collection libraries. These include such new features as Lambda Expressions, the Stream API, enhanced interfaces, and more. While JDT Core/UI has incorporated many Java 8 quick fixes and refactorings, there are still many features left to be done. For example, NetBeans has a refactoring that converts loops to Lambda expressions. This project is for exploring the porting of the such conversion mechanism in NetBeans to Eclipse. These may be manifested as refactoring and/or “quick fixes.” This project is open source. Please see the site link for downloads.

The Con­vert Con­stants to Enum refac­tor­ing for Eclipse pro­vides an au­to­mated ap­proach for trans­form­ing legacy Java code to use the new enu­mer­a­tion con­struct. This se­man­tics-pre­serv­ing tool in­creases type safety, pro­duces code that is eas­ier to com­pre­hend, re­moves un­nec­es­sary com­plex­ity, and elim­i­nates brit­tle­ness prob­lems that nor­mally pre­vent sep­a­rate com­pi­la­tion.

The Convert Constants to Enum refactoring for Eclipse provides an automated approach for transforming legacy Java code to use the new enumeration construct. This semantics-preserving tool increases type safety, produces code that is easier to comprehend, removes unnecessary complexity, and eliminates brittleness problems that normally prevent separate compilation.

Point­cut fragility is a well-doc­u­mented prob­lem in As­pect-Ori­ented Pro­gram­ming; changes to the base-code can lead to join points in­cor­rectly falling in or out of the scope of point­cuts. In this pro­ject, we use an au­to­mated ap­proach which lim­its fragility prob­lems by pro­vid­ing me­chan­i­cal as­sis­tance in point­cut main­te­nance. The ap­proach is based on har­ness­ing ar­bi­trar­ily deep struc­tural com­mon­al­i­ties be­tween pro­gram el­e­ments cor­re­spond­ing to join points se­lected by a point­cut. The ex­tracted pat­terns are then ap­plied to later ver­sions to offer sug­ges­tions of new join points that may re­quire in­clu­sion. To il­lus­trate that the mo­ti­va­tion be­hind our pro­posal is well-founded, we first em­pir­i­cally es­tab­lish that join points cap­tured by a sin­gle point­cut typ­i­cally por­tray a sig­nif­i­cant amount of unique struc­tural com­mon­al­ity by an­a­lyz­ing pat­terns ex­tracted from 23 As­pectJ pro­grams. Then, we demon­strate the use­ful­ness of our tech­nique by re­ju­ve­nat­ing point­cuts in mul­ti­ple ver­sions of 3 of these pro­grams. The re­sults show that our pa­ra­me­ter­ized heuris­tic al­go­rithm was able to au­to­mat­i­cally infer new join points in sub­se­quent ver­sions with an av­er­age re­call of 0.93. More­over, these join points ap­peared, on av­er­age, in the top 4th per­centile of the sug­ges­tions, in­di­cat­ing that the re­sults were pre­cise.

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 project, we use an automated approach which 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 3 of these programs. The results show that our parameterized heuristic algorithm was able to automatically infer new join points in subsequent versions with an average recall of 0.93. Moreover, these join points appeared, on average, in the top 4th percentile of the suggestions, indicating that the results were precise.