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

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

MODULARITY 2016 – Proceedings

Contents - Abstracts - Authors


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

Modularity Research Results

Modular Design and Reasoning

Segregating Feature Interfaces to Support Software Product Line Maintenance
Bruno B. P. Cafeo, Claus Hunsen, Alessandro Garcia, Sven Apel, and Jaejoon Lee
(PUC-Rio, Brazil; University of Passau, Germany; Lancaster University, UK)
Although software product lines are widely used in practice, their maintenance is challenging. Features as units of behaviour can be heavily scattered across the source code of a product line, hindering modular reasoning. To alleviate this problem, feature interfaces aim at enhancing modular reasoning about features. However, considering all members of a feature interface is often cumbersome, especially due to the large number of members arising in practice. To address this problem, we present an approach to group members of a feature interface based on their mutual dependencies. We argue that often only a subset of all interface members is relevant to a maintenance task. Therefore, we propose a graph representation that is able to capture the collaboration between members and apply a clustering algorithm to it to group highly-related members and segregate non-related members. On a set of ten versions of a real-world product line, we evaluate the effectiveness of our approach, by comparing the two types of feature interfaces (segregated vs. original interfaces) with co-change information from the version-control system. We found a potential reduction of 62% of the interface members to be considered during maintenance. This way, the effort to reason about features can be reduced.
Publisher's Version Article Search
Reasoning Tradeoffs in Languages with Enhanced Modularity Features
José Sánchez and Gary T. Leavens
(Universidad Nacional, Costa Rica; University of Central Florida, USA)
The continuous need for more ambitious, more complex, and more dependable software systems demands mechanisms to modularize such systems and reason about their correctness. The reasoning process is affected by the programming language’s features, like dynamic dispatching, implicit invocation and oblivious aspect weaving, and by how the programmer uses them. In this paper, by devising a unifying formal setting, we show how reasoning varies with the different language mechanisms, and provide sound rules for reasoning about programs that use these features. While analyzing these mechanisms we explore the main compromises or tradeoffs that led to them and explain the disciplines they impose and the strength of the reasoning conclusions one can derive in each case. Our contributions will benefit both language designers and programmers. Language designers will benefit from learning the effects of different modularity features on reasoning. Programmers will learn how to reason about programs that use such features.
Publisher's Version Article Search
Unveiling and Reasoning about Co-change Dependencies
Marcos César de Oliveira, Rodrigo Bonifácio, Guilherme N. Ramos, and Márcio Ribeiro
(MPOG, Brazil; University of Brasília, Brazil; Federal University of Alagoas, Brazil)
Product flexibility is one of the expected benefits of a modular design, and thus "it should be possible to make drastic changes to a module without changing others." Accordingly, the data available on version control systems might help software architects to reason about some quality attributes of the modular decomposition of a system. In this paper we investigate the impact of co-change dependencies into system stability, that is, the potential ripple effect that might occur during maintenance tasks. Here we use (a) Design Structure Matrices (DSMs) for visualizing dependencies motivated by assets’ co-change and (b) two metrics for estimating system stability: Propagation Cost of Changes and Clustered Cost of a Decomposition. We conducted a comprehensive study about co-change dependencies and their effects on system stability, considering the change history of six open-source Java systems: Derby, Eclipse UI, Eclipse JDT, Hadoop, Geronimo, and Lucene; and one relevant financial systems of the Brazilian Government (SIOP). We evaluated two distinct situations: first considering only the static dependencies of each system and then considering both static and co-change dependencies of each system. There is a significant impact of the co-change dependencies on the stability measurements for Derby, Hadoop, Lucene, and SIOP. This result suggests that the modular decomposition of these systems does not resemble their change history. Accordingly, our findings provide empirical evidence that the common approach for reasoning about the modular decomposition, which often uses only static dependencies, hides important details about the costs of maintenance tasks.
Publisher's Version Article Search
The Expression Problem, Trivially!
Yanlin Wang and Bruno C. d. S. Oliveira
(University of Hong Kong, China)
This paper presents a novel and simple solution to Wadler’s Expression Problem that works in conventional object-oriented languages. Unlike all existing solutions in Java-like languages, this new solution does not use any kind of generics: it relies only on subtyping. The key to the solution is the use of covariant type refinement of return types (or fields): a simple feature available in many object-oriented languages, but not as widely known or used as it should be. We believe that our results present valuable insights for researchers and programming language designers interested in extensibility. Furthermore our results have immediate applicability as practical design patterns for programmers interested in improving extensibility of their programs.
Publisher's Version Article Search

Concurrency and Recovery

