Aspect-oriented Research Articles

Detecting broken pointcuts using structural commonality and degree of interest

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).

Investigating the Effect of Aspect-Oriented Refactoring on the Unit Testing Effort of Classes: An Empirical Evaluation

This paper aims at investigating empirically the effect of aspect-oriented (AO) refactoring on the unit testability of classes in object-oriented software. The unit testability of classes has been addressed from the perspective of the unit testing effort, and particularly from the perspective of the unit test cases (TCs) construction. We investigated, in fact, different research questions: (1) the impact of AO refactoring on source code attributes (size, complexity, coupling, cohesion and inheritance), attributes that are mostly related to the unit testability of classes, (2) the impact of AO refactoring on unit test code attributes (size, assertions, invocations and data creation), attributes that are indicators of the effort involved to write the code of unit TCs, and (3) the relationships between the variations observed after AO refactoring in both source code and unit test code attributes. We used in the study different techniques: correlation analysis, statistical tests and linear regression. We performed an empirical evaluation using data collected from three well-known open source (Java) software systems (JHOTDRAW, HSQLBD and PETSTORE) that have been refactored using AO programming (AspectJ). Results suggest that: (1) overall, the effort involved in the construction of unit TCs of refactored classes has been reduced, (2) the variations of source code attributes have more impact on methods invocation between unit TCs, and finally (3) the variations of unit test code attributes are more influenced by the variation of the complexity of refactored classes compared to the other class attributes.

The design and implementation of multi-source application middleware based on service bus

With the rapid development of the Internet of Things(IoT), the real-time monitoring data are increasing with different types and large amounts. Aiming at taking full advantages of the data, we designed and implemented an application middleware, which not only supports the three-layer architecture of IoT information system but also enables the flexible configuration of multiple resources access and other accessional modules. The middleware platform shows the characteristics of lightness, security, AoP (aspect-oriented programming), distribution and real-time, which can let application developers construct the information processing systems on related areas in a short period. It focuses not limited to these functions: pre-processing of data format, the definition of data entity, the callings and handlings of distributed service and massive data process. The result of experiment shows that the performance of middleware is more excellent than some message queue construction to some degree and its throughput grows better as the number of distributed nodes increases while the code is not complex. Currently, the middleware is applied to the system of Shanghai Pudong environmental protection agency and achieved a great success.

Special issue on software reuse

Special issue on software reuse

Specifying and identifying widely used crosscutting concerns

To ensure quality of code in large software systems, refactoring operations are the norm. With this goal in mind, it is helpful to direct preventive maintenance of large object-oriented legacy systems towards the more advanced aspect-oriented paradigm. However, manually identifying crosscutting concerns, candidate to be rendered as aspects, in large legacy systems can be an overwhelming task. We propose an approach and provide a tool to identify crosscutting concerns embedded in an object-oriented system. Our approach analyses the implementation of classes and their relationships and looks for specific user-defined schemata. We discuss how to build schemata and provide some general ones, devised in accordance with current aspect-oriented programming practices.Compared to existing approaches, our solution is flexible and achieves higher precision in detecting crosscutting concerns. Moreover, it provides the developer with an accurate identification of snippets of code which can be removed from classes and embedded into aspects. The proposed solution has been validated by applying it to a case study, i.e., a large extant software system, suitably selected to assess the quality attained by the aspect-oriented version produced with the assistance of our tool, in comparison with a design performed by expert human developers.

Language Oriented Modularity: From Theory to Practice

