MODULARITY Companion 2016
15th International Conference on Modularity (MODULARITY Companion 2016)
Powered by
Conference Publishing Consulting

15th International Conference on Modularity (MODULARITY Companion 2016), March 14–17, 2016, Málaga, Spain

MODULARITY Companion 2016 – Proceedings

Contents - Abstracts - Authors

Frontmatter

Title Page

Message from the General Chair
On behalf of the Organizing Committee, it is our great pleasure to welcome you to the 15 th edition of the Modularity conference (Modularity 2016). This conference will take place at the School of Informatics of the University of Málaga, Spain, from the 14 th till the 17 th of March, 2016. Modularity 2016 is the premier forum for presenting the latest advances in software modularity, with an emphasis on improving the modularization of software artifacts that cut across traditional abstraction boundaries.
Messages from the PC Chairs
Messages from the Research Results Program Chair and from the Modularity Visions Program Chair
Modularity 2016 Organization
Committee listings
Message from the Chairs of the Workshop CROW 2016
CROW addresses all aspects of using constraints and functional reactive programming principles in conjunctions with objects and imperative languages. This is increasingly relevant to respond to challenges posed by, for example, the requirements for applications to work across different devices and form-factors, to provide best-effort computing in the face of unreliable devices and networks, and to more fully utilise HPC technology. However, many questions remain. For example, the interactions among constraints, reactive or event-based programming, and mainstream imperative and object-oriented languages are still not well-understood, and different implementation techniques to combine these paradigms are still being explored. The lack of large applications written with combinations of these paradigms means that there is little experience with patterns and tools for such applications, and modularity mechanisms required for such large applications are in their infancy or completely absent.
Message from the Chairs of the Workshop FOAL 2016
The Fifteenth Foundations of Aspect-Oriented Languages (FOAL) workshop was held at the Fifteenth International Conference on Modularity in Malaga, Spain, on March 15, 2016. This workshop was designed to be a forum for research in formal foundations of aspect-oriented and other advanced separation of concern mechanisms. The call for papers announced the areas of interest for FOAL as including: semantics of advanced separation of concern mechanisms, specification and verification for such mechanisms, type systems, static analysis, theory of testing, theory of composition, theory of translation (compilation) and rewriting, and comparison of different advanced modularization and separation of concern mechanisms. The call for papers welcomed all theoretical and foundational studies of foundations of aspect-oriented languages.
Message from the Chairs of the Workshop LaMOD 2016
Welcome to the Language Modularity À La Mode Workshop (LaMOD'16), Málaga, Spain, 15 March 2016, co-located with Modularity 2016. Nowadays, applications are often built from components written in a variety of languages, as well as a variety of versions of a particular language. However, _modularity_ is still considered mainly in the context of a single language and in the context of a single version of a language. The objective of this workshop is to divert the spotlight from standard mono-, intra-, or single versioned-language modularity, to a new form of multi (versioned)- or inter-language modularity, or simply put, _language modularity_. Language modularity may have very different targets: Support of embedded languages, e.g., SQL within Java, R within LaTeX; Interoperability of general-purpose languages within or without a common virtual machine, e.g., Java and Scala, OCaml and Java; Interoperability of variants of the same language in a managed way, e.g., statically- and dynamically-typed variants of the same language, e.g., ECMAScript and its strict mode, or provision for legacy code as in C#; Design of a family of compatible domain-specific languages (DSLs) or aspect languages (DSALs), e.g., language-oriented programming (LOP), language-oriented modularity (LOM); Modular definition of a language as a core language and extensions, e.g., Oz; Use of legacy language features along-side new ones, and how legacy systems can take advantage of new modularity mechanisms offered in new language versions, e.g., the ModuleSpec import system type (PEP 451) in Python 3, modular Java (Project Jigsaw, JEP 200). The workshop aims to bring together researchers interested in the various issues of language modularity with the objective of taking part in defining the underlying principles and tools that are necessary to strengthen the multilingual/multi-language versioned world of today.
Info
Message from the Chairs of the Workshop LASSY 2016
Welcome to the first edition of the LASSY workshop on Live Adaptation of Software Systems, taking place on March 14, 2016 in Malaga (Spain), collocated with the 15th International Conference on Modularity (Modularity 2016, formerly known as AOSD). The main objective of this workshop is to provide a space for discussion and collaboration of researchers working on the problem of live software adaptation from different research perspectives.
Message from the Chairs of the Workshop MASS 2016
Welcome to the Workshop on Modularity Across the System Stack (MASS’16), held in Málaga, Spain, on March the 14th 2016. This workshop, co-located with the 15th International Conference on Modularity (Modularity 2016), is aimed at bringing researchers together to explore the interaction between modularity and computer systems.
Message from the Chairs of the Workshop MOMO 2016
Welcome to the First International Modularity in Modelling Workshop (MOMO) at the 15th International Conference on Modularity (MODULARITY 2016). MOMO aims at bringing together researchers interested in the theoretical and practical challenges resulting from applying modularity, advanced separation of concerns and composition at the modelling level. It is intended to provide a forum for presenting new ideas and discussing the impact of the use of modularization in the context of MDE at different levels of abstraction.

Keynotes

Constraints and Modularity (Keynote)
Alan Borning
(University of Washington, USA)
A constraint is a declarative description of a relation that we want to have hold, for example, that a set of icons be equally spaced and positioned at the bottom of a window, or that a resistor in an electrical circuit simulation obey Ohm’s Law. A constraint can support modularity in programs by providing a succinct way to express some property, in a way that lets it be combined flexibly with other constraints. Historically there have been two principal views of constraints in programing languages: as equations to be solved, or as relations to be maintained in the face of change. In this talk I’ll concentrate on the second view and how such constraints can be used in building interactive systems. There is a long history of work in this area. A key early system was Ivan Sutherland’s Sketchpad from 1963 [5]; a less notable but still early system was my own ThingLab from 1979 [1]. In this talk I’ll describe a little of that history, including a demo of a revived version of ThingLab, using the original code from 1979 running in a web browser using an interpreter written in Javascript. I’ll then describe some recent work on constraints for interactive systems, including Babelsberg and Wallingford. Babelsberg [3, 4] is a family of object constraint languages that allows constraints to be integrated with an existing object-oriented language. In particular, Babelsberg enables the programmer to write constraints that include object-oriented constructs such as message sends and that respect object encapsulation, as well as explicit constraints on object identity. Finally, Wallingford [2] is a new constraint reactive programming language implemented in the Rosette solver-aided programming language [6, 7]. Wallingford adopts many of the approaches in Babelsberg to integrating constraints and object-oriented programming, and adds reactive constraints that enable the system to respond to events by declaring constraints that become active when an event occurs, or while a condition holds.
Publisher's Version Article Search
From Crosscutting Concerns to Feature Interactions: A Tale of Misunderstandings and Enlightenments (Keynote)
Sven Apel
(University of Passau, Germany)
Both crosscutting concerns and feature interactions are phenomena that may impair modularity. Crosscutting concerns have been in the center of interest in aspect-oriented software development. Much research in this direction—including my own—is aimed at developing mechanisms to avoid and manage code scattering and tangling, with a strong focus on source-code organization. Feature interactions have been studied even earlier. Research on feature interactions always emphasized behavioral aspects that arise when two features interact, regardless of the implementation. Both phenomena are related, but not as closely as one may think. In this talk, I will tell my personal story on how I started my research career with investigating crosscutting concerns and—after a long journey and many misunderstanding and enlightments—arrived at being interested in feature interactions. In some sense this journey is also a journey of a whole community that emerged from different research areas, and I will share my experience gathered from this journey and synthesize lessons learned. In particular, I will highlight the (historical) differences of research on crosscutting concerns and feature interactions. Furthermore, by means of recent experimental results, I will emphasize that there are different types of feature interactions and that these type are related (some to crosscutting concerns). I will close the talk with a call to action to accept and approach the New Feature Interaction Challenge, which is to understand and exploit the different types of feature interactions to build better software (e.g., to develop better tools for feature-interaction testing).
Publisher's Version Article Search
Simulating Cities: A Systems Design Perspective (Keynote)
Cristina V. Lopes
(University of California at Irvine, USA)
Population, environmental, and technological changes are reshaping the infrastructure of our urban environments, and will be a major focus of attention in the near future. Cities have always accommodated new technologies, such as the invention and widespread use of motorized vehicles, mass transportation, and recently, electric vehicles. Yet every new technology brings with it challenges in policy making. With the advent of alternative energy and and the Internet of Things, there is suddenly a plethora of new technologies that will require major restructuring of cities. Some examples are electric and autonomous vehicles, solar energy, unmanned aerial vehicles, and smart homes and buildings. In order to establish sound public policies, all these new technologies can greatly benefit from urban simulations, to measure their impact on the city and its people before the policies are defined.
Publisher's Version Article Search

Tool Demonstrations

Modular Modeling with a Computational Twist in MetaMod
Ana Maria Şutîi, Tom Verhoeff, and Mark van den Brand
(Eindhoven University of Technology, Netherlands)
Model-driven engineering (MDE) is a software development methodology that promises to alleviate the complex task of writing software. To achieve its goals, MDE makes use of models. Although models are concise representations of the knowledge in a domain, they can become large and complex. In dealing with complexity, modularity has proven to be a good ally for engineers in general software development. Inspired by this, we set to explore modularity for models. To this end, we incorporated two mechanisms: grouping and fragment abstractions. The second ingredient, in particular, gives rise to an interesting combination between modeling elements and computational elements. To test our ideas, we have implemented a prototype metamodeling language called MetaMod. To highlight MetaMod's essential features we have included a small example for train tracks.
Publisher's Version Article Search
Tool Support for Component-Based Semantics
L. Thomas van Binsbergen, Neil Sculthorpe, and Peter D. Mosses
(Royal Holloway University of London, UK; Swansea University, UK)
The developers of a programming language need to document its intended syntax and semantics, and to update the documentation when the language evolves. They use formal grammars to define context-free syntax, but usually give only an informal description of semantics. Use of formal semantics could greatly increase the consistency and completeness of language documentation, support rapid prototyping, and allow empirical validation. Modularity of semantics is essential for practicality when scaling up to definitions of larger languages. Component-based semantics takes modularity to the highest possible level. In this approach, the semantics of a language is defined by equations translating its constructs (compositionally) to combinations of so-called fundamental constructs, or `funcons'. The definition of each funcon is a small, highly reusable component. The PLanCompS project has defined a substantial library of funcons, and shown their reusability in several case studies. We have designed a meta-language called CBS for component-based semantics, and an IDE to support development, rapid prototyping, and validation of definitions in CBS. After introducing and motivating CBS, we demonstrate how the IDE can be used to browse and edit the CBS definition of a toy language, to generate a prototype implementation of the language, and to parse and run programs.
Publisher's Version Article Search Info
Development Environment for Literal Inter-Language Use Case Driven Modularization
Michal Bystrický and Valentino Vranić
(Slovak University of Technology in Bratislava, Slovakia)
Commonly, during programming the code related to use cases becomes scattered across different modules and at the same time the code related to different use cases becomes tangled. This way, it is hard to follow the intent, which is otherwise well comprehensible in use cases. In this paper, we demonstrate a development environment for literal inter-language use case driven modularization. The environment enables to preserve use cases and their steps and have each use case text and related code focused in one file. For this, code instrumentation at three levels is involved: continuous processing, preprocessing, and execution. The approach itself requires also execution control provided by a dedicated framework. Many aspects of the program can be controlled directly from the use case text. At the same time, it is comprehensible to a wide range of stakeholders. A layered 3D layout of the use case dependencies is provided in the environment (https://bitbucket.org/bystricky/literal-use-cases, https://www.youtube.com/watch?v=R4ArqH4ZdgI).
Publisher's Version Article Search Video
Dynamic Software Evolution through Interpreter Adaptation
Walter Cazzola and Albert Shaqiri
(University of Milan, Italy)
Significant research has been dedicated to dynamic software evolution and adaptation that lead to different approaches which can mainly be categorized as either architecture-based or language-based. But there was little or no focus on dynamic evolution achieved through language interpreter adaptation. In this paper we present a model for such adaptations and illustrate their applicability and usefulness on practical examples developed in Neverlang, a framework for modular language development with features for dynamic adaptation of language interpreters.
Publisher's Version Article Search

Student Research Competition

Selective Process Instrumentation in Virtual Machine
Ivan Vasilev
(NovSU, Russia)
System instrumentation is widely used in different analyze tools, but they are usually hard to maintain and rather slow. To solve this problems we present our approach to instrumentation with multi-leveled plugins and instrumentation of individual processes.
Publisher's Version Article Search
Language Oriented Modularity: From Theory to Practice
Arik Hadas
(Open University of Israel, Israel)
Language Oriented Modularity (LOM) is a methodology that is based on Language Oriented Programming (LOP) and applied to Domain-Specific Aspect Languages (DSALs) rather than Domain-Specific Languages (DSLs). Like LOP, which involves the development and use of DSLs on-demand during the software development process, LOM involves the development and use of DSALs on-demand during the software modularization process. However, LOM is underutilized and often not used at all in modern projects. The goal of this research is to improve the applicability and suitability of LOM for resolving crosscutting concerns in real world projects.
Publisher's Version Article Search
The Modularity of Object Propositions
Ligia Nistor
(Carnegie Mellon University, USA)
A significant concern in verification research is the ability to reason modularly about programs with state. Recent work has used substructural logics including separation logic , permissions, and Hoare Type Theory to specify each function in terms of its effect on its footprint. The motivation of our work is the need for formal specifications that allow one to hide shared data between two abstractions. In 2014, we proposed object propositions as an automatable extension to abstract predicates. We allow state to be shared between two objects, by providing fractional permissions to access the common data hidden in a predicate, without revealing this sharing in the objects' specifications. Unlike conventional object invariant and ownership-based work, our system allows ownership transfer by passing unique permissions (permissions with a fraction of 1) from one reference to another. Unlike separation logic and permission systems, we can modify objects without owning them. This has information-hiding and system-structuring benefits.
Publisher's Version Article Search

Workshop on Constrained and Reactive Objects (CROW 2016)

Reactive Object Queries: Consistent Views in Object-Oriented Languages
Stefan Lehmann, Tim Felgentreff, Jens Lincke, Patrick Rein, and Robert Hirschfeld
(HPI, Germany)
Maintaining consistency between data throughout a system using scattered, imperative code fragments is challenging. Some mechanisms address this challenge by making data dependencies explicit. Among these mechanisms are reactive collections, which define data dependencies for collections of objects, and object queries, which allow developers to query their program for a subset of objects. However, on their own, both of these mechanisms are limited. Reactive collections require an initial collection to apply reactive operations to and object queries do not update its result as the system changes. Using these two mechanisms in conjunction allows each to mitigate the disadvantage of the other. To do so, object queries need to respond to state changes of the system. In this paper, we propose a combination of both mechanisms, called reactive object queries. Reactive object queries allow the developer to declaratively select all objects in a program that match a particular predicate, creating a view. Additionally, views can be composed of other views using reactive operations. All views are automatically updated when the program state changes. To better integrate with existing imperative systems, we provide fine-grained events signaling view updates. We implemented the proposed concepts in JavaScript. Our initial experience with example applications shows that the combined concept eases the integration of reactive mechanisms with object-oriented environments by avoiding scattered update code.
Publisher's Version Article Search Info
Reactive Programming with Reactive Variables
Christopher Schuster and Cormac Flanagan
(University of California at Santa Cruz, USA)
Reactive Programming enables declarative definitions of time-varying values (signals) and their dependencies in a way that changes are automatically propagated. In order to use reactive programming in an imperative object-oriented language, signals are usually modelled as objects. However, computations on primitive values then have to lifted to signals which usually involves a verbose notation. Moreover, it is important to avoid cycles in the dependency graph and glitches, both of which can result from changes to mutable global state during change propagation. This paper introduces reactive variables as extension to imperative languages. Changes to reactive variables are automatically propagated to other reactive variables but, in contrast to signals, reactive variables cannot be reified and used as values. Instead, references to reactive variables always denote their latest values. This enables computation without explicit lifting and limits the dependents of a reactive variable to the lexical scope of its declaration. The dependency graph is therefore topologically ordered and acyclic. Additionally, reactive updates are prevented from mutating global state to ensure consistency. We present a working prototype implementation in JavaScript based on the sweet.js macro system and a formalism for integration with general imperative languages.
Publisher's Version Article Search
Toward a New Constraint Imperative Programming Language for Interactive Graphics
Hiroshi Hosobe
(Hosei University, Japan)
To construct interactive graphics such as graphical user interfaces and interactive webpages is an important matter in computer programming. For this purpose, imperative programming usually has been used. On the other hand, researchers have been attempting to apply constraint programming to interactive graphics. Furthermore, the paradigm of constraint imperative programming has been proposed. This position paper reports our ongoing work on P5CP, a new constraint imperative programming language for interactive graphics. To integrate imperative and constraint programming, we adopt the notion of events in imperative programming and the notion of guards in concurrent constraint programming. We show a simple example program in this language.
Publisher's Version Article Search
Emfrp: A Functional Reactive Programming Language for Small-Scale Embedded Systems
Kensuke Sawada and Takuo Watanabe
(Tokyo Institute of Technology, Japan)
In this paper, we introduce a new functional reactive programming (FRP) language Emfrp designed to support small-scale embedded systems. An Emfrp program defines a system as a fixed directed graph whose nodes correspond to the time-varying values in the system. The language equips a simple mechanism that enables each node to refer the past values of arbitrary nodes. Using this mechanism, Emfrp provides simplicity and flexibility for describing complex time-dependent reactive behaviors without space and time leaks. Our Emfrp compiler produces platform-independent ANSI-C code that can run on multiple processors including resource constrained microcontrollers. To demonstrate the capabilities of the language, we show a simple but non-trivial example application.
Publisher's Version Article Search
Wallingford: Toward a Constraint Reactive Programming Language
Alan Borning
(University of Washington, USA)
Wallingford is an experimental constraint reactive programming language that supports objects with state, persistent constraints on those objects, and reactive constraints that enable the system to respond to events by declaring constraints that become active when an event occurs, or while a condition holds. It is implemented in Rosette, a solver-aided programming language and environment for constructing DSLs in turn implemented in Racket. This short paper is a snapshot of work-in-progress on the system.
Publisher's Version Article Search
A Library-Based Approach to Context-Dependent Computation with Reactive Values: Suppressing Reactions of Context-Dependent Functions using Dynamic Binding
Hiroaki Inoue and Atsushi Igarashi
(Kyoto University, Japan)
Language constructs for programming context-dependent computation are required in recent software development, where context information influences program behavior, whose description is often scattered around several modules as conditional expressions. The Context-Oriented Programming (COP) community has revealed that context-dependent computations should be modularized into partially defined methods, those partial methods should be adaptable at run-time, and a method dispatching mechanism should take context information into account. Such language constructs enhance modularity of a program. Although contexts are usually reactively changeable, many existing COP approaches do not consider the relation between contexts and reactive information. In this paper, we develop a Scala library for context-dependent computations, based on the idea of contexts as reactive values, which are well studied in the field of Functional Reactive Programming. We also show that dynamic binding is useful to control how reactive values influence context dependent functions; it provides context caching to prevent unexpected reactions.
Publisher's Version Article Search
Enabling Modular Persistence for Reactive Data Models in F# Client-Server Web Applications
Loïc Denuzière and Adam Granicz
(IntelliFactory, Hungary)

Functional languages have been used with great success in the domain of web programming. The use of reactive programming approaches to deal with time-varying data reduces the need for callbacks, and allows web applications to be written in a more declarative style.

In spite of advances in functional reactive web programming, various issues remain with integrating reactive data into web pages. Portions of presentation-layer code are typically written in the functional language and imperatively added to a container section on a page, fragmenting design and requiring developers to work around the lack of proper and safe integration between the data, client and server tiers of their applications.

In this paper, we investigate the use of F# compile-time metaprogramming techniques to enable developing type-safe, reactive client-server applications with seamless server-side persistence using WebSharper, a mature F# web framework. Next to the two-way binding between client-side data models and their corresponding presentation, the reactive data models in our work can also express the details of server-side persistence and synchronization, using a modular approach and a strongly-typed communication channel over web sockets with communicating agents between the two tiers.

The work presented also enables using annotated HTML markup templates, translated by an F# type provider to our statically-typed reactive data models. This way, the design artifacts can be externalized into native HTML that designers can easily work with, and markup changes are checked against the F# code base at compile time.

We demonstrate the combination of these techniques with a data-aware single-page client-server chat application, expressed entirely in F#. We find that type safety, the uniform F# programming model, and the reactive design around data binding, synchronization, and persistence greatly enhances developer productivity.


Publisher's Version Article Search
Automatically Selecting and Optimizing Constraint Solver Procedures for Object-Constraint Languages
Tim Felgentreff, Stefan Lehmann, Robert Hirschfeld, Sebastian Gerstenberg, Jakob Reschke, Lars Rückert, Patrick Siegler, Jan Graichen, Christian Nicolai, and Malte Swart
(HPI, Germany)
Object-constraint programming provides a design to integrate constraints with dynamic, object-oriented programming languages. It allows developers to encode multi-way constraints over objects and object collections using existing, object-oriented abstractions. These constraints are automatically maintained at run-time. One original goal of the Babelsberg-family of object-constraint programming languages was to allow users familiar with the imperative paradigm to quickly and efficiently make use of constraint solver capabilities. Yet, practical problems often require careful selection of solvers to find good solutions (or any at all). Furthermore, solver performance can vary and while most solvers come with various optimizations, developers have to have a good understanding of the solving process to use these optimizations effectively. This, however, is difficult to achieve if the solver is automatically selected by the system. In this work, we discuss three different implementations for automatic solver selection that we used in Babelsberg implementations. As a second step, we look at the performance potential of edit constraints that are available in some solvers such as Cassowary or DeltaBlue, and how they can be applied automatically to improve solver performance. We argue that these techniques make object-constraint programming more practical by improving the quality and performance of solutions.
Publisher's Version Article Search

Workshop on Foundations Of Aspect-Oriented Languages (FOAL 2016)

An Advice Mechanism for Non-local Flow Control
Hidehiko Masuhara, Kenta Fujita, and Tomoyuki Aotani
(Tokyo Institute of Technology, Japan)
We propose an advice mechanism called Chop&Graft for non-local flow control. It offers a novel chop pointcut that lets a piece of advice terminate the current execution, and graft and retry operators that resume and restart the terminated executions. By using pointcuts for specifying the region of termination, the mechanism is more robust and more concise than the traditional exception handling mechanisms that rely on names or exception classes. The paper presents the design of the mechanism along with the sketches of two implementations using delimited continuations or threads and exceptions.
Publisher's Version Article Search
Using Continuations and Aspects to Tame Asynchronous Programming on the Web
Paul Leger and Hiroaki Fukuda
(Universidad Católica del Norte, Chile; Shibaura Institute of Technology, Japan)
In asynchronous programming of JavaScript, callbacks are widely used to develop rich interactive Web applications. However, the dependency among callbacks can make it difficult to understand and maintain pieces of code, which will mix concerns eventually. Unfortunately, current solutions for JavaScript do not fully address the aforementioned issue. This paper presents Sync/cc, a JavaScript library that uses continuations and aspects to allow developers to write asynchronous pieces of code in a synchronous style, preventing callback dependencies. Unlike current solutions, Sync/cc is modular, customizable, and succinct because it does not require special and scattered keywords, code refactoring, or adding ad-hoc implementations like state machines. In practice, Sync/cc uses a) continuations to only suspend the current handler execution until the asynchronous operation is resolved, and b) aspects to apply continuations in a non-intrusive way.
Publisher's Version Article Search
Toward Disposable Domain-Specific Aspect Languages
Arik Hadas and David H. Lorenz
(Open University of Israel, Israel; Technion, Israel)
Consider the task of auditing an application whose main functionality is to execute commands received from clients. One could audit command executions with AspectJ. Alternatively, one could design, implement, and use a domain-specific aspect language for auditing, and then throw the language away. In this paper we argue that such disposable aspect languages are useful and that developing them may overall be as cost-effective as using general-purpose aspect languages.
Publisher's Version Article Search

Language Modularity À La Mode (LaMOD 2016)

A Lightweight Optimization Technique for Data Types à la Carte
Hirotada Kiriyama, Tomoyuki Aotani, and Hidehiko Masuhara
(Tokyo Institute of Technology, Japan)
Data types à la carte (DTC) is a technique for adding new variants to data types modularly. A drawback of DTC compared with simple variant types, which are commonly used to define data types in functional programming languages, is runtime inefficiency caused by the destruction of these values. In this paper, we propose a lightweight optimization technique for functions that destruct the values of DTC data types. It makes their execution as efficient as their non-DTC counterparts by just (1) deriving non-extensible algebraic data types isomorphic to ex- tensible data types defined in DTC fashion and (2) using them within the type annotations that specify concrete data types using the composition operator given in DTC. The approach is based on an insight on the functions: the functions never depend on any con- crete data types but merely constrain them. We implemented functions that take an extensible data type defined in DTC fashion and derive an isomorphic non-extensible algebraic data type using Template Haskell. Our experimental re- sults show that DTC functions using our approach run as efficiently as their non-DTC counterparts and avoid performance slow down even if the data types are extended multiple times.
Publisher's Version Article Search
Multi-level Debugging for Interpreter Developers
Bastian Kruck, Stefan Lehmann, Christoph Keßler, Jakob Reschke, Tim Felgentreff, Jens Lincke, and Robert Hirschfeld
(HPI, Germany)
Conventional debuggers require programmers to work on multiple levels of abstraction at once when inspecting call stacks or data. This demands considerable cognitive overhead and deep system knowledge of all implementation technologies involved. When developing an interpreter, programmers often create a dedicated debugger to have a higher-level perspective on the client-language; the resulting use of multiple debuggers at once leads to mental context switches and needs an elaborated method. We present an integrated debugging tool in which interpreter developers define and select the levels of abstraction on which they focus. Our debugger provides them with an abstraction-specialized view. We consider both host-language and guest-language levels, since either may be levels of interest in a debugging session. We show how this separation into host-language levels can ease the debugging of applications through filtering call stacks and specializing call stack representation on levels.
Publisher's Version Article Search Info
Toward Practical Language Oriented Modularity
Arik Hadas and David H. Lorenz
(Open University of Israel, Israel; Technion, Israel)
Language oriented modularity (LOM) implies the use of multiple domain specific aspect languages (DSALs) simultaneously. The complexity of implementing these DSALs has significant implications on the practicality of LOM. In this paper we describe a transformation-based approach to DSAL implementation that reduces the overall cost of implementing the weaving semantics and thus improves the practicality of LOM.
Publisher's Version Article Search
Literal Inter-Language Use Case Driven Modularization
Michal Bystrický and Valentino Vranić
(Slovak University of Technology in Bratislava, Slovakia)
Use cases are a practically proven choice to concisely and precisely express what highly interactive systems do. Several attempts have been made to modularize code according to use cases. None of these approaches is able to gather all the code related to a use case in one module and to reflect its steps. However, to allow for code to be modularized according to use case flows and their steps, an instrumentation environment is necessary. In this paper, literal multi-language use case coding based on defragmentation is proposed. The approach aims at fully preserving use case flows in as comprehensible form as possible. The steps of use case flows appear directly in the code as comments. Despite being comments, the steps are active, which is achieved by a dedicated preprocessor and framework. The detailed step implementation gathers all the code fragments of each step each of which may be in a different programming language.
Publisher's Version Article Search
Towards Improving Interface Modularity in Legacy Java Software through Automated Refactoring
Raffi Khatchadourian, Olivia Moore, and Hidehiko Masuhara
(City University of New York, USA; Tokyo Institute of Technology, Japan)
The skeletal implementation pattern is a software design pattern consisting of defining an abstract class that provides a partial interface implementation. However, since Java allows only single class inheritance, if implementers decide to extend a skeletal implementation, they will not be allowed to extend any other class. Also, discovering the skeletal implementation may require a global analysis. Java 8 enhanced interfaces alleviate these problems by allowing interfaces to contain (default) method implementations, which implementers inherit. Java classes are then free to extend a different class, and a separate abstract class is no longer needed; developers considering implementing an interface need only examine the interface itself. We argue that both these benefits improve software modularity, and discuss our ongoing work in developing an automated refactoring tool that would assist developers in taking advantage of the enhanced interface feature for their legacy Java software.
Publisher's Version Article Search Video Info

Workshop on Live Adaptation of Software Systems (LASSY 2016)

Adaptation Scoping

Hierarchical Layer-Based Class Extensions in Squeak/Smalltalk
Matthias Springer, Hidehiko Masuhara, and Robert Hirschfeld
(Tokyo Institute of Technology, Japan; HPI, Germany)
Class extensions are frequently used in programming languages such as Ruby and Smalltalk to add or change methods of a class that is defined in the same application or in a different one. They suffer from modularity issues if globally visible: Other applications using the same classes are then affected by the modifications. This paper presents a hierarchical approach for dynamically scoping class extensions in dynamically-typed, class-based programming languages supporting class nesting. Our mechanism allows programmers to define the scope of class extensions and to reuse class extensions in other programs. Class extensions can be scoped according to a nested class hierarchy or based on whether programmers regard a potentially affected class as a black box or not. Class extensions are organized in layers, where multiple layers targeting the same class can be active at the same time.
Publisher's Version Article Search
Compatibility Layers for Interface Mediation at Run-Time
Patrick Rein, Robert Hirschfeld, Stefan Lehmann, and Jens Lincke
(HPI, Germany)
In adaptable systems, one module might require an interface from another module which the second module does not provide. For some cases, the particular provider module and its interface which will be available at run-time can not be anticipated during development time. In such situations with various provider interfaces, current mitigation strategies for interface mismatches struggle as they often rely on advanced knowledge about one particular providing module. Therefore, we propose the concept of compatibility layers which is based on modular interface mappings. These mappings are applied to adapt the provided interface at run-time. Each mapping contains a set of general requirements for the provided interface and a set of derived functions based on the required features. We have implemented the concept of compatibility layers in a Squeak/Smalltalk prototype based on context-oriented programming. Based on this prototype, we discuss the resulting trade-offs and illustrate exemplary interface mismatches in Squeak/Smalltalk which could be mediated by the prototype.
Publisher's Version Article Search

Software Processes

A Taxonomy of Context-Aware Software Variability Approaches
Kim Mens, Rafael Capilla, Nicolás Cardozo, and Bruno Dumas
(Université Catholique de Louvain, Belgium; Rey Juan Carlos University, Spain; Trinity College Dublin, Ireland; University of Namur, Belgium)
Modern software systems demand more and more smart capabilities depending on their context of use, as well as the ability to dynamically adapt these capabilities according to sensed context changes. This requires appropriate techniques for modelling, representing and handling context-aware software variability. While traditional variability modelling approaches like feature orientation and software product lines are evolving to address the increased dynamicity and context specificity required for this new generation of software systems, new paradigms such as context-oriented programming have emerged. Although developed independently, since they address similar issues, many similarities exist between these approaches. The purpose of this paper is to define, categorise and compare key concepts shared by these approaches. Such a taxonomy is a first step towards a better understanding of the differences and similarities between different approaches for managing context-aware software variability, and to achieve a cross-fertilisation between them.
Publisher's Version Article Search
A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems
Harumi Watanabe, Ikuta Tanigawa, Midori Sugaya, Nobuhiko Ogura, and Kenji Hisazumi
(Tokai University, Japan; Kyushu University, Japan; Shibaura Institute of Technology, Japan; Tokyo City University, Japan)
The paper introduces new kinds of diagrams for describing organizations and interactions of layers based on context-oriented technology for context-sensitive embedded system developments. The concept of layers is suitable for processing context-aware embedded systems. As mentioned in several related literatures, layer-interactions cause critical problems such as deadlock, collision, and multi-invocation. To comprehend these problems at a high level, diagrams for visualizing relationships among layers are required. In a previous work, we proposed an OS-like architecture based on context-oriented technologies for embedded system development. The layering mechanism of the architecture dispatches or inserts layers with their states for dealing with layer-interaction problems. The goal of this paper is to introduce diagrams that contain notations for relating with the elements of the layering mechanism. To accomplish this, we consider the following issues: (1) the relations between layers, (2) layer-state management, and (3) context management attributes. The diagrams contribute to understanding layer-interaction problems with time delay and mutually exclusive layers. To explain the diagrams, we provide a simple example of an automatic cleaner robot.
Publisher's Version Article Search
Towards the Dynamic Reconfiguration of Quality Attributes
Jose-Miguel Horcas, Mónica Pinto, and Lidia Fuentes
(University of Málaga, Spain)
There are some Quality Attributes (QAs) whose variability is addressed through functional variability in the software architecture. Separately modelling the variability of these QAs from the variability of the base functionality of the application has many advantages (e.g., a better reusability), and facilitates the reconfiguration of the QA variants at runtime. Many factors may vary the QA functionality: variations in the user preferences and usage needs; variations in the non-functional QAs; variations in resources, hardware, or even in the functionality of the base application, that directly affect the product's QAs. In this paper, we aim to elicit the relationships and dependencies between the functionalities required to satisfy the QAs and all those factors that can provoke a reconfiguration of the software architecture at runtime. We follow an approach in which the variability of the QAs is modelled separately from the base application functionality, and propose a dynamic approach to reconfigure the software architecture based on those reconfiguration criteria.
Publisher's Version Article Search

Alternative Adaptation Models

A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems
Nguonly Taing, Thomas Springer, Nicolás Cardozo, and Alexander Schill
(TU Dresden, Germany; Trinity College Dublin, Ireland)
Role-based approaches gain more and more interest for modeling and implementing variable software systems. Role models clearly separate static behavior represented by players and dynamic behavior modeled as roles which can be dynamically bound and unbound to players at run time. To support the execution of role-based systems, a dynamic binding mechanism is required. Especially, since instances of the same player type can play different roles in a single context, the binding mechanism is required to operate at instance level. In this paper, we introduce a mechanism called dynamic instance binding for implementing a runtime for role-based systems. It maintains a look-up table that allows the run-time system to determine and invoke the currently active role binding at instance level. We explain dynamic instance binding mechanism in detail and demonstrate that it is flexible enough to support both adaptation and evolution of software systems at run time.
Publisher's Version Article Search
Model for Fusion of Software Components
Juan-Alberto Hernández-Martínez and Ulises Juárez-Martínez
(Instituto Tecnológico de Orizaba, Mexico)
Current applications, especially those that cannot stop their execution, such as banking systems, airport management, and critical mission environments, among others, require of suitable mechanisms to respond immediately and automatically to constant changes of the execution environment and user requirements. In response to such issues, self-adaptation and dynamic evolution of the software allow to perform the necessary adjustments dynamically, minimizing human intervention. However, although these approaches resolve much of the problem, most of the solutions applied consist of adding functionality causing that the resulting applications to be large and/or with unnecessary or irrelevant elements. In order to strengthen the adaptation and evolution of software, the establishment of mechanisms supported in the principles of knowledge areas with greater maturity such as biology, chemistry, among others, results in an attractive alternative. In this sense, current paper proposes a new approach for adapting and creating software components at run-time based on a simplified chemical model for creating molecules. The main idea behind this approach is that every atom corresponds to a software component and every molecule correspond to a new adaptation or creation of a software component whose structure, functionality and behavior could be formed both of its own characteristics or execution environment.
Publisher's Version Article Search

Workshop on Modularity Across the System Stack (MASS 2016)

Modular Real-Time Systems

Towards Availability and Real-Time Guarantees for Protected Module Architectures
Jo Van Bulck, Job Noorman, Jan Tobias Mühlberg, and Frank Piessens
(KU Leuven, Belgium)
Protected Module Architectures are a new brand of security architectures whose main objective is to support the secure isolated execution of software modules with a minimal Trusted Computing Base (TCB) -- several prototypes for embedded systems (and also the Intel Software Guard eXtensions for higher-end systems) ensure isolation with a hardware-only TCB. However, while these architectures offer strong confidentiality and integrity guarantees for software modules, they offer no availability (let alone real-time) guarantees. This paper reports on our work-in-progress towards extending a protected module architecture for small microprocessors with availability and real-time guarantees. Our objective is to maintain the existing security guarantees with a hardware-only TCB, but to also guarantee availability (and even real-time properties) if one can also trust the scheduler. The scheduler, as any software on the platform, remains untrusted for confidentiality and integrity -- but it is sufficient to trust the scheduler module to get availability guarantees even on a partially compromised platform.
Publisher's Version Article Search

Systems and Contexts

Improving System Integration using a Modular Configuration Specification Language
Markus Raab
(Vienna University of Technology, Austria)
In today's systems we often plug together configurable standard components in a modular way. Most software, however, does not specify its configuration in a way suitable for other software. The aim of our configuration specification language SpecElektra is to fill this gap. It allows us to externally specify the configuration items of non-standardized configuration files. In SpecElektra we assign properties that enable additional validations and transformations. As a result, we can safely and easily configure software at run-time. The approach integrates standard software while retaining its modularity. We demonstrate how high-level configuration items help us to cope with changes in system-oriented goals.
Publisher's Version Article Search
Toward Fluent Module Interactions
Tetsuo Kamina, Tomoyuki Aotani, and Hidehiko Masuhara
(Ritsumeikan University, Japan; Tokyo Institute of Technology, Japan)
Recent progress on sensor technologies poses challenges on software development such as more interaction with physical environment and context-awareness. This trend makes it difficult to decide the boundaries between changing module interactions. In this paper, we propose a concept of fluent module interactions where we characterize the module interactions in three dimensions, i.e., definition, duration, and scope. Module interactions in any of those dimensions can change dynamically. We also propose a possible extension of existing programming language with fluent module interactions based on context-oriented programming (COP). Then, we derive a future research roadmap for realizing fluent module interactions that covers a wide range of research fields including theory, implementation, engineering, and applications.
Publisher's Version Article Search

Reflection

Static Meta-Object Protocols: Towards Efficient Reflective Object-Oriented Languages
Tony Clark
(Sheffield Hallam University, UK)
Reflection and extensibility in object-oriented programming languages can be supported by meta-object protocols (MOP) that define class-based interfaces over data representation and execution features. MOPs are typically dynamic in the sense that type-based dispatching is used to select between feature implementations at run time leading to a significant difference in execution speed compared to non-MOP-based languages. Defining a corresponding static-MOP would seem to be a solution whereby type-dispatching can occur at compile time. Such an approach requires the integration of a static type system with a MOP. This paper introduces a new reflective and extensible language called JMF written in Java that aims to generate efficient code through the use of a static-MOP. The contribution of this paper is to characterise a static-MOP and to show how it integrates with a type system for JMF.
Publisher's Version Article Search
A Design of Deep Reification
Shigeru Chiba, YungYu Zhuang, and Maximilian Scherr
(University of Tokyo, Japan)
This short paper presents our design of deep reification, which is a reflection mechanism for computation offloading. As heterogeneous computing is getting popular, several systems have been proposed and implemented for offloading a part of Java program to an external processor such as GPU. Deep reification provides the common functionality among those systems so that it will help their development. It dynamically extracts abstract syntax trees of offloaded methods as well as offloaded objects and class definitions. These methods, objects, and classes are deeply copied to be sent to an external processor. Deep reification also allows user programmers to annotate offloaded code to give optimization hints to the offloading system built with deep reification.
Publisher's Version Article Search
Towards Projection: Mapping Reflection onto the Userland
Nick Papoulias and Serge Stinckwich
(UMMISCO, France; UPMC, France)
Allowing end-users to extend and adapt applications can speedup software evolution and serve as a pedagogical tool for programming. Alas even open-ended architectures (like the Emacs architecture) presuppose a significant familiarity with programming languages and tools for end-users. General visual programming (as in the case of blocks) offers a more gentle alternative but still introduces additional tools and cognitive abstractions for prospective developers. We propose a possible third alternative: the direct mapping of reflective and meta-programming facilities onto base-level notions and interfaces through an additional self representation model, the projection layer. Our main hypothesis is that for certain types of applications used by non programmers (like for e.g., simulation software) this projection to the base-level has the potential to open a more gradual learning path for programming extensions, by using the same UI and abstractions that the end-user is already familiar with. This position paper analyses our approach and describes our on-going efforts to support or refute our hypothesis through a case-study on software for crisis assessment.
Publisher's Version Article Search

Systems and Aspects

Green Software using Aspect Orientation for Cyber-Physical-Systems
Nadia Gámez and Lidia Fuentes
(University of Málaga, Spain)
Green Computing emphasizes the need for reducing the environ-mental impact of systems by reducing their energy waste. Nowa-days IT systems as Cyber-Physical-Systems (CPS) are composed by many physical entities interconnected and working together. Therefore, saving energy in these systems implies to be aware of the energy in all the software modules that compose the system running in every device. Since all modules could collaborate in making a software system more energy efficient, these green-ness attributes may have a crosscutting nature. Aspect-Oriented tech-niques could be applied specifically for energy saving in this kind of systems with specific requirements. We discuss the characteris-tics that a framework to allow injecting green aspects to CPS both at design and at runtime would have to provide.
Publisher's Version Article Search
Application-Specific Language-Oriented Modularity: A Case Study of the oVirt Project
Arik Hadas and David H. Lorenz
(Open University of Israel, Israel; Technion, Israel)
Despite the availability of general purpose aspect languages (GPALs) and the availability of frameworks for creating domain specific aspect languages (DSALs), tangled and scattered code still prevails in modern software projects. Through the prism of a case study of the oVirt open source project we examine the conjecture that it may simply be too costly to implement crosscutting concerns in today's GPALs and DSALs. We introduce a subcategory of DSALs, called application specific aspect languages (ASALs), that along with a programming methodology, called language oriented modularity (LOM), allows such concerns to be modularized in a cost-effective, practical way. We illustrate this process concretely for the oVirt project.
Publisher's Version Article Search

Workshop on Modularity in Modelling (MOMO 2016)

On the Modularization Provided by Concern-Oriented Reuse
Matthias Schöttle, Omar Alam, Jörg Kienzle, and Gunter Mussbacher
(McGill University, Canada)
Reuse is essential in modern software engineering, and hence also in the context of model-driven engineering (MDE). Concern-Oriented Reuse (CORE) proposes a new way of structuring model-driven software development where models of the system are modularized by domains of abstraction within units of reuse called concerns. Within a concern, models are further decomposed and modularized by views and features. High-level concerns can reuse lower-level concerns, and models within a concern can extend other models belonging to the same concern, resulting in complex inter- and intra-concern dependencies. To clearly specify what dependencies are allowed between models belonging to the same or to different concerns, CORE advocates a three-part interface to describe each concern (variation, customization, and usage interfaces). This paper presents the CORE metamodel that formalizes the CORE concepts and enables the integration of different mod- elling languages within the CORE framework.
Publisher's Version Article Search Info
Towards Generic Modularization Transformations
Martin Fleck, Javier Troya, and Manuel Wimmer
(Vienna University of Technology, Austria; University of Seville, Spain)
Modularization concepts have been introduced in several modeling languages in order to tackle the problem that real-world models quickly become large monolithic artifacts. Having these concepts at hand allows for structuring models during modeling activities. However, legacy models often lack a proper structure, and thus, still remain monolithic artifacts. In order to tackle this problem, we present in this paper a modularization transformation which can be reused for several modeling languages by binding their concrete concepts to the generic ones offered by the modularization transformation. This binding is enough to reuse different modularization strategies provided by search-based model transformations. We demonstrate the applicability of the modularization approach for Ecore models.
Publisher's Version Article Search
Separation of Concerns in Epidemiological Modelling
Thi Mai Anh Bui, Mikal Ziane, Serge Stinckwich, Tuong Vinh Ho, Benjamin Roche, and Nick Papoulias
(Vietnam National University, Vietnam; UMMISCO, France; UPMC, France; Paris Descartes University, France; LIP6, France)
Modeling and simulation have been heavily used in epidemiology, for instance to study the transmission of infectious diseases, their pathogenicity and their propagation. A major hindrance to modeling in epidemiology is the mixing of concerns that ought to be separated. The most obvious one is the computer implementation that should not be mixed with domain aspects. But several domain concerns should also be separated from the core epidemiological ones. These include the distribution of the studied populations into spatial regions, age intervals, sexes, species, viral strains... We propose an approach that relies on a mathematical model of the dynamics of a compartment-based population. The separation of domain concerns is provided by expressing each one as a stochastic automaton and combining them with a tensor sum. A DSL, Kendrick, and a tool, support this approach that has been validated on several case studies.
Publisher's Version Article Search
Towards Contractual Interfaces for Reusable Functional Quality Attribute Operationalisations
Jose-Miguel Horcas, Mónica Pinto, Lidia Fuentes, and Steffen Zschaler
(University of Málaga, Spain; King's College London, UK)
The quality of a software system can be measured by the extent to which it possesses a desired combination of quality attributes (QAs). While some QAs are achieved implicitly through the interaction of various functional components of the system, others (e.g., security) can be encapsulated in dedicated software components. These QAs are known as functional quality attributes (FQAs). As applications may require different FQAs, and each FQA can be composed of many concerns (e.g., access control and authentication), integrating FQAs is very complex and requires dedicated expertise. Software architects are required to manually define FQA components, identify appropriate points in their architecture where to weave them, and verify that the composition of these FQA components with the other components is correct. This is a complex and error prone process. In our previous work we defined reusable FQAs by encapsulating them as aspectual architecture models that can be woven into a base architecture. So far, the joinpoints for weaving had to be identified manually. This made it difficult for software architects to verify that they have woven all the necessary FQAs into all the right places. In this paper, we address this problem by introducing a notion of contract for FQAs so that the correct application of an FQA (or one of its concerns) can be checked or, alternatively, appropriate binding points can be identified and proposed to the software architect automatically.
Publisher's Version Article Search
Addressing Modularity for Heterogeneous Multi-model Systems using Model Federation
Fahad R. Golra, Antoine Beugnard, Fabien Dagnat, Sylvain Guerin, and Christophe Guychard
(IRISA, France; Telecom Bretagne, France; Institut Mines-Telecom, France; Openflexo, France)
Model-Driven Engineering (MDE) proposes to modularize complex software-intensive systems using multiple models where each module serves a specific concern. These concerns of a system might be diverse and the use of multiple heterogeneous models often becomes inevitable. These models adhere to different paradigms and use distinct formalisms, which makes it hard to ensure consistency among them. Moreover, these models might contain certain concepts (at times overlapping) that are reused for building cross-concern views/models. Maintaining models using separation of concerns in a heterogeneous modeling space becomes difficult. Traditional MDE suggests the use of model transformations to maintain the mappings between heterogeneous models. In this paper, we introduce a different approach based on model federation to map heterogeneous models. In contrast to traditional approaches where heterogeneous models are gathered in a single technological space, model federation keeps them in their own technological spaces. We provide a mechanism so that elements of these models are accessible for the development of cross-concern views/models from their respective technological spaces.
Publisher's Version Article Search
Modular Multilevel Metamodeling with MetaMod
Ana Maria Şutîi, Tom Verhoeff, and Mark van den Brand
(Eindhoven University of Technology, Netherlands)
The increase of software driven functionalities in products leads to more complex software. Helping with the construction of this complex software, models in model-driven engineering have become larger and more complex. As a consequence, the models are harder to understand and the need to reuse models is augmented. Given these two goals: increasing understandability and reuse of models, and inspired by modular programming in the realm of general software development and its role in fulfilling these goals (among others), we set to explore modularity mechanisms for models. Although work has been done to address the issue of modularity in models, there is no commonly agreed method for doing it. Ours is an attempt to discover the basic modularity elements for models. We have done this in the context of a simple multilevel metamodeling language that we designed, MetaMod, where we introduced a few modularity mechanisms: groups, fragment abstractions and applications. To test the feasibility of our ideas, we created a prototype of this language and a few exploratory examples in the language.
Publisher's Version Article Search

proc time: 0.77