Aspect Oriented Programming

Software understanding (for documentation, maintenance or evolution) is one of the longest-standing problems in Computer Science. The use of "high-level" programming paradigms and object-oriented languages helps, but fundamentally remains far from solving the problem. Most programming languages and systems have fallen prey to the assumption that they are supposed to capture idealized models of computation inspired by deceptively simple metaphors such as objects and mathematical functions. Aspect-oriented programming languages have made a significant break through by noticing that, in many situations, humans think and describe in crosscutting terms. In this paper we suggest that the next break through would require looking even closer to the way humans have been thinking and describing complex systems for thousand of years using natural languages. While natural languages themselves are not appropriate for programming, they contain a number of elements that make descriptions concise, effective and understandable. In particular, natural languages referentiality is a key factor in supporting powerful program organizations that can be easier understood by humans.

Aspect-Orientated approach was created to solve scattering and tangling issues generated by the implementation of crosscutting requirements in programming. This approach has been proposed in many research areas regarding the entire process of software development, from requirements and business process models to code generating. Enterprise Architecture (EA) allows structural organization of artifacts generated during Information Systems development and reflects relational view existent between the artifacts, but, in general, it disregards the crosscutting concerns existent between them. In this paper, we present a scenario of these concerns at EA level using the Zachman Framework.

Threshold of software metrics can be used as indicators to identify possible anomalies in software. Aspect-Oriented (AO) Programming is a new programming paradigm that solved the crosscutting problem by decomposes the crosscutting concern in aspect module. Establishing the threshold of AO software metrics in order to identify anomalies in AO software is necessary. The Gang-of-Four (GoF) patterns are widely accepted as good design. Metrics extracted from the GoF patterns should be relevant information for preliminary obtaining the threshold. In this paper, we present some metric thresholds, which established from the 23 aspect-based GoF patterns. We also validate the thresholds through 2 AO software examples. The results show that the thresholds can be used to preliminary indicate anomalies in AO software.

Usage data logged from user interactions can be extremely valuable for evaluating software usability. However, instrumenting software to collect usage data is a time-intensive task that often requires technical expertise as well as an understanding of the usability issues to be explored. We have developed a new technique for software instrumentation that removes the need for programming. Interactive Usability Instrumentation (IUI) allows usability evaluators to work directly with a system's interface to specify what components ...

Almost a year ago, Microsoft has introduced the .NET architecture as a new component-based programming environment, which allows for easy integration of classical distributed programming techniques with Web computing. .NETdefines a type system and introduces notions such ...

C++ retains the ANSI C preprocessor, although its limitations have been widely recognised. The authors describe FOG, a meta-compiler for a super-set of C++, that provides replacement preprocessing and introduces static meta-programming, while preserving the spirit of C++. They show how implementation of preprocessor functionality in an Object-Oriented style eliminates unnecessary replication from practical C++ programs, and supports recent Object-Oriented Programming developments to a much greater extent than existing tools.

We are investigating one of the claims of C++ object applications and its lack of garbage collectors. Therefore, an object memory management in C++ legacy systems can be automatically developed and integrated more easily than other kinds of object management techniques: explicit (manual). For instance, research effort has been done to improve object memory management technique, such as incremental garbage collector, reference counter, conservative garbage collector, smart pointer, and so on. Theses techniques have some limitations, such as amalgamated functional and technical aspects in the same object oriented programs and its implementation has to be done manually. Generally speaking, we need a mechanism and tool to i) separate object lifecycle management from functional aspects and ii) implement this task automatically and implicitly. We propose a method and develop a tool to manage object lifecycle management in C++ systems using the generational mark and compact technique and therefore to eliminate implicitly storage management bugs. Our approach is developed based on aspect-oriented programming and AspectC++™, in which we define an aspect as a software artefact that addresses a concern such as memory management in C++ applications.

Almost a year ago, Microsoft has introduced the .NET architecture as a new component-based programming environment, which allows for easy integration of classical distributed programming techniques with Web computing. .NETdefines a type system and introduces notions such ...

