Product line software engineering (PLSE) has been recognized as a key software development paradigm for meeting diverse needs of the global market efficiently and effectively giving competitive advantages to IT industries and embedded systems developers. The PLSE paradigm has been changing the way software developers think about software development: from the single application view to the application family, i.e., product line, view. Several software engineering concepts and techniques have been developed to support the product line engineering, including commonality and variability analysis, product line architecture, variation points and variants, and variability management. However, modularity of software in the context of product line engineering has become even more important than it was in the context of single application development as we need to manage variability and also promote reuse across a family of related applications. We must take the variability into consideration when we design for modularity, bringing another dimension of complexity into software engineering.

In my talk, I will give an overview of the evolution of reuse concepts, introduce product line engineering, and then discuss various approaches to modularity in the context of product line variability. Pending research issues will also be discussed.

Modularity has been around for a long time. Good designers attempt to make use of it as much as possible. Languages have been developed to support it. Language extensions have attempted to deal with the situations where languages themselves fail. Tools have been designed to accommodate and encourage it. Most of these efforts, however, are geared toward "simple" homogeneous applications. Unfortunately, modern applications can be a lot more complex and bring up new and exciting challenges in terms of modularity. Today's applications, even relatively simple ones, involve multiple processes running on multiple machines, processes that are often external to the application itself and out of the control of the developers. The individual processes involve multiple threads, complex thread interactions, and opaque libraries. All these affect the way we look at systems and how we approach modularity.

In this talk we will look at the organization of several applications we have been building including the programming environment Code Bubbles, the semantic search tool S6, and our intelligent office sign, and consider how modular they are, how flexible their design is, and how we succeeded or failed in accommodating modularity in the face of other challenges such as portability, maintainability, efficiency, and extensibility. We will also look at how programming environments and tools, which are integral to the programming process, can either help or hinder modularity.

Developing extensions to general-purpose langauges or domain-specific languages with support for new kinds of abstractions is an ongoing trend. Modern language workbenches, such as EMFText of Xtext, support this trend and facilitate implementing langauges in terms of transformations from the new language into an established (intermediate) language. Often, however, the implementation of one element in the source language becomes scattered and tangled in the target language, which makes transformations complex. Furthermore, even though many languages share core concepts, current approaches do not support sharing transformations that implement their semantics; the only possibility of re-using transformations from a language is to extend it syntactically. We have identified dispatching as fundamental to most abstraction mechanisms. With the ALIA4J approach, we provide a meta-model of dispatching to act as rich and extensible intermediate language that allows more direct transformation. The semantics of core language concepts can be modularly implemented as extension of the meta-model. For the execution of the intermediate language, we provide both platform-independent and platform-dependent Java Virtual Machine extensions, the latter of which even allows the modular implementation of machine code optimizations.

In this demo, participants get an overview of advanced dispatching and the ALIA4J approach. By the example of a language for text-based adventure games, they will see the usage of ALIA4J as back-end for a language developed in EMFText. Finally, the implementation of new atomic language concepts and their optimization is demonstrated.

It is important to understand semantic differences between a pair of Java methods during maintenance. However, textual or syntactic difference is insufficient to give clear idea which code fragment realizes a single functionality in Java methods. In this paper, we present an Eclipse plugin for semantic differentiation of a given pair of Java methods.

In this session, we introduce an application of Javassist technology for commercial purposes. The Java troubleshooting tool "ENdoSnipe", developed by Acroquest Technology, realizes noninvasive diagnosis looking into the internal behavior of the applied Java system without any change of the source code. ENdoSnipe can obtain the detailed information of every targeted method such as the processing time, the method's starting time, arguments and so on.

In standard AspectJ, aspects and base code are often insufficiently decoupled, as aspects hold pointcuts, which can contain explicit textual references to base code. This hinders aspect evolution and reuse, and may hinder reasoning about aspects on the base-code side. In this demo we present join point interfaces as an extension to the aspect-oriented programming language AspectJ. Opposed to AspectJ, with join point interfaces aspects and base code communicate only through a shared interface abstraction. Aspects themselves go without pointcuts and only reference the interface. Pointcuts are typically defined on the base-code side, or not at all, as join point interfaces also support pure explicit invocation as known from publish-subscribe systems. As a result, users obtain a language which decouples aspects from base code using a modular type-checking algorithm, and which they can use to adopt aspects gradually as they desire.

