MODULARITY Companion 2015 – Author Index |
Contents -
Abstracts -
Authors
|
Alam, Omar |
MODULARITY Companion '15-DEMO: "Feature Modelling and Traceability ..."
Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE
Matthias Schöttle, Nishanth Thimmegowda, Omar Alam, Jörg Kienzle, and Gunter Mussbacher (McGill University, Canada) This demonstration paper presents TouchCORE, a multi-touch enabled software design modelling tool aimed at developing scalable and reusable software design models following the concerndriven software development paradigm. After a quick review of concern-orientation, this paper primarily focusses on the new features that were added to TouchCORE since the last demonstration at Modularity 2014 (were the tool was still called TouchRAM). TouchCORE now provides full support for concern-orientation. This includes support for feature model editing and different modes for feature model and impact model visualization and assessment to best assist the concern designers as well as the concern users. To help the modeller understand the interactions between concerns, TouchCORE now also collects tracing information when concerns are reused and stores that information with the woven models. This makes it possible to visualize from which concern(s) a model element in the woven model has originated. @InProceedings{MODULARITY Companion15p11, author = {Matthias Schöttle and Nishanth Thimmegowda and Omar Alam and Jörg Kienzle and Gunter Mussbacher}, title = {Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {11--14}, doi = {}, year = {2015}, } Info |
|
Combemale, Benoit |
MODULARITY Companion '15-DEMO: "Towards the Use of Slicing ..."
Towards the Use of Slicing Techniques for an Efficient Invariant Checking
Wuliang Sun, Benoit Combemale , and Robert B. France (Colorado State University, USA; University of Rennes 1, France; INRIA, France) In Model Driven Development (MDD), invariant checking involves determining whether a model is consistent with invariants defined in a metamodel. Such checking can improve developers' understanding of modeled aspects of complex systems and uncover structural errors in design models during the early stages of software development. General-purpose rigorous analysis tools that check invariants are likely to perform the analysis over the entire metamodel and model. Their scalability thus becomes an issue (e.g., the time used for checking can be up to several hours) with very large metamodels and models (e.g., more than 500,000 elements). In this paper we introduce model slicing within the invariant checking process, and use a slicing technique to reduce the size of checking inputs to improve the scalability of existing invariant checking tools. The evaluation we performed provides evidence that model slicing can significantly reduce the time to perform the invariant checking while preserving the checking results. @InProceedings{MODULARITY Companion15p23, author = {Wuliang Sun and Benoit Combemale and Robert B. France}, title = {Towards the Use of Slicing Techniques for an Efficient Invariant Checking}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {23--24}, doi = {}, year = {2015}, } |
|
France, Robert B. |
MODULARITY Companion '15-DEMO: "Towards the Use of Slicing ..."
Towards the Use of Slicing Techniques for an Efficient Invariant Checking
Wuliang Sun, Benoit Combemale , and Robert B. France (Colorado State University, USA; University of Rennes 1, France; INRIA, France) In Model Driven Development (MDD), invariant checking involves determining whether a model is consistent with invariants defined in a metamodel. Such checking can improve developers' understanding of modeled aspects of complex systems and uncover structural errors in design models during the early stages of software development. General-purpose rigorous analysis tools that check invariants are likely to perform the analysis over the entire metamodel and model. Their scalability thus becomes an issue (e.g., the time used for checking can be up to several hours) with very large metamodels and models (e.g., more than 500,000 elements). In this paper we introduce model slicing within the invariant checking process, and use a slicing technique to reduce the size of checking inputs to improve the scalability of existing invariant checking tools. The evaluation we performed provides evidence that model slicing can significantly reduce the time to perform the invariant checking while preserving the checking results. @InProceedings{MODULARITY Companion15p23, author = {Wuliang Sun and Benoit Combemale and Robert B. France}, title = {Towards the Use of Slicing Techniques for an Efficient Invariant Checking}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {23--24}, doi = {}, year = {2015}, } |
|
Hadas, Arik |
MODULARITY Companion '15-DEMO: "First-Class Domain Specific ..."
First-Class Domain Specific Aspect Languages
Arik Hadas and David H. Lorenz (Open University of Israel, Israel; Technion, Israel) Programming in a domain specific aspect language (DSAL) typically involves some language workbench for transforming the DSAL code and some AOP composition framework for weaving the transformed code. However, DSAL development remains second-class in two respects. Unlike programming in a general purpose aspect language, compiling DSAL code requires pre-processing that makes the program source code incompatible with existing AOP tools. Unlike defining a domain specific language, defining a DSAL requires weaving semantics whose specification is not supported in the language workbench. In this work we present a DSAL workbench solution in which DSALs are first-class DSLs as well as first-class AOP languages. We illustrate the approach by integrating the Spoofax language workbench and the Awesome composition framework into such a DSAL workbench. @InProceedings{MODULARITY Companion15p29, author = {Arik Hadas and David H. Lorenz}, title = {First-Class Domain Specific Aspect Languages}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {29--30}, doi = {}, year = {2015}, } MODULARITY Companion '15-DEMO: "A Language Workbench for Implementing ..." A Language Workbench for Implementing Your Favorite Extension to AspectJ Arik Hadas and David H. Lorenz (Open University of Israel, Israel; Technion, Israel) Many extensions to AspectJ are proposed and prototyped. However, without a supportive language workbench the proper evaluation and production of these extensions is often prohibitively costly. We demonstrate a novel language workbench for creating such extensions, comprising Awesome and Spoofax. The implementation of two advanced extensions to AspectJ are illustrated: explicit join points (EJPs) and closure join points (CJPs). Not only were these extensions fully implemented from scratch with reasonable effort, but also our implementations support advanced features that were omitted in the original prototypes. The demonstration will provide a hands-on overview of the process of implementing EJPs and CJPs in our workbench and how one can implement other extensions with relative ease. @InProceedings{MODULARITY Companion15p19, author = {Arik Hadas and David H. Lorenz}, title = {A Language Workbench for Implementing Your Favorite Extension to AspectJ}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {19--20}, doi = {}, year = {2015}, } |
|
Hisazumi, Kenji |
MODULARITY Companion '15-DEMO: "A Structure of a C# Framework ..."
A Structure of a C# Framework ContextCS Based on Context-Oriented Programming
Ikuta Tanigawa, Nobuhiko Ogura , Midori Sugaya, Harumi Watanabe, and Kenji Hisazumi (Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan; Kyushu University, Japan) Context-oriented programming (COP) treats context explicitly and provides mechanisms to adapt behavior dynamically in reaction to changes in context at runtime. These languages are desirable to context-sensitive embedded software since such software usually works in various contexts of heterogeneous devices and complex environments. Moreover, a practical development requires proper handling of legacy programs and product lines. To realize these characteristics, we have developed a C# framework called Con-textCS that contains the following features: layer creation at runtime, separation of layer managing program, and the layer with annotation. The article presents the structure of ContextCS. @InProceedings{MODULARITY Companion15p21, author = {Ikuta Tanigawa and Nobuhiko Ogura and Midori Sugaya and Harumi Watanabe and Kenji Hisazumi}, title = {A Structure of a C# Framework ContextCS Based on Context-Oriented Programming}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {21--22}, doi = {}, year = {2015}, } |
|
Kienzle, Jörg |
MODULARITY Companion '15-DEMO: "Feature Modelling and Traceability ..."
Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE
Matthias Schöttle, Nishanth Thimmegowda, Omar Alam, Jörg Kienzle, and Gunter Mussbacher (McGill University, Canada) This demonstration paper presents TouchCORE, a multi-touch enabled software design modelling tool aimed at developing scalable and reusable software design models following the concerndriven software development paradigm. After a quick review of concern-orientation, this paper primarily focusses on the new features that were added to TouchCORE since the last demonstration at Modularity 2014 (were the tool was still called TouchRAM). TouchCORE now provides full support for concern-orientation. This includes support for feature model editing and different modes for feature model and impact model visualization and assessment to best assist the concern designers as well as the concern users. To help the modeller understand the interactions between concerns, TouchCORE now also collects tracing information when concerns are reused and stores that information with the woven models. This makes it possible to visualize from which concern(s) a model element in the woven model has originated. @InProceedings{MODULARITY Companion15p11, author = {Matthias Schöttle and Nishanth Thimmegowda and Omar Alam and Jörg Kienzle and Gunter Mussbacher}, title = {Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {11--14}, doi = {}, year = {2015}, } Info |
|
Kimelman, Doug |
MODULARITY Companion '15-DEMO: "Subjective, Multidimensional ..."
Subjective, Multidimensional Modularity with Korz
Harold Ossher, David Ungar, and Doug Kimelman (IBM Research, USA) Korz is a new computational model that provides for context-oriented programming by combining implicit arguments and multiple dispatch in a slot-based model. This synthesis enables the writing of software that supports contextual variation along multiple dimensions, and graceful evolution of that software to support new, unexpected dimensions of variability, without the need for additional mechanism such as layers or aspects. With Korz, a system consists of a sea of method and data slots in a multidimensional space. There is no fixed organization of slots into objects – a slot pertains to a number of objects instead of being contained by a single object – and slots can come together according to the implicit context in any given situation, yielding subjective objects. There is no dominant decomposition, and no dimension holds sway over any other. IDE support is essential for managing complexity when working with the slot space and with subjectivity, allowing the task at hand to dictate what subspaces to isolate and what dominance of dimensions to use when presenting nested views to the user. We have implemented a prototype interpreter and IDE, and used it on several examples. This early experience has revealed much that needs to be done, but has also shown promise. It seems that Korz's particular combination of concepts, each well-known from the past, is indeed more powerful than the sum of its parts. @InProceedings{MODULARITY Companion15p15, author = {Harold Ossher and David Ungar and Doug Kimelman}, title = {Subjective, Multidimensional Modularity with Korz}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {15--18}, doi = {}, year = {2015}, } |
|
Logre, Ivan |
MODULARITY Companion '15-DEMO: "Composition Challenges for ..."
Composition Challenges for Sensor Data Visualization
Ivan Logre, Sébastien Mosser, and Michel Riveill (University of Nice Sophia Antipolis, France; CNRS, France) Connected objects and monitoring systems continuously produce data about their environment. Dashboards are then designed to aggregate and present these data to end-users. Technologies used to design and implement visualization dashboards are babbling from a software engineering point of view. This paper highlights how this domain could benefit from leveraging separation of concerns and software composition paradigms to support dashboard design. @InProceedings{MODULARITY Companion15p25, author = {Ivan Logre and Sébastien Mosser and Michel Riveill}, title = {Composition Challenges for Sensor Data Visualization}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {25--26}, doi = {}, year = {2015}, } |
|
Lorenz, David H. |
MODULARITY Companion '15-DEMO: "First-Class Domain Specific ..."
First-Class Domain Specific Aspect Languages
Arik Hadas and David H. Lorenz (Open University of Israel, Israel; Technion, Israel) Programming in a domain specific aspect language (DSAL) typically involves some language workbench for transforming the DSAL code and some AOP composition framework for weaving the transformed code. However, DSAL development remains second-class in two respects. Unlike programming in a general purpose aspect language, compiling DSAL code requires pre-processing that makes the program source code incompatible with existing AOP tools. Unlike defining a domain specific language, defining a DSAL requires weaving semantics whose specification is not supported in the language workbench. In this work we present a DSAL workbench solution in which DSALs are first-class DSLs as well as first-class AOP languages. We illustrate the approach by integrating the Spoofax language workbench and the Awesome composition framework into such a DSAL workbench. @InProceedings{MODULARITY Companion15p29, author = {Arik Hadas and David H. Lorenz}, title = {First-Class Domain Specific Aspect Languages}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {29--30}, doi = {}, year = {2015}, } MODULARITY Companion '15-DEMO: "A Language Workbench for Implementing ..." A Language Workbench for Implementing Your Favorite Extension to AspectJ Arik Hadas and David H. Lorenz (Open University of Israel, Israel; Technion, Israel) Many extensions to AspectJ are proposed and prototyped. However, without a supportive language workbench the proper evaluation and production of these extensions is often prohibitively costly. We demonstrate a novel language workbench for creating such extensions, comprising Awesome and Spoofax. The implementation of two advanced extensions to AspectJ are illustrated: explicit join points (EJPs) and closure join points (CJPs). Not only were these extensions fully implemented from scratch with reasonable effort, but also our implementations support advanced features that were omitted in the original prototypes. The demonstration will provide a hands-on overview of the process of implementing EJPs and CJPs in our workbench and how one can implement other extensions with relative ease. @InProceedings{MODULARITY Companion15p19, author = {Arik Hadas and David H. Lorenz}, title = {A Language Workbench for Implementing Your Favorite Extension to AspectJ}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {19--20}, doi = {}, year = {2015}, } |
|
Matheson, Dan |
MODULARITY Companion '15-DEMO: "Modeling Requirements for ..."
Modeling Requirements for Model-Driven Engineering of Large Software Solutions Needing a Modular Approach
Dan Matheson (Colorado State University, USA) This paper accompanies a poster submission for the Modularity 2015 conference. The results described in the poster and this overview paper are the accumulation from six years of industry project experience. The projects were multi-year in length with development team sizes of 10 – 20 people, plus the customers. The long project times necessitated the modular structuring of the solution to enable the delivery of partial value as soon as possible. The modular structuring began at the requirements level. The poster lists a brief summary, some of the research questions, the process approaches used and some of the modeling artifacts found useful. There is still work to be done to convert the informal results to a more formal basis in terms of meta-models and cognitive effectiveness. @InProceedings{MODULARITY Companion15p27, author = {Dan Matheson}, title = {Modeling Requirements for Model-Driven Engineering of Large Software Solutions Needing a Modular Approach}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {27--28}, doi = {}, year = {2015}, } |
|
Mosser, Sébastien |
MODULARITY Companion '15-DEMO: "Composition Challenges for ..."
Composition Challenges for Sensor Data Visualization
Ivan Logre, Sébastien Mosser, and Michel Riveill (University of Nice Sophia Antipolis, France; CNRS, France) Connected objects and monitoring systems continuously produce data about their environment. Dashboards are then designed to aggregate and present these data to end-users. Technologies used to design and implement visualization dashboards are babbling from a software engineering point of view. This paper highlights how this domain could benefit from leveraging separation of concerns and software composition paradigms to support dashboard design. @InProceedings{MODULARITY Companion15p25, author = {Ivan Logre and Sébastien Mosser and Michel Riveill}, title = {Composition Challenges for Sensor Data Visualization}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {25--26}, doi = {}, year = {2015}, } |
|
Mussbacher, Gunter |
MODULARITY Companion '15-DEMO: "Feature Modelling and Traceability ..."
Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE
Matthias Schöttle, Nishanth Thimmegowda, Omar Alam, Jörg Kienzle, and Gunter Mussbacher (McGill University, Canada) This demonstration paper presents TouchCORE, a multi-touch enabled software design modelling tool aimed at developing scalable and reusable software design models following the concerndriven software development paradigm. After a quick review of concern-orientation, this paper primarily focusses on the new features that were added to TouchCORE since the last demonstration at Modularity 2014 (were the tool was still called TouchRAM). TouchCORE now provides full support for concern-orientation. This includes support for feature model editing and different modes for feature model and impact model visualization and assessment to best assist the concern designers as well as the concern users. To help the modeller understand the interactions between concerns, TouchCORE now also collects tracing information when concerns are reused and stores that information with the woven models. This makes it possible to visualize from which concern(s) a model element in the woven model has originated. @InProceedings{MODULARITY Companion15p11, author = {Matthias Schöttle and Nishanth Thimmegowda and Omar Alam and Jörg Kienzle and Gunter Mussbacher}, title = {Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {11--14}, doi = {}, year = {2015}, } Info |
|
Ogura, Nobuhiko |
MODULARITY Companion '15-DEMO: "A Structure of a C# Framework ..."
A Structure of a C# Framework ContextCS Based on Context-Oriented Programming
Ikuta Tanigawa, Nobuhiko Ogura , Midori Sugaya, Harumi Watanabe, and Kenji Hisazumi (Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan; Kyushu University, Japan) Context-oriented programming (COP) treats context explicitly and provides mechanisms to adapt behavior dynamically in reaction to changes in context at runtime. These languages are desirable to context-sensitive embedded software since such software usually works in various contexts of heterogeneous devices and complex environments. Moreover, a practical development requires proper handling of legacy programs and product lines. To realize these characteristics, we have developed a C# framework called Con-textCS that contains the following features: layer creation at runtime, separation of layer managing program, and the layer with annotation. The article presents the structure of ContextCS. @InProceedings{MODULARITY Companion15p21, author = {Ikuta Tanigawa and Nobuhiko Ogura and Midori Sugaya and Harumi Watanabe and Kenji Hisazumi}, title = {A Structure of a C# Framework ContextCS Based on Context-Oriented Programming}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {21--22}, doi = {}, year = {2015}, } |
|
Ossher, Harold |
MODULARITY Companion '15-DEMO: "Subjective, Multidimensional ..."
Subjective, Multidimensional Modularity with Korz
Harold Ossher, David Ungar, and Doug Kimelman (IBM Research, USA) Korz is a new computational model that provides for context-oriented programming by combining implicit arguments and multiple dispatch in a slot-based model. This synthesis enables the writing of software that supports contextual variation along multiple dimensions, and graceful evolution of that software to support new, unexpected dimensions of variability, without the need for additional mechanism such as layers or aspects. With Korz, a system consists of a sea of method and data slots in a multidimensional space. There is no fixed organization of slots into objects – a slot pertains to a number of objects instead of being contained by a single object – and slots can come together according to the implicit context in any given situation, yielding subjective objects. There is no dominant decomposition, and no dimension holds sway over any other. IDE support is essential for managing complexity when working with the slot space and with subjectivity, allowing the task at hand to dictate what subspaces to isolate and what dominance of dimensions to use when presenting nested views to the user. We have implemented a prototype interpreter and IDE, and used it on several examples. This early experience has revealed much that needs to be done, but has also shown promise. It seems that Korz's particular combination of concepts, each well-known from the past, is indeed more powerful than the sum of its parts. @InProceedings{MODULARITY Companion15p15, author = {Harold Ossher and David Ungar and Doug Kimelman}, title = {Subjective, Multidimensional Modularity with Korz}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {15--18}, doi = {}, year = {2015}, } |
|
Riveill, Michel |
MODULARITY Companion '15-DEMO: "Composition Challenges for ..."
Composition Challenges for Sensor Data Visualization
Ivan Logre, Sébastien Mosser, and Michel Riveill (University of Nice Sophia Antipolis, France; CNRS, France) Connected objects and monitoring systems continuously produce data about their environment. Dashboards are then designed to aggregate and present these data to end-users. Technologies used to design and implement visualization dashboards are babbling from a software engineering point of view. This paper highlights how this domain could benefit from leveraging separation of concerns and software composition paradigms to support dashboard design. @InProceedings{MODULARITY Companion15p25, author = {Ivan Logre and Sébastien Mosser and Michel Riveill}, title = {Composition Challenges for Sensor Data Visualization}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {25--26}, doi = {}, year = {2015}, } |
|
Schöttle, Matthias |
MODULARITY Companion '15-DEMO: "Feature Modelling and Traceability ..."
Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE
Matthias Schöttle, Nishanth Thimmegowda, Omar Alam, Jörg Kienzle, and Gunter Mussbacher (McGill University, Canada) This demonstration paper presents TouchCORE, a multi-touch enabled software design modelling tool aimed at developing scalable and reusable software design models following the concerndriven software development paradigm. After a quick review of concern-orientation, this paper primarily focusses on the new features that were added to TouchCORE since the last demonstration at Modularity 2014 (were the tool was still called TouchRAM). TouchCORE now provides full support for concern-orientation. This includes support for feature model editing and different modes for feature model and impact model visualization and assessment to best assist the concern designers as well as the concern users. To help the modeller understand the interactions between concerns, TouchCORE now also collects tracing information when concerns are reused and stores that information with the woven models. This makes it possible to visualize from which concern(s) a model element in the woven model has originated. @InProceedings{MODULARITY Companion15p11, author = {Matthias Schöttle and Nishanth Thimmegowda and Omar Alam and Jörg Kienzle and Gunter Mussbacher}, title = {Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {11--14}, doi = {}, year = {2015}, } Info |
|
Sugaya, Midori |
MODULARITY Companion '15-DEMO: "A Structure of a C# Framework ..."
A Structure of a C# Framework ContextCS Based on Context-Oriented Programming
Ikuta Tanigawa, Nobuhiko Ogura , Midori Sugaya, Harumi Watanabe, and Kenji Hisazumi (Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan; Kyushu University, Japan) Context-oriented programming (COP) treats context explicitly and provides mechanisms to adapt behavior dynamically in reaction to changes in context at runtime. These languages are desirable to context-sensitive embedded software since such software usually works in various contexts of heterogeneous devices and complex environments. Moreover, a practical development requires proper handling of legacy programs and product lines. To realize these characteristics, we have developed a C# framework called Con-textCS that contains the following features: layer creation at runtime, separation of layer managing program, and the layer with annotation. The article presents the structure of ContextCS. @InProceedings{MODULARITY Companion15p21, author = {Ikuta Tanigawa and Nobuhiko Ogura and Midori Sugaya and Harumi Watanabe and Kenji Hisazumi}, title = {A Structure of a C# Framework ContextCS Based on Context-Oriented Programming}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {21--22}, doi = {}, year = {2015}, } |
|
Sun, Wuliang |
MODULARITY Companion '15-DEMO: "Towards the Use of Slicing ..."
Towards the Use of Slicing Techniques for an Efficient Invariant Checking
Wuliang Sun, Benoit Combemale , and Robert B. France (Colorado State University, USA; University of Rennes 1, France; INRIA, France) In Model Driven Development (MDD), invariant checking involves determining whether a model is consistent with invariants defined in a metamodel. Such checking can improve developers' understanding of modeled aspects of complex systems and uncover structural errors in design models during the early stages of software development. General-purpose rigorous analysis tools that check invariants are likely to perform the analysis over the entire metamodel and model. Their scalability thus becomes an issue (e.g., the time used for checking can be up to several hours) with very large metamodels and models (e.g., more than 500,000 elements). In this paper we introduce model slicing within the invariant checking process, and use a slicing technique to reduce the size of checking inputs to improve the scalability of existing invariant checking tools. The evaluation we performed provides evidence that model slicing can significantly reduce the time to perform the invariant checking while preserving the checking results. @InProceedings{MODULARITY Companion15p23, author = {Wuliang Sun and Benoit Combemale and Robert B. France}, title = {Towards the Use of Slicing Techniques for an Efficient Invariant Checking}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {23--24}, doi = {}, year = {2015}, } |
|
Tanigawa, Ikuta |
MODULARITY Companion '15-DEMO: "A Structure of a C# Framework ..."
A Structure of a C# Framework ContextCS Based on Context-Oriented Programming
Ikuta Tanigawa, Nobuhiko Ogura , Midori Sugaya, Harumi Watanabe, and Kenji Hisazumi (Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan; Kyushu University, Japan) Context-oriented programming (COP) treats context explicitly and provides mechanisms to adapt behavior dynamically in reaction to changes in context at runtime. These languages are desirable to context-sensitive embedded software since such software usually works in various contexts of heterogeneous devices and complex environments. Moreover, a practical development requires proper handling of legacy programs and product lines. To realize these characteristics, we have developed a C# framework called Con-textCS that contains the following features: layer creation at runtime, separation of layer managing program, and the layer with annotation. The article presents the structure of ContextCS. @InProceedings{MODULARITY Companion15p21, author = {Ikuta Tanigawa and Nobuhiko Ogura and Midori Sugaya and Harumi Watanabe and Kenji Hisazumi}, title = {A Structure of a C# Framework ContextCS Based on Context-Oriented Programming}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {21--22}, doi = {}, year = {2015}, } |
|
Thimmegowda, Nishanth |
MODULARITY Companion '15-DEMO: "Feature Modelling and Traceability ..."
Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE
Matthias Schöttle, Nishanth Thimmegowda, Omar Alam, Jörg Kienzle, and Gunter Mussbacher (McGill University, Canada) This demonstration paper presents TouchCORE, a multi-touch enabled software design modelling tool aimed at developing scalable and reusable software design models following the concerndriven software development paradigm. After a quick review of concern-orientation, this paper primarily focusses on the new features that were added to TouchCORE since the last demonstration at Modularity 2014 (were the tool was still called TouchRAM). TouchCORE now provides full support for concern-orientation. This includes support for feature model editing and different modes for feature model and impact model visualization and assessment to best assist the concern designers as well as the concern users. To help the modeller understand the interactions between concerns, TouchCORE now also collects tracing information when concerns are reused and stores that information with the woven models. This makes it possible to visualize from which concern(s) a model element in the woven model has originated. @InProceedings{MODULARITY Companion15p11, author = {Matthias Schöttle and Nishanth Thimmegowda and Omar Alam and Jörg Kienzle and Gunter Mussbacher}, title = {Feature Modelling and Traceability for Concern-Driven Software Development with TouchCORE}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {11--14}, doi = {}, year = {2015}, } Info |
|
Ungar, David |
MODULARITY Companion '15-DEMO: "Subjective, Multidimensional ..."
Subjective, Multidimensional Modularity with Korz
Harold Ossher, David Ungar, and Doug Kimelman (IBM Research, USA) Korz is a new computational model that provides for context-oriented programming by combining implicit arguments and multiple dispatch in a slot-based model. This synthesis enables the writing of software that supports contextual variation along multiple dimensions, and graceful evolution of that software to support new, unexpected dimensions of variability, without the need for additional mechanism such as layers or aspects. With Korz, a system consists of a sea of method and data slots in a multidimensional space. There is no fixed organization of slots into objects – a slot pertains to a number of objects instead of being contained by a single object – and slots can come together according to the implicit context in any given situation, yielding subjective objects. There is no dominant decomposition, and no dimension holds sway over any other. IDE support is essential for managing complexity when working with the slot space and with subjectivity, allowing the task at hand to dictate what subspaces to isolate and what dominance of dimensions to use when presenting nested views to the user. We have implemented a prototype interpreter and IDE, and used it on several examples. This early experience has revealed much that needs to be done, but has also shown promise. It seems that Korz's particular combination of concepts, each well-known from the past, is indeed more powerful than the sum of its parts. @InProceedings{MODULARITY Companion15p15, author = {Harold Ossher and David Ungar and Doug Kimelman}, title = {Subjective, Multidimensional Modularity with Korz}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {15--18}, doi = {}, year = {2015}, } |
|
Watanabe, Harumi |
MODULARITY Companion '15-DEMO: "A Structure of a C# Framework ..."
A Structure of a C# Framework ContextCS Based on Context-Oriented Programming
Ikuta Tanigawa, Nobuhiko Ogura , Midori Sugaya, Harumi Watanabe, and Kenji Hisazumi (Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan; Kyushu University, Japan) Context-oriented programming (COP) treats context explicitly and provides mechanisms to adapt behavior dynamically in reaction to changes in context at runtime. These languages are desirable to context-sensitive embedded software since such software usually works in various contexts of heterogeneous devices and complex environments. Moreover, a practical development requires proper handling of legacy programs and product lines. To realize these characteristics, we have developed a C# framework called Con-textCS that contains the following features: layer creation at runtime, separation of layer managing program, and the layer with annotation. The article presents the structure of ContextCS. @InProceedings{MODULARITY Companion15p21, author = {Ikuta Tanigawa and Nobuhiko Ogura and Midori Sugaya and Harumi Watanabe and Kenji Hisazumi}, title = {A Structure of a C# Framework ContextCS Based on Context-Oriented Programming}, booktitle = {Proc.\ MODULARITY Companion}, publisher = {ACM}, pages = {21--22}, doi = {}, year = {2015}, } |
22 authors
proc time: 1.06