Abstract: Feature models (FMs) are a popular formalism for describing the commonality and variability of software product lines (SPLs) in terms of features. SPL development increasingly involves manipulating many large FMs, and thus scalable modular techniques that support compositional development of complex SPLs are required. In this paper, we describe how a set of complementary operators (aggregate, merge, slice) provides practical support for separation of concerns in feature modeling. We show how the combination of these operators can assist in tedious and error prone tasks such as automated correction of FM anomalies, update and extraction of FM views, reconciliation of FMs and reasoning about properties of FMs. For each task, we report on practical applications in different domains. We also present a technique that can efficiently decompose FMs with thousands of features and report our experimental results.

Abstract: Self-adapting systems are becoming widespread in emerging fields such as autonomic, mobile and ubiquitous computing. Context-oriented programming (COP) is a promising language-level solution for the implementation of context-aware, self-adaptive software. However, current COP approaches struggle to effectively manage the asynchronous nature of context provisioning. We argue that, to solve these issues, COP features should be designed to fit nicely in the concurrency model supported by the language. This work presents the design rationale of ContextErlang, which introduces COP in the Actor Model. We provide evidence that ContextErlang constitutes a viable solution to implement context-aware software in a highly concurrent and distributed setting. We discuss a case study and an evaluation of run-time performance.

Abstract: A variety of language features to modularize crosscutting concerns have recently been discussed, e.g. open modules, annotation-based pointcuts, explicit join points, and quantified-typed events. All of these ideas are essentially a form of aspect-oriented interface between object-oriented and crosscutting modules, but the representation of this interface differs. While previous works have studied maintenance of AO programs versus OO programs, an empirical comparison of different AO interfaces to each other to investigate their benefits has not been performed. The main contribution of this work is a rigorous empirical study that evaluates the effectiveness of these proposals for AO interfaces towards software maintenance by applying them to 35 different releases of a software product line called MobileMedia and 50 different releases of a web application called Health Watcher. Our comparative analysis using quantitative metrics proposed by Chidamber and Kemerer shows the strengths and weaknesses of these AO interface proposals. Our change impact analysis shows the design stability provided by each of these recent proposals for AO interfaces.

Abstract: In this work we consider specification and compositional verification for interference detection when several aspects are woven together under joint-weaving semantics without recursion. In this semantics, whenever a joinpoint of an aspect is reached, the corresponding advice is begun even if the joinpoint is inside the advice of other aspects. This captures most of the possible aspect interference cases in AspectJ. Moreover, the given technique is used to capture cooperation among aspects, which enhances modularity. The extended specification and proof obligations should provide insight to the possible interactions among aspects in a reusable library.

Abstract: To increase modularity, aspect-oriented programming provides a mechanism based on implicit invocation: An aspect can influence runtime behavior of other modules without the need that these modules refer to the aspect. Recent studies show that a significant part of reported bugs in aspect-oriented programs are caused exactly by this implicitness. These bugs are difficult to detect because aspect-oriented source code elements and their locations are transformed or even lost after compilation. We investigate four dedicated fault models and identify ten tasks that a debugger should be able to perform for detecting aspect-orientation-specific faults. We show that existing debuggers are not powerful enough to support all identified tasks because the aspect-oriented abstractions are lost after compilation. This paper describes the design and implementation of a debugger for aspect-oriented languages using a dedicated intermediate representation preserving the abstraction level of aspect-oriented source code. We define a debugging model which is aware of aspect-oriented concepts. Based on the model, we implement a user interface with functionalities supporting the identified tasks, like visualizing pointcut evaluation and program composition.

Abstract: Tracing program actions back to the concerns that have caused them and blaming specific code artifacts for concern interference are known challenges of AOP and related advanced modularity paradigms. In this work we address these challenges in the context of AspectLTL, a temporal-logic based language for the specification and implementation of crosscutting concerns, which has a composition and synthesis-based weaving process whose output is a correct-by-construction executable artifact. When a specification is realizable, we provide two-way traceability information that links each allowed or forbidden transition in the generated program with the aspects that have justified its presence or elimination. When a specification is unrealizable, we provide an interactive game proof that demonstrates conflicts that should be fixed. The techniques are implemented and demonstrated using running examples.

