Demonstrations

Abstract – Feature-Oriented Domain Analysis (FODA), proposed by K. Kang in 1990, is an analysis method used in Software Product Line Engineering (SPLE). It focuses on identifying and classifying "features" of the target system at the early stage of development. Some features are realized as primary modules and some may become cross-cutting concerns as the design is elaborated. FODA is important at the early stage of AOSD-based development of software systems. Although a feature diagram in FODA is intuitive and easy to understand, one may be faced with two issues as its size increases; (1) Graphical Editing, and (2) Consistency and Validation Checking. Tool support is desirable in these cases.

FD Checker is a GUI-based tool for supporting these two issues. It is implemented by customizing the iDot tool to provide a GUI front-end for the back-end analyzer Alloy. A feature diagram, constructed with the graphical editing commands, is translated into an Alloy source text file. Alloy returns the analysis result, which can also be viewed from the GUI front-end. In the translation process, FD Checker adapts the formal analysis method proposed in our previous work. The analysis problem is essentially the satisfiability checking of the propositional logic formula, where the formula faithfully represents the semantics of the given feature diagram. Because it is based on the iDot tool, FD Checker can make use of many enriched functions that can be reused from iDot, such as the fish-eye viewer or interactive resizing. The demonstration will show how one constructs and checks feature diagrams with FD Checker.

Abstract – Aspect-oriented programming (AOP) is a promising approach for the rapid development of profiling, debugging, testing, and reverse engineering tools. However, while current aspect weavers prevent or limit weaving in the Java class library, complete method coverage is essential in the aforementioned application areas. Weaving aspects in the Java class library is difficult, because modifying core classes may break bootstrapping and crash the Java Virtual Machine. In this demonstration, we present MAJOR and CARAJillo, two new tools for comprehensive aspect weaving, covering all application classes (including those that are dynamically downloaded or generated), the Java class library, as well as vendor-specific classes of the Java runtime system.

MAJOR offers basic support for comprehensive aspect weaving, whereas CARAJillo also provides efficient access to complete calling context information within aspects. Both tools rely on FERRARI, a generic bytecode instrumentation framework that enables user-defined instrumentation modules (UDIs) to be applied to all methods executing in a system. MAJOR is based on the AJ-UDI (a UDI for AspectJ), whereas CARAJillo composes the AJ-UDI with the CC-UDI (a UDI for efficient calling context reification). The AJ-UDI relies on the standard AspectJ compiler and weaver. We demonstrate our tools by applying aspects for profiling, debugging, and testing.

Abstract – In this demonstration we present an approach that facilitates variability implementation, management, and tracing from architectural modeling to implementation of product lines by integrating both aspect-oriented and model-driven software development. We use models to describe product lines. Domain requirements as well as the product line architecture are captured in models. Formally defined mappings between those models allow for an automatic creation of a product architecture based on product requirements. A code generator generates a running system from the final product architecture model. Aspect-oriented techniques are used to implement the variants in the models as well as in the transformers and generators. Furthermore, a seamless integration of a variant management tool into our tool chain supports the expression of dependencies between features and transformation and generation steps. We demonstrate our approach using an industrial case study of a home automation system conducted at Siemens AG.

Abstract – We present an industrial demonstration focused on the construction of a digital publishing platform on top of JBoss using aspects. We have applied AOSD methods and tools during the full software development process from requirements to deployment. The goal of the demonstration is to show that (i) AOSD integrates well with existing standard paradigms such as component-based software engineering, (ii) the resulting software exhibits good evolvability and variability, and (iii) AOSD increases the overall business value of digital publishing services by supporting characteristics of an ideal news product that allows direct marketing to targeted groups of customers.

