Abstract: Variability management is a common challenge for Software Product Line (SPL) adoption, since developers need suitable mechanisms for specifying and implementing variability that occurs at different SPL artifacts (requirements, design, implementation, and test). In this paper, we present a novel approach for use case scenario variability management, enabling a better separation of concerns between languages used to manage variabilities and languages used to specify use case scenarios. The result is that both representations can be understood and evolved in a separate way. We achieve such a goal by modeling variability management as a crosscutting phenomenon, for the reason that artifacts such as feature models, product configurations, and configuration knowledge crosscut each other with respect to each specific SPL member. After applying our approach to different case studies, we achieved a better feature modularity and scenario cohesion.

Abstract: Despite the upsurge of interest in the Aspect-Oriented Programming (AOP) paradigm, there remain few results on test data generation techniques for AOP. Furthermore, there is no work on search-based optimization for test data generation, an approach that has been shown to be successful in other programming paradigms.In this paper, we introduce a search-based optimization approach to automated test data generation for structural coverage of AOP systems. We present the results of an empirical study that demonstrates the effectiveness of the approach. We also introduce a domain reduction approach for AOP testing and show that this approach not only reduces test effort, but also increases test effectiveness. This finding is significant, because similar studies for non-AOP programming paradigms show no such improvement in effectiveness, merely a reduction in effort. We also present the results of an empirical study of the reduction in test effort achieved by focusing specifically on branches inside aspects.

Abstract: Aspects that in isolation behave correctly, may interact when being combined. When interaction changes an aspect's behaviour or disables an aspect, we call this interference. One particular type of interference occurs when aspects are applied to shared join points, since then the ordering of the aspects can also influence the behaviour of the composition. We present an approach to detect aspect interference at shared join points. Aspect compositions are modelled by using a graph production system for modelling aspect-language semantics. A graph-based model of a join point is generated from the source-code of the system. This graph is transformed into a runtime-state representation. Combined with the production system (and the correct tooling) the execution of the aspects is simulated. This simulation results in a labelled transition system that can be used to analyse and verify different properties of the system at the join point. Simulation of the entire system can be computationally expensive. In our approach, we decide to abstract base system execution into non-deterministic valuation and carefully choosing advice semantics, such that simulation of the entire system can be avoided.

Abstract: As model-driven software development covers additional parts of the development process, the complexity of software models increases as well. At the same time, however, many modelling languages do not provide adequate support for modularising models. For this reason, there has been an increasing interest in the topic of model modularisation, often under the heading of aspect-oriented modelling (AOM). The approaches range from techniques that closely mimic concepts from aspect-oriented programming (AOP), such as AspectJ, to very powerful composition techniques for specific types of models--for example, state machines. We believe that AOM is more than just copying the concepts of AOP at the modelling level and should rightly include a large number of other model-composition techniques. However, developing model composition techniques and tooling is costly. To minimise the effort required, this paper presents a generic technique for model composition. The technique is based on invasive software composition and our Reuseware tooling and can be used with arbitrary modelling languages. The basic technique itself is language independent, but it can be adapted to construct language- and purpose-specific composition techniques for specific modelling languages and situations. Hence, it can be used both as a tool for developing specific model-modularisation techniques and as an instrument of research for studying basic properties and concepts of model modularisation. The paper gives a detailed description of our approach and evaluates it using a number of examples.

Abstract: Traditional methods characterize a software product line's requirements using either functional or quality criteria. This appears to be inadequate to assess modularity, detect interferences, and analyze trade-offs. We take advantage of both symmetric and asymmetric views of aspects, and perform formal concept analysis to examine the functional and quality requirements of an evolving product line. The resulting concept lattice provides a rich notion which allows remarkable insights into the modularity and interactions of requirements. We formulate a number of problems that aspect-oriented product line requirements engineering should address, and present our solutions according to the concept lattice. We describe a case study applying our approach to analyze a mobile game product line's requirements, and review lessons learned.

