Aspect-oriented Programming Paradigm Research Articles

Non-Intrusive Continuous Monitoring of Smart City Platforms

Smart city platforms provide several services to facilitate the development of applications. Such platforms typically manage several applications, deal with a large volume of data, and serve many devices and users that generate a high volume of requests. The large number of requests to handle and the complex operations to perform often cause overloads on the platform, degrading the quality of service provided to users and applications. In this context, monitoring the underlying computational infrastructure in which smart city platforms and applications are deployed and the platform operations is essential. The monitoring process can allow for examining fluctuations in the behavior of the platform's components to detect performance degradation and overloads (including unforeseen ones), contribute to avoiding interruptions in the platform's services, and increase its scalability to assimilate significant amounts of requests, devices, and users. This paper presents a strategy and architecture to enable the non-intrusive monitoring of operations on smart city platforms and their underlying infrastructure. The proposal covers monitoring at multiple levels and is based on the aspect-oriented programming (AOP) paradigm so that it is possible to monitor the platform's operations without intervening in the platform's implementation or generating coupling regarding monitoring. This paper presents the implementation of the monitoring architecture and its instantiation in the context of Smart Geo Layers (SGeoL), a platform that has been used in several real-world smart city applications. This paper also reports the results of computational experiments to evaluate the performance of the proposed monitoring architecture for response time to requests, CPU usage, and RAM utilization. The obtained results show an evident increase in response time with the number of simultaneous requests and a significant correlation between the response time and the CPU utilization in the deployment of the monitoring architecture.

Automated and non-intrusive provenance capture with UML2PROV

Data provenance is a form of knowledge graph providing an account of what a system performs, describing the data involved, and the processes carried out over them. It is crucial to ascertaining the origin of data, validating their quality, auditing applications behaviours, and, ultimately, making them accountable. However, instrumenting applications, especially legacy ones, to track the provenance of their operations remains a significant technical hurdle, hindering the adoption of provenance technology. UML2PROV is a software-engineering methodology that facilitates the instrumentation of provenance recording in applications designed with UML diagrams. It automates the generation of (1) templates for the provenance to be recorded and (2) the code to capture values required to instantiate those templates from an application at run time, both from the application’s UML diagrams. By so doing, UML2PROV frees application developers from manual instrumentation of provenance capturing while ensuring the quality of recorded provenance. In this paper, we present in detail UML2PROV’s approach to generating application code for capturing provenance values via the means of Bindings Generation Module (BGM). In particular, we propose a set of requirements for BGM implementations and describe an event-based design of BGM that relies on the Aspect-Oriented Programming (AOP) paradigm to automatically weave the generated code into an application. Finally, we present three different BGM implementations following the above design and analyze their pros and cons in terms of computing/storage overheads and implications to provenance consumers.

RESOURCE-INDEPENDENT REPRESENTATION OF SORTING NETWORKS IN Set@l PROGRAMMING LANGUAGE

The development of scalable parallel programs for high-performance computer systems with reconfigurable and hybrid architectures is an important problem in the field of modern supercomputer engineering. Resource-independent applied software in the high-level COLAMO programming language describes only the limited number of the algorithm implementations for some configurations due to the inductive principle of the information graph forming. However, the creation of efficient resource-independent parallel software requires programming tool that supports both induction and reduction of calculations. To solve the problem, we propose the application of the Set@l programming language based on the aspect-oriented programming paradigm and set-theoretical code representation. According to the aspect-oriented concept, Set@l describes an algorithm for the problem solution and its parallelizing and other implementation features as separated program modules – source code and various aspects. The programming language being considered has much in common with traditional set-theory-based languages such as SETL, SETLX and SETL2, but Set@l introduces the essential classification of collections by parallelism, definiteness, orderliness and other criteria. In contrast to the high-level COLAMO programming language, Set@l specifies the full information graph of a computational problem in the absolutely parallel form and describes the reduction principles for all configurations of a computer system as independent aspects of a program. In this paper, we demonstrate that the aspect-oriented sorting program in the Set@l language defines different types of quadratic sorting networks and various methods of their partition and reduction.

