Open Access. Powered by Scholars. Published by Universities.®
Physical Sciences and Mathematics Commons™
Open Access. Powered by Scholars. Published by Universities.®
- Keyword
-
- Java (17)
- Refactoring (17)
- Java 8 (12)
- Software engineering (11)
- Programming languages (9)
-
- Default methods (8)
- Streams (8)
- Scala (7)
- Automated refactoring (6)
- Empirical studies (6)
- Software evolution (6)
- Software maintenance (6)
- Software tools (6)
- Static analysis (6)
- Typestate analysis (6)
- Aspect-oriented programming (5)
- Automatic parallelization (4)
- Computer science (4)
- Enumerated types (4)
- Interfaces (4)
- Introduction to computer programming (4)
- Aspect-Oriented programming (3)
- Aspect-oriented software (3)
- Concurrency (3)
- Deep learning (3)
- Functional programming (3)
- Imperative programs (3)
- Object oriented programming (3)
- Programming (3)
- Python (3)
- Publication Year
- Publication
- Publication Type
- File Type
Articles 61 - 80 of 80
Full-Text Articles in Physical Sciences and Mathematics
Detecting Broken Pointcuts Using Structural Commonality And Degree Of Interest, Raffi T. Khatchadourian, Awais Rashd, Hidehiko Masuhara, Takuya Watanabe
Detecting Broken Pointcuts Using Structural Commonality And Degree Of Interest, Raffi T. Khatchadourian, Awais Rashd, Hidehiko Masuhara, Takuya Watanabe
Publications and Research
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 daunting, especially in large and complex systems. We present an automated approach that recommends pointcuts that are likely to require modification due to a certain base-code change and ones that do not. Our hypothesis is that join points selected by a pointcut exhibit common structural characteristics. Patterns describing such commonalities recommend pointcuts that have potentially broken to the developer. The approach …
Porting The Netbeans Java 8 Enhanced For Loop Lambda Expression Refactoring To Eclipse, Md Arefin, Raffi T. Khatchadourian
Porting The Netbeans Java 8 Enhanced For Loop Lambda Expression Refactoring To Eclipse, Md Arefin, Raffi T. Khatchadourian
Publications and Research
Java 8 is one of the largest upgrades to the popular language and framework in over a decade. However, the Eclipse IDE is missing several key refactorings that could help developers take advantage of new features in Java 8 more easily. In this paper, we discuss our ongoing work in porting the enhanced for loop to lambda expression refactoring from the NetBeans IDE to Eclipse. We also discuss future plans for new Java 8 refactorings not found in any current IDE.
Porting The Netbeans Java 8 Enhanced For Loop Lambda Expression Refactoring To Eclipse, Md Arefin, Raffi T. Khatchadourian
Porting The Netbeans Java 8 Enhanced For Loop Lambda Expression Refactoring To Eclipse, Md Arefin, Raffi T. Khatchadourian
Publications and Research
Java 8 is one of the largest upgrades to the popular language and framework in over a decade. However, the Eclipse IDE is missing several key refactorings that could help developers take advantage of new features in Java 8 more easily. In this paper, we discuss our ongoing work in porting the enhanced for loop to lambda expression refactoring from the NetBeans IDE to Eclipse. We also discuss future plans for new Java 8 refactorings not found in any current IDE.
Fraglight: Shedding Light On Broken Pointcuts In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Awais Rashid, Hidehiko Masuhara, Takuya Watanabe
Fraglight: Shedding Light On Broken Pointcuts In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Awais Rashid, Hidehiko Masuhara, Takuya Watanabe
Publications and Research
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 daunting, especially in large and complex systems. We demonstrate an automated tool called FRAGLIGHT that recommends a set of pointcuts that are likely to require modification due to a certain base-code change. The underlying approach is rooted in harnessing unique and arbitrarily deep structural commonality between program elements corresponding to join points selected by a pointcut in a particular software version. …
Assessing Satellite Image Data Fusion With Information Theory Metrics, James Cross
Assessing Satellite Image Data Fusion With Information Theory Metrics, James Cross
Dissertations and Theses
A common problem in remote sensing is estimating an image with high spatial and high spectral resolution given separate sources of measurements from satellite instruments, one having each of these desirable properties. This thesis presents a survey of seven families of algorithms which have been developed to provide this common pattern of satellite image data fusion. They are all tested on artificially degraded sets of satellite data from the Moderate Resolution Imaging Spectroradiometer (“MODIS”) with known ideal results, and evaluated using the commonly accepted data fusion assessment metrics spectral angle mapper (“SAM”) and Erreur Relative Globale Adimensionelle de Synth`ese (“ERGAS”). …
Pointcut Rejuvenation: Recovering Pointcut Expressions In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Phil Greenwood, Awais Rashid, Harry Xu
Pointcut Rejuvenation: Recovering Pointcut Expressions In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Phil Greenwood, Awais Rashid, Harry Xu
Publications and Research
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, …
Formalizing Reusable Aspect-Oriented Concurrency Control, Neelam Soundarajan, Derek Bronish, Raffi T. Khatchadourian
Formalizing Reusable Aspect-Oriented Concurrency Control, Neelam Soundarajan, Derek Bronish, Raffi T. Khatchadourian
Publications and Research
Java and its library provide powerful concurrency control mechanisms. However, their use can lead to similar synchronization code scattered across multiple classes, synchronization and functional code being tangled together, and similar code being duplicated in many applications. Aspect-oriented (AO) programming makes it possible to address these problems. However, the specific behavior of systems built using AO techniques can be challenging to comprehend. We propose a specification approach to precisely express such systems' critical concurrency and synchronization properties. We illustrate the method with a simple example.
Enumeration Refactoring: A Tool For Automatically Converting Java Constants To Enumerated Types, Raffi T. Khatchadourian, Benjamin Muskalla
Enumeration Refactoring: A Tool For Automatically Converting Java Constants To Enumerated Types, Raffi T. Khatchadourian, Benjamin Muskalla
Publications and Research
Java 5 introduces several new features that significantly improve 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, 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 …
Optimal Cryptographic Hardness Of Learning Monotone Functions, Dana Dachman-Soled, Homin K. Lee, Tal Malkin, Rocco A. Servedio, Andrew Wan, Hoeteck Wee
Optimal Cryptographic Hardness Of Learning Monotone Functions, Dana Dachman-Soled, Homin K. Lee, Tal Malkin, Rocco A. Servedio, Andrew Wan, Hoeteck Wee
Publications and Research
Over the years a range of positive algorithmic results have been obtained for learning various classes of monotone Boolean functions from uniformly distributed random examples. Prior to our work, however, the only negative result for learning monotone functions in this model has been an information-theoretic lower bound showing that certain super-polynomial-size monotone circuits cannot be learned to accuracy 1/2+w(log n/ p n) (Blum, Burch, and Langford, FOCS’98). This is in contrast with the situation for nonmonotone functions, where a wide range of cryptographic hardness results establish that various “simple” classes of polynomial-size circuits are not learnable by polynomial-time algorithms.
In …
Pointcut Rejuvenation: Recovering Pointcut Expressions In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Phil Greenwood, Awais Rashid, Guoqing Harry Xu
Pointcut Rejuvenation: Recovering Pointcut Expressions In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Phil Greenwood, Awais Rashid, Guoqing Harry Xu
Publications and Research
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. 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. We demonstrate the usefulness of our technique by rejuvenating pointcuts in multiple versions of several …
Contributing Factors To Pointcut Fragility, Phil Greenwood, Awais Rashid, Raffi T. Khatchadourian
Contributing Factors To Pointcut Fragility, Phil Greenwood, Awais Rashid, Raffi T. Khatchadourian
Publications and Research
Pointcut fragility is a well-documented problem of Aspect-Oriented Programming with changes to the base-code causing join points to incorrectly fall in or out of scope. In order to combat this problem a tool was developed that provides mechanical assistance to pointcut maintenance. This tool relied on the deep structural commonalities between program elements to detect when pointcut fragility occurs. During the assessment of this tool a number of common practices were uncovered that were employed both in the aspect and base-code that contributed to or prevented pointcut fragility. This paper documents the practices uncovered and describes how they can affect …
Specifying Reusable Aspects, Neelam Soundarajan, Raffi T. Khatchadourian
Specifying Reusable Aspects, Neelam Soundarajan, Raffi T. Khatchadourian
Publications and Research
Aspect-Oriented Programming enables developers to manage, in a more modular fashion, implementations of crosscutting concerns that might be scattered or tangled if aspect-oriented techniques were not utilized. Our interest in this paper is in considering techniques for specifying precise properties of aspects. In particular, we are interested in specifying reusable aspects; i.e., aspects that correspond to crosscutting concerns that occur in many systems. These abstract aspects can be reused in various systems where a particular concern is applicable. Although there has been work on issues related to reasoning about aspects and the behaviors of aspect-oriented systems, specifying reusable abstract aspects …
On The Assessment Of Pointcut Design In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Phil Greenwood, Awais Rashid
On The Assessment Of Pointcut Design In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Phil Greenwood, Awais Rashid
Publications and Research
No abstract provided.
Rejuvenate Pointcut: A Tool For Pointcut Expression Recovery In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Awais Rashid
Rejuvenate Pointcut: A Tool For Pointcut Expression Recovery In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Awais Rashid
Publications and Research
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 …
Pointcut Rejuvenation: Recovering Pointcut Expressions In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Phil Greenwood, Awais Rashid, Guoqing Harry Xu
Pointcut Rejuvenation: Recovering Pointcut Expressions In Evolving Aspect-Oriented Software, Raffi T. Khatchadourian, Phil Greenwood, Awais Rashid, Guoqing Harry Xu
Publications and Research
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 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 …
Enforcing Behavioral Constraints In Evolving Aspect-Oriented Programs, Raffi T. Khatchadourian, Johan Dovland, Neelam Soundarajan
Enforcing Behavioral Constraints In Evolving Aspect-Oriented Programs, Raffi T. Khatchadourian, Johan Dovland, Neelam Soundarajan
Publications and Research
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 rely-guarantee style reasoning system for the Aspect-Oriented Programming (AOP) paradigm, adopting a trace-based …
Reasoning About The Behavior Of Aspect-Oriented Programs, Neelam Soundarajan, Raffi T. Khatchadourian, Johan Dovland
Reasoning About The Behavior Of Aspect-Oriented Programs, Neelam Soundarajan, Raffi T. Khatchadourian, Johan Dovland
Publications and Research
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-guarantee approach 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.
Automated Refactoring Of Legacy Java Software To Enumerated Types, Raffi T. Khatchadourian, Jason Sawin, Atanas Rountev
Automated Refactoring Of Legacy Java Software To Enumerated Types, Raffi T. Khatchadourian, Jason Sawin, Atanas Rountev
Publications and Research
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 …
Automated Refactoring Of Legacy Java Software To Enumerated Types, Raffi T. Khatchadourian, Jason Sawin, Atanas Rountev
Automated Refactoring Of Legacy Java Software To Enumerated Types, Raffi T. Khatchadourian, Jason Sawin, Atanas Rountev
Publications and Research
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 …
Rely-Guarantee Approach To Reasoning About Aspect-Oriented Programs, Raffi T. Khatchadourian, Neelam Soundarajan
Rely-Guarantee Approach To Reasoning About Aspect-Oriented Programs, Raffi T. Khatchadourian, Neelam Soundarajan
Publications and Research
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 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.