MODULARITY 2015 – Proceedings

Messages from the Chairs
On behalf of the organizing committee, welcome to the 14th International Conference on Modularity, held in Fort Collins, Colorado, on March 16-19, 2015. This conference addresses software modularity, which is a key property that impacts our ability to conceive, design, develop, validate, integrate, and evolve modern information systems and their underlying software artifacts. These problems present great theoretical and practical challenges, and the solutions are of interest to both researchers and practitioners.

Main Research

Language Design

Dynamically Composing Languages in a Modular Way: Supporting C Extensions for Dynamic Languages
Matthias Grimmer, Chris Seaton, Thomas Würthinger, and Hanspeter Mössenböck
(JKU Linz, Austria; Oracle Labs, UK; Oracle Labs, Switzerland)
Many dynamic languages such as Ruby, Python and Perl offer some kind of functionality for writing parts of applications in a lower-level language such as C. These C extension modules are usually written against the API of an interpreter, which provides access to the higher-level language's internal data structures. Alternative implementations of the high-level languages often do not support such C extensions because implementing the same API as in the original implementations is complicated and limits performance. In this paper we describe a novel approach for modular composition of languages that allows dynamic languages to support C extensions through interpretation. We propose a flexible and reusable cross-language mechanism that allows composing multiple language interpreters, which run on the same VM and share the same form of intermediate representation - in this case abstract syntax trees. This mechanism allows us to efficiently exchange runtime data across different interpreters and also enables the dynamic compiler of the host VM to inline and optimize programs across multiple language boundaries. We evaluate our approach by composing a Ruby interpreter with a C interpreter. We run existing Ruby C extensions and show how our system executes combined Ruby and C modules on average over 3x faster than the conventional implementation of Ruby with native C extensions, and on average over 20x faster than an existing alternate Ruby implementation on the JVM (JRuby) calling compiled C extensions through a bridge interface. We demonstrate that cross-language inlining, which is not possible with native code, is performance-critical by showing how speedup is reduced by around 50% when it is disabled.

Generalized Layer Activation Mechanism through Contexts and Subscribers
Tetsuo Kamina, Tomoyuki Aotani, and Hidehiko Masuhara
(Ritsumeikan University, Japan; Tokyo Institute of Technology, Japan)
Context-oriented programming (COP) languages modularize context-dependent behaviors in multiple classes into layers. These languages have layer activation mechanisms so that the behaviors in layers take effect on a particular unit of computation during a particular period of time. Existing COP languages have different layer activation mechanisms, and each of them has its own advantages. However, because these mechanisms interfere with each other in terms of extent (time duration) and scope (a set of units of computations) of activation, it is not trivial to combine them into a single language. We propose a generalized layer activation mechanism based on contexts and subscribers to implement the different activation mechanisms in existing COP languages in a single COP language called ServalCJ. Contexts specify the extent of activation through temporal logic terms, and subscribers specify the scope of activation through operators provided by the language. We implement a compiler of ServalCJ, and demonstrate its expressiveness by writing a couple of application programs.

Structured Synchronous Reactive Programming with Céu
Francisco Sant' Anna, Roberto Ierusalimschy, and Noemi Rodriguez
(PUC-Rio, Brazil)
Structured synchronous reactive programming (SSRP) augments classical structured programming (SP) with continuous interaction with the environment. We advocate SSRP as viable in multiple domains of reactive applications and propose a new abstraction mechanism for the synchronous language Céu: Organisms extend objects with an execution body that composes multiple lines of execution to react to the environment independently. Compositions bring structured reasoning to concurrency and can better describe state machines typical of reactive applications. Organisms are subject to lexical scope and automatic memory management similar to stack-based allocation for local variables in SP. We show that this model does not require garbage collection or a free primitive in the language, eliminating memory leaks for organisms by design.

Video

Info

Software Engineering

AspectMatlab++: Annotations, Types, and Aspects for Scientists
Andrew Bodzay and Laurie Hendren
(McGill University, Canada)
In this paper we present extensions to an aspect oriented compiler developed for MATLAB. These extensions are intended to support important functionality for scientists, and include pattern matching on annotations, and types of variables, as well as new manners of exposing context. We provide use-cases of these features in the form of several general-use aspects which focus on solving issues that arise from use of dynamically-typed languages. We also detail performance enhancements to the ASPECTMATLAB compiler which result in an order of magnitude in performance gains.