The object-oriented software suffers from code tangling and code scattering problems leading to weak code reusability and difficult application evolution. New approaches supporting an advanced separation of concerns (ASoC) are proposed to overcome this dilemma. These latter provide a more powerful constructs for software decomposition than the object-oriented paradigm and their comparison is increasingly considered as an important issue.
This paper is dedicated to the comparison and the assessment of two samples of ASoC approaches: aspect-oriented programming (AOP) and subject-oriented programming (SOP).

We present an overview of JTL (the Java Tools Language, pronounced "Gee-tel"), a novel language for querying JAVA [8] programs. JTL was designed to serve the development of source code software tools for JAVA, and as a small language to aid programming language extensions to JAVA. Applications include definition of pointcuts for aspect-oriented programming, fixing type constraints for generic programming, specification of encapsulation policies, definition of micro-patterns, etc. We argue that the JTL expression of each of these is systematic, concise, intuitive and general.

Metamodelling is an activity that is getting much more attention by the research community. One of the main causes of this recent interest is being an important piece for the different approaches for Model-Driven Development (MDD). In this context, the definition and implementation of metamodels not only is important for improving the MDD, but also for their later reuse.

The field of Artificial Immune Systems (AIS) is becoming more popular and AIS-based works spanning from theoretical modeling and simulation to wide variety of applications. In particular, some of the references are of synthetic approaches to understand and simulate the biological immune system, and others that develop computational methodologies inspired by the immune system to solve real-world problems. The AIS research group at the University of Memphis headed by Prof. Dipankar Dasgupta publishing the updated AIS bibliography since 1997. While this bibliography has been compiled with the utmost care and we tried to make it a complete review of the references in the field, there may be errors in the references we cited and we may have left out some important citations. In either case, we will appreciate any help you give us to update the future versions. All comments, suggestions and additions are welcome to improve this bibliography. Please send your contributions to Prof. Dipankar Dasgupta ([email protected]). The compilers are also grateful to the researchers who helped us in our literature collection by either sending copies of citations or copies of documents. The authors take no responsibility, however, for any errors, missing information, the contents and quality of the references, nor for the usefulness and/or the consequences of applying the models or methodologies.

Aspect-oriented programming (AOP) has been successfully applied to application code thanks to techniques such as Java bytecode instrumentation. Unfortunately, with current technology, such as AspectJ, aspects cannot be woven into standard Java class libraries. This restriction is particularly unfortunate for aspects that would benefit from a complete bytecode coverage, such as profiling or debugging aspects. In this paper we present an adaptation of the popular As-pectJ weaver that is able to weave aspects also into standard Java class libraries. We evaluate our approach with existing profiling aspects, which now cover all bytecode executing in the virtual machine. In addition, we present a new aspect for memory leak detection that also benefits from our approach.

In this paper, we present the design and the implementation of the dataflow pointcut in AspectJ compiler ajc 1.5.0. Some security concerns are sensitive to flow of information in a program execution. The dataflow pointcut has been proposed by Masuhara and Kawauchi in order to easily implement such security concerns in aspect-oriented programming languages. The pointcut identifies join points based on the origins of values. The dataflow pointcut can detect and fix a lot of vulnerabilities that result from not validating input effectively, e.g., web application vulnerabilities, process injection, log forging, and path injection. AspectJ extends the Java programming language to implement crosscutting concerns modularly in general. The implementation methodology of the dataflow pointcut which depends in defineuse analysis is described in detail together with case studies that demonstrate how the implemented dataflow pointcut can detect a considerable number of vulnerabilities.

Software connectors play an important role in distributed system. In recent years, software developers have been facing more challenges of connectors which are used to connect distributed components. Design of connectors in an existing system encounters many issues such as dependency of components, how can we choose the connectors between them based on scenario quality, match these connectors with design pattern, and implement them. In this paper, we propose a software model and use a developing tool to design connectors between components in distributed system. A case study is done to maintain high level of independency between components and to illustrate this independency. The solution makes use of Aspect-Oriented Programming (AOP) to communicate the components.

