Powered by
15th International Conference on Modularity (MODULARITY Companion 2016),
March 14–17, 2016,
Málaga, Spain
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.
@InProceedings{MODULARITY Companion16p146,
author = {Jo Van Bulck and Job Noorman and Jan Tobias Mühlberg and Frank Piessens},
title = {Towards Availability and Real-Time Guarantees for Protected Module Architectures},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {146--151},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY Companion16p152,
author = {Markus Raab},
title = {Improving System Integration using a Modular Configuration Specification Language},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {152--157},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY Companion16p158,
author = {Tetsuo Kamina and Tomoyuki Aotani and Hidehiko Masuhara},
title = {Toward Fluent Module Interactions},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {158--159},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY Companion16p160,
author = {Tony Clark},
title = {Static Meta-Object Protocols: Towards Efficient Reflective Object-Oriented Languages},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {160--167},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY Companion16p168,
author = {Shigeru Chiba and YungYu Zhuang and Maximilian Scherr},
title = {A Design of Deep Reification},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {168--171},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY Companion16p172,
author = {Nick Papoulias and Serge Stinckwich},
title = {Towards Projection: Mapping Reflection onto the Userland},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {172--175},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY Companion16p176,
author = {Nadia Gámez and Lidia Fuentes},
title = {Green Software using Aspect Orientation for Cyber-Physical-Systems},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {176--177},
doi = {},
year = {2016},
}
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.
@InProceedings{MODULARITY Companion16p178,
author = {Arik Hadas and David H. Lorenz},
title = {Application-Specific Language-Oriented Modularity: A Case Study of the oVirt Project},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {178--183},
doi = {},
year = {2016},
}
proc time: 1.08