Aspect-oriented Programming Concepts Research Articles

ASPECT-ORIENTED SOFTWARE TESTING TECHNIQUES: A REVIEW

- Software testing is a prominent area of research as it ensures the quality and reliability of the software. Testing an aspect-oriented software is also the latest area of research. Although, research in aspect-oriented software testing has reported a couple of new testing techniques. But, there is no work yet indicated in the literature to focus on the basic fundamentals of the aspect-oriented software testing and relationship with traditional software testing techniques. Therefore, this position paper handles this shortcoming and presents the basic concepts of aspect-oriented programming, phases of aspect-oriented software development life cycle and testing phases for new researchers to gather the information on the subject. This paper also presents a comprehensive detail about the relationship of aspect-oriented software testing techniques with other traditional testing techniques.

Aspect composition for multiple target languages using LARA

Usually, Aspect-Oriented Programming (AOP) languages are an extension of a specific target programming language (e.g., AspectJ for Java and AspectC++ for C++). Although providing AOP support with target language extensions may ease the adoption of an approach, it may impose constraints related with constructs and semantics. Furthermore, by tightly coupling the AOP language to the target language the reuse potential of many aspects, especially the ones regarding non-functional requirements, is lost. LARA is a domain-specific language inspired by AOP concepts, having the specification of source-to-source transformations as one of its main goals. LARA has been designed to be, as much as possible, independent of the target language and to provide constructs and semantics that ease the definition of concerns, especially related to non-functional requirements. In this paper, we propose techniques to overcome some of the challenges presented by a multilanguage approach to AOP of cross-cutting concerns focused on non-functional requirements and applied through the use of a weaving process. The techniques mainly focus on providing well-defined library interfaces that can have concrete implementations for each supported target language. The developer uses an agnostic interface and the weaver provides a specific implementation for the target language. We evaluate our approach using 8 concerns with varying levels of language agnosticism that support 4 target languages (C, C++, Java and MATLAB) and show that the proposed techniques contribute to more concise LARA aspects, high reuse of aspects, and to significant effort reductions when developing weavers for new imperative, object-oriented programming languages.

Applying Separation of Concern for Developing Softwares Using Aspect Oriented Programming Concepts

Aspects provide a means of separating cross-cutting concerns from our core implementation code into separate modules. Cross-cutting concerns are pieces of functionality that are used across multiple parts of a system. They cut across, as opposed to standing alone. For example if every method of our program requires logging information for identification then a logging aspect can be applied to methods external to the method implementation without using logging information with the methods internally. It's a powerful technique to help employ the principle of separation of concerns within code. Aspect Oriented Programming (AOP) is a methodology that provides separation of crosscutting concerns by introducing a new unit of modularization—an aspect. Each aspect focuses on a specific crosscutting functionality.

Aspect-oriented RTL HW design using SystemC

With the increasing complexity of digital hardware designs, hardware description languages are being pushed to higher levels of abstraction, thus allowing for the use of design artifacts which were previously exclusive to the software domain. In this paper we aim to contribute to this scenario by proposing artifacts and guidelines for hardware design at the register transfer level using object-oriented and aspect-oriented programming concepts. Our methodology is based on features provided by SystemC, a C++-based hardware description language, and leverages on its synthesizable subset in order to produce designs suitable for circuit synthesis. Our experimental results show that the introduction of aspect-oriented design artifacts results in an increased level of flexibility and reusability while yielding a circuit area overhead of only 2.5% when compared to non-aspect-oriented designs.

Tailoring video recording to support efficient GUI testing and debugging

Automated GUI tests typically comprise of several test steps that are executed on the GUI before reaching a point of assertion. Comparing a longer and complex execution of a GUI test to its test instructions for debugging is a laborious task: re-establish the test environment, slow down test execution for human perception, and locate the currently executed test step. Video documentation of GUI tests for debugging purposes is already present in several industry tools. However, it is not optimized for effective documentation of on-screen actions nor synched with the executed test instructions. We present a video-based documentation of automated GUI tests that links the executed test case instruction to the on-screen response of the application under test. Screen recording is optimized for speed and memory consumption while all relevant details are captured. Additional browsing capabilities for easier debugging are introduced. Concepts of aspect-oriented programming are adapted for tracing of pre-compiled test case scripts. Our concepts are evaluated by a working implementation, a series of performance measurements during a technical experiment, and industrial experience from 370 real-world test cases carried out in a large software company. The limits of our implementation regarding video capturing and code tracing are explored with a specialized test frame.

Implementing OS components in hardware using AOP

