Powered by
15th International Conference on Modularity (MODULARITY 2016),
March 14–17, 2016,
Málaga, Spain
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.
@InProceedings{MODULARITY16p106,
author = {Tomas Tauber and Bruno C. d. S. Oliveira},
title = {Modular Architecture for Code and Metadata Sharing},
booktitle = {Proc.\ MODULARITY},
publisher = {ACM},
pages = {106--117},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY16p118,
author = {Matthias Springer and Fabio Niephaus and Robert Hirschfeld and Hidehiko Masuhara},
title = {Matriona: Class Nesting with Parameterization in Squeak/Smalltalk},
booktitle = {Proc.\ MODULARITY},
publisher = {ACM},
pages = {118--129},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY16p130,
author = {Rem Gensh and Alexander Romanovsky and Alex Yakovlev},
title = {On Structuring Holistic Fault Tolerance},
booktitle = {Proc.\ MODULARITY},
publisher = {ACM},
pages = {130--133},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY16p134,
author = {Marcel Weiher and Robert Hirschfeld},
title = {Constraints as Polymorphic Connectors},
booktitle = {Proc.\ MODULARITY},
publisher = {ACM},
pages = {134--145},
doi = {},
year = {2016},
}
proc time: 1.01