Scaling Step-Wise Refinement (2004)

by Don Batory, Jacob Neal Sarvela, Axel Rauschmayer
Venue:IEEE TRANSACTIONS ON SOFTWARE ENGINEERING
Add To MetaCart
Results 1 - 10 of 454

Mapping features to models: A template approach based on superimposed variants

by Krzysztof Czarnecki - GPCE 2005 - Generative Programming and Component Enginering. 4th International Conference , 2005
"... Abstract. Although a feature model can represent commonalities and variabilities in a very concise taxonomic form, features in a feature model are merely symbols. Mapping features to other models, such as behavioral or data specifications, gives them semantics. In this paper, we propose a general te ..."
Abstract - Cited by 179 (9 self) - Add to MetaCart
Abstract. Although a feature model can represent commonalities and variabilities in a very concise taxonomic form, features in a feature model are merely symbols. Mapping features to other models, such as behavioral or data specifications, gives them semantics. In this paper, we propose a general template-based approach for mapping feature models to concise representations of variability in different kinds of other models. We show how the approach can be applied to UML 2.0 activity and class models and describe a prototype implementation. 1
(Show Context)

Formalizing cardinality-based feature models and their specialization

by Krzysztof Czarnecki, Simon Helsen, Ulrich Eisenecker - Software Process: Improvement and Practice , 2005
"... Abstract Feature modeling is an important approach to capture the commonalities and variabilities in system families and product lines. Cardinality-based feature modeling integrates a number of existing extensions of the original feature-modeling notation from Feature-Oriented Domain Analysis. Stage ..."
Abstract - Cited by 169 (18 self) - Add to MetaCart
Abstract Feature modeling is an important approach to capture the commonalities and variabilities in system families and product lines. Cardinality-based feature modeling integrates a number of existing extensions of the original feature-modeling notation from Feature-Oriented Domain Analysis. Staged configuration is a process that allows the incremental configuration of cardinality-based feature models. It can be achieved by performing a step-wise specialization of the feature model. In this paper, we argue that cardinality-based feature models can be interpreted as a special class of context-free grammars. We make this precise by specifying a translation from a feature model into a context-free grammar. Consequently, we provide a semantic interpretation for cardinalitybased feature models by assigning an appropriate semantics to the language recognized by the corresponding grammar. Finally, we give an account on how feature model specialization can be formalized as transformations on the grammar equivalent of feature models.

Granularity in software product lines

by Christian Kästner, et al. , 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.
(Show Context)

Variability Management with Feature-Oriented Programming and Aspects

by Mira Mezini, Klaus Ostermann , 2004
"... This paper presents an analysis of feature-oriented and aspect-oriented modularization approaches with respect to variability management as needed in the context of system families. This analysis serves two purposes. On the one hand, our analysis of the weaknesses of feature-oriented approaches (FOA ..."
Abstract - Cited by 117 (3 self) - Add to MetaCart
This paper presents an analysis of feature-oriented and aspect-oriented modularization approaches with respect to variability management as needed in the context of system families. This analysis serves two purposes. On the one hand, our analysis of the weaknesses of feature-oriented approaches (FOAs for short) emphasizes the importance of crosscutting modularity as supported by the aspect-oriented concepts of pointcut and advice. On the other hand, by pointing out some of AspectJ's weaknesses and by demonstrating how Caesar, a language which combines concepts from both AspectJ and FOAs, is more effective in this context, we also demonstrate the power of appropriate support for layer modules.
(Show Context)

Context-Oriented Programming

by Robert Hirschfeld, Pascal Costanza, Oscar Nierstrasz - Journal of Object Technology, March-April 2008, ETH Zurich , 2008
"... Context-dependent behavior is becoming increasingly important for a wide range of application domains, from pervasive computing to common business applications. Unfortunately, mainstream programming languages do not provide mechanisms that enable software entities to adapt their behavior dynamically ..."
Abstract - Cited by 116 (27 self) - Add to MetaCart
Context-dependent behavior is becoming increasingly important for a wide range of application domains, from pervasive computing to common business applications. Unfortunately, mainstream programming languages do not provide mechanisms that enable software entities to adapt their behavior dynamically to the current execution context. This leads developers to adopt convoluted designs to achieve the necessary runtime flexibility. We propose a new programming technique called Context-oriented Programming (COP) which addresses this problem. COP treats context explicitly, and provides mechanisms to dynamically adapt behavior in reaction to changes in context, even after system deployment at runtime. In this paper, we lay the foundations of COP, show how dynamic layer activation enables multi-dimensional dispatch, illustrate the application of COP by examples in several language extensions, and demonstrate that COP is largely independent of other commitments to programming style. 1
(Show Context)