In this paper we propose a SystemC-based design methodology focusing on the implementation of operating system components in hardware by using Aspect-oriented Programming concepts. As a case study to validate our approach, we have designed and implemented a hardware thread scheduler and a debugging aspect program. For comparison purposes, a hand-made scheduler with debugging capabilities was also implemented. The hardware synthesis results shown that Aspect-oriented Programming concepts and techniques can be efficiently applied to digital hardware design in SystemC through the proposed methodology. The observed overhead in terms of area was less than 1% and the increase in the longest path delay for the circuit was less than 3%. Being SystemC an extension of C++, our strategy puts effective hardware implementation of operating system components into reach for many operating system developers.

Study on the Software Development Based on AOP Technology

<!-- /* Font Definitions */ @font-face {font-family:??; panose-1:2 1 6 0 3 1 1 1 1 1; mso-font-alt:SimSun; mso-font-charset:134; mso-generic-font-family:auto; mso-font-pitch:variable; mso-font-signature:3 135135232 16 0 262145 0;} @font-face {font-family:

Aspect-Oriented Action Semantics Descriptions

The modularity of programming language descriptions allows the designer to describe each programming language feature in a separated module that can be studied independently of others. Action Semantics is a formal notation that produce modular descriptions of programming languages. This paper proposes to use concepts of Aspect-oriented programming to improve the modularity of action semantics descriptions. To achieve this goal, an aspect-oriented notation is proposed and applied to describe some programming language concepts.

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.

Aspect-oriented Prolog in a language processing context

Language processors can be derived from logic grammars. That several concerns in the processor such as parsing, several kinds of analysis or transformations, can be specified as aspects of the logic grammar is demonstred. For that purpose, the authors bring the concepts of aspect-oriented programming to Prolog in a systematic way, based on established Prolog technology. The authors illustrate that typical Prolog programming techniques can be described as generic aspects and provided in a library to support reusable concerns. A domain-specific language (DSL) is developed to improve readability of aspect-oriented specifications.

The design and implementation of AspectC++

Aspect-Oriented Programming (AOP) is a programming paradigm that supports the modular implementation of crosscutting concerns. Thereby, AOP improves the maintainability, reusability, and configurability of software in general. Although already popular in the Java domain, AOP is still not commonly used in conjunction with C/C++. For a broad adoption of AOP by the software industry, it is crucial to provide solid language and tool support. However, research and tool development for C++ is known to be an extremely hard and tedious task, as the language is overwhelmed with interacting features and hard to analyze. Getting AOP into the C++ domain is not just technical challenge. It is also the question of integrating AOP concepts with the philosophy of the C++ language, which is very different from Java. This paper describes the design and development of the AspectC++ language and weaver, which brings fully-fledged AOP support into the C++ domain.

Modeling and performance analysis for security aspects

The problem of effectively designing and analyzing software to realize non-functional requirements is an important research topic. The significant benefits of such work include detecting and removing defects earlier, reducing development time and cost while improving the system’s quality. The Formal Design Analysis Framework (FDAF) is an aspect-oriented approach that supports the design and analysis of multiple non-functional properties for distributed, real-time systems. In this paper, a security attribute, data origin authentication, is defined as a reusable aspect based on its security pattern definition. The FDAF provides a UML extension to weave the security aspect into a UML architecture design. This is accomplished by abstracting Aspect-Oriented Programming concepts join point and advice up to the design level. The FDAF supports the automated translation of a UML architecture design into Rapide [D.C. Luckham, J.J. Kenney, L.M. Augustin, J. Vera, D. Bryan, W. Mann, Specification and analysis of system architecture using Rapide, IEEE Transactions on Software Engineering 21 (4) (1995) 336–354], a formal architecture description language, allowing the simulation of a system’s response time. Thus, the response time of a design with and without the security aspect can be respectively analyzed, and the performance cost of this aspect can be predicted. One of the translation algorithms, which have been implemented in the FDAF tool support, and its proof are presented. The FDAF approach is illustrated using a Domain Name System example.

Consistent Integration of Heterogeneous Data Bases

Abstract Planning and controlling of routing of intermodal transportation (e.g. continent-wide in Europe) has to consider heterogeneous restrictions prescribed by the ordering company or institution, by the involved carriers, unloaders, warehouses, authorities or receivers of the complete logistic chain. This often implies cascaded queries to and transactions through heterogeneous and geographically disclosed data bases in different countries. The logical consistency of these transactions is based on the constraint propagation and satisfaction along their implementation. An object-oriented approach for, is the concept of Aspect-Oriented Programming to inherit interfaces between objects (or object classes) through the whole transaction. This new concept is adapted to heterogeneous traffic data bases in routing tasks.