JavaRAG: A Java Library for Reference Attribute Grammars
Niklas Fors, Gustav Cedersjö, and Görel Hedin
(Lund University, Sweden)
Reference attribute grammars (RAGs) is a powerful formalism for developing modular extensible compilers and program analysis tools. This paper presents JavaRAG, an implementation of RAGs as a Java library that is independent of the abstract syntax tree structure. This makes it possible to extend legacy compilers implemented in Java with RAG computations. We have evaluated the approach by integrating with EMF, ANTLR, and hand-built abstract syntax trees, and we compare performance and specification size with JastAdd and Kiama which are other RAG-based tools. Our JavaRAG library is open source and is used in a compiler for the dataflow language CAL.

Architecture-Sensitive Heuristics for Prioritizing Critical Code Anomalies
Everton Guimarães, Alessandro Garcia, and Yuanfang Cai
(PUC-Rio, Brazil; Drexel University, USA)
The progressive insertion of code anomalies in evolving software systems might lead to architecture degradation symptoms. Code anomalies are particularly harmful when they contribute to the architecture degradation. Although several approaches have been proposed aiming to detect anomalies in the source code, most of them fail to assist developers when prioritizing code anomalies critical to the architectural design. Blueprints of the architecture design are artifacts often available in industry software projects. However, such blueprints are rarely explored to support the prioritization of code anomalies in terms of their architecture relevance. This paper proposes and evaluates 2 sets of blueprint-based heuristics for supporting the prioritization of critical code anomalies. The prioritization is based on their potential impact on revealing architectural drift problems. The heuristics allow developers prioritizing critical code anomalies by exploiting architectural information provided in the blueprint. The contributions of this paper include: (i) a set of architecture sensitive heuristics to support developers when prioritizing critical code anomalies; (ii) an evaluation of the proposed heuristics in terms of their prioritization accuracy in 3 systems; and (iii) an empirical analysis on how the blueprints’ information might enhance the prioritization of critical code anomalies, as opposed to existing heuristics strictly based on source code analysis.

Feature Scattering in the Large: A Longitudinal Study of Linux Kernel Device Drivers
Leonardo Passos, Jesús Padilla, Thorsten Berger, Sven Apel, Krzysztof Czarnecki, and Marco Tulio Valente
(University of Waterloo, Canada; University of Passau, Germany; Federal University of Minas Gerais, Brazil)
Feature code is often scattered across wide parts of the code base. But, scattering is not necessarily bad if used with care—in fact, systems with highly scattered features have evolved successfully over years. Among others, feature scattering allows developers to circumvent limitations in programming languages and system design. Still, little is known about the characteristics governing scattering, which factors influence it, and practical limits in the evolution of large and long-lived systems. We address this issue with a longitudinal case study of feature scattering in the Linux kernel. We quantitatively and qualitatively analyze almost eight years of its development history, focusing on scattering of device-driver features. Among others, we show that, while scattered features are regularly added, their proportion is lower than non-scattered ones, indicating that the kernel architecture allows most features to be integrated in a modular manner. The median scattering degree of features is constant and low, but the scattering-degree distribution is heavily skewed. Thus, using the arithmetic mean is not a reliable threshold to monitor the evolution of feature scattering. When investigating influencing factors, we find that platform-driver features are 2.5 times more likely to be scattered across architectural (subsystem) boundaries when compared to non-platform ones. Their use illustrates a maintenance-performance trade-off in creating architectures as for Linux kernel device drivers.

Formal Methods 1