Abstract: Jointly deployed aspects may interact with each other. While some interactions might be intended, unintended interactions (interferences) can break a program. Detecting and resolving interferences is particularly hard if aspects are developed independently, without knowledge of each other. Work on interference detection has focused so far on the correctness of weaved programs. In this paper, we focus on the correctness and completeness of aspect weaving . We show that a large class of interferences result from incorrect or incomplete weaving and present a language-independent analysis of correctness and completeness of weaving. For certain types of interactions automatic resolution is possible. In this case, our algorithm computes a "weaving schedule" that ensures correctness and completeness of the weaving process. This is possible without special purpose program annotations or formal specifications of aspect semantics. Our technique can check weaving interferences independently of any base program and is applicable to aspects that contain implicit mutual dependencies in their implementation.

Abstract: Aspect-oriented programming (AOP) eases the development of profilers, debuggers, and reverse engineering tools. Such tools frequently rely on calling context information. However, current AOP technology, such as AspectJ, does not offer dedicated support for accessing complete calling context within aspects. In this paper, we introduce a novel approach to calling context reification that reconciles flexibility, efficiency, accuracy, and portability. It relies on a generic bytecode instrumentation framework ensuring complete bytecode coverage, including the standard Java class library. We compose our program transformations for calling context reification with the AspectJ weaver, providing the aspect developer an efficient mechanism to manipulate a customizable representation of the complete calling context. To highlight the benefits of our approach, we present ReCrash as an aspect using a stack-based calling context representation; ReCrash is an existing tool that generates unit tests to reproduce program failures. In comparison with the original ReCrash tool, our aspect resolves several limitations, is extensible, covers also the standard Java class library, and causes less overhead.

Abstract: Theme/UML is an existing approach to aspect-oriented modelling that supports the modularisation and composition of concerns, including crosscutting ones, in design. To date, its lack of integration with model-driven engineering (MDE) techniques has limited its benefits across the development lifecycle. Here, we describe our work on facilitating the use of Theme/UML as part of an MDE process. We have developed a transformation tool that adopts model-driven architecture (MDA) standards. It defines a concern composition mechanism, implemented as a model transformation, to support the enhanced modularisation features of Theme/UML. We evaluate our approach by applying it to the development of mobile, context-aware applications-an application area characterised by many non-functional requirements that manifest themselves as crosscutting concerns.

Abstract: Alternative semantics for aspect-oriented abstractions can be defined by language designers using extensible aspect compiler frameworks. However, application developers are prevented from tailoring the language semantics in an application-specific manner. To address this problem, we propose an architecture for aspect-oriented languages with an explicit meta-interface to language semantics. We demonstrate the benefits of such an architecture by presenting several scenarios in which aspect-oriented programs use the meta-interface of the language to tailor its semantics to a particular application execution context.

Abstract: JavaScript is a popular scripting language that is particularly useful for client-side programming together with HTML /XML on the Web. As JavaScript programs become more complex and large, separation of concerns at the implementation level is a significant challenge. Aspect orientation has been a well known concept to realize improved separation; however, existing mechanisms require modifications in the target modules for aspect weaving in JavaScript (i.e., not "complete" separation). In this paper, we propose an Aspect-Oriented JavaScript framework, named "AOJS", which realizes the complete separation of aspects and other core modules in JavaScript. AOJS can specify function executions, variable assignments and file initializations in JavaScript programs as the joinpoints of aspects. Moreover, AOJS guarantees the complete separation of aspects and core program modules by adopting a proxy-based architecture for aspect weaving. By utilizing these features, we confirmed that AOJS offers improved modifiability and extendability for JavaScript programming.

