MODULARITY Companion 2016 – Author Index |
Contents -
Abstracts -
Authors
|
Capilla, Rafael |
MODULARITY Companion '16-LASSY: "A Taxonomy of Context-Aware ..."
A Taxonomy of Context-Aware Software Variability Approaches
Kim Mens , Rafael Capilla, Nicolás Cardozo, and Bruno Dumas (Université Catholique de Louvain, Belgium; Rey Juan Carlos University, Spain; Trinity College Dublin, Ireland; University of Namur, Belgium) Modern software systems demand more and more smart capabilities depending on their context of use, as well as the ability to dynamically adapt these capabilities according to sensed context changes. This requires appropriate techniques for modelling, representing and handling context-aware software variability. While traditional variability modelling approaches like feature orientation and software product lines are evolving to address the increased dynamicity and context specificity required for this new generation of software systems, new paradigms such as context-oriented programming have emerged. Although developed independently, since they address similar issues, many similarities exist between these approaches. The purpose of this paper is to define, categorise and compare key concepts shared by these approaches. Such a taxonomy is a first step towards a better understanding of the differences and similarities between different approaches for managing context-aware software variability, and to achieve a cross-fertilisation between them. @InProceedings{MODULARITY Companion16p119, author = {Kim Mens and Rafael Capilla and Nicolás Cardozo and Bruno Dumas}, title = {A Taxonomy of Context-Aware Software Variability Approaches}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {119--124}, doi = {}, year = {2016}, } |
|
Cardozo, Nicolás |
MODULARITY Companion '16-LASSY: "A Dynamic Instance Binding ..."
A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems
Nguonly Taing, Thomas Springer, Nicolás Cardozo, and Alexander Schill (TU Dresden, Germany; Trinity College Dublin, Ireland) Role-based approaches gain more and more interest for modeling and implementing variable software systems. Role models clearly separate static behavior represented by players and dynamic behavior modeled as roles which can be dynamically bound and unbound to players at run time. To support the execution of role-based systems, a dynamic binding mechanism is required. Especially, since instances of the same player type can play different roles in a single context, the binding mechanism is required to operate at instance level. In this paper, we introduce a mechanism called dynamic instance binding for implementing a runtime for role-based systems. It maintains a look-up table that allows the run-time system to determine and invoke the currently active role binding at instance level. We explain dynamic instance binding mechanism in detail and demonstrate that it is flexible enough to support both adaptation and evolution of software systems at run time. @InProceedings{MODULARITY Companion16p137, author = {Nguonly Taing and Thomas Springer and Nicolás Cardozo and Alexander Schill}, title = {A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {137--142}, doi = {}, year = {2016}, } MODULARITY Companion '16-LASSY: "A Taxonomy of Context-Aware ..." A Taxonomy of Context-Aware Software Variability Approaches Kim Mens , Rafael Capilla, Nicolás Cardozo, and Bruno Dumas (Université Catholique de Louvain, Belgium; Rey Juan Carlos University, Spain; Trinity College Dublin, Ireland; University of Namur, Belgium) Modern software systems demand more and more smart capabilities depending on their context of use, as well as the ability to dynamically adapt these capabilities according to sensed context changes. This requires appropriate techniques for modelling, representing and handling context-aware software variability. While traditional variability modelling approaches like feature orientation and software product lines are evolving to address the increased dynamicity and context specificity required for this new generation of software systems, new paradigms such as context-oriented programming have emerged. Although developed independently, since they address similar issues, many similarities exist between these approaches. The purpose of this paper is to define, categorise and compare key concepts shared by these approaches. Such a taxonomy is a first step towards a better understanding of the differences and similarities between different approaches for managing context-aware software variability, and to achieve a cross-fertilisation between them. @InProceedings{MODULARITY Companion16p119, author = {Kim Mens and Rafael Capilla and Nicolás Cardozo and Bruno Dumas}, title = {A Taxonomy of Context-Aware Software Variability Approaches}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {119--124}, doi = {}, year = {2016}, } |
|
Dumas, Bruno |
MODULARITY Companion '16-LASSY: "A Taxonomy of Context-Aware ..."
A Taxonomy of Context-Aware Software Variability Approaches
Kim Mens , Rafael Capilla, Nicolás Cardozo, and Bruno Dumas (Université Catholique de Louvain, Belgium; Rey Juan Carlos University, Spain; Trinity College Dublin, Ireland; University of Namur, Belgium) Modern software systems demand more and more smart capabilities depending on their context of use, as well as the ability to dynamically adapt these capabilities according to sensed context changes. This requires appropriate techniques for modelling, representing and handling context-aware software variability. While traditional variability modelling approaches like feature orientation and software product lines are evolving to address the increased dynamicity and context specificity required for this new generation of software systems, new paradigms such as context-oriented programming have emerged. Although developed independently, since they address similar issues, many similarities exist between these approaches. The purpose of this paper is to define, categorise and compare key concepts shared by these approaches. Such a taxonomy is a first step towards a better understanding of the differences and similarities between different approaches for managing context-aware software variability, and to achieve a cross-fertilisation between them. @InProceedings{MODULARITY Companion16p119, author = {Kim Mens and Rafael Capilla and Nicolás Cardozo and Bruno Dumas}, title = {A Taxonomy of Context-Aware Software Variability Approaches}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {119--124}, doi = {}, year = {2016}, } |
|
Fuentes, Lidia |
MODULARITY Companion '16-LASSY: "Towards the Dynamic Reconfiguration ..."
Towards the Dynamic Reconfiguration of Quality Attributes
Jose-Miguel Horcas, Mónica Pinto, and Lidia Fuentes (University of Málaga, Spain) There are some Quality Attributes (QAs) whose variability is addressed through functional variability in the software architecture. Separately modelling the variability of these QAs from the variability of the base functionality of the application has many advantages (e.g., a better reusability), and facilitates the reconfiguration of the QA variants at runtime. Many factors may vary the QA functionality: variations in the user preferences and usage needs; variations in the non-functional QAs; variations in resources, hardware, or even in the functionality of the base application, that directly affect the product's QAs. In this paper, we aim to elicit the relationships and dependencies between the functionalities required to satisfy the QAs and all those factors that can provoke a reconfiguration of the software architecture at runtime. We follow an approach in which the variability of the QAs is modelled separately from the base application functionality, and propose a dynamic approach to reconfigure the software architecture based on those reconfiguration criteria. @InProceedings{MODULARITY Companion16p131, author = {Jose-Miguel Horcas and Mónica Pinto and Lidia Fuentes}, title = {Towards the Dynamic Reconfiguration of Quality Attributes}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {131--136}, doi = {}, year = {2016}, } |
|
Hernández-Martínez, Juan-Alberto |
MODULARITY Companion '16-LASSY: "Model for Fusion of Software ..."
Model for Fusion of Software Components
Juan-Alberto Hernández-Martínez and Ulises Juárez-Martínez (Instituto Tecnológico de Orizaba, Mexico) Current applications, especially those that cannot stop their execution, such as banking systems, airport management, and critical mission environments, among others, require of suitable mechanisms to respond immediately and automatically to constant changes of the execution environment and user requirements. In response to such issues, self-adaptation and dynamic evolution of the software allow to perform the necessary adjustments dynamically, minimizing human intervention. However, although these approaches resolve much of the problem, most of the solutions applied consist of adding functionality causing that the resulting applications to be large and/or with unnecessary or irrelevant elements. In order to strengthen the adaptation and evolution of software, the establishment of mechanisms supported in the principles of knowledge areas with greater maturity such as biology, chemistry, among others, results in an attractive alternative. In this sense, current paper proposes a new approach for adapting and creating software components at run-time based on a simplified chemical model for creating molecules. The main idea behind this approach is that every atom corresponds to a software component and every molecule correspond to a new adaptation or creation of a software component whose structure, functionality and behavior could be formed both of its own characteristics or execution environment. @InProceedings{MODULARITY Companion16p143, author = {Juan-Alberto Hernández-Martínez and Ulises Juárez-Martínez}, title = {Model for Fusion of Software Components}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {143--145}, doi = {}, year = {2016}, } |
|
Hirschfeld, Robert |
MODULARITY Companion '16-LASSY: "Compatibility Layers for Interface ..."
Compatibility Layers for Interface Mediation at Run-Time
Patrick Rein , Robert Hirschfeld , Stefan Lehmann, and Jens Lincke (HPI, Germany) In adaptable systems, one module might require an interface from another module which the second module does not provide. For some cases, the particular provider module and its interface which will be available at run-time can not be anticipated during development time. In such situations with various provider interfaces, current mitigation strategies for interface mismatches struggle as they often rely on advanced knowledge about one particular providing module. Therefore, we propose the concept of compatibility layers which is based on modular interface mappings. These mappings are applied to adapt the provided interface at run-time. Each mapping contains a set of general requirements for the provided interface and a set of derived functions based on the required features. We have implemented the concept of compatibility layers in a Squeak/Smalltalk prototype based on context-oriented programming. Based on this prototype, we discuss the resulting trade-offs and illustrate exemplary interface mismatches in Squeak/Smalltalk which could be mediated by the prototype. @InProceedings{MODULARITY Companion16p113, author = {Patrick Rein and Robert Hirschfeld and Stefan Lehmann and Jens Lincke}, title = {Compatibility Layers for Interface Mediation at Run-Time}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {113--118}, doi = {}, year = {2016}, } MODULARITY Companion '16-LASSY: "Hierarchical Layer-Based Class ..." Hierarchical Layer-Based Class Extensions in Squeak/Smalltalk Matthias Springer, Hidehiko Masuhara , and Robert Hirschfeld (Tokyo Institute of Technology, Japan; HPI, Germany) Class extensions are frequently used in programming languages such as Ruby and Smalltalk to add or change methods of a class that is defined in the same application or in a different one. They suffer from modularity issues if globally visible: Other applications using the same classes are then affected by the modifications. This paper presents a hierarchical approach for dynamically scoping class extensions in dynamically-typed, class-based programming languages supporting class nesting. Our mechanism allows programmers to define the scope of class extensions and to reuse class extensions in other programs. Class extensions can be scoped according to a nested class hierarchy or based on whether programmers regard a potentially affected class as a black box or not. Class extensions are organized in layers, where multiple layers targeting the same class can be active at the same time. @InProceedings{MODULARITY Companion16p107, author = {Matthias Springer and Hidehiko Masuhara and Robert Hirschfeld}, title = {Hierarchical Layer-Based Class Extensions in Squeak/Smalltalk}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {107--112}, doi = {}, year = {2016}, } |
|
Hisazumi, Kenji |
MODULARITY Companion '16-LASSY: "A Layer-Structure Diagram ..."
A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems
Harumi Watanabe, Ikuta Tanigawa, Midori Sugaya, Nobuhiko Ogura , and Kenji Hisazumi (Tokai University, Japan; Kyushu University, Japan; Shibaura Institute of Technology, Japan; Tokyo City University, Japan) The paper introduces new kinds of diagrams for describing organizations and interactions of layers based on context-oriented technology for context-sensitive embedded system developments. The concept of layers is suitable for processing context-aware embedded systems. As mentioned in several related literatures, layer-interactions cause critical problems such as deadlock, collision, and multi-invocation. To comprehend these problems at a high level, diagrams for visualizing relationships among layers are required. In a previous work, we proposed an OS-like architecture based on context-oriented technologies for embedded system development. The layering mechanism of the architecture dispatches or inserts layers with their states for dealing with layer-interaction problems. The goal of this paper is to introduce diagrams that contain notations for relating with the elements of the layering mechanism. To accomplish this, we consider the following issues: (1) the relations between layers, (2) layer-state management, and (3) context management attributes. The diagrams contribute to understanding layer-interaction problems with time delay and mutually exclusive layers. To explain the diagrams, we provide a simple example of an automatic cleaner robot. @InProceedings{MODULARITY Companion16p125, author = {Harumi Watanabe and Ikuta Tanigawa and Midori Sugaya and Nobuhiko Ogura and Kenji Hisazumi}, title = {A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {125--130}, doi = {}, year = {2016}, } |
|
Horcas, Jose-Miguel |
MODULARITY Companion '16-LASSY: "Towards the Dynamic Reconfiguration ..."
Towards the Dynamic Reconfiguration of Quality Attributes
Jose-Miguel Horcas, Mónica Pinto, and Lidia Fuentes (University of Málaga, Spain) There are some Quality Attributes (QAs) whose variability is addressed through functional variability in the software architecture. Separately modelling the variability of these QAs from the variability of the base functionality of the application has many advantages (e.g., a better reusability), and facilitates the reconfiguration of the QA variants at runtime. Many factors may vary the QA functionality: variations in the user preferences and usage needs; variations in the non-functional QAs; variations in resources, hardware, or even in the functionality of the base application, that directly affect the product's QAs. In this paper, we aim to elicit the relationships and dependencies between the functionalities required to satisfy the QAs and all those factors that can provoke a reconfiguration of the software architecture at runtime. We follow an approach in which the variability of the QAs is modelled separately from the base application functionality, and propose a dynamic approach to reconfigure the software architecture based on those reconfiguration criteria. @InProceedings{MODULARITY Companion16p131, author = {Jose-Miguel Horcas and Mónica Pinto and Lidia Fuentes}, title = {Towards the Dynamic Reconfiguration of Quality Attributes}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {131--136}, doi = {}, year = {2016}, } |
|
Juárez-Martínez, Ulises |
MODULARITY Companion '16-LASSY: "Model for Fusion of Software ..."
Model for Fusion of Software Components
Juan-Alberto Hernández-Martínez and Ulises Juárez-Martínez (Instituto Tecnológico de Orizaba, Mexico) Current applications, especially those that cannot stop their execution, such as banking systems, airport management, and critical mission environments, among others, require of suitable mechanisms to respond immediately and automatically to constant changes of the execution environment and user requirements. In response to such issues, self-adaptation and dynamic evolution of the software allow to perform the necessary adjustments dynamically, minimizing human intervention. However, although these approaches resolve much of the problem, most of the solutions applied consist of adding functionality causing that the resulting applications to be large and/or with unnecessary or irrelevant elements. In order to strengthen the adaptation and evolution of software, the establishment of mechanisms supported in the principles of knowledge areas with greater maturity such as biology, chemistry, among others, results in an attractive alternative. In this sense, current paper proposes a new approach for adapting and creating software components at run-time based on a simplified chemical model for creating molecules. The main idea behind this approach is that every atom corresponds to a software component and every molecule correspond to a new adaptation or creation of a software component whose structure, functionality and behavior could be formed both of its own characteristics or execution environment. @InProceedings{MODULARITY Companion16p143, author = {Juan-Alberto Hernández-Martínez and Ulises Juárez-Martínez}, title = {Model for Fusion of Software Components}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {143--145}, doi = {}, year = {2016}, } |
|
Lehmann, Stefan |
MODULARITY Companion '16-LASSY: "Compatibility Layers for Interface ..."
Compatibility Layers for Interface Mediation at Run-Time
Patrick Rein , Robert Hirschfeld , Stefan Lehmann, and Jens Lincke (HPI, Germany) In adaptable systems, one module might require an interface from another module which the second module does not provide. For some cases, the particular provider module and its interface which will be available at run-time can not be anticipated during development time. In such situations with various provider interfaces, current mitigation strategies for interface mismatches struggle as they often rely on advanced knowledge about one particular providing module. Therefore, we propose the concept of compatibility layers which is based on modular interface mappings. These mappings are applied to adapt the provided interface at run-time. Each mapping contains a set of general requirements for the provided interface and a set of derived functions based on the required features. We have implemented the concept of compatibility layers in a Squeak/Smalltalk prototype based on context-oriented programming. Based on this prototype, we discuss the resulting trade-offs and illustrate exemplary interface mismatches in Squeak/Smalltalk which could be mediated by the prototype. @InProceedings{MODULARITY Companion16p113, author = {Patrick Rein and Robert Hirschfeld and Stefan Lehmann and Jens Lincke}, title = {Compatibility Layers for Interface Mediation at Run-Time}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {113--118}, doi = {}, year = {2016}, } |
|
Lincke, Jens |
MODULARITY Companion '16-LASSY: "Compatibility Layers for Interface ..."
Compatibility Layers for Interface Mediation at Run-Time
Patrick Rein , Robert Hirschfeld , Stefan Lehmann, and Jens Lincke (HPI, Germany) In adaptable systems, one module might require an interface from another module which the second module does not provide. For some cases, the particular provider module and its interface which will be available at run-time can not be anticipated during development time. In such situations with various provider interfaces, current mitigation strategies for interface mismatches struggle as they often rely on advanced knowledge about one particular providing module. Therefore, we propose the concept of compatibility layers which is based on modular interface mappings. These mappings are applied to adapt the provided interface at run-time. Each mapping contains a set of general requirements for the provided interface and a set of derived functions based on the required features. We have implemented the concept of compatibility layers in a Squeak/Smalltalk prototype based on context-oriented programming. Based on this prototype, we discuss the resulting trade-offs and illustrate exemplary interface mismatches in Squeak/Smalltalk which could be mediated by the prototype. @InProceedings{MODULARITY Companion16p113, author = {Patrick Rein and Robert Hirschfeld and Stefan Lehmann and Jens Lincke}, title = {Compatibility Layers for Interface Mediation at Run-Time}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {113--118}, doi = {}, year = {2016}, } |
|
Masuhara, Hidehiko |
MODULARITY Companion '16-LASSY: "Hierarchical Layer-Based Class ..."
Hierarchical Layer-Based Class Extensions in Squeak/Smalltalk
Matthias Springer, Hidehiko Masuhara , and Robert Hirschfeld (Tokyo Institute of Technology, Japan; HPI, Germany) Class extensions are frequently used in programming languages such as Ruby and Smalltalk to add or change methods of a class that is defined in the same application or in a different one. They suffer from modularity issues if globally visible: Other applications using the same classes are then affected by the modifications. This paper presents a hierarchical approach for dynamically scoping class extensions in dynamically-typed, class-based programming languages supporting class nesting. Our mechanism allows programmers to define the scope of class extensions and to reuse class extensions in other programs. Class extensions can be scoped according to a nested class hierarchy or based on whether programmers regard a potentially affected class as a black box or not. Class extensions are organized in layers, where multiple layers targeting the same class can be active at the same time. @InProceedings{MODULARITY Companion16p107, author = {Matthias Springer and Hidehiko Masuhara and Robert Hirschfeld}, title = {Hierarchical Layer-Based Class Extensions in Squeak/Smalltalk}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {107--112}, doi = {}, year = {2016}, } |
|
Mens, Kim |
MODULARITY Companion '16-LASSY: "A Taxonomy of Context-Aware ..."
A Taxonomy of Context-Aware Software Variability Approaches
Kim Mens , Rafael Capilla, Nicolás Cardozo, and Bruno Dumas (Université Catholique de Louvain, Belgium; Rey Juan Carlos University, Spain; Trinity College Dublin, Ireland; University of Namur, Belgium) Modern software systems demand more and more smart capabilities depending on their context of use, as well as the ability to dynamically adapt these capabilities according to sensed context changes. This requires appropriate techniques for modelling, representing and handling context-aware software variability. While traditional variability modelling approaches like feature orientation and software product lines are evolving to address the increased dynamicity and context specificity required for this new generation of software systems, new paradigms such as context-oriented programming have emerged. Although developed independently, since they address similar issues, many similarities exist between these approaches. The purpose of this paper is to define, categorise and compare key concepts shared by these approaches. Such a taxonomy is a first step towards a better understanding of the differences and similarities between different approaches for managing context-aware software variability, and to achieve a cross-fertilisation between them. @InProceedings{MODULARITY Companion16p119, author = {Kim Mens and Rafael Capilla and Nicolás Cardozo and Bruno Dumas}, title = {A Taxonomy of Context-Aware Software Variability Approaches}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {119--124}, doi = {}, year = {2016}, } |
|
Ogura, Nobuhiko |
MODULARITY Companion '16-LASSY: "A Layer-Structure Diagram ..."
A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems
Harumi Watanabe, Ikuta Tanigawa, Midori Sugaya, Nobuhiko Ogura , and Kenji Hisazumi (Tokai University, Japan; Kyushu University, Japan; Shibaura Institute of Technology, Japan; Tokyo City University, Japan) The paper introduces new kinds of diagrams for describing organizations and interactions of layers based on context-oriented technology for context-sensitive embedded system developments. The concept of layers is suitable for processing context-aware embedded systems. As mentioned in several related literatures, layer-interactions cause critical problems such as deadlock, collision, and multi-invocation. To comprehend these problems at a high level, diagrams for visualizing relationships among layers are required. In a previous work, we proposed an OS-like architecture based on context-oriented technologies for embedded system development. The layering mechanism of the architecture dispatches or inserts layers with their states for dealing with layer-interaction problems. The goal of this paper is to introduce diagrams that contain notations for relating with the elements of the layering mechanism. To accomplish this, we consider the following issues: (1) the relations between layers, (2) layer-state management, and (3) context management attributes. The diagrams contribute to understanding layer-interaction problems with time delay and mutually exclusive layers. To explain the diagrams, we provide a simple example of an automatic cleaner robot. @InProceedings{MODULARITY Companion16p125, author = {Harumi Watanabe and Ikuta Tanigawa and Midori Sugaya and Nobuhiko Ogura and Kenji Hisazumi}, title = {A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {125--130}, doi = {}, year = {2016}, } |
|
Pinto, Mónica |
MODULARITY Companion '16-LASSY: "Towards the Dynamic Reconfiguration ..."
Towards the Dynamic Reconfiguration of Quality Attributes
Jose-Miguel Horcas, Mónica Pinto, and Lidia Fuentes (University of Málaga, Spain) There are some Quality Attributes (QAs) whose variability is addressed through functional variability in the software architecture. Separately modelling the variability of these QAs from the variability of the base functionality of the application has many advantages (e.g., a better reusability), and facilitates the reconfiguration of the QA variants at runtime. Many factors may vary the QA functionality: variations in the user preferences and usage needs; variations in the non-functional QAs; variations in resources, hardware, or even in the functionality of the base application, that directly affect the product's QAs. In this paper, we aim to elicit the relationships and dependencies between the functionalities required to satisfy the QAs and all those factors that can provoke a reconfiguration of the software architecture at runtime. We follow an approach in which the variability of the QAs is modelled separately from the base application functionality, and propose a dynamic approach to reconfigure the software architecture based on those reconfiguration criteria. @InProceedings{MODULARITY Companion16p131, author = {Jose-Miguel Horcas and Mónica Pinto and Lidia Fuentes}, title = {Towards the Dynamic Reconfiguration of Quality Attributes}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {131--136}, doi = {}, year = {2016}, } |
|
Rein, Patrick |
MODULARITY Companion '16-LASSY: "Compatibility Layers for Interface ..."
Compatibility Layers for Interface Mediation at Run-Time
Patrick Rein , Robert Hirschfeld , Stefan Lehmann, and Jens Lincke (HPI, Germany) In adaptable systems, one module might require an interface from another module which the second module does not provide. For some cases, the particular provider module and its interface which will be available at run-time can not be anticipated during development time. In such situations with various provider interfaces, current mitigation strategies for interface mismatches struggle as they often rely on advanced knowledge about one particular providing module. Therefore, we propose the concept of compatibility layers which is based on modular interface mappings. These mappings are applied to adapt the provided interface at run-time. Each mapping contains a set of general requirements for the provided interface and a set of derived functions based on the required features. We have implemented the concept of compatibility layers in a Squeak/Smalltalk prototype based on context-oriented programming. Based on this prototype, we discuss the resulting trade-offs and illustrate exemplary interface mismatches in Squeak/Smalltalk which could be mediated by the prototype. @InProceedings{MODULARITY Companion16p113, author = {Patrick Rein and Robert Hirschfeld and Stefan Lehmann and Jens Lincke}, title = {Compatibility Layers for Interface Mediation at Run-Time}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {113--118}, doi = {}, year = {2016}, } |
|
Schill, Alexander |
MODULARITY Companion '16-LASSY: "A Dynamic Instance Binding ..."
A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems
Nguonly Taing, Thomas Springer, Nicolás Cardozo, and Alexander Schill (TU Dresden, Germany; Trinity College Dublin, Ireland) Role-based approaches gain more and more interest for modeling and implementing variable software systems. Role models clearly separate static behavior represented by players and dynamic behavior modeled as roles which can be dynamically bound and unbound to players at run time. To support the execution of role-based systems, a dynamic binding mechanism is required. Especially, since instances of the same player type can play different roles in a single context, the binding mechanism is required to operate at instance level. In this paper, we introduce a mechanism called dynamic instance binding for implementing a runtime for role-based systems. It maintains a look-up table that allows the run-time system to determine and invoke the currently active role binding at instance level. We explain dynamic instance binding mechanism in detail and demonstrate that it is flexible enough to support both adaptation and evolution of software systems at run time. @InProceedings{MODULARITY Companion16p137, author = {Nguonly Taing and Thomas Springer and Nicolás Cardozo and Alexander Schill}, title = {A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {137--142}, doi = {}, year = {2016}, } |
|
Springer, Matthias |
MODULARITY Companion '16-LASSY: "Hierarchical Layer-Based Class ..."
Hierarchical Layer-Based Class Extensions in Squeak/Smalltalk
Matthias Springer, Hidehiko Masuhara , and Robert Hirschfeld (Tokyo Institute of Technology, Japan; HPI, Germany) Class extensions are frequently used in programming languages such as Ruby and Smalltalk to add or change methods of a class that is defined in the same application or in a different one. They suffer from modularity issues if globally visible: Other applications using the same classes are then affected by the modifications. This paper presents a hierarchical approach for dynamically scoping class extensions in dynamically-typed, class-based programming languages supporting class nesting. Our mechanism allows programmers to define the scope of class extensions and to reuse class extensions in other programs. Class extensions can be scoped according to a nested class hierarchy or based on whether programmers regard a potentially affected class as a black box or not. Class extensions are organized in layers, where multiple layers targeting the same class can be active at the same time. @InProceedings{MODULARITY Companion16p107, author = {Matthias Springer and Hidehiko Masuhara and Robert Hirschfeld}, title = {Hierarchical Layer-Based Class Extensions in Squeak/Smalltalk}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {107--112}, doi = {}, year = {2016}, } |
|
Springer, Thomas |
MODULARITY Companion '16-LASSY: "A Dynamic Instance Binding ..."
A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems
Nguonly Taing, Thomas Springer, Nicolás Cardozo, and Alexander Schill (TU Dresden, Germany; Trinity College Dublin, Ireland) Role-based approaches gain more and more interest for modeling and implementing variable software systems. Role models clearly separate static behavior represented by players and dynamic behavior modeled as roles which can be dynamically bound and unbound to players at run time. To support the execution of role-based systems, a dynamic binding mechanism is required. Especially, since instances of the same player type can play different roles in a single context, the binding mechanism is required to operate at instance level. In this paper, we introduce a mechanism called dynamic instance binding for implementing a runtime for role-based systems. It maintains a look-up table that allows the run-time system to determine and invoke the currently active role binding at instance level. We explain dynamic instance binding mechanism in detail and demonstrate that it is flexible enough to support both adaptation and evolution of software systems at run time. @InProceedings{MODULARITY Companion16p137, author = {Nguonly Taing and Thomas Springer and Nicolás Cardozo and Alexander Schill}, title = {A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {137--142}, doi = {}, year = {2016}, } |
|
Sugaya, Midori |
MODULARITY Companion '16-LASSY: "A Layer-Structure Diagram ..."
A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems
Harumi Watanabe, Ikuta Tanigawa, Midori Sugaya, Nobuhiko Ogura , and Kenji Hisazumi (Tokai University, Japan; Kyushu University, Japan; Shibaura Institute of Technology, Japan; Tokyo City University, Japan) The paper introduces new kinds of diagrams for describing organizations and interactions of layers based on context-oriented technology for context-sensitive embedded system developments. The concept of layers is suitable for processing context-aware embedded systems. As mentioned in several related literatures, layer-interactions cause critical problems such as deadlock, collision, and multi-invocation. To comprehend these problems at a high level, diagrams for visualizing relationships among layers are required. In a previous work, we proposed an OS-like architecture based on context-oriented technologies for embedded system development. The layering mechanism of the architecture dispatches or inserts layers with their states for dealing with layer-interaction problems. The goal of this paper is to introduce diagrams that contain notations for relating with the elements of the layering mechanism. To accomplish this, we consider the following issues: (1) the relations between layers, (2) layer-state management, and (3) context management attributes. The diagrams contribute to understanding layer-interaction problems with time delay and mutually exclusive layers. To explain the diagrams, we provide a simple example of an automatic cleaner robot. @InProceedings{MODULARITY Companion16p125, author = {Harumi Watanabe and Ikuta Tanigawa and Midori Sugaya and Nobuhiko Ogura and Kenji Hisazumi}, title = {A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {125--130}, doi = {}, year = {2016}, } |
|
Taing, Nguonly |
MODULARITY Companion '16-LASSY: "A Dynamic Instance Binding ..."
A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems
Nguonly Taing, Thomas Springer, Nicolás Cardozo, and Alexander Schill (TU Dresden, Germany; Trinity College Dublin, Ireland) Role-based approaches gain more and more interest for modeling and implementing variable software systems. Role models clearly separate static behavior represented by players and dynamic behavior modeled as roles which can be dynamically bound and unbound to players at run time. To support the execution of role-based systems, a dynamic binding mechanism is required. Especially, since instances of the same player type can play different roles in a single context, the binding mechanism is required to operate at instance level. In this paper, we introduce a mechanism called dynamic instance binding for implementing a runtime for role-based systems. It maintains a look-up table that allows the run-time system to determine and invoke the currently active role binding at instance level. We explain dynamic instance binding mechanism in detail and demonstrate that it is flexible enough to support both adaptation and evolution of software systems at run time. @InProceedings{MODULARITY Companion16p137, author = {Nguonly Taing and Thomas Springer and Nicolás Cardozo and Alexander Schill}, title = {A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {137--142}, doi = {}, year = {2016}, } |
|
Tanigawa, Ikuta |
MODULARITY Companion '16-LASSY: "A Layer-Structure Diagram ..."
A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems
Harumi Watanabe, Ikuta Tanigawa, Midori Sugaya, Nobuhiko Ogura , and Kenji Hisazumi (Tokai University, Japan; Kyushu University, Japan; Shibaura Institute of Technology, Japan; Tokyo City University, Japan) The paper introduces new kinds of diagrams for describing organizations and interactions of layers based on context-oriented technology for context-sensitive embedded system developments. The concept of layers is suitable for processing context-aware embedded systems. As mentioned in several related literatures, layer-interactions cause critical problems such as deadlock, collision, and multi-invocation. To comprehend these problems at a high level, diagrams for visualizing relationships among layers are required. In a previous work, we proposed an OS-like architecture based on context-oriented technologies for embedded system development. The layering mechanism of the architecture dispatches or inserts layers with their states for dealing with layer-interaction problems. The goal of this paper is to introduce diagrams that contain notations for relating with the elements of the layering mechanism. To accomplish this, we consider the following issues: (1) the relations between layers, (2) layer-state management, and (3) context management attributes. The diagrams contribute to understanding layer-interaction problems with time delay and mutually exclusive layers. To explain the diagrams, we provide a simple example of an automatic cleaner robot. @InProceedings{MODULARITY Companion16p125, author = {Harumi Watanabe and Ikuta Tanigawa and Midori Sugaya and Nobuhiko Ogura and Kenji Hisazumi}, title = {A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {125--130}, doi = {}, year = {2016}, } |
|
Watanabe, Harumi |
MODULARITY Companion '16-LASSY: "A Layer-Structure Diagram ..."
A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems
Harumi Watanabe, Ikuta Tanigawa, Midori Sugaya, Nobuhiko Ogura , and Kenji Hisazumi (Tokai University, Japan; Kyushu University, Japan; Shibaura Institute of Technology, Japan; Tokyo City University, Japan) The paper introduces new kinds of diagrams for describing organizations and interactions of layers based on context-oriented technology for context-sensitive embedded system developments. The concept of layers is suitable for processing context-aware embedded systems. As mentioned in several related literatures, layer-interactions cause critical problems such as deadlock, collision, and multi-invocation. To comprehend these problems at a high level, diagrams for visualizing relationships among layers are required. In a previous work, we proposed an OS-like architecture based on context-oriented technologies for embedded system development. The layering mechanism of the architecture dispatches or inserts layers with their states for dealing with layer-interaction problems. The goal of this paper is to introduce diagrams that contain notations for relating with the elements of the layering mechanism. To accomplish this, we consider the following issues: (1) the relations between layers, (2) layer-state management, and (3) context management attributes. The diagrams contribute to understanding layer-interaction problems with time delay and mutually exclusive layers. To explain the diagrams, we provide a simple example of an automatic cleaner robot. @InProceedings{MODULARITY Companion16p125, author = {Harumi Watanabe and Ikuta Tanigawa and Midori Sugaya and Nobuhiko Ogura and Kenji Hisazumi}, title = {A Layer-Structure Diagram and a Layer-Interaction Diagram towards a Context-Oriented Development Methodology for Embedded Systems}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {125--130}, doi = {}, year = {2016}, } |
23 authors
proc time: 0.24