- Program Chairs:
- Christoph Borchert,
- Michael Haupt,
- Daniel Lohmann,
- David Lorenz
Systems software, comprising artifacts ranging from middleware servers over virtual machines and operating systems to hardware descriptions, typically bears great inherent complexity. This brings about intricate relationships between logical modules of such systems that are seldom clearly expressed in source code or architecture descriptions. As more and more features and requirements are being "pushed down" into the infrastructure, the developers of systems software need better tools and techniques for dealing with the ensuing increased complexity. The design and implementation of systems-level software presents unique opportunities and challenges for research on software modularity. These challenges include the need to address the inherent complexity of infrastructure software, the need for strong assurances of correct and predictable behavior, the need for maximum run-time performance, and the necessity of dealing with the large body of existing systems software components.
The Modularity in Systems Software (MISS) workshop series aims to provide a highly interactive forum for researchers and developers to discuss the application of and relationships between exciting new modularity constructs for systems software such as aspects, features, components, traits and context layers. The goal is to put these constructs into a common reference frame and to build connections between the software engineering and systems communities.
The call for papers attracted eight submissions, all of which were accepted for inclusion in the workshop program, covering topics ranging from hardware design languages to programming language design. In addition, the program includes an invited talk by Christian Mathis from SAP Innovation Center Potsdam, addressing issues in language design for scalable business applications.
Proceeding Downloads
AspectVHDL stage 1: the prototype of an aspect-oriented hardware description language
Hardware description languages are a promising field for the application of aspect technology. In a case study with the MB-Lite soft core CPU, which is an open, cycle accurate re-implementation of Xilinx' Microblaze processor, we show that crosscutting ...
Automatic aspectization of systemC
A successful monitoring framework for SystemC requires access to internal variables of modules and channels, and the ability to trace the execution of threads and methods. We propose a framework for automatically instrumenting user code and exposing its ...
Understanding linux feature distribution
Managing variability is hard. This applies both to feature modeling itself as well as the maintenance of the corresponding feature implementations which poses additional challenges. Especially in embedded systems and system software that are developed ...
Modularity and conventions for maintainable concurrent language implementations: a review of our experiences and practices
In this paper, we review what we have learned from implementing languages for parallel and concurrent programming, and investigate the role of modularity. To identify the approaches used to facilitate correctness and maintainability, we ask the ...
Writing a modular GPGPU program in Java
This paper proposes a Java to CUDA runtime program translator for scientific-computing applications. Traditionally, these applications have been written in Fortran or C without using a rich modularization mechanism. Our translator enables those ...
Modular and non-invasive distributed memory parallelization
This paper presents an aspect-oriented library to support parallelization of Java applications for distributed memory environments, using a message-passing approach. The library was implemented using AspectJ language, and aims to provide a set of ...
UniAspect: a language-independent aspect-oriented programming framework
- Akira Ohashi,
- Kazunori Sakamoto,
- Tomoyuki Kamiya,
- Reisha Humaira,
- Satoshi Arai,
- Hironori Washizaki,
- Yoshiaki Fukazawa
Existing AOP tools, typified by AspectJ, are proposed as extensions of a single language. Therefore, most existing AOP tools cannot deal with cross-cutting concerns, which are scattered on many modules implemented in two or more languages. We propose a ...
Decoupling context: introducing quantification in object teams
In this paper, we propose role-oriented programming, which is realized in the language Object Teams/Java, as an alternative approach toward modularizing context-dependent concerns. We aim to integrate the benefits of quantification without introducing ...