Abstract: Most current aspect composition mechanisms rely on syntactic references to the base modules or wildcard mechanisms quantifying over such syntactic references in pointcut expressions. This leads to the well-known problem of pointcut fragility. Semantics-based composition mechanisms aim to alleviate such fragility by focusing on the meaning and intention of the composition hence avoiding strong syntactic dependencies on the base modules. However, to date, there are no empirical studies validating whether semantics based composition mechanisms are indeed more expressive and less fragile compared to their syntax-based counterparts. In this paper we present a first study comparing semantics- and syntax-based composition mechanisms in aspect-oriented requirements engineering (AORE). In our empirical study the semantics-based compositions examined were found to be indeed more expressive and less fragile. The semantics-based compositions in the study also required one to reason about composition interdependencies early on hence potentially reducing the overhead of revisions arising from later trade-off analysis and stakeholder negotiations. However, this added to the overhead of specifying the compositions themselves. Furthermore, since the semantics-based compositions considered in the study were based on natural language analysis, they required initial effort investment into lexicon building as well as strongly depended on advanced tool support to expose the natural language semantics.

Abstract: Dynamic deployment of aspects brings greater flexibility and reuse potential, but requires proper means for scoping aspects. Scoping issues are particularly crucial in a distributed context: adequate treatment of distributed scoping is necessary to enable the propagation of aspect instances across host boundaries and to avoid inconsistencies due to unintentional spreading of data and computations in a distributed system.We motivate the need for expressive scoping of dynamically-deployed distributed aspects by an analysis of the deficiencies of current approaches for distributed aspects. Extending recent work on deployment strategies for non-distributed aspects, we then introduce a set of high-level strategies for specifying locality of aspect propagation and activation, and illustrate the corresponding gain in expressiveness. We present the operational semantics of our proposal using Scheme interpreters, first introducing a model of distributed aspects that covers the range of current proposals, and then extending it with dynamic aspect deployment. This work shows that, given some extensions to their original execution model, deployment strategies are directly applicable to the expressive scoping of distributed aspects.

Abstract: In this paper we present a generic, mirror-based debugging architecture that supports runtime visibility and traceability of aspect oriented (AO) software systems Runtime visibility supports inspection of an executing AO-system in terms of AO programming abstractions and code artifacts such as (dynamic) aspects, advices, pointcuts, aspect instances and advice applications Runtime traceability supports inspection of the stack to identify advices that could have been executed, that are being executed, or that may be executed later Additionally, traceability supports identification and inspection of the pointcut that causes a specific adviceWe have created a mirror based architecture that offers introspection support including an aspect-aware breakpoint model for AOP-related runtime events We introduce the concept of hook frames to trace joinpoints and their advices on the stackWe validate the genericity of our architecture in two instantiations -- JBoss AOP and AspectJ/ABC -- and evaluate both instantiations by applying concrete debugging scenarios

Abstract: This paper presents AspectO ptima , a language independent, aspect-oriented framework consisting of a set of ten base aspects--each one providing a well-defined reusable functionality--that can be configured to ensure the ACID properties (Atomicity, Consistency, Isolation, and Durability) for transactional objects. The overall goal of AspectO ptima is to serve as a case study for aspect-oriented software development, particularly for evaluating the expressivity of AOP languages and how they address complex aspect interactions and dependencies. The ten base aspects of AspectO ptima are simple, yet have complex dependencies and interactions among each other. To implement different concurrency control and recovery strategies, these aspects can be composed and assembled into different configurations; some aspects conflict with each other, others have to adapt their run time behavior according to the presence or absence of other aspects. The design of AspectO ptima highlights the need for a set of key language features required for implementing reusable aspect-oriented frameworks. To illustrate the usefulness of AspectO ptima as a means for evaluating programming language features, an implementation of AspectO ptima in AspectJ is presented. The experiment reveals that AspectJ 's language features do not directly support implementation of reusable aspect-oriented frameworks with complex dependencies and interactions. The encountered AspectJ language limitations are discussed, workaround solutions are shown, potential language improvements are proposed where appropriate, and some preliminary measurements are presented that highlight the performance impact of certain language features.