Comparative Analysis of Various Testing Techniques used for Aspect-Oriented Software System

<p>Nowadays, Aspect-Oriented Programming (AOP) paradigm is getting more popularity in the field of software development. But testing an Aspect-oriented software system (AOSS) is not well matured. Therefore, many researchers have been focusing on testing an AOSS. Moreover, the literature indicates that very few papers have devoted to literature survey but still there is need to study in depth of various testing techniques used for AOSS. Therefore, in this paper, a comprehensive study of existing various testing techniques for AOSS have been conducted and present a comparative analysis result of various testing techniques based on various parameters.</p>

A formal approach to derive an aspect oriented programming-based implementation of a secure access control filter

Context: Nowadays, Information Systems (IS) are at the heart of most companies and constitute then a critical element that needs an adequate attention regarding security issues of sensitive data it manages.Objective: This paper presents a formal approach for the development of a filter to secure access to sensitive resources of information systems.Method: The proposed approach consists of three complementary steps. Designers start by modeling the functionalities of the system and its security requirements using dedicated UML diagrams. These diagrams are then automatically translated into a formal B specification suitable not only for reasoning about data integrity checking but also for the derivation of a trustworthy implementation. Indeed, a formal refinement process is applied on the generated B specification to obtain a relational-like B implementation which is then translated into an AspectJ implementation, connected to a SQL Server (release 2014) relational database system. Such a generation is performed following the aspect oriented programming paradigm which permits a separation of concerns by making a clear distinction between functional and security aspects.Results: A systematic formal approach to derive a secure filter that regulates access to the sensitive data of an information system. The filter considers both static and dynamic access rules. A tool that supports the proposed approach is also provided.Conclusion: The approach has been applied on several case studies that demonstrate that the development of a tool permits to free the developers from tedious and error-prone tasks since they have just to push a button to generate the AspectJ code of an application.

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.

An approach to design test oracle for aspect oriented software systems using soft computing approach

Software testing is one of the most important process in the software development life cycle, since it ensures the delivery of good quality software to the user. In order to make this process more efficient, automated testing is required. Automated testing offers the advantages of reduced cost and time and it is also more reliable than manual means. In automated testing, test oracle process is required to test software applications. The software applications developed using aspect oriented programming paradigm can also be tested using automated testing. Aspect oriented programming offers the advantages over object oriented programming paradigm by centralizing various cross cutting concerns in a software code, thereby improving the modularity of the code. Since the crosscutting concern is separated into a single module, maintenance of such systems becomes easy. In this paper, the artificial neural network approach is used for testing the aspect oriented programming applications by developing test oracle.

Practical Benefits of Aspect-Oriented Programming Paradigm in Discrete Event Simulation

Aspect-oriented modeling and simulation is a new approach which uses the separation of concerns principle to enhance the quality of models and simulation tools. It adopts the separation of concerns (SOC) principle. Thus, crosscutting concerns such as processes synchronization, steady state detection, and graphical animation could be separated from simulation functional modules. The capture of crosscutting concerns in a modular way is carried out to cope with complexity and to achieve the required engineering quality factors such as robustness, modularity, adaptability, and reusability. This paper provides a summary of aspect-oriented paradigm with its usage in simulation by illustrating the main crosscutting concerns that may infect simulation systems. A practical example is given with the use of the Japrosim discrete event simulation library.

Exploring the Educational Benefits of Introducing Aspect-Oriented Programming Into a Programming Course

This paper explores the educational benefits of introducing the aspect-oriented programming paradigm into a programming course in a study on a sample of 75 undergraduate software engineering students. It discusses how using the aspect-oriented paradigm, in addition to the object-oriented programming paradigm, affects students' programs, their exam results, and their overall perception of the theoretically claimed benefits of aspect-oriented programming. The research methodology, consisting of automating the analysis of student-created computer programs, administering surveys, and collecting exam results, provided an objective measurement of the benefits of the paradigm for novice programmers, as well as evaluating their perception of its usefulness. The results show that the use of aspect-oriented programming as a supplement to object-oriented programming enhances the productivity of novice program code software engineering students and leads to increased understanding of theoretical concepts. Students readily accepted the new paradigm and recognized its benefits.