Access controls are difficult to implement and evidently deficient under certain conditions. Traditional controls offer no protection for unclassified information, such as a telephone list of employees that is unrestricted, yet available only to members of the company. On the opposing side of the continuum, organizations such as hospitals that manage highly sensitive information require stricter access control measures. Yet, traditional access control may well have inadvertent consequences in such a context. Often, in unpredictable circumstances, users that are denied access could have prevented a calamity had they been allowed access. It has been proposed that controls such as auditing and accountability policies be enforced to deter rather than prevent unauthorized usage. In dynamic environments preconfigured access control policies may change dramatically depending on the context. Moreover, the cost of implementing and maintaining complex preconfigured access control policies sometimes far outweighs the benefits. This paper considers an adaptation of usage control as a proactive means of deterrence control to protect information that cannot be adequately or reasonably protected by access control.

Some security concerns are sensitive to flow of information in a program execution. The dataflow pointcut has been proposed by Masuhara and Kawauchi in order to easily implement such security concerns in aspect-oriented programming (AOP) languages. The pointcut identifies join points based on the origins of values. This paper presents a formal framework for this pointcut based on the λ calculus. Dataflow tags are propagated statically to track data dependencies between expressions. We introduce a static semantics for tag propagation and prove that it is consistent with respect to the dynamic semantics of the propagation. We instrument the static effect-based type system to propagate tags, match and inject advices. This static approach can be used to minimize the cost of dataflow pointcuts by reducing the runtime overhead since much of the dataflow information would be available statically and at the same time it can be used for verification. The proposed semantics for advice weaving is in the spirit of AspectJ where advices are injected before, after, or around the join points that are matched by their respective pointcuts. Inspired from the formal framework, the AspectJ compiler ajc is extended with the dataflow pointcut that tracks data dependencies inside methods.

This paper describes and assesses the experiences gained using aspect-oriented programming as supported by the AspectJ language. Aspect-oriented programming is intended to support the modularisation in the design of concerns that are inherently cross-cutting in traditional object-oriented design.

Aspect-oriented programming languages provide their own join point description language or mechanism for specifying join points during the execution of a program where additional code needs to be executed. However, until now such join point description languages are far from being mature and do not even match those examples which are considered to be typical for aspect-oriented programming. Aspect-oriented programming techniques built upon a base language that already provides some reflective capabilities can already benefit from these features to determine join points. In this paper we demonstrate the weaknesses of current aspect-oriented languages using an implementation of the Observer design pattern as an example. Furthermore, we show how a join point specification based on the reflective capabilities of Smalltalk and its combination with the aspect-oriented programming system AspectS solves such deficiencies.

This paper presents a novel programming model for explicitly separating parallelization and middlewarespecific concerns in Bag-of-Tasks (BoT) grid applications. The model uses Java threads for application decomposition, and aspect-oriented programming to dynamically (and transparently) convert the application's thread objects into independent grid tasks, using the services of a specific grid middleware API. This paper also describes early experimental results showing the model's modularity gains and performance overhead, when applied to implement BoT grid applications using OurGrid.

This chapter identifies evolution-related issues and challenges in aspectoriented programming. It can serve as a guideline for adopters of aspect technology to get a better idea of the evolution issues they may confront sooner or later, of the risks involved, and of the state-of-the-art in the techniques currently available to help them in addressing these issues. We focus in particular on the programming level, although some of the issues and challenges addressed may apply to earlier software development life-cycle phases as well. The discussed issues range from the exploration of crosscutting concerns in legacy code, via the migration of this code to an aspect-oriented solution, to the maintenance and evolution of the final aspectoriented program over time. We discuss state-of-the-art techniques which address the issues of aspect exploration, extraction and evolution, and point out several issues for which no adequate solutions exist yet. We conclude that, even though some promising techniques are currently being investigated, due to the relative immaturity of the research domain many of the techniques are not out of the lab as yet.