Abstract: Several efforts have been made to incorporate aspect-oriented abstractions into the modelling level. Several modelling languages have appeared, which are mainly UML extensions that incorporate aspect-oriented constructions (e.g. advices or pointcuts). Although these extensions help to improve the modularisation of software designs, their incorporation makes it more complex to understand how the model works after being composed (e.g. woven). In order to overcome this problem, different aspect-oriented model weavers, such as Motorola WEAVR, AOEM and KerTheme, were proposed. These weavers provide the infrastructure for testing and debugging the models before moving into an implementation. However, these model weavers are static in the sense that aspects cannot be woven and unwoven at run time (i.e. during model execution). Hence, software systems that require dynamic weaving (e.g. adaptive applications) are not properly supported. Reasoning about this kind of application can be more complex due to the intrinsic dynamic nature. The novel contribution of this work is an aspect-oriented dynamic model weaver that can be used for running aspect-oriented models where aspects are woven and unwoven during model execution. These ideas are illustrated using a location-aware intelligent transportation system.

Abstract: As discussed in a recent report for which I was a co-author, "as computers and communication bandwidth become faster and cheaper, computing and communication capabilities will be embedded in all types of objects and structures in the physical environment. Applications with enormous societal impact and economic benefit will be created by harnessing these capabilities in time and across space. We refer to systems that bridge the cyber-world of computing and communications with the physical world as cyber-physical systems (CPS). The internet transformed how humans interact and communicate with one another, revolutionized how and where information is accessed, and even changed how people buy and sell in the marketplace. Similarly, CPS will transform how humans interact with and control the physical world around us. Examples of CPS include medical devices and systems, aerospace systems, transportation vehicles and intelligent highways, defense systems, robotic systems, process control, factory automation, building and environmental control and smart spaces. However, the confluence of recent key technologies is fundamentally altering how these types of systems will operate. For example, the level of uncertainty in which these systems operate is growing (hence the need for greater robustness), and pervasive wireless access is opening these systems to unprecedented dynamic and non-deterministic influences." This talk will describe this new and emerging field called CPS. The talk will focus on what is new and why we need fundamentally new approaches to face robustness and openness challenges. Aspect oriented programming will be proposed as a possible basis for key work in CPS.

Abstract: The benefits of defining explicit pointcut interfaces in aspect-oriented applications have been advocated by many. A pointcut interface exposes a set of crosscutting abstract behaviours (as named pointcut signatures) that multiple aspects in the application can use. In accordance with the dependency inversion and stable dependencies principles, a pointcut interface should expose only stable abstractions in order to maximally promote its reuse across a family of applications.In this paper, we propose a domain-driven architecture method for designing such stable pointcut interfaces. The method employs systematic reengineering of use case models to discover stable abstractions that are anchored in the domain model of the application. During architecture design, these stable domain abstractions are mapped to pointcut interfaces. As part of this mapping activity, the architecture is constrained to ensure that the pointcut interfaces can be implemented correctly.We have applied this method in two applications, where we validate that pointcut interfaces can be reused for implementing the composition logic of different aspects without requiring modification to their pointcut signatures. Moreover, the method consistently yields pointcut interface hierarchies.

Abstract: Aspect-oriented concepts are currently exploited to model systems from the beginning of their development. Aspects capture potentially crosscutting concerns and make it easier to formulate desirable properties and to understand analysis results than in a tangled system. However, the complexity of interactions among different aspectualized entities may reduce the benefit of aspect-oriented separation of crosscutting concerns. Some interactions may be intended or may be emerging behavior, while others are the source of unexpected inconsistencies. It is therefore desirable to detect inconsistencies as early as possible, preferably at the modeling level. We propose an approach for analyzing interactions and potential inconsistencies at the level of requirements modeling. We use a variant of UML to model requirements in a use case driven approach. Activities that are used to refine use cases are the joinpoints to compose crosscutting concerns. The activities and their composition are formalized using the theory of graph transformation systems, which provides analysis support for detecting potential conflicts and dependencies between rule-based transformations. This theory is used to effectively reason about potential interactions and inconsistencies caused by aspect-oriented composition. The analysis is performed with the graph transformation tool AGG in order to get a better understanding of the potential behavior of the composed system. In addition, the activity control flow of the aspect/base specification and the composition operators are taken into account to identify the relevant interactions.