A Cohesion Measure for C in the Context of an AOP Paradigm

Cohesion measures the relative functional strength of a module and impacts the internal attribute of a function such as modularity. Modularity has become an accepted approach in every engineering discipline. The concept of modular design has considerably reduced the complexity of software design. It represents the strength of bond between the internal elements of the modules. To achieve effective modularity, design concepts like functional independence are considered to be very important. Aspect-oriented software development (AOSD) has emerged over the last decade as a paradigm for separation of concerns, which aims to increase the modularity. Therefore the presence of aspects affects the cohesiveness of a module. Like any new technology, aspect-oriented programming (AOP) was introduced to solve problems related to object-orientation (OO), and more in particular Java .It was noticed that AOP’s ideas were not necessarily tied to OO (and Java) but also to less modular paradigm like imperative programming. Moreover, several metrics have been proposed to assess aspect-oriented systems quality attributes in an object oriented context. However, not much work has been done to assess the impact of AOP on imperative style of programming (also called procedural paradigm, such as C language). Therefore, metrics are required to measure quality attributes for AOP used with imperative programming. Cohesion is considered an important software quality attribute. In this context, this paper presents an approach for measuring cohesion based on dependence analysis using control flow graphs (CFG).

A Compiler for Multimodal Scenarios

We exploit the main similarity between the aspect-oriented programming paradigm and the inter-object, scenario-based approach to specification, in order to construct a new way of executing systems based on the latter. Specifically, we transform multimodal scenario-based specifications, given in the visual language of live sequence charts (LSC), into what we call scenario aspects , implemented in AspectJ. Unlike synthesis approaches, which attempt to take the inter-object scenarios and construct intra-object state-based per-object specifications or a single controller automaton, we follow the ideas behind the LSC play-out algorithm to coordinate the simultaneous monitoring and direct execution of the specified scenarios. Thus, the structure of the specification is reflected in the structure of the generated code; the high-level inter-object requirements and their structure are not lost in the translation. The transformation/compilation scheme is fully implemented in a UML2-compliant tool we term the S2A compiler (for Scenarios to Aspects), which provides full code generation of reactive behavior from inter-object multimodal scenarios. S2A supports advanced scenario-based programming features, such as multiple instances and exact and symbolic parameters. We demonstrate our work with an application whose inter-object behaviors are specified using LSCs. We discuss advantages and challenges of the compilation scheme in the context of the more general vision of scenario-based programming.

Aspect-oriented development of cluster computing software

In complex software systems, modularity and readability tend to be degraded owing to inseparable interactions between concerns that are distinct features in a program. Such interactions result in tangled code that is hard to develop and maintain. Aspect-Oriented Programming (AOP) is a powerful method for modularizing source code and for decoupling cross-cutting concerns. A decade of growing research on AOP has brought the paradigm into many exciting areas. However, pioneering work on AOP has not flourished enough to enrich the design of distributed systems using the refined AOP paradigm. This article investigates three case studies that cover time-honored issues such as fault-tolerant computing, network heterogeneity, and object replication in the cluster computing community using the AOP paradigm. The aspects that we define here are simple, intuitive, and reusable. Our intensive experiences show that (i) AOP can improve the modularity of cluster computing software by separating the source code into base and instrumented parts, and (ii) AOP helps developers to deploy additional features to legacy cluster computing software without harming code modularity and system performance.

Side-effect localization for lazy, purely functional languages via aspects

Many side-effecting programming activities, such as profiling and tracing, can be formulated as crosscutting concerns and be framed as side-effecting aspects in the aspect-oriented programming paradigm. The benefit gained from this separation of concerns is particularly evident in purely functional programming, as adding such aspects using techniques such as monadification will generally lead to crosscutting changes. This paper presents an approach to provide side-effecting aspects for lazy purely functional languages in a user transparent fashion. We propose a simple yet direct state manipulation construct for developing side-effecting aspects and devise a systematic monadification scheme to translate the woven code to monadic style purely functional code. Furthermore, we present a static and dynamic semantics of the aspect programs and reason about the correctness of our monadification scheme with respect to them.