The Java Modeling Language (JML) is a behavioral interface specification language (BISL) designed for Java. It was developed to improve functional software correctness of Java applications. However, the JML compiler explores the reflection technique and data structures not supported by Java ME applications. In order to eliminate such a problem, this paper proposes the use of AspectJ to implement a new JML compiler, which generates an instrumented bytecode compliant with both Java SE and Java ME applications. The paper includes a comparative study to demonstrate the quality of the final code generated by our compiler. The size of the code is compared against the code generated by an existent JML compiler. Moreover, we evaluate the amount of additional code required to implement the JML assertions in Java applications. Results indicate that the overhead in the code size produced by our approach is very small, which is essential for Java ME applications.

Most of the object-oriented cohesion metrics proposed in the literature define static cohesion at class level. Measurement of object-level dynamic cohesion however gives better insight into the behavioural aspects of the system. In this paper, dynamic cohesion metrics are introduced which provide scope of cohesion measurement up to object level and take into account important and widely used object-oriented features such as inheritance, polymorphism and dynamic binding during measurement. A theoretical framework is introduced before defining the measures and a theoretic validation of the proposed measures is carried out to make them more meaningful. A dynamic analyser tool is developed using aspect-oriented programming (AOP) to perform dynamic analysis of Java applications for the purpose of collecting run-time data for computation of the proposed dynamic cohesion measures. Further, an experiment is carried out for the proposed dynamic cohesion metrics using 20 Java programs and this study shows that the proposed dynamic cohesion metrics are more accurate and useful in comparison to the existing cohesion metrics. Moreover, the proposed dynamic cohesion metrics are validated empirically using source code APIs of Java Development Kit (JDK) and the proposed metrics are found to be better indicators of change-proneness of classes than the existing cohesion metrics.

This paper reports our experience using AspectJ, a general-purpose aspect-oriented extension to Java, to implement distribution and persistence concerns in a web-based information system. This system was originally implemented in Java and restructured with AspectJ. Our main contribution is to show that AspectJ is useful for implementing several persistence and distribution concerns in the considered application, but also in similar applications. We have also identified interferences between the implemented aspects and a few drawbacks in the language, so we suggest some minor language modifications that could significantly improve similar implementations. Despite those problems, we argue that the AspectJ implementation is superior to the pure Java implementation. Some of the aspects implemented in our experiment are abstract and constitute a simple aspect framework. The other aspects are application specific but we suggest that different implementations might follow the same aspect patterns. The framework and the patterns allow us to propose architecture-specific guidelines that provide practical advice for both restructuring and implementing certain kinds of persistent and distributed applications with AspectJ.

An aspect observes the execution of a base program; when certain actions occur, the aspect runs some extra code of its own. In the AspectJ language, the observations that an aspect can make are confined to the current action: it is not possible to directly observe the history of a computation.

In order to bridge the gap between conceptual modeling and aspect oriented programming, many researchers have proposed extensions of the UML towards graphical notations for aspects. However, notations without an underlying formal semantics and syntax are not amenable to automated tool support. Tool-suppor- ted aspect modeling requires an aspect meta model as a basis. In this paper we follow a

This paper describes our recent work on MATISSE, a framework for MATLAB to C compilation. We focus on the new optimizations and transformations, as well as on OpenCL generation. MATISSE is controlled with LARA, an aspect-oriented language, able to specify transformations to the input MATLAB code (e.g., insertion of code for variable initialization and for monitoring) and to express information concerning types and shapes of variables. We evaluate the compiler with a set of benchmarks when targeting both an embedded system and a desktop system. The results show that we were able to achieve a speedup up to 1.8× by employing information provided by LARA aspects. We also compare the execution time of the generated C code with the original code running on MATLAB, and we achieve a geometric mean speedup of 19×. The geometric mean speedup reduces to 12× when optimizing the MATLAB code with LARA aspects. Finally, we present a preliminary version of a fully-functioning pragma-based OpenCL generator, built over the MATISSE framework.