A Type-and-Effect System for Asynchronous, Typed Events
Yuheng Long and Hridesh Rajan
(Iowa State University, USA)
Implicit concurrency between handlers is important for event driven systems because it helps simultaneously promote modularity and scalability. Knowing the side-effect of the handlers is critical in these systems to avoid concurrency hazards such as data races. As event systems are dynamic because statically known and unknown handlers can register at almost any time during program execution, static effect analyses must reconcile over competing goals such as precision, soundness and modularity. We recently developed asynchronous, typed events, a system that can analyze the effects of the handlers at runtime. This mechanism utilizes runtime information to enable precise effect computation and greatly improves concurrency between handlers. In this paper, we present the formal underpinnings of asynchronous, typed events, and examine the concurrency safety properties it provides. The technical innovations of our system include a novel effect system to soundly approximate the dynamism introduced by runtime handlers registration, a static analysis to precompute the effects and a dynamic analysis that uses the precomputed effects to improve concurrency. Our design simplifies modular concurrency reasoning and avoids concurrency hazards.
Publisher's Version Article Search
On Ordering Problems in Message Passing Software
Yuheng Long, Mehdi Bagherzadeh, Eric Lin, Ganesha Upadhyaya, and Hridesh Rajan
(Iowa State University, USA)
The need for concurrency in modern software is increasingly fulfilled by utilizing the message passing paradigm because of its modularity and scalability. In the message passing paradigm, concurrently running processes communicate by sending and receiving messages. Asynchronous messaging introduces the possibility of message ordering problems: two messages with a specific order in the program text could take effect in the opposite order in the program execution and lead to bugs that are hard to find and debug. We believe that the engineering of message passing software could be easier if more is known about the characteristics of message ordering problems in practice. In this work, we present an analysis to study and quantify the relation between ordering problems and semantics variations of their underlying message passing paradigm in over 30 applications. Some of our findings are as follows: (1) semantic variations of the message passing paradigm can cause ordering problems exhibited by applications in different programming patterns to vary greatly; (2) some semantic features such as in-order messaging are critical for reducing ordering problems; (3) modular enforcement of aliasing in terms of data isolation allows small test configurations to trigger the majority of ordering problems.
Publisher's Version Article Search
Fault Tolerance with Aspects: A Feasibility Study
Sven Karol, Norman A. Rink, Bálint Gyapjas, and Jeronimo Castrillon
(TU Dresden, Germany)
To enable correct program execution on unreliable hardware, software can be made fault-tolerant by adding program statements or machine instructions for fault detection and recovery. Manually modifying programs does not scale, and extending compilers to emit additional machine instructions lacks flexibility. However, since software-implemented hardware fault tolerance (SIHFT) can be understood as a cross-cutting concern, we propose aspect-oriented programming as a suitable implementation technique. We prove this proposition by implementing an AN encoder based on AspectC++. In terms of performance and fault coverage, we achieve comparable results to existing compiler-based solutions.
Publisher's Version Article Search

Languages and Modularity

Modularity and Optimization in Synergy
Walter Cazzola and Albert Shaqiri
(University of Milan, Italy)
As with traditional software, the complexity of a programming language implementation is faced with modularization which favors the separation of concerns, independent development, maintainability and reuse. However, modularity interferes with language optimization as the latter requires context information that crosses over the single module boundaries and involves other modules. This renders hard to provide the optimization for a single language concept to be reusable with the concept itself. Therefore, the optimization is in general postponed to when all language concepts are available. We defined a model for modular language development with a multiple semantic actions dispatcher based on condition guards that are evaluated at runtime. The optimization can be implemented as context-dependent extensions applied a posteriori to the composed language interpreter without modifying a single component implementation. This renders effective the defined optimization within the language concept boundaries according to the context provided by other language concepts when available and eases its reuse with the language concepts implementation independently of its usage context. The presented model is integrated into the Neverlang development framework and is demonstrated on the optimization of a Javascript interpreter written in Neverlang. We also discuss the applicability of our model to other frameworks for modular language development.
Publisher's Version Article Search
Cooperative Decoupled Processes: The E-Calculus and Linearity
Andi Bejleri, Mira Mezini, and Patrick Eugster
(TU Darmstadt, Germany; Lancaster University, UK; Purdue University, USA)
Event-driven programming has become a major paradigm in developing concurrent, distributed systems. Its benefits are often informally captured by the key tenet of “decoupling”, a notion which roughly captures the ability of modules to join and leave (or fail) applications dynamically, and to be developed by independent parties. Programming models for event-driven programming either make it hard to reason about global control flow, thus hampering sound execution, or sacrifice decoupling to aid in reasoning about control flow. This work fills the gap by introducing a programming model – dubbed cooperative decoupled processes – that achieves both decoupling and reasoning about global control flow. We introduce this programming model through an event calculus, loosely inspired by the Join calculus, that enables reasoning about cooperative decoupled processes through the concepts of pre- and postconditions. A linear type system controls aliasing of events to ensure uniqueness of control flow and thus safe exchange of shared events. Fundamental properties of the type system such as subject reduction, migration safety, and progress are established.
Publisher's Version Article Search
CPL: A Core Language for Cloud Computing
Oliver Bračevac, Sebastian Erdweg, Guido Salvaneschi, and Mira Mezini
(TU Darmstadt, Germany; Lancaster University, UK)
Running distributed applications in the cloud involves deployment. That is, distribution and configuration of application services and middleware infrastructure. The considerable complexity of these tasks resulted in the emergence of declarative JSON-based domain-specific deployment languages to develop deployment programs. However, existing deployment programs unsafely compose artifacts written in different languages, leading to bugs that are hard to detect before run time. Furthermore, deployment languages do not provide extension points for custom implementations of existing cloud services such as application-specific load balancing policies. To address these shortcomings, we propose CPL (Cloud Platform Language), a statically-typed core language for programming both distributed applications as well as their deployment on a cloud platform. In CPL, application services and deployment programs interact through statically typed, extensible interfaces, and an application can trigger further deployment at run time. We provide a formal semantics of CPL and demonstrate that it enables type-safe, composable and extensible libraries of service combinators, such as load balancing and fault tolerance.
Publisher's Version Article Search