Panini: A Concurrent Programming Model for Solving Pervasive and Oblivious Interference
Mehdi Bagherzadeh and Hridesh Rajan
(Iowa State University, USA)
Modular reasoning about concurrent programs is complicated by the possibility of interferences happening between any two instructions of a task (pervasive interference), and these interferences not giving out any information about the behaviors of potentially interfering concurrent tasks (oblivious interference). Reasoning about a concurrent program would be easier if a programmer modularly and statically (1) knows precisely the program points at which interferences may happen (sparse interference), and (2) has some insights into behaviors of potentially interfering tasks at these points (cognizant interference). In this work we present Panini, a core concurrent calculus which guarantees sparse interference, by controlling sharing among concurrent tasks, and cognizant interference, by controlling dynamic name bindings and accessibility of states of tasks. Panini promotes capsule-oriented programming whose concurrently running capsules own their states, communicate by asynchronous invocations of their procedures and dynamically transfer ownership. Panini limits sharing among two capsules to other capsules and futures, limits accessibility of a capsule states to only through its procedures and dispatches a procedure invocation on the static type of its receiver capsule. We formalize Panini, present its semantics and illustrate how its interference model, using behavioral contracts, enables Hoare-style modular reasoning about concurrent programs with interference.

Dynamic Dispatch for Method Contracts through Abstract Predicates
Wojciech Mostowski and Mattias Ulbrich
(University of Twente, Netherlands; KIT, Germany)
Dynamic method dispatch is a core feature of object-oriented programming by which the executed implementation for a polymorphic method is only chosen at runtime. In this paper, we present a specification and verification methodology which extends the concept of dynamic dispatch to design-by-contract specifications. The formal specification language JML has only rudimentary means for polymorphic abstraction in expressions. We promote these to fully flexible specification-only query methods called model methods that can, like ordinary methods, be overridden to give specifications a new semantics in subclasses in a transparent and modular fashion. Moreover, we allow them to refer to more than one program state which give us the possibility to fully abstract and encapsulate two-state specification contexts, i.e., history constraints and method postconditions. We provide the semantics for model methods by giving a translation into a first order logic and according proof obligations. We fully implemented this framework in the KeY program verifier and successfully verified relevant examples.

Formal Methods 2

Modular Reasoning in the Presence of Event Subtyping
Mehdi Bagherzadeh, Robert Dyer, Rex D. Fernando, José Sánchez, and Hridesh Rajan
(Iowa State University, USA; Bowling Green State University, USA; University of Wisconsin-Madison, USA; University of Central Florida, USA)
Separating crosscutting concerns while preserving modular reasoning is challenging. Type-based interfaces (event types) separate modularized crosscutting concerns (observers) and traditional object-oriented concerns (subjects). Event types paired with event specifications were shown to be effective in enabling modular reasoning about subjects and observers. Similar to class subtyping, organizing event types into subtyping hierarchies is beneficial. However, unrelated behaviors of observers and their arbitrary execution orders could cause unique, somewhat counterintuitive, reasoning challenges in the presence of event subtyping. These challenges threaten both tractability of reasoning and reuse of event types. This work makes three contributions. First, we pose and explain these challenges. Second, we propose an event-based calculus to show how these challenges can be overcome. Finally, we present modular reasoning rules of our technique and show its applicability to other event-based techniques.

A Programming Model and Framework for Comprehensive Dynamic Analysis on Android
Haiyang Sun, Yudi Zheng, Lubomír Bulej, Alex Villazón, Zhengwei Qi, Petr Tůma, and Walter Binder
(Shanghai Jiao Tong University, China; University of Lugano, Switzerland; Charles University, Czech Republic; Universidad Privada Boliviana, Bolivia)
The multi-process architecture of Android applications combined with the lack of suitable APIs make dynamic program analysis (DPA) on Android challenging and unduly difficult. Existing analysis tools and frameworks are tailored mainly to the needs of security-related analyses and are not flexible enough to support the development of generic DPA tools. In this paper we present a framework that, besides providing the fundamental support for the development of DPA tools for Android, enables development of cross-platform analyses that can be applied to applications targeting the Android and Java platforms. The framework provides a convenient high-level programming model, flexible instrumentation support, and strong isolation of the base program from the analysis. To boost developer productivity, the framework retains Java as the main development language, while seamless integration with the platform overcomes the recurring obstacles hindering development of DPA tools for Android. We evaluate the framework on two diverse case studies, demonstrating key concepts, the flexibility of the framework, and analysis portability.

MODULARITY 2015 – Proceedings

Frontmatter

Main Research

Language Design

Software Engineering

Formal Methods 1

Formal Methods 2