Results 1 - 10
of
153
Granularity in software product lines
, 2008
"... Building software product lines (SPLs) with features is a challenging task. Many SPL implementations support features with coarse granularity – e.g., the ability to add and wrap entire methods. However, fine-grained extensions, like adding a statement in the middle of a method, either require intric ..."
Abstract
-
Cited by 131 (48 self)
- Add to MetaCart
Building software product lines (SPLs) with features is a challenging task. Many SPL implementations support features with coarse granularity – e.g., the ability to add and wrap entire methods. However, fine-grained extensions, like adding a statement in the middle of a method, either require intricate workarounds or obfuscate the base code with annotations. Though many SPLs can and have been implemented with the coarse granularity of existing approaches, fine-grained extensions are essential when extracting features from legacy applications. Furthermore, also some existing SPLs could benefit from fine-grained extensions to reduce code replication or improve readability. In this paper, we analyze the effects of feature granularity in SPLs and present a tool, called Colored IDE (CIDE), that allows features to implement coarse-grained and fine-grained extensions in a concise way. In two case studies, we show how CIDE simplifies SPL development compared to traditional approaches.
An overview of CaesarJ
- In Transactions on Aspect-Oriented Software Development I
, 2006
"... Abstract. CaesarJ is an aspect-oriented language which unifies aspects, classes and packages in a single powerful construct that helps to solve a set of different problems of both aspect-oriented and component-oriented programming. The paper gradually introduces the concepts of the lan-guage and ill ..."
Abstract
-
Cited by 114 (11 self)
- Add to MetaCart
(Show Context)
Abstract. CaesarJ is an aspect-oriented language which unifies aspects, classes and packages in a single powerful construct that helps to solve a set of different problems of both aspect-oriented and component-oriented programming. The paper gradually introduces the concepts of the lan-guage and illustrates them by showing how they can be used for non-invasive component refinement and integration, as well as for develop-ment of well modularized flexible aspects. In this way we demonstrate that the combination of aspect-oriented constructs for join-point inter-ception with advanced modularization techniques like virtual classes and propagating mixin composition can open the path towards large-scale as-pect components. 1
Expressive pointcuts for increased modularity
- IN: ECOOP
"... In aspect-oriented programming, pointcuts are used to describe cross-cutting structure. Pointcuts that abstract over irrelevant implementation details are clearly desired to better support maintainability and modular reasoning. We present an analysis which shows that current pointcut languages sup ..."
Abstract
-
Cited by 104 (11 self)
- Add to MetaCart
(Show Context)
In aspect-oriented programming, pointcuts are used to describe cross-cutting structure. Pointcuts that abstract over irrelevant implementation details are clearly desired to better support maintainability and modular reasoning. We present an analysis which shows that current pointcut languages support lo-calization of crosscutting concerns but are problematic with respect to infor-mation hiding. To cope with the problem, we present a pointcut language that exploits information from different models of program semantics, such as the execution trace, the syntax tree, the heap, static type system, etc., and supports abstraction mechanisms analogous to functional abstraction. We show how this raises the abstraction level and modularity of pointcuts and present first steps toward an efficient implementation by means of a static analysis technique.
Harmless advice
- University of Pennsylvania, Computer and Information Science Department, Levine Hall
, 2005
"... This paper defines an object-oriented language with harmless aspect-oriented advice. A piece of harmless advice is a computation that, like ordinary aspect-oriented advice, executes when control reaches a designated control-flow point. However, unlike ordinary advice, harmless advice is designed to ..."
Abstract
-
Cited by 84 (9 self)
- Add to MetaCart
This paper defines an object-oriented language with harmless aspect-oriented advice. A piece of harmless advice is a computation that, like ordinary aspect-oriented advice, executes when control reaches a designated control-flow point. However, unlike ordinary advice, harmless advice is designed to obey a weak noninterference property. Harmless advice may change the termination behavior of computations and use I/O, but it does not otherwise influence the final result of the mainline code. The benefit of harmless advice is that it facilitates local reasoning about program behavior. More specifically, programmers may ignore harmless advice when reasoning about the partial correctness properties of their programs. In addition, programmers may add new pieces of harmless advice to pre-existing programs in typical “after-the-fact ” aspect-oriented style without fear they will break important data invariants used by the mainline code. In order to detect and enforce harmlessness, the paper defines a novel type and effect system related to information-flow type systems. The central technical result is that well-typed harmless advice does not interfere with the mainline computation. The paper also presents an implementation of the language and a case study using harmless advice to implement security policies. 1.
Modular software design with crosscutting interfaces
- IEEE Software
, 2006
"... Aspect-oriented programming languages such as AspectJ offer new mechanisms for decomposing systems into modules and composing modules into systems. This paper introduces crosscut programming interfaces (XPIs) as a practical approach to improving the modular designs of programs written using AspectJ- ..."
Abstract
-
Cited by 77 (4 self)
- Add to MetaCart
(Show Context)
Aspect-oriented programming languages such as AspectJ offer new mechanisms for decomposing systems into modules and composing modules into systems. This paper introduces crosscut programming interfaces (XPIs) as a practical approach to improving the modular designs of programs written using AspectJ-style AOP. It does not limit existing aspect-oriented mechanisms or require new ones.
Information Hiding Interfaces for Aspect-Oriented Design
- IN ESEC/FSE-13: PROCEEDINGS OF THE 10TH EUROPEAN SOFTWARE ENGINEERING CONFERENCE HELD JOINTLY WITH 13TH ACM SIGSOFT INTERNATIONAL SYMPOSIUM ON FOUNDATIONS OF SOFTWARE ENGINEERING
, 2005
"... The growing popularity of aspect-oriented languages, such as AspectJ, and of corresponding design approaches, makes it important to learn how best to modularize programs in which aspect-oriented composition mechanisms are used. We contribute an approach to information hiding modularity in programs t ..."
Abstract
-
Cited by 70 (8 self)
- Add to MetaCart
(Show Context)
The growing popularity of aspect-oriented languages, such as AspectJ, and of corresponding design approaches, makes it important to learn how best to modularize programs in which aspect-oriented composition mechanisms are used. We contribute an approach to information hiding modularity in programs that use quantified advising as a module composition mechanism. Our approach rests on a new kind of interface: one that abstracts a crosscutting behavior, decouples the design of code that advises such a behavior from the design of the code to be advised, and that can stipulate behavioral contracts. Our interfaces establish design rules that govern how specific points in program execution are exposed through a given join point model and how conforming code on either side should behave. In a case study of the HyperCast overlay network middleware system, including a real options analysis, we compare the widely cited oblivious design approach with our own, showing significant weaknesses in the former and benefits in the latter.
The Paradoxical Success of Aspect-Oriented Programming
- ACM SIGPLAN NOTICES
, 2006
"... Aspect-oriented programming is considered a promising new technology. As object-oriented programming did before, it is beginning to pervade all areas of software engineering. With its growing popularity, practitioners and academics alike are wonder-ing whether they should start looking into it, or o ..."
Abstract
-
Cited by 69 (3 self)
- Add to MetaCart
Aspect-oriented programming is considered a promising new technology. As object-oriented programming did before, it is beginning to pervade all areas of software engineering. With its growing popularity, practitioners and academics alike are wonder-ing whether they should start looking into it, or otherwise risk having missed an important development. The author of this essay finds that much of aspect-oriented programming’s success seems to be based on the conception that it improves both modularity and the structure of code, while in fact, it works against the pri-mary purposes of the two, namely independent development and understandability of programs. Not seeing any way of fixing this situation, he thinks the success of aspect-oriented programming to be paradoxical.
Aspectual Mixin Layers: Aspects and Features in Concert
- In Proc. of Intl. Conf. on Software Engineering
, 2006
"... Feature-Oriented Programming (FOP) decomposes complex software into features. Features are main abstractions in design and implementation. They reflect user requirements and incrementally refine one another. Although, features crosscut object-oriented architectures they fail to express all kinds of ..."
Abstract
-
Cited by 54 (14 self)
- Add to MetaCart
(Show Context)
Feature-Oriented Programming (FOP) decomposes complex software into features. Features are main abstractions in design and implementation. They reflect user requirements and incrementally refine one another. Although, features crosscut object-oriented architectures they fail to express all kinds of crosscutting concerns. This weakness is exactly the strength of aspects, the main abstraction mechanism of Aspect-Oriented Programming (AOP). In this article we contribute a systematic evaluation and comparison of both paradigms, AOP and FOP, with focus on incremental software development. It reveals that aspects and features are not competing concepts. In fact AOP has several strengths to improve FOP in order to implement crosscutting features. Symmetrically, the development model of FOP can aid AOP in implementing incremental designs. Consequently, we propose the architectural integration of aspects and features in order to profit from both paradigms. We introduce aspectual mixin layers (AMLs), an implementation approach that realizes this symbiosis. A subsequent evaluation and a case study reveal that AMLs improve the crosscutting modularity of features as well as aspects become well integrated into incremental development style.
Managing the Evolution of Aspect-Oriented Software with Model-based Pointcuts
- In Proceedings of the European Conference on Object-Oriented Programming (ECOOP
, 2006
"... Abstract. In spite of the more advanced modularisation mechanisms, aspect-oriented programs still suffer from evolution problems. Due to the fragile pointcut problem, seemingly safe modifications to the base code of an aspect-oriented program can have an unexpected impact on the semantics of the poi ..."
Abstract
-
Cited by 43 (5 self)
- Add to MetaCart
(Show Context)
Abstract. In spite of the more advanced modularisation mechanisms, aspect-oriented programs still suffer from evolution problems. Due to the fragile pointcut problem, seemingly safe modifications to the base code of an aspect-oriented program can have an unexpected impact on the semantics of the pointcuts defined in that program. This can lead to broken aspect functionality due to accidental join point misses and unintended join point captures. We tackle this problem by declaring pointcuts in terms of a conceptual model of the base program, rather than defining them directly in terms of how the base program is structured. As such, we achieve an effective decoupling of the pointcuts from the base program’s structure. In addition, the conceptual model provides a means to verify where and why potential fragile pointcut conflicts occur, by imposing structural and semantic constraints on the conceptual model, that can be verified when the base program evolves. To validate our approach we implemented a model-based pointcut mechanism, which we used to define some aspects on SmallWiki, a medium-sized application, and subsequently detected and resolved occurrences of the fragile pointcut problem when this application evolved. 1
Separation of concerns with procedures, annotations, advice and pointcuts
- In ECOOP 2005
"... Abstract. There are numerous mechanisms for separation of concerns at the source code level. Three mechanisms that are the focus of recent attention – metadata annotations, pointcuts and advice – can be modeled together with good old-fashioned procedures as providing different kinds of bindings: pro ..."
Abstract
-
Cited by 40 (1 self)
- Add to MetaCart
(Show Context)
Abstract. There are numerous mechanisms for separation of concerns at the source code level. Three mechanisms that are the focus of recent attention – metadata annotations, pointcuts and advice – can be modeled together with good old-fashioned procedures as providing different kinds of bindings: procedure calls bind program points to operations, annotations bind attributes to program points; pointcuts bind sets of points to various descriptions of those sets; named pointcuts bind attributes to sets of points; and advice bind the implementation of an operation to sets of points. This model clarifies how the mechanisms work together to separate concerns, and yields guidelines to help developers use the mechanisms in practice. 1