Language-oriented modularity (LOM) is a methodology that complements language-oriented programming (LOP) in providing on-demand language abstraction solutions during software development. It involves the implementation and immediate utilization of domain-specific languages (DSLs) that are also aspect-oriented (DSALs). However, while DSL development is affordable thanks to modern language workbenches, DSAL development lacks similar tool support. Consequently, LOM is often impractical and underutilized. The challenge we address is making the complexity of DSAL implementation comparable to that of DSLs and the effectiveness of programming with DSALs comparable to that of general-purpose aspect languages (GPALs). Today, despite being essentially both domain-specific and aspect-oriented, DSALs seem to be second-class. Aspect development tools (e.g., AJDT) do not work on DSAL code. DSL development tools like language workbenches (e.g., Spoofax) neither deal with the backend weaving nor handle the composition of DSALs. DSAL composition frameworks (e.g., Awesome) do not provide frontend development tools. DSAL code transformation approaches (e.g., XAspects) do not preserve the semantics of DSAL programs in the presence of other aspect languages. We extend AspectJ with a small set of annotations and interfaces that allows DSAL designers to define a semantic-preserving transformation to AspectJ and interface with AspectJ tools. Our transformation approach enables the use of standard language workbench to implement DSALs and use of standard aspect development tools to program with those DSALs. As a result, DSALs regain first-class status with respect to both DSLs and aspect languages. This, on the one hand, lowers the cost of developing DSALs to the level of DSLs and, on the other hand, raises the effectiveness of using a DSAL to the level of a GPAL. Consequently, LOM becomes cost-effective compared to the LOP baseline. We modified the ajc compiler to support our approach. Using two different language workbenches (Spoofax and Xtext) we then implemented several DSALs. AspectJ was supported out-of-the-box. We implemented Cool to demonstrate that the non-trivial composition of AspectJ and Cool can be accommodated using our approach. We applied LOM to crosscutting concerns in two open source projects (oVirt and muCommander), implementing in the process application-specific DSALs, thus providing a sense of the decrease in the cost of developing composable DSALs and the increase in the effectiveness of programming with them. Crosscutting concerns remain a problem in modern real-world projects (e.g., as observed in oVirt). DSALs are often the right tool for addressing these concerns. Our work makes LOM practical, thus facilitating use of DSAL solutions in the software development process.

Open Programming Language Interpreters

Context: This paper presents the concept of open programming language interpreters and the implementation of a framework-level metaobject protocol (MOP) to support them. Inquiry: We address the problem of dynamic interpreter adaptation to tailor the interpreter's behavior on the task to be solved and to introduce new features to fulfill unforeseen requirements. Many languages provide a MOP that to some degree supports reflection. However, MOPs are typically language-specific, their reflective functionality is often restricted, and the adaptation and application logic are often mixed which hardens the understanding and maintenance of the source code. Our system overcomes these limitations. Approach: We designed and implemented a system to support open programming language interpreters. The prototype implementation is integrated in the Neverlang framework. The system exposes the structure, behavior and the runtime state of any Neverlang-based interpreter with the ability to modify it. Knowledge: Our system provides a complete control over interpreter's structure, behavior and its runtime state. The approach is applicable to every Neverlang-based interpreter. Adaptation code can potentially be reused across different language implementations. Grounding: Having a prototype implementation we focused on feasibility evaluation. The paper shows that our approach well addresses problems commonly found in the research literature. We have a demonstrative video and examples that illustrate our approach on dynamic software adaptation, aspect-oriented programming, debugging and context-aware interpreters. Importance: To our knowledge, our paper presents the first reflective approach targeting a general framework for language development. Our system provides full reflective support for free to any Neverlang-based interpreter. We are not aware of any prior application of open implementations to programming language interpreters in the sense defined in this paper. Rather than substituting other approaches, we believe our system can be used as a complementary technique in situations where other approaches present serious limitations.

Improving Network Security using Aspect Oriented Programming

System security is critical in many modern software applications, yet there are many examples of system with little or no effective security in place. Modern computer System provides the most effective tool that the world uses for communication and exchange of information. Security of these applications is essinial ,but many are used to get to data without effective security. It is basic for system architects to ensure that the system is secuere as possible. Software designers need to insert or execute security in their applications. Security can be effectively implemented before the phases of the product improvement process, yet some designers for the most part ignore the security functionalities of their framework. System security issues include ways which program security influences overall system security. This paper concentrates on the ways in which Aspect-Oriented Programming (AOP) can be utilized to incorporate security into such software. The way security is actualized utilizing Aspect Oriented Programming is described, as is an approach to decrease the complexity of the program by permitting programming engineers to include security after the underlying program improvement stage is done.

Dynamic slicing of distributed Aspect-Oriented Programs: A context-sensitive approach

This paper presents a dynamic parallel context-sensitive slicing algorithm for distributed AOPs. The context-sensitivity makes the computed slice more precise and accurate. We introduce parallelism in our algorithm to make slice computation faster. We have developed a tool called D-AspectJ slicer to compute dynamic slices for distributed AOPs. The proposed slicing technique is compared with two other related existing techniques using ten case studies. The experimentation shows that our proposed slicing algorithm generates smaller slices in less time as compared to other two existing algorithms.

Achieving dynamicity in security policies enforcement using aspects

The dynamic configuration and evolution of large-scale heterogeneous systems has made the enforcement of security requirements one of the most critical phases throughout the system development lifecycle. In this paper, we propose a framework architecture to associate the security policies with the specification and the execution phases of applications defined for these systems. Our proposed framework is based on an aspect-oriented programming approach and on the organization-based access control model to dynamically enforce and manage the access and the usage control. The deployment of the framework modules, proposed in this paper, takes into account the changes that may occur in the security policy during the application execution. We also present the implementation as well as the evaluation of our proposition.