Abstract: Desktop client applications interact with both local and remote resources. This is both a benefit in terms of the rich features desktop clients can provide, but also a security risk. Due to their high connectivity, desktop clients can leave a user's machine vulnerable to viruses, malicious plug-ins, and scripts. Aspect-Oriented Software Development can be used to address security concerns in software in a modular fashion. However, most existing research focuses on the protection of server-side resources. In this paper we introduce an aspect-oriented mechanism, Authority Aspects, to enforce the Principle of Least Privilege on desktop clients. This helps to ensure that legitimate resource access is allowed and illegitimate access is blocked. We present a case study applying our approach on two desktop applications: an RSS feed aggregator and a Web browser.

Abstract: The lack of architecturally-significant mechanisms for aspectual composition might artificially hinder the specification of stable and reusable design aspects. Current aspect-oriented approaches at the architecture-level tend to mimic programming language join point models while overlooking mainstream architectural concepts such as styles and their semantics. Syntax-based pointcuts are typically used to select join points based on the names of architectural elements, exposing architecture descriptions to pointcut fragility and reusability problems. This paper presents style-based composition, a new flavor of aspect composition at the architectural level based on architectural styles. We propose style-based join point models and provide a pointcut language that supports the selection of join points based on style-constrained architectural models. Stability and reusability assessments of the proposed style-based composition model were carried out through three case studies involving different styles. The interplay of style-based pointcuts and some style composition techniques is also discussed.

Abstract: Aspect oriented programming (AOP) has started to achieve industry adoption for custom programs and some adoption in frameworks such as the Spring framework. Aspect oriented programming provides many benefits -- it can increase the scope of concerns that can be captured cleanly, it has explicit language support, and the separation provided by AOP provides an elegant mechanism for custom solutions.In this paper we present a model for AOP testing. This includes a model for risk assessment, an associated fault model and AOP testing patterns. We also propose further opportunities for research in the area for automated AOP risk assessment and testing.At ApTSi™ (Applied Technology Solutions, Inc.) we have been applying AOP in the creation of our SOASense™ framework, and in our consulting engagements. We are seeing adoption typically in classical AOP areas such as Logging, Error Handling, Audit events, etc. In these scenarios, having a reliable AOP implementation is critical. For example, having an Audit event not occur for a service call due to a faulty join-point definition can have severe legal implications. We need a solution that provides reliability, is repeatable and enables us to assess risk.

Abstract: Aspect-oriented modeling (AOM) is a promising technique for untangling the concerns of complex enterprise software systems AOM decomposes the crosscutting concerns of a model into separate models that can be woven together to form a composite solution model In many domains, such as multi-tiered e-commerce web applications, separating concerns is much easier than deducing the proper way to weave the concerns back together into a solution model For example, modeling the types and sizes of caches that can be leveraged by a Web application is much easier than deducing the optimal way to weave the caches back into the solution architecture to achieve high system throughput This paper presents a technique called constraint-based weaving that maps model weaving to a constraint satisfaction problem (CSP) and uses a constraint-solver to deduce the appropriate weaving strategy By mapping model weaving to a CSP and leveraging a constraint solver, our technique (1) generates solutions that are correct with respect to the weaving constraints, (2) can incorporate complex global weaving constraints, (3) can provide weaving solutions that are optimal with respect to a weaving cost function, and (4) can eliminate manual effort that would normally be required to specify pointcuts and maintain them as target models change The paper also presents the results of a case study that applies our CSP weaving technique to a representative enterprise Java application Our evaluation of this case study showed a reduction in manual effort that our technique provides

Abstract: As the use of aspects spreads, it is becoming common to weave multiple aspects into a system, treating different concerns. In this special section, we present three papers that deal with the issue of how aspects may interact, and in particular how they may interfere with each other. Aspect interactions can arise at all stages of software development, including requirements, design, and implementation. The issues somewhat differ at each stage, and in fact for interference itself several definitions are in use.