One major undertaking in the design of join point interfaces was to make the language as flexible to use as standard AspectJ, while nevertheless providing interfaces supported by strong type checks that can completely avoid type errors at composition time. In this demo we will discuss this inherent trade-off, we will present JPIs as an extension to the AspectBench Compiler, and will show how the language eases the maintenance of existing AspectJ applications.

TouchRAM is a multitouch-enabled tool for agile software design modelling aimed at developing scalable and reusable software design models. This paper briefly summarizes the main features of the Reusable Aspect Models modelling approach that TouchRAM is based on, and then describes how the tool is used during the design process to incrementally elaborate a complex software design model.

To comprehend programs or to fix a bug, programmers always mentally simulate the program execution by reading the source code. Aspect-oriented programming (AOP) increases this mental effort, because it can alter the state and the behavior of the base program at a join point to any extent by executing advices. Advices are implicitly invoked in the source code and their compositions at a join point may vary according to the runtime context. They can access and even change the context values of join points. Without appropriate tools, it is difficult to notice the effects of the implicitly executed advices. The goal of my work is to increase the comprehensibility of AO programs by using a graphical tool, that can succinctly visualize the state and behavioral changes at join points.

Dynamic Program Analysis (DPA) tools commonly rely on bytecode instrumentation which is done by means of low-level bytecode manipulation libraries. While providing a lot of flexibility and expressiveness to developers, using those libraries is usually time consuming, error-prone, and tedious. Approaches that leverage aspect-oriented programming (AOP) serve to reduce the development effort by providing higher abstraction layer for creating instrumentations. However, AOP-based tools have certain known limitations, high performance overhead being one of them. This work is intended to help DPA tool developers to choose the proper instrumentation framework that fully satisfies their needs.

We propose a framework for processing source code supporting multiple programming languages, named UNICOEN. UNICOEN reduces development costs and differences between tool implementations. We evaluated UNICOEN by developing a tool which supports 7 programming languages.

In this paper, we propose an analysis tool for mining software repository (MSR) called E-CUBE, which corresponds to three types of evolution in MSR (i.e., Platform Evolution, Target Evolution and Scale Evolution). To encapsulate the essence of these types of evolution, we introduce modular construction for MSR studies to E-CUBE. We make a choice of features (i.e., modules) in the field of MSR using Feature Oriented Domain Analysis (FODA) and implement those modules using an internal Domain specific language (DSL).

We propose Method Shells, which is a module system for switching a set of destructive class extensions at runtime. Destructive class extensions are getting popular and supported by a number of languages. By using destructive class extensions, you can add new methods to existing classes and redefine existing methods without rewriting the original source code by only writing differences in a separate file. For this reason, destructive class extensons are suitable for reusing an entire program, such as libraries. However, difference destructive class extensions redefining the same method in the same class may conflict. Our module system can switch sets of destructive class extensions activated and deactivated at runtime. Futhermore, we defined the formal semantics of our module system and proposed a way to impliment methodshells without runtime overheads.

In this paper, we propose a mechanism of user-defined operators with better expressiveness while keeping composability. Our user-defined operators, named protean operators, can express arbitrary Parsing Expression Grammar (PEG) syntax, and they can also express complex user-defined literals. A library of user-defined operators is composable - the library can use with any other libraries. We have developed ProteaJ, which is an extension of Java 1.4 supporting protean operators.

Although JavaScript is one of the major languages used for web and other general applications, it does not have a language-level module system. Lack of module system causes name conflicts when programmer uses libraries. We introduce a JavaScript module system with formal semantics. As an implementation, we also introduce a source-to-source transformation from JavaScript with module to JavaScript itself for current JavaScript engines to use them.