Abstract: For every new language construct (or abstraction), we have been always developing new syntax. Is this a right approach? In this paper, we propose that, if we develop a new language construct for advanced modularity, we should consider the use of dynamic text for designing the construct. We mention that language constructs designed with only syntactic extensions (i.e. static text) are not satisfactory in aspect oriented programming. Then we present our two prototype systems to demonstrate language constructs designed with dynamic text. One is synchronous copy and paste and the other is a virtual-file editor named Kide. We show how they enable aspect-oriented programming in plain Java.

Abstract: The aim of this work is to provide better support for adaption and refinement of generic code. This type of flexibility is desirable in order to fully reap the potential of generic programming. Our proposal for an improved mechanism is an extension to the previously published Package Templates (PT) mechanism, which is designed for development of reusable modules that can be adapted to their specific purpose when used in a program. The PT mechanism relies on compile-time specialization, and supports separate type checking and type-safe composition of modules. The extension to PT presented here is called required types, and can be seen as an enhanced form of type parameters, allowing them the same flexibility as other elements of the PT mechanism. We implement a subset of the Boost Graph Library in order to exemplify, validate, and compare our approach to other options.

Abstract: Aspect Oriented Modeling (AOM) aims to provide enhanced separation of concerns during the design phase and proclaims many benefits (e.g., easier model evolution, reduced modeling effort, and reduced modeling errors) over traditional modeling paradigms such as object-oriented modeling. However, empirical evaluations of these benefits is severely lacking in the AOM community. In this paper, we empirically evaluate one of the AOM profiles: AspectSM, via a controlled experiment to assess if it can help in reducing modeling errors (referred as conformance errors in this paper), which is one of the benefits offered by AOM. AspectSM is a UML profile, which is developed to support automated state-based robustness testing. With AspectSM, crosscutting behaviors are modeled as aspect state machines using the stereotypes defined in AspectSM. We evaluate the conformance error rates of applying AspectSM from various perspectives by conducting four activities: 1) identifying modeling defects, 2) comprehending state machines, 3) modeling state machines, and 4) weaving aspect state machines into base state machines. For most of these activities, experimental results show that the error rates while performing these four activities using AspectSM are significantly lower than standard UML state machine modeling approaches.

Abstract: UML state machines are widely used for modeling software behavior. Due to the low-level character of the language, UML state machines are often poorly modularized and hard to use. High-Level Aspects (HiLA) is an aspect-oriented extension of UML state machines which provides high-level language constructs for behavior modeling. HiLA considerably improves the modularity of UML state machines by extending them by semantic aspects. This paper presents the weaving process for HiLA that we have shown to be sound with respect to the transition-system semantics of HiLA. In particular, we show how our weaving process deals with implicit state activation (and deactivation), maps semantic pointcuts to syntactic elements, and resolves potential conflicts between different aspects. The process has been implemented in an extension of the Hugo/RT UML translator and model checker, the correctness of our weaving is validated by model checking.

Abstract: CiAO is the first operating-system family that has been developed with AOP concepts from the very beginning. By its aspect-aware design and implementation, CiAO reaches excellent configurability, separation of concerns, and low footprints in the resulting systems that outperform leading commercial implementations. CiAO implements the automotive operating-system standard OSEK/AUTOSAR OS and provides configurability of all fundamental system properties by means of AOP. We describe the aspect-aware design approach and implementation idioms that led to this efficiency and flexibility. On the example of three larger case studies from CiAO, we demonstrate how AOP can be employed in this respect on different levels of complexity: From highly configurable, yet efficient low-level hardware abstractions over the implementation of central kernel policies up to the decomposition of a complete operating-system specification. Our results show that by a consequent application of the aspect-aware approach, AOP becomes a promising technology to reach configurability, separation of concerns, and runtime/memory efficiency on all levels of operating-system development.