Abstract: Aspect-orientation (AO) is a recent technology for handling crosscutting concerns in a structured and modular manner. In spite of being considered useful, researchers often complain that industry is not widely adopting AO concepts and technologies in commercial projects.This paper reports on real usage of aspect-orientation in an industrial project, which means that AO, in particular the AspectJ language, is part of a real software product. AO is basically used to overcome several critical problems. Those problems are well motivated and discussed in detail. Some of them are hard to solve with conventional programming techniques whereas the application of an appropriate AO-based solution is very straightforward. Since some of the reported problems are not really of crosscutting nature, the solutions might be questionable. This leads to a discussion about the "political correctness" of this approach. Furthermore, the paper also explains why and how the project management could be convinced to use AspectJ.

Abstract: In KAOS, a goal-oriented requirements engineering approach, requirements are obtained from the goals a system must accomplish. When modeling goals some of them will be tangled and scattered all over the system. This will increase the complexity of the system, thus diminishing the understandability of it. Identification of cross-cutting concerns at requirements enables us to separate those concerns from the very beginning and provide a simpler and enhanced design of the system so it will have a better evolution. By combining goals and aspects we will improve the system's maintainability, reusability and evolution over time.

Abstract: Achieving sufficient execution performance is a challenging goal of software development. Unfortunately, violating performance requirements is often revealed at a late stage of the development. Fixing a performance problem at such a late stage is difficult in terms of cost and time. To solve this problem, this paper presents QoSWeaver , which is a tool suite for developing application-level scheduling using aspects. QoSWeaver weaves scheduling code written in an aspect into web application code. The scheduling code gets an application thread to voluntarily yield its execution to implement a custom scheduling policy. The idea of scheduling at the application level is not new, but aspect-oriented programming (AOP) makes it more realistic by separation of scheduling code. For fine-grained scheduling, QoSWeaver provides a profile-based pointcut generator , which automatically generates appropriate pointcuts. To investigate the ability of QoSWeaver for implementing practical scheduling policies, we used QoSWeaver for tuning the performance of a river monitoring system named Kasendas , which is a web application system. For reliable examination, Kasendas was originally developed by an outside corporation and then it was tuned by the authors with QoSWeaver. The authors could successfully improve the performance of Kasendas under heavy workload. The cost of the performance tuning was reasonably small. Furthermore, our approach achieved better performance than other techniques such as admission control and priority scheduling provided by the JVM or Linux. We could implement various policies such as deadlock-aware or adaptive scheduling.

Abstract: e is an aspect-oriented hardware verification language that is widely used to verify the design of electronic circuits through the development and execution of testbenches. In recent years, the continued growth of the testbenches developed at Infineon Technologies has resulted in their becoming difficult to understand, maintain and extend. Consequently, a decision was taken to document the testbenches at a higher level of abstraction. Accordingly, we attempted to model our legacy test suites with an existing aspect-oriented modelling approach. In this paper we describe our experience of applying Theme/UML, an aspect-oriented modelling approach, to the representation of aspect-oriented testbenches implemented in e. It emerged that the common aspect-oriented concepts supported by Theme/UML were not sufficient to adequately represent the e language, primarily due to e's dynamic, temporal nature. Based on this experience we propose a number of requirements that must be addressed before aspect-oriented modelling approaches such as Theme/UML are capable of representing aspect-oriented systems implemented in e.

Abstract: Execution traces are naturally represented at the design level with UML sequence diagrams. During a system execution, trace-based aspects can be used to monitor behavioral patterns and protocols and may e.g. provide mitigation strategies for unwanted behavior. Trace-based and stateful aspects have evolved to handle such reoccurring interaction patterns at the implementation level. We define a STAIRS-inspired semantics for trace-based Java aspects, and a sequence diagram aspect notation with a mapping to a trace-based Java implementation. We use this to show that aspect composition is semantics preserving with respect to refinement under the given semantics.

Abstract: It is our great pleasure to welcome you to the Foundations of Aspect-Oriented Languages 2009 workshop. This year the workshop continues its tradition of being a major forum for presentation and discussion of recent research results on the formal underpinnings of aspect oriented programming languages. The call for papers attracted 12 submissions from Asia, Europe, North and South America. The program committee accepted 6 papers that cover topics ranging from fundamental issues of the semantics of AO languages to applications of formal methods for the safe composition of features.