Research Track

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 provides aspect-oriented application-level scheduling. QoSWeaver weaves scheduling code written in an aspect into application code. The scheduling code gets an application thread to voluntarily yield its execution to implement a scheduling policy. The idea of scheduling at the application level is not new, but aspect-oriented programming makes it more realistic by separation of scheduling code. QoSWeaver also provides a profile-based pointcut generator, which automatically generates pointcuts for fine-grained scheduling. 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. 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 and the work of the performance tuning was not large.

Object-oriented frameworks play an important role in different kinds of software, such as product-lines, middleware, GUI components, IDEs, etc. Over the past recent years, fundamentals of framework design stabilized around the adoption of design patterns. However, major difficulties concerning framework learning and usage are still evident, and constitute a burden for those who have to deal with it. This paper proposes an approach that aims to facilitate framework usage, based on the concept of specialization aspect. We show how framework hot-spots can be modularized in terms of specialization aspects, and how these can give support for specializing a framework in a step-wise way. The approach is conservative, in the sense that specialization aspects can be developed for an existing framework "as is". In order to support these claims, a case study has been carried out by applying the technique on the JHotDraw graphical framework.

The layered architecture of middleware platforms (such as CORBA, SOAP, J2EE) is a mixed blessing. On the one hand, layers provide services such as demarshaling, session management, request despatching, quality-of-service (QoS) etc. In a typical middleware platform, every request passes through each layer, whether or not the services provided by that layer are needed for that specific request. This rigid layer processing can lower overall system throughput, and reduce availability and/or increase vulnerability to denial-of-service attacks. For use cases where the response is a simple function of the request input parameters, bypassing middleware layers may be permissible and highly advantageous. Unfortunately, if an application developer desires to selectively bypass the middleware, and process some requests in the lower layer, she has to write platform-specific, intricate low-level code. To evade this trap, we propose to extend the middleware platform with new aspect-oriented modeling syntax, code generation tools, and a development process for building bypassing implementations. Bypassing implementations provide better use of server´s resources, leading to better overall client experience. Our core contribution is this idea: aspect-oriented extensions to IDL, additional code generation, along with an enhanced run-time, can enable application developers to conveniently bypass middleware layers when they are not needed, thus improving the server´s performance and providing more “operational headroom”.

In this paper, we discuss the limitations of the current syntactic composition mechanisms in aspect-oriented requirements engineering (AORE). We highlight that such composition mechanisms not only increase coupling between aspects and base concerns but are also insufficient to capture the intentionality of the aspect composition. Furthermore, they force the requirements engineer to reason about semantic influences and trade-offs among aspects from a syntactic perspective. We present a requirements description language (RDL) that enriches the existing natural language requirements specification with semantic information derived from the semantics of the natural language itself. Composition specifications are written based on these semantics rather than requirements syntax hence providing improved means for expressing the intentionality of the composition, in turn facilitating semantics-based reasoning about aspect influences and trade-offs. We also discuss the practicality of the use of this RDL by outlining the automation support for requirements annotation (realized as an extension of the Wmatrix natural language processing tool suite) to expose the semantics which are in turn utilized to facilitate composition and analysis (supported by the MRAT tool).

Join Point Designation Diagrams (JPDDs) permit developers to design aspect-oriented software on an abstract level. Consequently, JPDDs permit developers to communicate their software design independent of the programming language in use. However, developer face two problems. First, they need to understand the semantics of JPDDs in addition to their programming language. Second, after designing aspects using JPDDs they need to decide how to map them into their programming language. A tool-supported translation of JPDDs into a known aspect-oriented language obviously would ease both problems. However, in order to translate a JPDD it is also necessary to determine what a good translation is, i.e. it is necessary to have a number of principles that determine what a good translation is. This paper describes a tool-supported translation of JPDDs to aspect-oriented languages. Principles for translating JPDDs are described and a concrete mapping to the aspect-oriented language AspectJ is explained.

Design rules express constraints on the behavior and structure of a program. These rules can help ensure that a program follows a set of established practices, and avoids certain classes of errors.

Design rules often crosscut program structure and enforcing them is emerging as an important application domain for Aspect Oriented Programming. For many interesting design rules, current general purpose AOP languages lack the expressiveness to characterize them statically and enforce them at compile time.

We have developed a domain specific language called Program Description Logic (PDL). PDL allows succinct declarative definitions of programmatic structures which correspond to design rule violations. PDL is based on a fully static and expressive pointcut language. PDL pointcuts allow characterizing a wide range of design rules without sacrificing static verification.

We evaluate PDL by comparing it to FxCop, an industrial strength tool for checking design rules.

Most approaches to programming language extensibility have worked by pairing syntactic extension with semantic extension. We present an approach that works through a combination of presentation extension and semantic extension. We also present an architecture for this approach, an Eclipse-based implementation targeting the Java programming language, and examples that show how presentation extension, both with and without semantic extension, can make programs more expressive.