An Aspect-Oriented Framework for Weaving Domain-Specific Concerns into Component-Based Systems

Software components are used in various application domains, and many component models and frameworks have been proposed to fulfill domain-specific requirements. The general trend followed by these approaches is to provide ad-hoc models and tools for capturing these requirements and for implementing their support within dedicated runtime platforms, limited to features of the targeted domain. The challenge is then to propose more flexible solutions, where components reuse is domain agnostic. In this article, we present a framework supporting compositional construction and development of applications that must meet various extra-functional/domain-specific requirements. The key points of our contribution are: i) We target development of component-oriented applications where extra-functional requirements are expressed as annotations on the units of composition in the application's architecture. ii) These annotations are implemented as open and extensible component-based containers, achieving full separation of functional and extra-functional concerns. iii) Finally, the full machinery is implemented using the Aspect-Oriented Programming paradigm. We validate our approach with two case studies: the first is related to real-time and embedded applications, while the second refers to the distributed context-aware middleware domain.

Separation of scattered concerns

Aspect Mining is a dynamic area of research in the field of Software Engineering. Aspects are concerns that are intermingled with other concerns thereby reducing the understandability, maintainability and scalability of the code. The concept of Separation of Concerns (SoC) is often achieved untill the Design Phase, but gets difficult in the later phases of the software development life cycle (SDLC). During program maintenance the maintenance team is left with an aggregation of procedures and variables, both of which may be generically called user-defined tokens. This paper proposes a graph-based approach to address the problem of SoC during program maintenance. This is done by the removal of some source code elements (e.g., user-defined-tokens), which can be responsible for tangled concerns and complex code. These user-definedtokens can be treated separately under the Aspect Oriented Programming paradigm. The paper proposes a graphical-model, which represents a procedural program and defines a mathematical- model to identify and remove the tangled and interleaving code-fragments. Thereafter these code fragments are traced back to the requirements engineering level through a formal traceability model. This process yields the corresponding user requirements that are associated with these scattered code fragments. These identified user requirements are put forward as Aspects, to be handled or re-engineered under the Aspect Oriented Programming paradigm.

MAINTAINABILITY METRICS FOR ASPECT-ORIENTED SOFTWARE

Maintainability is an important factor that developers should be concerned because two-thirds of software costs involve maintenance. Aspect-oriented programming (AOP) paradigm is aimed to increase the software maintainability. It solves code tangling and code scattering problems by introducing a new modular unit, called "aspect". Various research works are provided to support measuring the object-oriented software, but only few studies are set up to support measuring the aspect-oriented software. This paper proposes aspect-oriented software maintainability metrics and a set of aspect-oriented design guidelines to support the metrics. By combining the proposed guidelines, object-oriented design principles, and aspect-oriented design principles, the metrics are constructed according to the Factor-Strategy (FS) quality model and the Factor-Criteria-Metric (FCM) quality model. Principle violation check definitions in the form of Boolean expressions are also defined to conduct software measurement and to fulfill the metrics. Finally, the aspect-oriented software maintainability metrics are applied to detect design principle violations in fifty AspectJ systems. The results show that for all systems their hidden flaws are exposed. Moreover, the proposed metrics are used to compare the maintainability between two versions of systems written in Java and AspectJ.

Mismatch Patterns and Adaptation Aspects: A Foundation for Rapid Development of Web Service Adapters

Standardization in Web services simplifies integration. However, it does not remove the need for adapters due to possible heterogeneity among service interfaces and protocols. In this paper, we characterize the problem of Web services adaptation focusing on business interfaces and protocols adapters. Our study shows that many of the differences between business interfaces and protocols are recurring. We introduce mismatch patterns to capture these recurring differences and to provide solutions to resolve them. We leverage mismatch patterns for service adaptation with two approaches: by developing stand-alone adapters and via service modification. We then dig into the notion of adaptation aspects that, following aspect-oriented programming paradigm and service modification approach, allow for rapid development of adapters. We present a study showing that it is a preferable approach in many cases. The proposed approach is implemented in a proof-of-concept prototype tool, and evaluated using both qualitative and quantitative methods.