Abstract: The prevalence of threats and attacks in modern systems demands programming techniques that help developers maintain security and privacy. In particular, frameworks for composing components written by multiple parties must enable the authors of each component to erect safeguards against intrusion by other components. Object-capability systems have been particularly prominent for enabling encapsulation in such contexts.We describe the program structures dictated by object capabilities and compare these against those that ensue from feature-oriented programming. We argue that the scalability offered by the latter appears to clash with the precision of authority designation demanded by the former. In addition to presenting this position from first principles, we illustrate it with a case study. We then offer a vision of how this conflict might be reconciled, and discuss some of the issues that need to be considered in bridging this mismatch. Our findings suggest a significant avenue for research at the intersection of software engineering and security.

Abstract: Aspect-Oriented Programming (AOP) started fifteen years ago with the remark that modularization of so-called crosscutting functionalities is a fundamental problem for the engineering of large-scale applications. Originating at Xerox PARC, this observation has sparked the development of a new style of programming features that is gradually gaining traction. However, theoretical foundations of AOP have been much less studied than its applicability. This paper proposes to put a bridge between AOP and the notion of 2-category to enhance the conceptual understanding of AOP. Starting from the connection between the λ-calculus and the theory of categories, we provide an internal language for 2-categories and show how it can be used to define the first categorical semantics for a realistic functional AOP language, called MinAML. We then take advantage of this new categorical framework to introduce the notion of computational 2-monads for AOP. We illustrate their conceptual power by defining a 2-monad for Eric Tanter's execution levels---which constitutes the first algebraic semantics for execution levels---and then introducing the first exception monad transformer specific to AOP that gives rise to a non-flat semantics for exceptions by taking levels into account.

Abstract: A class extension, also known as open classes, allows programmers to modify existing classes and thus it is supported by several programming languages. However, class extensions imply a risk that they supply different definitions for the same method and those definitions conflict with each other. Several module systems have been proposed to address these conflicts. One approach lexically restricts the scope of class extensions but they do not allow us to change the behavior of methods called indirectly. Another approach is to make only class extensions explicitly imported effective while preserving the local rebinding property, which allows us to change the behavior of indirectly called methods. However, this approach causes conflicts if potentially conflicting class extensions are imported together. To address this problem, we propose a new module system named method shelters. A method shelter confines a scope of class extensions while preserving the local rebinding property. Hidden class extensions in a method shelter are not visible from the outside. We implemented a prototype of the proposed module system in Ruby. This paper illustrates several examples of the use of method shelters and also shows the results of benchmarks on our prototype.

Abstract: With the recent immersion of advanced mobile devices in the daily lives of millions, pervasive computing is becoming a reality. Developing pervasive software systems is inherently difficult though it requires to deal with heterogeneous infrastructure besides peer-to-peer communication and device mobility. Thus, programming support for such applications must provide loose coupling between different participants, as well as loose coupling between applications and communication protocols. Event-based programming provides an appealing paradigm to decouple participants, however many event-based systems and languages have hardwired communication protocols, which limits their adaptability to heterogeneous deployment environments. In this paper we address this issue by abstracting the context in which events are created and handled, including protocols used to convey, compose, and consume these events. More precisely, we propose to extend an event-based programming model with context aspects --- conspects for short. We demonstrate the elegant usage of conspects through several examples based on their implementation in EventJava and illustrate how they allow to modularize event-based pervasive software. We also provide a thorough empirical investigation of the performance overheads and benefits of conspects, including the costs of weaving them dynamically. Through empirical evaluations, we assess the benefits of conspects for switching protocols without any changes to the base applications through three case studies with EventJava. The three studies are (1) a tornado monitoring system deployed on different architectures ranging from desktop x86 to embedded LEON3, (2) a mobile social networking suite with protocols for different scenarios, and (3) the introduction of a novel adaptive communication protocol in our mobile social network suite as well as in a novel robotic swarm application.