Aspect Oriented Programming Perspective in Software Agents and Simulation

Agent-driven Simulation Framework-AdSiF provides a declarative scripting agent programming language. Stateoriented programming paradigm combined with multi-programming paradigms is at the background of script, which allows programming by extended state charts. Aspect-oriented programming paradigm draws a solution background related with scattered codes, scattered requirements and tangled requirements. While object-oriented programming paradigm gives a vertical software design, aspect orientation enhances this vertically deep design by horizontal association. Aspect-oriented programming paradigm, which is one of the components of AdSiF’s state oriented programming paradigm, provides a solution by a loosely-coupled script description to the problems mentioned. For this purpose, states and behaviours, which satisfy scattered requirements, are distributed to behaviour’s and behaviour lists, respectively and behaviour phase transitions based on behaviours and active states are allowed. In addition to all, Furthermore, in simulation and agent programming world, the solution provides a solution by shifting modelling aspects conditionally in run time for conceptually different modelling requirements and also tangled requirements. The solution carries aspect oriented programming from design time to execution time and provides a dynamically manageable, flexible, loosely coupled and high coherent design.

Comparación de Uso del Patrón de Diseño Decorator y la Programación Orientada a Aspectos en .NET para Modularizar Incumbencias Cruzadas

Looking for modular .NET software solutions, this article describes and illustrates how to produce modular .NET solutions through the use of the object-oriented software design pattern Decorator and the aspectoriented programming (AOP) tool PostSharp for the crosscutting concerns modularization of an application. The application is a base and traditional crosscutting concerns example (logging example). This article presents solutions of logging by the use of Decorator and PostSharp for the modularization of its crosscutting concerns. It also gives details of the advantages and disadvantages of both solutions. Furthermore, this article specifies AOP information that is part of PostSharp and proposes applying PostSharp and Decorator to achieve higher modularity level solutions.

Assessing Organizational Effectiveness of Cooperative Agents

This paper investigates the effect of agents coalitional strategy on their effectiveness using an evaluation approach that causes no alteration of the global system’s performance. Cooperation process is thus considered during the execution of a Multiagent System (MAS) in order to collect all necessary data for the evaluation phase. A structural analysis is then led to set instant and global assessments of the agents management and output. The observation and evaluation tools are implemented using aspect-oriented programming. We prove through experiments that they do not alter the global performance of the system regarding execution time and reached scores. The approach could then be validated as an objective evaluator of the system by judging real organizational capabilities of its agents in achieving their goals.

PENGEMBANGAN LEMBAR KEGIATAN SISWA BERBASIS KEARIFAN LOKAL TEMA KEGEMARANKU SUBTEMA GEMAR BEROLAHRAGA & GEMAR BERNYANYI DAN MENARI DI KELAS I SDN UTAMA 1 TARAKAN

<p>This research aims to produce students’ worksheet based on local wisdom for first grade on theme my hobbies subtheme love in doing sports& singing and dancing of SDN Utama 1 Tarakan. This research was <em>Research and Development</em> with adopt procedure from Borg and Gall which is potential and problem, gather information, product design, design validation, the revised design, product testing, product revision, testing usage, and product revision. This result showed that : (a) student worksheet included in the category of valid from aspect content and material with average score 4,44 category very good, aspect language with average score 4 category good, and aspect desain with average score 4,04 category very good (b) student worksheet included in the category of practic with average score 3,83 category good (c) student worksheet included in the category effective from aspect observation student activity with average score 3,45 category good, aspect student respons with average score 4,32 category very good, and aspect of students learning outcomes with average score 4,74 category very good.</p><p> </p><strong>Keyword:</strong> <em>Student Worksheet, Local Culture</em>

Extensible modeling with managed data in Java

Many model-driven development (MDD) tools employ specialized frameworks and modeling languages, and assume that the semantics of models is provided by some form of code generation. As a result, programming against models is cumbersome and does not integrate well with ordinary programming languages and IDEs. In this paper we present MD4J, a modeling approach for embedding metamodels directly in Java, using plain interfaces and annotations. The semantics is provided by data managers that create and manipulate models. This architecture enables two kinds of extensibility. First, the data managers can be changed or extended to obtain different base semantics of a model. This allows a kind of aspect-oriented programming. Second, the metamodels themselves can be extended with additional fields and methods to modularly enrich a modeling language. We illustrate our approach using the example of state machines, discuss the implementation, and evaluate it with two case-studies: the execution of UML activity diagrams and an aspect-oriented refactoring of JHotDraw.