Cooperative aspect-oriented programming

Aspect-oriented programming (AOP) seeks to improve software modularity via the separation of cross-cutting concerns. AOP proponents often advocate a development strategy where programmers write the main application (base code), ignoring cross-cutting concerns, and then aspect programmers, domain experts in their specific concerns, weave in the logic for these more specialized cross-cutting concerns. This purely oblivious strategy, however, has empirically been shown to tightly couple aspects to base code in many cases, hindering aspect modularity and reuse. In essence, the more intricate the weaving between the cross-cutting concern and the base code (lexically and/or semantically), the harder it becomes to: (a) robustly specify how to weave the aspects in at the required points, (b) capture interactions between aspects and base code, and (c) preserve the correct weaving as the base code evolves. We propose an alternate methodology, termed cooperative aspect-oriented programming (Co-AOP), where complete lexical separation of concerns is not taken as an absolute requirement. Instead, cross-cutting concerns are explicitly modeled as abstract interfaces through explicit join points (EJPs). Programmers specify where these interfaces interact with base code either through explicit lexical references or via traditional oblivious aspects. This explicit awareness allows base code and aspects to cooperate in ways that were previously not possible: arbitrary blocks of code can be advised, advice can be explicitly parameterized, base code can guide aspects in where to apply advice, and aspects can statically enforce new constraints upon the base code that they advise. These new techniques allow aspect modularity and program safety to increase, and bring us towards a cooperative AOP paradigm. We illustrate our methodology via an example on transactions, and also give an initial evaluation of cooperative AOP through an empirical study on program extensibility comparing both the traditional and cooperative AOP methodologies. Initial results show that cooperative AOP techniques result in code that is less complex with lower overall coupling, facilitating extensibility.

UML Extensions for Aspect Oriented Software Development.

AOSD (Aspect Oriented Software Development) is an emerging discipline in Software Engineering. It focuses on the separation of concerns of the ’70s, aiming at improving modularity, to ensure maintainability in the sense of extensibility, changeability and reuse, towards an evolutionary software product responding to a more dynamic environment. The AOP (Aspect Oriented Programming) paradigm of the ’90s focuses on the separation of the crosscutting concerns, which are in general non functional requirements (quality requirements). It is now of general agreement that the entanglement and scattering of concerns must be handled early in the software life cycle. However, these aspects are inherent to all the stages of software development, from requirements elicitation to code implementation. Many concepts and mechanisms have been proposed to handle properly these issues; however terms are in general semantically slightly dierent in each discipline where they have been formulated and used, causing misunderstanding and confusion. This paper presents an AOSD UML core for early aspects (requirements, analysis and design disciplines), constructed gathering dierent modelling elements found in the literature, focusing particularly on the AOSD ontolgy document of the Common Foundation for AOSD of the European Community, and dierent

A LOOSELY COUPLED ASPECT LANGUAGE FOR SOA APPLICATIONS

The aspect-oriented programming (AOP) paradigm offers software developers with powerful modularization abstractions to help them explicitly separate design concerns at the source code level. However, the impact of AOP in the service-oriented architecture (SOA) paradigm has been dwarfed by the fact that existing AOP solutions are tightly coupled to a particular programming language, middleware system or execution platform. Clearly, this not only restricts the implementation choices available to application developers, but it also clashes with the heterogeneous and loosely coupled nature of SOA. This paper presents the Web Service Aspect Language (WSAL) that seamlessly integrates AOP and SOA concepts, thus avoiding the drawbacks of existing solutions. In WSAL, aspects themselves are freely specified, implemented and executed as loosely coupled web services. This characteristic allows WSAL aspects to be easily woven into the message flow exchanged between service consumers and service providers, in a way that is completely independent from any particular implementation technology. This paper also reports on the implementation and preliminary evaluation of a prototype aspect weaver for WSAL, which is based on an existing web intermediary technology.