Abstract: A considerable amount of research, especially within the OO and AOSD communities, has focused on understanding the potential and limitations of various composition techniques. This has led to a large number of proposals for alternative composition techniques, including many variations of message dispatch, inheritance, and aspect mechanisms. This paper makes the case that there is no single perfect composition technique that suits every situation, since different techniques incur different tradeoffs. The proper composition technique to use depends on the particular design problem and its requirements (such as the required adaptability, reusability, understandability and robustness). However, most programming languages limit the available composition techniques to a very few. To address this, we propose a novel composition model, called Co-op. The model provides dedicated abstractions that can be used to express a wide variety of object composition techniques ("composition operators"). Examples include various forms of inheritance, delegation, and aspects. The proposed model unifies objects (with encapsulated state and a message interface) and composition operators; composition operators are specified as first-class citizens. Multiple composition operators can be combined within the same application, and composition operators can even be used to compose new composition operators from existing ones. This opens new possibilities for developing domain-specific composition operators, taxonomies of composition operators, and for reuse and refinement of composition operators. To validate and experiment with the proposed model, we have designed and implemented a simple language, Co-op/I, that we also use in this paper to show concrete examples.

Abstract: Research in the area of multi-DSAL development has been mainly devoted to enabling the interoperability of multiple aspect mechanisms. Less attention has been given to making programming with multiple aspect languages practical. For domain specific aspect languages (DSALs) to be used in practice, there is a need for tools that make multi-DSAL development effective. This paper focuses on one such tool: a debugger. We define a multi-DSAL debug interface (MDDI) for inspecting the composition specification and the runtime state and behavior of applications written in multiple DSALs. To implement the interface, a multi-DSAL debug agent and special debug attributes are introduced into the weaving process. A concrete implementation of MDDI over the Awesome aspect composition framework is presented. For validation we demonstrate a simple command-line AwesomeDebugger that uses the debug interface.

Abstract: Emerging languages are often source-to-source compiled to mainstream ones, which offer standardized, fine-tuned implementations of non-functional concerns (NFCs)-including persistence, security, transactions, and testing. Because these NFCs are specified through metadata such as XML configuration files, compiling an emerging language to a mainstream one does not include NFC implementations. Unable to access the mainstream language's NFC implementations, emerging language programmers waste development effort reimplementing NFCs. In this paper, we present a novel approach to reusing NFC implementations across languages by automatically translating metadata. To add an NFC to an emerging language program, the programmer declares metadata, which is then translated to reuse the specified NFC implementation in the source-to-source compiled mainstream target language program. By automatically translating metadata, our approach eliminates the need to reimplement NFCs in the emerging language. As a validation, we add unit testing and transparent persistence to X10 by reusing implementations of these NFCs in Java and C++, the X10 backend compilation targets. The reused persistence NFC is efficient and scalable, making it possible to checkpoint and migrate processes, as demonstrated through experiments with third-party X10 programs. These results indicate that our approach can effectively reuse NFC implementations across languages, thus saving development effort.

Abstract: Computers were invented largely as mental aids. In inventing object-orientation, Alan Kay renewed that vision on a metaphorical level that no longer subordinated computers to human minds. Trygve Reenskaug tried to link the worlds of the human and the computer together with Model-View-Controller, but at the time he got only half the job done. Today we're stuck in this Kantian object world where individual objects act alone and programmers live inside of classes looking out: there is rarely any sense of collective behaviour in object-oriented systems, and there is rarely any degree of behavioural (self-)organization. I have been working with Trygve on a paradigm called DCI (Data, Context and Interaction) that places the human experiences of design and use of programs equally at centre stage. It balances the object interaction view with the traditional data conceptualization of class-oriented programming. DCI offers a vision of computers and people being mutually alive in Christopher Alexander's sense of great design. It serves Kay's original vision of object-orientation powering computers as mental adjuncts, as well as his vision of objects as a recursion on the concept of a computer. In this world with a rapidly growing number of increasingly connected human minds, DCI opens up a playful dialogue contrasting metaphors of collective human reasoning and Kay's vision of object computation.