The goal of this paper is to model and detect composition conflicts related to introductions. Within this context, we identify several categories of composition conflicts. To analyze the causes of these conflicts precisely, we first model the structure of programs as graphs. Next, we model introductions as graph transformation rules. We define explicit rules to describe when composition conflicts related to introductions occur. We built a prototype tool that detects and visualizes the occurrence of such conflicts in AspectJ programs, making use of an existing graph analysis and rewriting tool. The graph-based models are generated automatically from the source code of Java programs and AspectJ introductions. However, our approach does not make strong assumptions about either the aspect or base language; it has been designed to be applicable to other AOP languages.

Modern source-level debuggers support dynamic breakpoints that are guarded by conditions based on program state. Such breakpoints address situations where a static breakpoint is not sufficiently precise to characterise a point of interest in program execution. However, we believe that current IDE support for dynamic breakpoints are cumbersome to use. Firstly, guard conditions formulated in (nonaspect-oriented) source-languages cannot directly express control-flow conditions, forcing developers to seek alternative formulations. Secondly, guard-conditions can be complex expressions and manually typing them is cumbersome.

We present the Control-flow Breakpoint Debugger (CBD). CBD uses a dynamic pointcut language to characterise control-flow breakpoints---dynamic breakpoints which are conditional on the control-flow through which they were reached. CBD provides a "point-and-click" GUI to specify and incrementally refine control-flow breakpoints, thereby avoiding the burden of manually editing the potentially complex expressions that define them. We performed 20 case studies debugging and fixing documented bugs in 3 existing applications. Our results show that dynamic breakpoints in general are useful in practice, and that CBD´s GUI allows specifying them adequately in the majority of cases.

We define and study bisimulation for proving contextual equivalence in an aspect extension of the untyped lambda-calculus. To our knowledge, this is the first study of coinductive reasoning principles aimed at proving equality of aspect programs. The language we study is very small, yet powerful enough to encode mutable references and a range of temporal pointcuts (including cflow and regular event patterns).

Examples suggest that our bisimulation principle is useful. For an encoding of higher-order programs with state, our methods suffice to establish well-known and well-studied subtle examples involving higher-order functions with state.

Even in the presence of first class dynamic advice and expressive pointcuts, our reasoning principles show that aspect-aware interfaces can aid in ensuring that clients of a component are unaffected by changes to an implementation. Our paper generalizes existing results given for \emph{open modules} to also include a variety of history-sensitive pointcuts such as cflow and regular event patterns.

Our formal techniques and results suggest that aspects are amenable to the formal techniques developed for stateful higher-order programs.

Beginning with BETA, a range of programming language mechanisms such as virtual classes (class-valued attributes of objects) have been developed to allow inheritance in the presence of mutually dependent classes. This paper presents Tribe, a type system which generalises and simplifies other formalisms of such mechanisms, by treating issues which are inessential for soundness, such as the precise details of dispatch and field initialisation, as orthogonal to the core formalism. Tribe can support path types dependent simultaneously on both classes and objects, which is useful for writing library code, and ubiquitous access to an object´s family, which offers family polymorphism without the need to drag around family arguments. Languages based on Tribe will be both simpler and more expressive than existing designs, while having a simpler type system, serving as a useful basis for future language designs.

We study the denotational semantics of an aspect calculus by compositional translation to a functional language with higher-order store and ML-style references. The calculus is designed to construct only ``additive'' aspects i.e. those that do not elide the execution of the base computation. Such an aspect calculus is sufficiently expressive to encode before(), after() and around() advice which calls proceed() exactly once. We prove that our translation is adequate i.e. it reflects observational equivalence. Further if a standard object-oriented view of labels is adopted, the translation is fully abstract i.e. it preserves and reflects observational equivalence. A pleasing consequence is that full abstraction of the target-language semantics is thereby inherited by the source-language semantics. This yields the first fully abstract game model for a functional language of additive aspects.

e is a programming language designed for modeling and verification of electronic systems. As such it is used extensively in the microchip industry, and was recently declared an IEEE standard. e is also a powerful general-purpose language used in the implementation of complex commercial software tools.

It was suggested some time ago that a number of idioms in e resemble those of AOP, but the suggestion was never examined in depth. The present paper takes up this task. For this purpose the relevant mechanisms in e are compared with those of today´s prominent aspect-oriented language—AspectJ—with respect to syntax, semantics, and application.

e´s aspect-oriented capabilities turn out to be a small subset of AspectJ´s, but an interesting one. It is weaker in its support for implementing developmental and non-functional concerns. However, with its simpler syntax and economical semantics, e captures in a natural way crosscutting concerns that stem from the application domain. Thus, e seems to exemplify an original variant of AOP - one that is conservative and robust from a software design point of view.