Metrics measurement for cost estimation in modeldriven engineering (MDE) is complex because of number of different artifacts that can potentially be generated. The complexity arises as auto-generated code, manually added code, and noncode artifacts must be sized separately for their contribution to overall effort. In this paper, we address measurement of a special kind of code artifacts called metadata-based aspect-oriented code. Our MDE toolset delivers large database-centric business-critical enterprise applications. We cater to special needs of enterprises by providing support for customization along three concerns, namely design strategies, architecture, and technology platforms ( d, a, t ) in customer-specific applications. Code that is generated for these customizations is conditional in nature, in the sense that model-to-text transformation takes place differently based on choices along these concerns. In our recent efforts to apply Constructive Cost Model (COCOMO) II to our MDE practices, we discovered that while the measurement of the rest of code and non-code artifacts can be easily automated, product-linelike nature of code generation for specifics of d, a, t requires special treatment. Our contribution is the use of feature models to capture variations in these dimensions and their mapping to code size estimates. Our initial implementation suggests that this approach scales well considering the size of our applications and takes a step forward in providing complete cost estimation for MDE applications using COCOMO II.

Design patterns offer flexible solutions to common problems in software development. Recent studies have shown that several design patterns involve crosscutting concerns. Unfortunately, object-oriented (OO) abstractions are often not able to modularize those crosscutting concerns, which in turn decrease the system reusability and maintainability. Hence, it is important verifying whether aspect-oriented approaches support improved modularization of crosscutting concerns relative to design patterns. Ideally, quantitative studies should be performed to compare object-oriented and aspect-oriented implementations of classical patterns with respect to important software engineering attributes, such as coupling and cohesion. This paper presents a quantitative study that compares aspect-based and OO solutions for a representative set of design patterns. We have used stringent software engineering attributes as the assessment criteria. We have found that most aspect-oriented solutions improve separation of pattern-related concerns, although some aspect-oriented implementations of specific patterns resulted in higher coupling and more lines of code.

Whereas it is generally acknowledged that code tangling reduces the quality of software and that aspect-oriented programming (AOP) is a means of addressing this problem, there is | as yet | no clear denition or characterisation of AOP. Therefore, the main goal of the ECOOP'97 AOP workshop was to identify the \good questions" for exploring the idea of AOP.

Aspect-oriented programming modularizes crosscutting concerns into aspects with the advice invoked at the specified points of program execution. Aspects can be used in a harmful way that invalidates desired properties and even destroys the conceptual integrity of programs. To assure the quality of an aspect-oriented system, rigorous analysis and design of aspects are highly desirable. In this paper, we present an approach to aspect-oriented modeling and verification with finite state machines. Our approach provides explicit notations (e.g., pointcut, advice and aspect) for capturing crosscutting concerns and incremental modification requirements with respect to class state models. For verification purposes, we compose the aspect models and class models in an aspect-oriented model through a weaving mechanism. Then we transform the woven models and the class models not affected by the aspects into FSP (Finite State Processes), which are to be checked by the LTSA (Labeled Transition System Analyzer) model checker against the desired system properties. We have applied our approach to the modeling and verification of three aspect-oriented systems. To further evaluate the effectiveness of verification, we created a large number of flawed aspect models and verified them against the system requirements. The results show that the verification has revealed all flawed models. This indicates that our approach is effective in quality assurance of aspect-oriented state models. As such, our approach can be used for model-checking state-based specification of aspect-oriented design and can uncover some system design problems before the system is implemented.

Almost a year ago, Microsoft has introduced the .NET architecture as a new component-based programming environment, which allows for easy integration of classical distributed programming techniques with Web computing. .NET defines a type system and introduces notions such as component, object, and interface, which are building blocks for distributed multi-language component-based applications. As many other component frameworks, .NET mainly focuses on functional interfaces of components. Nonfunctional aspects of components, such as resource usage (CPU, memory), timing behavior, fault-tolerance, or security requirements are currently not expressed in .NET's component interfaces. These properties are essential for building reliable distributed applications with predictable behavior even in cases of faults.

The application of aspect-oriented programming (AOP) to the embedded operating system domain is still a very controversial topic, as this area demands high performance and small memory footprint. However, recent studies quantifying aspects overheads in AspectC++ show that the resource cost is very low. Therefore, operating system development may benefit with the modularization of crosscutting concerns and system specialization offered by AOP.