Abstract: Aspect-orientation is a mechanism for modularizing cross-cutting concerns that has been added to many existing software engineering languages. The implementations of aspect-oriented language extensions, however, are typically tied to a specific base language. There is little or no code reuse between aspect-oriented extensions for different base languages, which makes these extensions difficult and expensive to build. In addition, existing software engineering tools do not work with the resulting aspect-oriented languages unless new plugins are developed.We present Carpenter, an object-oriented framework for developing aspect-oriented language extensions. An aspect language is developed by reusing classes for generic language constructs from Carpenter, and writing subclasses of the abstractions in Carpenter to define new language constructs. An aspect weaver is created by implementing framework interfaces to weave language-specific constructs. The coordination of the weaving process is done by the Carpenter framework. Aspect languages developed with Carpenter get full IDE support with only a few lines of code. We have used our framework to create aspect weavers for Java, JLo, and AspectU.

Abstract: Modularity is a key concept for large and complex applications and an important enabler for collaborative research. In comparison, virtual machines (VMs) are still mostly monolithic pieces of software. Our goal is to significantly reduce to the cost of extending VMs to efficiently host and execute multiple, dynamic languages. We are designing and implementing a VM following the "everything is extensible" paradigm. Among the novel use cases that will be enabled by our research are: VM extensions by third parties, support for multiple languages inside one VM, and a universal VM for mobile devices.Our research will be based on the existing state of the art. We will reuse an existing metacircular Java VM and an existing dynamic language VM implemented in Java. We will split the VMs into fine-grained modules, define explicit interfaces and extension points for the modules, and finally re-connect them.Performance is one of the most important concerns for VMs. Modularity improves flexibility but can introduce an unacceptable performance overhead at the module boundaries, e.g., for inter-module method calls. We will identify this overhead and address it with novel feedback-directed compiler optimizations. These optimizations will also improve the performance of modular applications running on top of our VM.The expected results of our research will be not only new insights and a new design approach for VMs, but also a complete reference implementation of a modular VM where everything is extensible by third parties and that supports multiple languages.

Abstract: In this paper we introduce a model as a foundation for heterogeneous services, therefore unifying web services technologies in SOA (Service Oriented Architecture), specifically, SOAP/WS* and RESTful models. This model abstracts away from service implementations, in order to verify and to enforce some important security properties.

Abstract: This demonstration presents a novel design-flow and as-pect-oriented language called LARA [1], which is currently used to guide the mapping of high-level C application codes to heterogeneous high-performance embedded sys-tems. In particular, LARA is capable of capturing complex strategies and schemes involving: hardware/software parti-tioning, code specialization, source code transformations and code instrumentation. A key element of LARA, and a distinguishing feature from existing approaches, is its abil-ity to support the specification of non-functional require-ments and user knowledge in a non-invasive way in the exploration of suitable implementations. The design-flow incorporates several tools, such as a LARA frontend, a hardware/software partitioning tool, an aspect weaver, cost estimator, and a source-level transformation engine. All these components can be coordinated as part of an elabo-rate application mapping strategy using LARA. In this demonstration, we illustrate how non-functional cross-cutting concerns such as runtime monitorization and performance are codified and described in LARA and how the weaving process affects selected applications. Further-more, we also explain how third-party tools, such as gprof, can be incorporated into the design-flow and aspect de-scription, for instance, to affect the hardware/software partitioning process. We demonstrate how LARA can exploit the extraction of run-time information, such as variable ranges and can control code transforms and compiler optimizations for customization of the implementations of the corresponding computations on FPGAs.

