{"title":"Modularity for the changing meaning of changing","authors":"W. Harrison","doi":"10.1145/1960275.1960313","DOIUrl":"https://doi.org/10.1145/1960275.1960313","url":null,"abstract":"In the past, modular structures for software systems have rested upon several assumptions that may no longer characterize the changing world of dynamic computing. Important among these assumptions is that the decision to use or reuse a particular component is made at the time a client is developed. But the advent of a variety of modern software architectures like SOA, mobile/ubiquitous computing, grids, and AOSD emphasize deferring these decisions about component choice until run-time.\u0000 The presumption of development-time choice has had deep influence on many of the characteristics of programming languages. We explore the impact of the change of implementation selection from development-time to run-time on programming language constructs and middleware, and conclude that there is a model for software that satisfies the needs of future, more dynamic environments in a way that can be achieved as a compatible extension of today's common object-oriented languages.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130457959","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":"EventCJ: a context-oriented programming language with declarative event-based context transition","authors":"T. Kamina, Tomoyuki Aotani, H. Masuhara","doi":"10.1145/1960275.1960305","DOIUrl":"https://doi.org/10.1145/1960275.1960305","url":null,"abstract":"This paper proposes EventCJ, a context-oriented programming (COP) language that can modularly control layer activation based on user-defined events. In addition to defining context-specific behaviors by using existing COP constructs, the EventCJ programmer declares events to specify when and on which instance layer switching should happen, and layer transition rules to specify which layers should be activated/deactivated upon events. These constructs enable controlling layer activation on a per-instance basis, separately from a base program. We also demonstrate an approach to verify safety properties of layer transitions by using a model checker. With these advantages, EventCJ enables more modular descriptions of context-aware programs, especially when layer switching is triggered in many places of a program, or by activities external to the base program. We implemented a prototype EventCJ compiler with Eclipse IDE support.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131272632","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}
Urjaswala Vora, Peeyush Chomal, R. Upadhyay, Vikram Khati
{"title":"Modularity in continually evolving systems","authors":"Urjaswala Vora, Peeyush Chomal, R. Upadhyay, Vikram Khati","doi":"10.1145/1960314.1960316","DOIUrl":"https://doi.org/10.1145/1960314.1960316","url":null,"abstract":"The design of a continually-evolving system deteriorates in proportion to the frequency of evolution as much as the complexity of evolution. Here we introduce a design paradigm, Temporal Control Flow Rule-based Architecture (TeCFRA), with a vision to support dynamic evolution in software architecture. TeCFRA provides this support especially when new rules for existing business processes co-exist with old rules. TeCFRA also strives to attain a higher precision level in change-impact analysis.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"34 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128119733","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":"Analyzing the discipline of preprocessor annotations in 30 million lines of C code","authors":"Jörg Liebig, Christian Kästner, S. Apel","doi":"10.1145/1960275.1960299","DOIUrl":"https://doi.org/10.1145/1960275.1960299","url":null,"abstract":"The C preprocessor cpp is a widely used tool for implementing variable software. It enables programmers to express variable code (which may even crosscut the entire implementation) with conditional compilation. The C preprocessor relies on simple text processing and is independent of the host language (C, C++, Java, and so on). Language-independent text processing is powerful and expressive - programmers can make all kinds of annotations in the form of #ifdefs - but can render unpreprocessed code difficult to process automatically by tools, such as refactoring, concern management, and variability-aware type checking. We distinguish between disciplined annotations, which align with the underlying source-code structure, and undisciplined annotations, which do not align with the structure and hence complicate tool development. This distinction raises the question of how frequently programmers use undisciplined annotations and whether it is feasible to change them to disciplined annotations to simplify tool development and to enable programmers to use a wide variety of tools in the first place. By means of an analysis of 40 medium-sized to large-sized C programs, we show empirically that programmers use cpp mostly in a disciplined way: about 84% of all annotations respect the underlying source-code structure. Furthermore, we analyze the remaining undisciplined annotations, identify patterns, and discuss how to transform them into a disciplined form.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"21 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127958577","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":"Modularity for the modern world: summary of invited keynote","authors":"M. Shaw","doi":"10.1145/1960275.1960277","DOIUrl":"https://doi.org/10.1145/1960275.1960277","url":null,"abstract":"Aspect-oriented software development is motivated by the desire to localize definitions of independent concerns in the software. Localized definitions are a form of modularity that achieve separation of concerns in the design, but the non-hierarchical character of the concerns creates structure clashes with the hierarchical modular constructs in conventional programming languages. Aspect-oriented modularity achieves the benefits of localized definitions, but at the costs of complexity both in the tools that weave the aspects into code and in the task of understanding the interactions among definitions.\u0000 Aspect-oriented modularity is one of several types of modularity that have emerged in the past decade or so. Much of this growth has been triggered by the penetration of computing and information technology into all aspects of modern life. Much of the conventional wisdom of software engineering, especially about modularity, is challenged by the shift from in-house software development to composition of Internet-accessible resources and by the involvement of end-user programmers in development.\u0000 This talk will discuss the larger landscape of modularity in modern computing and information systems, including the motivations for introducing modularity, the sorts of information that can usefully be modularized, mechanisms that bridge from the modular abstractions to running code, generality/power tradeoffs, and examples that show this diversity.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"89 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115727745","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":"Refactoring at the core of agile software development","authors":"J. Yoder","doi":"10.1145/1960314.1960327","DOIUrl":"https://doi.org/10.1145/1960314.1960327","url":null,"abstract":"Refactoring code to make it more maintainable and extendable has become a more mainstream practice. Refactoring is the process of changing software without altering its external behavior. It is done in such as way to improve the structure of the code to allow for later extensions or to make maintenance of the code easier. It is important to refactor your code in a disciplined way to minimize disruptions and to allow the system to safely evolve. Improving a systems structure and readability through refactoring enhances its comprehensibility, readability, and maintainability.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"63 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125927789","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}
Christoph Bockisch, S. Malakuti, M. Aksit, Shmuel Katz
{"title":"Making aspects natural: events and composition","authors":"Christoph Bockisch, S. Malakuti, M. Aksit, Shmuel Katz","doi":"10.1145/1960275.1960312","DOIUrl":"https://doi.org/10.1145/1960275.1960312","url":null,"abstract":"Language extensions are proposed to make aspects more natural for programmers. The extensions involve two main elements: (1) Completely separating the identification of events and locally accumulating information about them from any possible response to the events, and (2) composing both events and aspects into hierarchies that loosen the connection to code-level methods and field names. The combination of these extensions are shown (in preliminary experiments) to increase modularity, and facilitate using terminology natural for each concern. Extensions to AspectJ and Compose* are shown to illustrate how the concepts can be easily embodied in particular languages. The execution model of ALIA4J is used to present the concepts in a language-independent way, providing a prototype generic implementation of the extensions, that can be used to implement them for both AspectJ and Compose*. The extensions increase the flexibility of aspects, encourage reuse, and allow expressing events and responses to them in terms natural to the concern that an aspect treats.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"10 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130298423","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":"Reducing combinatorics in testing product lines","authors":"C. Kim, D. Batory, S. Khurshid","doi":"10.1145/1960275.1960284","DOIUrl":"https://doi.org/10.1145/1960275.1960284","url":null,"abstract":"A Software Product Line (SPL) is a family of programs where each program is defined by a unique combination of features. Testing or checking properties of an SPL is hard as it may require the examination of a combinatorial number of programs. In reality, however, features are often irrelevant for a given test - they augment, but do not change, existing behavior, making many feature combinations unnecessary as far as testing is concerned. In this paper we show how to reduce the amount of effort in testing an SPL. We represent an SPL in a form where conventional static program analysis techniques can be applied to find irrelevant features for a test. We use this information to reduce the combinatorial number of SPL programs to examine.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"69 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128344111","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":"Self-refining aspects for dynamic program analysis","authors":"Danilo Ansaloni","doi":"10.1145/1960314.1960342","DOIUrl":"https://doi.org/10.1145/1960314.1960342","url":null,"abstract":"Accurate and efficient dynamic analysis tools are needed for understanding and improving performance of programs. However, such tools often produce perturbed and misleading results, since the inserted analysis code may interfere with runtime optimizations performed by the just-in-time compiler. In this work, I present an approach based on aspect-oriented programming (AOP) to dynamically refine the scope of an analysis, gradually reducing the number of intercepted join points at runtime, considering only those that are relevant for the specific analysis. The motivating example is an aspect-based hotspot locator based on execution time profiling.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"15 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132032927","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 a proper aspect-oriented model for distributed systems","authors":"Ismael Mejía","doi":"10.1145/1960314.1960346","DOIUrl":"https://doi.org/10.1145/1960314.1960346","url":null,"abstract":"The adoption of Aspect Oriented Programming (AOP), and in general, of more sophisticated composition models is a recent trend in software engineering to address the problem of the correct modularization of cross-cutting concerns. However, most of these models are not well-suited for the particular conditions, scale and complexity of the problems inherent to distributed systems. This paper outlines a minimum set of desirable criteria for an aspect oriented model for those systems. We study some problems with existing models and propose a solution inspired by the actor model with aspect mobility and controlled invasiveness.","PeriodicalId":353153,"journal":{"name":"Aspect-Oriented Software Development","volume":"15 1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2011-03-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132263527","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}