Context: Data-flow testing approaches have been used for procedural and object-oriented programs, and shown to be effective in detecting faults. However, few such approaches have been evaluated for aspectoriented programs. In such programs, data-flow interactions can occur between base classes and aspects, which can affect the behavior of both. Faults resulting from such interactions are hard to detect unless the interactions are specifically targeted during testing. Objective: This paper presents an approach and tool implementation for measuring data-flow coverage based on state variables defined in base classes or aspects in AspectJ programs. The paper also reports on an empirical study that compares the cost and effectiveness of data-flow test criteria that are based on state variables with two control-flow criteria. Method: Effectiveness of the criteria was evaluated for various fault types. Cost-effectiveness of test suites that cover all state variable definition-use associations (DUAs) was evaluated for three coverage levels: 100%, 90%, and 80%. Results: The effort needed to obtain a test case that achieves data-flow coverage is higher than the effort needed to obtain a test case that covers a block or a branch in an advised class. Covering certain data flow associations requires more effort than for other types of data flow associations. The data-flow test criteria based on state variables of a base-class are in general more effective than control-flow criteria. Conclusions: Overall, it is cost-effective to obtain test suites at the 90% coverage level of data-flow criteria. detect errors caused by implementation details not addressed in the specifications .

Aspect-oriented programming (AOP), now practically a consolidated academic discipline, has yet to build more solid industrial foundations, especially in the realms of the .NET platform. It's believed that this situation is caused by the lack of a robust and user-friendly AOP tool for .NET comparable with the Java-based AspectJ. This work investigates the basic infrastructure required for building such a tool: aspect-oriented weaving with the common language runtime (CLR) environment. In this regard, a classification schema is built, analysing the attributes a hypothetical aspect weaver for .NET might have. It assesses the different classes of weavers that can be built on top of the CLR today and investigates what extensions to the platform would be needed in order to enable more sophisticated weaving technologies. Some typical use cases for the resulting AOP tools, and classify what attributes a corresponding weaver would need to have in order to fulfil these requirements. Finally, two existing aspect weaver implementations in terms of these very same attributes are analysed.

One of the fundamental motivations for employing exception handling in the development of robust applications is to lexically separate error handling code so that it can be independently reused and modified. It is usually assumed that the implementation of exception handling can be better modularized by the use of aspect-oriented programming (AOP). However, the trade-offs involved in using AOP with this goal are not yet well-understood. This paper presents an in-depth investigation of the adequacy of the AspectJ language for modularizing exception handling code. The study consisted in refactoring existing applications so that the code responsible for implementing heterogeneous error handling strategies was moved to separate aspects. We have performed quantitative assessments of four systems -three object-oriented and one aspect-oriented -based on four fundamental quality attributes, namely separation of concerns, coupling, cohesion, and conciseness. Our investigation also included a multi-perspective analysis of the refactored systems, including (i) the reusability of the aspectized error handling code, (ii) the beneficial and harmful aspectization scenarios, and (iii) the scalability of AOP to aspectize exception handling in the presence of other crosscutting concerns.

Program slicing is a decomposition technique which has many applications in various software engineering activities such as program debugging, testing, maintenance etc. Aspect-oriented programming (AOP) is a new programming paradigm that enables modular implementation of cross-cutting concerns such as exception handling, security, synchronization, logging etc. The unique features of AOP such as join-point, advice, aspect, introduction etc. pose difficulties for slicing of AOPs. We propose a dynamic slicing algorithm for aspect-oriented programs. Our algorithm uses a dependence-based representation called Dynamic Aspect-Oriented Dependence Graph (DADG) as the intermediate program representation. The DADG is an arc-classified digraph which represents various dynamic dependences between the statements of the aspect-oriented program. We have used a trace file to store the execution history of the program. We have developed a tool called Dynamic Depenedence Slicing Tool (DDST) to implement our algorithm. We have tested our algorithm on many programs for 40-50 runs. The resulting dynamic slice is precise as we create a node in the DADG for each occurrence of the statement in the execution trace.