Modularity Visions

Modularity Mechanisms

Modular Architecture for Code and Metadata Sharing
Tomas Tauber and Bruno C. d. S. Oliveira
(University of Hong Kong, China)
Every fragment of code we write has dependencies and associated metadata. Code dependencies range from local references and standard library definitions to external third party libraries. Metadata spans from within source code files (hierarchical names and code comments) to external files and database servers (package-level dependency configurations, build and test results, code reviews etc.). This scattered storage and non-uniform access limits our programming environments in their functionality and extensibility. In this paper, we propose a modular system architecture, Haknam, better suited for code and related metadata sharing. Haknam precisely tracks code interdependencies, allows flexible naming and querying of code references, and collects code fragments and their related metadata as messages in a distributed log-centric pipeline. We argue that this setting brings considerable advantages. In particular, we focus on modular development of tools and services that can assist in programming-related tasks. Every new functionality can be simply added by creating and processing messages from the distributed pipeline.
Publisher's Version Article Search
Matriona: Class Nesting with Parameterization in Squeak/Smalltalk
Matthias Springer, Fabio Niephaus, Robert Hirschfeld, and Hidehiko Masuhara
(HPI, Germany; Tokyo Institute of Technology, Japan; SAP Labs, USA; Viewpoints Research Institute, USA)
We present Matriona, a module system for Squeak, a Smalltalk dialect. It supports class nesting and parameterization and is based on a hierarchical name lookup mechanism. Matriona solves a range of modularity issues in Squeak. Instead of a flat class organization, it provides a hierarchical namespace, that avoids name clashes and allows for shorter local names. Furthermore, it provides a way to share behavior among classes and modules using mixins and class hierarchy inheritance (a form of inheritance that subclasses an entire class family), respectively. Finally, it allows modules to be externally configurable, which is a form of dependency management decoupling a module from the actual implementation of its dependencies. Matriona is implemented on top of Squeak by introducing a new keyword for run-time name lookups through a reflective mechanism, without modifying the underlying virtual machine. We evaluate Matriona with a series of small applications and will demonstrate how its features can benefit modularity when porting a simple application written in plain Squeak to Matriona.
Publisher's Version Article Search

Modularity and Architecture

On Structuring Holistic Fault Tolerance
Rem Gensh, Alexander Romanovsky, and Alex Yakovlev
(Newcastle University, UK)
Computer systems are developed taking into account that they should be easily maintained in the future. It is one of the main requirements for the sound architectural design. The existing approaches to introducing fault tolerance rely on recursive system structuring out of functional components – this typically results in non-optimal fault tolerance. The paper proposes a vision of structuring complex many-core systems by introducing a special component supporting system-wide fault tolerance coordination. The component acts as a central module making decisions about fault tolerance strategies to be implemented by individual system components depending on the performance and energy requirements specified as system operating modes.
Publisher's Version Article Search
Constraints as Polymorphic Connectors
Marcel Weiher and Robert Hirschfeld
(HPI, Germany; Microsoft, Germany; SAP Labs, USA; Viewpoints Research Institute, USA)
The architecture of interactive systems does not match the procedural decomposition mechanisms available in most programming languages, leading to architectural mismatch. Constraint systems have been used only as black boxes for computing with primitive values of a specific type and for specific domains such as user interface layouts or program compilation. We propose constraints as a general purpose architectural connector for both describing the large-scale structure of interactive systems and matching that description with the actual implementation.
Publisher's Version Article Search

proc time: 0.04