Abstract: Dynamic aspect-oriented programming (AOP) enables runtime adaptation of programs. It enables sophisticated, aspect-based software engineering tools, such as adaptive profilers or debuggers, which dynamically modify instrumentation code in response to user interactions. Today, many AOP frameworks for Java, notably AspectJ, focus on aspect weaving at build-time or at load-time, and offer only limited support for program adaptation by (re)weaving aspects at runtime. In this article, we present HotWave, an AOP framework based on AspectJ for standard Java Virtual Machines (JVMs). HotWave supports dynamic (re)weaving of previously loaded classes, and it ensures that all classes loaded in a JVM can be (re)woven, including the classes of the standard Java class library. HotWave features inter-advice communication, a mechanism that allows for efficient data passing between advice that are woven into the same method. We explain HotWave's programming model and discuss our implementation techniques. As a case study, we present an adaptive, aspect-based profiler that leverages HotWave's distinguishing features. A performance evaluation shows that HotWave does not introduce any overhead when no aspect is woven and explores the overhead of runtime weaving. While the duration of runtime weaving can be significant, the execution of woven code with HotWave does not incur any extra overhead when compared to the execution of code woven at build-time or at load-time.

Abstract: This paper presents a modeling language to modularize the features of a system using orthogonal regions and to man-age the interactions between these features. Orthogonal regions are a language construct to structure a state ma-chine into a set of semi-independent behaviors. We intro-duce two concepts to manage the interactions between regions. First, we present a notion of interface between re-gions which captures the essence of their interactions. Second, we introduce a transactional composition operator to synchronize the regions and check the interaction for non-determinism and termination. The approach is eva-luated by comparing a monolithic legacy implementation of a telecommunication component to two refactored implementations. Our results show that transactional region composition can achieves independence between the im-plementations of the features of the system and that it improves the cohesion of the regions, compared to classic regions.

Abstract: Aspect languages for Smalltalk have not kept up with advances in aspect language research. Arguably the only well-known aspect language for Smalltalk is AspectS. It is a ground-breaking contribution, especially regarding dynamic aspects, yet it lacks amenities which aspect language users have come to rely on, e.g. the use of patterns in pointcuts and the ability to declare aspect precedence. Alternative aspect languages for Smalltalk are effectively absent. As a result, currently Smalltalk lacks a modern and powerful aspect language.To address this deficit, we elected to design and build PHANtom: a modern aspect language for Pharo Smalltalk. PHANtom is designed to be an aspect language in the spirit of Smalltalk: dynamic, simple and powerful. PHANtom is a modern aspect language because it incorporates what we consider to be the best features of languages that precede it, includes recent research results in aspect interactions and reentrancy control, and is designed from the onset to be optimized and compiled where possible. This demo presents PHANtom by first providing an introduction to the language, detailing its philosophy and fundamental features. It second discusses the salient features of the language by demonstrating the use of PHANtom in an example application.

Abstract: This paper presents an aspect-oriented library to support parallelization of Java applications for distributed memory environments, using a message-passing approach. The library was implemented using AspectJ language, and aims to provide a set of mechanisms to make easier to parallelize applications, as well as to solve well known problems of parallelization, such as lack of modularity and reusability. We compare the advantages of this method over the traditional approach, and we discuss differences to recent approaches that address the same problem. Results show benefits over other approaches, and, in most of cases, a competitive performance.

Abstract: In reactive systems, events are detected and responses (rea ctions to the detected events) are activated. These events ca n be given by a user, software, hardware or by a more complex processing of lower-level events. Complex Event Processin g (CEP) [13, 18] is a paradigm that focuses on the detection, processing, distribution and consumption of events. Crosscutting concerns are ubiquitous in software systems. Examples of typical crosscutting concerns are loggin g, persistence, security, transaction management and others . Aspect-Oriented Programming (AOP) [17] provides a modular representation of crosscutting concerns where the dev loper indicates where should these concerns be applied and what should be done. This way, scattering and tangling [24] of concerns is avoided. Aspects are applied at several different locations of the underlying system. Identifying the se locations with event detectors is a very natural approach to combine events and aspects. My research deals with understanding the implications of introducing language extensions to handle events and developing practical tools and techniques for composition al verification in this context. Moreover, we consider some of the semantic choices in combining events and aspects, their motivation and implica -

Abstract: We present and analyze a range of techniques for recovering from faults in complex hardware and software systems, from classical techniques that attempt to preserve the abstraction of perfection in the presence of faults to emerging techniques that adapt application functionality to transcend faults, overcome implementation errors in both the hardware and software, and adapt to the characteristics of the underlying execution environment.