An overview of CaesarJ

by Ivica Aracic, Vaidas Gasiunas, Mira Mezini, Klaus Ostermann - 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
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
(Show Context)

Traits: A mechanism for fine-grained reuse

by Stéphane Ducasse, Oscar Nierstrasz, Nathanael Schärli, Andrew P. Black - Transactions on Programming Languages and Systems , 2006
"... Inheritance is well-known and accepted as a mechanism for reuse in object-oriented languages. Unfortunately, due to the coarse granularity of inheritance, it may be difficult to decompose an application into an optimal class hierarchy that maximizes software reuse. Existing schemes based on single i ..."
Abstract - Cited by 112 (23 self) - Add to MetaCart
Inheritance is well-known and accepted as a mechanism for reuse in object-oriented languages. Unfortunately, due to the coarse granularity of inheritance, it may be difficult to decompose an application into an optimal class hierarchy that maximizes software reuse. Existing schemes based on single inheritance, multiple inheritance, or mixins, all pose numerous problems for reuse. To overcome these problems we propose traits, pure units of reuse consisting only of methods. We develop a formal model of traits that establishes how traits can be composed, either to form other traits, or to form classes. We also outline an experimental validation in which we apply traits to refactor a non-trivial application into composable units.

Safe composition of product lines

by Don Batory, Sahil Thaker - GENERATIVE PROGRAMMING AND COMPONENT ENGINEERING, 6TH INTERNATIONAL CONFERENCE (GPCE 2007) , 2007
"... Programs of a software product line can be synthesized by composing modules that implement features. Besides high-level domain constraints that govern the compatibility of features, there are also low-level implementation constraints: a feature module can reference classes that are defined in other ..."
Abstract - Cited by 110 (12 self) - Add to MetaCart
Programs of a software product line can be synthesized by composing modules that implement features. Besides high-level domain constraints that govern the compatibility of features, there are also low-level implementation constraints: a feature module can reference classes that are defined in other feature modules. Safe composition is the guarantee that programs composed from feature modules are absent of references to undefined classes, methods, and variables. We show how safe composition can be
(Show Context)

FeatureHouse: Language-independent, automatic software composition

by Sven Apel, Christian Kästner, Christian Lengauer - In Proc. Int’l Conf. on Software Engineering
"... Superimposition is a composition technique that has been applied successfully in many areas of software development. Although superimposition is a general-purpose concept, it has been (re)invented and implemented individually for various kinds of software artifacts. We unify languages and tools that ..."
Abstract - Cited by 96 (46 self) - Add to MetaCart
Superimposition is a composition technique that has been applied successfully in many areas of software development. Although superimposition is a general-purpose concept, it has been (re)invented and implemented individually for various kinds of software artifacts. We unify languages and tools that rely on superimposition by using the language-independent model of feature structure trees (FSTs). On the basis of the FST model, we propose a general approach to the composition of software artifacts written in different languages, Furthermore, we offer a supporting framework and tool chain, called FEATUREHOUSE. We use attribute grammars to automate the integration of additional languages, in particular, we have integrated Java, C#, C, Haskell, JavaCC, and XML. Several case studies demonstrate the practicality and scalability of our approach and reveal insights into the properties a language must have in order to be ready for superimposition. 1.

Reasoning about edits to feature models

by Thomas Thüm, Don Batory, Christian Kästner - In Proc. Int’l Conf. on Software Engineering
"... Features express the variabilities and commonalities among programs in a software product line (SPL). A feature model defines the valid combinations of features, where each combination corresponds to a program in an SPL. SPLs and their feature models evolve over time. We classify the evolution of a ..."
Abstract - Cited by 89 (17 self) - Add to MetaCart
Features express the variabilities and commonalities among programs in a software product line (SPL). A feature model defines the valid combinations of features, where each combination corresponds to a program in an SPL. SPLs and their feature models evolve over time. We classify the evolution of a feature model via modifications as refactorings, specializations, generalizations, or arbitrary edits. We present an algorithm to reason about feature model edits to help designers determine how the program membership of an SPL has changed. Our algorithm takes two feature models as input (before and after edit versions), where the set of features in both models are not necessarily the same, and it automatically computes the change classification. Our algorithm is able to give examples of added or deleted products and efficiently classifies edits to even large models that have thousands of features. 1
(Show Context)