RAMBUTANS: automatic AOP-specific test generation tool

Aspect-oriented programming (AOP) is a programmatic methodology to handle better modularized code by separating crosscutting concerns from the traditional abstraction boundaries. Automated testing, as one of the most demanding needs of the software development to reduce both human effort and costs, is a delicate issue in testing aspect-oriented programs. Prior studies in the automated test generation for aspect-oriented programs have been very limited with respect to the need for both adequate tool support and capability concerning effectiveness and efficiency. This paper describes a new AOP-specific tool for testing aspect-oriented programs, called RAMBUTANS. The RAMBUTANS tool uses a directed random testing technique that is especially well suited for generating tests for aspectual features in AspectJ. The directed random aspect of the tool is parameterized by associating weights to aspects, advice, methods, and classes by controlling object and joint point creations during the test generation process. We present a comprehensive empirical evaluation of our tool against the current AOP test generation approaches on three industrial aspect-oriented projects. The results of the experimental and statistical tests showed that RAMBUTANS tool produces test suites that have higher fault-detection capability and efficiency for AspectJ-like programs.

Defect Prediction Model for AOP-based Software Development using Hybrid Fuzzy C-Means with Genetic Algorithm and K-Nearest Neighbors Classifier

The number of defects has often been considered a vital indicator of quality of software. It is well known that we cannot go back and add quality. Software Quality and reliability are considered to be one of the most important concerns of software product. In this paper, we give a brief overview of an Aspect-Oriented Programming (AOP) and a model is proposed to predict defects. The model is empirically validated on the PROMISE Software Engineering Repository dataset with three different types of methods. One is Fuzzy CMeans Clustering (FCM) approach and another is K-Nearest Neighbors (KNN) classifier technique, have been performed in real data. Third is a hybrid approach (i.e. combination of fuzzy c-means and genetic algorithms) have been performed. The performance of data is evaluated in terms of Reliability, Accuracy, Mean Absolute Error (MAE), and Root Mean Square Error (RMSE). General Terms AOP, AOSD

A Perceptual Learning Approach to the Whorfian Hypothesis: Supervised Classification of Motion

AbstractRecent research on the relationship between grammatical aspect and motion event cognition has shown that speakers of nonaspect languages (e.g., German, Swedish) attend to event endpoints more than speakers of aspect languages (e.g., English, Spanish). In this study, we took a perceptual learning approach to the Whorfian hypothesis, training native English speakers to categorize events either in an English‐like way (same‐language bias) or in a Swedish‐like way (other‐language bias), with and without verbal interference in English. Results showed that successful learning occurred in both language conditions. However, verbal interference disrupted learning only in the condition where the perceptual dimension to be learned was also salient in the participant's native language. This revealed selective language influence depending on the associative or dissociative relationship between the linguistic features occurring in the observer's native language and the perceptual features of the stimuli presented to them.Open PracticesThis article has been awarded an Open Materials badge. All materials are publicly accessible in the IRIS digital repository at http://www.iris‐database.org. Learn more about the Open Practices badges from the Center for Open Science: https://osf.io/tvyxz/wiki.

Modularizing application and database evolution - an aspect-oriented framework for orthogonal persistence

Summary In the maintenance of software applications, database evolution is one common difficulty. In object-oriented databases, this process comprises schema evolution and instance adaptation. Both tasks usually require significant effort from programmers and database administrators. In this paper, we propose orthogonal persistence and aspect-oriented programming to support semi-transparent database evolution. A default mechanism for instance evolution is defined, but the user may provide modularized solutions using the aspect-oriented paradigm. We present our framework AOF4OOP to test the feasibility of our proposed approach. This prototype allows programmes to transparently access data in other versions of the database schema. We evaluate our framework, comparing it to related approaches using two real applications and measuring the improvement of the productivity of the programmer. Copyright © 2016 John Wiley & Sons, Ltd.

A Graph-Based Dynamic Slicing of Distributed Aspect-Oriented Software

Distributed computing has become very popular these days due to its speed, accuracy and fault tolerance capability. In this pa-per, we have considered the distributed Aspect-Oriented Programs (AOPs) where message passing and synchronization are handled by Aspects. In this paper, we present a parallel dynamic slicing algorithm for distributed AOPs. We introduce parallelism into our slicing algorithm to make the slice computation process much faster. Our algorithm is implemented on our developed tool, called DDG generator, to generate the required intermediate graphs for distributed AOPs. The proposed slicing technique is compared with one related existing technique using three case studies. The experimental results show that our proposed slicing algorithm generates precise slices in less time as compared to the existing algorithm.