This paper proposes an approach called SCoPE, which supports user-defined analysis-based pointcuts in aspect-oriented programming (AOP) languages. The advantage of our approach is better integration with existing AOP languages than previous approaches. Instead of extending the language, SCoPE allows the programmer to write a pointcut that analyzes a program by using a conditional (if) pointcut with introspective reflection libraries. A compilation scheme automatically eliminates runtime tests for such a pointcut. The approach also makes effects of aspects visible to the analysis, which is essential for determining proper aspect interactions. We implemented a SCoPE compiler for the AspectJ language on top of the AspectBench compiler using a backpatching technique. The implementation efficiently finds analysis-based pointcuts, and generates woven code without runtime tests for those pointcuts. Our benchmark tests with JHotDraw and other programs showed that SCoPE compiles programs with less than 1% compile-time overhead, and generates a program that is as efficient as an equivalent program that uses merely static pointcuts.

Wireless sensor networks consist of a system of distributed sensors embedded in the physical world, and promise to allow observation of previously unobservable phenomena. Since they are exposed to unpredictable environments, sensor-network applications must handle a wide variety of faults: software errors, node and link failures, and network partitions. The code to manually detect and recover from faults crosscuts the entire application, is tedious to implement correctly and efficiently, and is fragile in the face of program modifications. We investigate language support for modularly managing faults. Our insight is that such support can be naturally provided as an extension to existing ``macroprogramming'' systems for sensor networks. In such a system, a programmer describes a sensor network application as a centralized program; a compiler then produces equivalent node-level programs. We describe a simple checkpoint API for macroprograms, which can be automatically implemented in a distributed fashion across the network. We also describe declarative annotations that allow programmers to specify checkpointing strategies at a higher level of abstraction. We have implemented our approach in the Kairos macroprogramming system. Experiments show it to improve application availability by an order of magnitude and incur low messaging overhead.

cJ is an extension of Java that allows supertypes, fields, and methods of a class or interface to be provided only under some static subtyping condition. For instance, a cJ generic class, C, may provide a member method m only when the type provided for parameter P is a subtype of a specific type Q.

From a practical standpoint, cJ adds to generic Java classes the ability to express case-specific code. Unlike conditional compilation techniques (e.g., the C/C++ #ifdef construct) cJ is statically type safe and maintains the modular type-checking properties of Java generic classes: a cJ generic class can be checked independently of the code that uses it. Just like regular Java, checking a cJ class implies that all uses are safe, under the contract for type parameters specified in the class´s signature.

As a specific application, cJ addresses the well-known shortcomings of the Java Collections Framework (JCF). JCF data structures often throw run-time errors when an “optional” method is called upon an object that does not support it. Within the constraints of standard Java, the authors of JCF had to either sacrifice static type safety or suffer a combinatorial explosion of the number of types involved. cJ avoids both problems, maintaining both static safety and conciseness.

This paper describes a method for studying idioms-based implementations of crosscutting concerns, and our experiences with it in the context of a real-world, large-scale embedded software system. In particular, we analyse a seemingly simple concern, tracing, and show that it exhibits significant variability, despite the use of a prescribed idiom. We discuss the consequences of this variability in terms of how aspect-oriented software development techniques could help prevent it, how it paralyses (automated) migration efforts, and which aspect language features are required in order to obtain precise and concise aspects. Additionally, we elaborate on the representativeness of our results and on the usefulness of our proposed method.

Most current software systems contain undocumented high- level ideas implemented across multiple ?les and modules. When developers perform program maintenance tasks, they often waste time and e?ort locating and understanding these scattered concerns. We have developed a semi-automated concern location and comprehension tool, Find-Concept, designed to reduce the time developers spend on maintenance tasks and to increase their confidence in the results of these tasks. Find-Concept is effective because it searches a unique natural language-based representation of source code, uses novel techniques to expand initial queries into more effective queries, and displays search results in an easy-to-comprehend format. We describe the Find-Concept tool, the underlying program analysis, and an experimental study comparing Find-Concept’s search effectiveness with two state-of-the-art lexical and information retrieval-based search tools. Across nine action-oriented concern location tasks derived from open source bug reports, our Eclipse-based tool produced more effective queries more consistently than either competing search tool with similar user effort.

Inspired by our past manual aspect mining experiences, this paper describes a random walk model to approximate how crosscutting concerns can be discovered in the absence of domain knowledge of the investigated application. Random walks are performed on the coupling graphs extracted from the program sources. The ideas underlying the popular page-rank algorithm are adapted and extended to generate ranks reflecting the degrees of “popularity” and “significance” for each of the program elements on the coupling graphs. Filtering techniques, exploiting both types of ranks, are applied to produce a final list of candidates representing crosscutting concerns. The resulting aspect mining algorithm is evaluated on numerous Java applications ranging from a small-scale drawing application, to a medium-sized middleware application, and to a largescale enterprise application server. In seconds, the aspect mining algorithm is able to produce results comparable to our prior manual mining efforts. The mining algorithm also proves effective in helping domain experts identify latent crosscutting concerns.