Abstract – Unexpected interactions between aspects are still a major problem compromising AOP's applicability, especially in large projects involving many developers, including new team members. drUID is an Eclipse plugin that helps developers with the process of defining the dependencies between features and provides a test-based mechanism to verify aspect interactions. Developers using drUID are able to verify if the detected interaction is expected or not and act accordingly. In the demonstration, a small project will be used to show the capabilities of drUID as new aspects are introduced and interactions detected.

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, there is no aspect weaver available for JavaScript. Existing mechanisms require modifications in the target modules for aspect weaving in JavaScript (i.e., not "complete" separation). In this demonstration, we introduce 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 substitutions 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 will demonstrate how AOJS offers improved modifiability and extendability for JavaScript programming.

Abstract – Rich Internet Application (RIA) has been proposed in order to solve problems of current web applications. RIA provides sophisticated interfaces for representing complex processes and data. Therefore, it requires not only developers who implement application logic, but also designers who design the interface of an application in order to develop RIAs. In the development process of an application, the change of design and/or specification often occurs, which requires additional work on the part of the designer and developer. This is because the designers of web interfaces use HTML, and the developers modify the interfaces for dynamic generation of HTML tags based on the executed logics. That is, developers and designers have to share the source code of the interface in an application.

To address these challenges, we adopt the Flex Framework, which is part of the RIA framework released by Adobe Systems, to realize complete separation of programs from interface source code. In order to do this, we consider every event handler that handles events dispatched from interface components as an aspect, and then weave these aspects at runtime. As a result, developers and designers can concentrate on their own work.

Abstract – Conditional compilation is a conditional text inclusion facility which has widespread use in C/C++ code as the primary mechanism for implementing crosscutting concerns like debugging and configuration. In order to compare the benefits and drawbacks of using conditional compilation with more modern aspect-oriented techniques, it is important to understand the typical patterns of syntactical interaction between conditional regions and normal source code. R3V3RS3 is a reverse-engineering tool that reifies the "preprocessor blueprint model" of a C system, (i.e. a model of the syntactical interaction between source code and conditional compilation regions). This model can be queried for interesting patterns that have been specified declaratively. To handle the text processing nature of conditional compilation, R3V3RS3 is built on top of Fetch, a robust C/C++ analysis tool chain. R3V3RS3 has been applied to the Parrot VM to discover syntactical patterns of conditional compilation usage and to study the evolution of the number of pattern occurrences. In the demo, we apply the identified patterns of conditional compilation usage to a smaller VM and use these findings to decide which conditional compilation regions are interesting to refactor into aspects and which ones are not.

Abstract – The development of software product lines offers a tremendous challenge to software developers. Initially, the developers are faced with large amounts of heterogeneous information that specifies what is expected of the product line and its products. The developers then need to make decisions on what the common assets and variable elements must be, which parts to isolate in aspects to avoid crosscutting, how the SPL architecture is derived, etc. The sheer size of product line specifications, combined with the inherent problems of natural language specifications such as conflicts and ambiguity, make it very difficult for developers to take the right decisions and evaluate the various pertinent alternatives. LAVASH (LAncaster Variability AnalysiS toolkit for Heterogeneous requirements) is a tool suite that offers comprehensive support to software developers in handling large amounts of information during complex decision-making in SPL development. By automated processing and analysis of natural language specifications, the software developer can be assisted in evaluating alternatives pertaining to complex decisions. A number of capabilities are offered by the tool suite, including the derivation of feature trees, aspect identification and architecture decision-making. LAVASH achieves this by combining natural language processing with state-of-the-art reasoning models.

Abstract – Pointcut fragility is a well-documented problem in Aspect-Oriented Programming. Changes to the advised base-code can lead to join points incorrectly falling in or out of the scope of pointcut expressions. We demonstrate an AspectJ source-level inferencing tool called Rejuvenate Pointcut which limits the problems associated with fragile pointcuts by assisting the developer to rejuvenate pointcuts as the base-code evolves. The Eclipse IDE-based tool works by deriving intentional patterns from the advised join points which can later be used to offer suggestions of new join points which should also be advised with a given confidence. This work represents a significant step towards providing tool-supported maintainability for evolving aspect-oriented software.