{"title":"First-class domain specific aspect languages","authors":"Arik Hadas, D. Lorenz","doi":"10.1145/2735386.2735929","DOIUrl":"https://doi.org/10.1145/2735386.2735929","url":null,"abstract":"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.","PeriodicalId":401605,"journal":{"name":"Companion Proceedings of the 14th International Conference on Modularity","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-03-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129889175","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Composition challenges for sensor data visualization","authors":"Ivan Logre, Sébastien Mosser, M. Riveill","doi":"10.1145/2735386.2735927","DOIUrl":"https://doi.org/10.1145/2735386.2735927","url":null,"abstract":"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.","PeriodicalId":401605,"journal":{"name":"Companion Proceedings of the 14th International Conference on Modularity","volume":"35 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-03-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123629124","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"On liberating programs from the von neumann architecture via event-based modularization","authors":"S. Malakuti, M. Aksit","doi":"10.1145/2735386.2735387","DOIUrl":"https://doi.org/10.1145/2735386.2735387","url":null,"abstract":"From the early days of computers, researchers have been trying to invent effective and efficient means for expressing software systems through the introduction of new programming languages. In the early days, due to the limitations of the technology, the abstractions of the programming languages were conceptually close to the abstractions of the von Neumann based realization platforms. With the advancement of the technology, computers have been increasingly applied for complex problems in different application domains. This required the challenge of designing programming languages that resemble more the semantics of software rather than the concepts of underlying machinery. To this aim, various new language concepts, such as object-oriented, aspect-oriented, and event-based languages have been introduced. While these languages were successful in enhancing the expression power of languages towards more semantic concerns of application domains, they fail in short in representing emergent behavioral patterns of software effectively. We outline a set of requirements to overcome these shortcomings, and explain the concept of event-based modularization as a possible solution.","PeriodicalId":401605,"journal":{"name":"Companion Proceedings of the 14th International Conference on Modularity","volume":"35 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-03-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123533450","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Towards the use of slicing techniques for an efficient invariant checking","authors":"Wuliang Sun, B. Combemale, R. France","doi":"10.1145/2735386.2735926","DOIUrl":"https://doi.org/10.1145/2735386.2735926","url":null,"abstract":"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.","PeriodicalId":401605,"journal":{"name":"Companion Proceedings of the 14th International Conference on Modularity","volume":"48 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-03-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121650260","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Ikuta Tanigawa, Nobuhiko Ogura, Midori Sugaya, Harumi Watanabe, K. Hisazumi
{"title":"A structure of a c# framework ContextCS based on context-oriented programming","authors":"Ikuta Tanigawa, Nobuhiko Ogura, Midori Sugaya, Harumi Watanabe, K. Hisazumi","doi":"10.1145/2735386.2735925","DOIUrl":"https://doi.org/10.1145/2735386.2735925","url":null,"abstract":"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.","PeriodicalId":401605,"journal":{"name":"Companion Proceedings of the 14th International Conference on Modularity","volume":"86 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-03-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121716162","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Essential retroactive weaving","authors":"R. Salkeld, Ronald Garcia","doi":"10.1145/2735386.2736751","DOIUrl":"https://doi.org/10.1145/2735386.2736751","url":null,"abstract":"To help analyze unexpected behaviour, programming language environments and tools are beginning to support high-fidelity recordings of program executions. Such recordings are typically low-level and difficult to work with directly. Debugging and analyzing these recordings is easier and more powerful if it is possible to simulate executing additional code in the past context of the recording. In prior work we proposed retroactive weaving, the process of evaluating aspects as if they were present during a past execution. This concept is intended as a general framework for introducing additional code and defining the semantics of executing it post-hoc. In this paper we express retroactive weaving as a transformation on aspect-oriented programming languages and their semantics. We demonstrate this transformation by applying it to a simple core aspect-oriented language, and through a definitional interpreter illustrate its interactions with first-class function values, mutable state, and external input and output. In particular a key concern of retroactive weavers is maintaining soundness: behaving consistently with the context of the past execution, and failing if missing information makes this impossible. Retroactive weavers may need to include extra isolation or runtime checks to meet this requirement.","PeriodicalId":401605,"journal":{"name":"Companion Proceedings of the 14th International Conference on Modularity","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-03-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130643127","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"Modeling requirements for model-driven engineering of large software solutions needing a modular approach","authors":"D. Matheson","doi":"10.1145/2735386.2735928","DOIUrl":"https://doi.org/10.1145/2735386.2735928","url":null,"abstract":"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.","PeriodicalId":401605,"journal":{"name":"Companion Proceedings of the 14th International Conference on Modularity","volume":"54 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-03-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121964334","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
{"title":"A language workbench for implementing your favorite extension to AspectJ","authors":"Arik Hadas, D. Lorenz","doi":"10.1145/2735386.2735924","DOIUrl":"https://doi.org/10.1145/2735386.2735924","url":null,"abstract":"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.","PeriodicalId":401605,"journal":{"name":"Companion Proceedings of the 14th International Conference on Modularity","volume":"20 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2015-03-16","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131968104","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}