Results 1 - 10 of 211

Scaling Step-Wise Refinement

by Don Batory, Jacob Neal Sarvela, Axel Rauschmayer - IEEE TRANSACTIONS ON SOFTWARE ENGINEERING , 2004
"... Step-wise refinement is a powerful paradigm for developing a complex program from a simple program by adding features incrementally. We present the AHEAD (Algebraic Hierarchical Equations for Application Design) model that shows how step-wise refinement scales to synthesize multiple programs and mu ..."
Abstract - Cited by 454 (41 self) - Add to MetaCart
Step-wise refinement is a powerful paradigm for developing a complex program from a simple program by adding features incrementally. We present the AHEAD (Algebraic Hierarchical Equations for Application Design) model that shows how step-wise refinement scales to synthesize multiple programs and multiple noncode representations. AHEAD shows that software can have an elegant, hierarchical mathematical structure that is expressible as nested sets of equations. We review a tool set that supports AHEAD. As a demonstration of its viability, we have bootstrapped AHEAD tools from equational specifications, refining Java and non-Java artifacts automatically; a task that was accomplished only by ad hoc means previously.
(Show Context)

Implementing Layered Designs with Mixin Layers

by Yannis Smaragdakis, Don Batory - In ECCOP ’98: Proceedings of the 12th European Conference on Object-Oriented Programming , 1998
"... Abstract. Mixin layers are a technique for implementing layered object-oriented subclasses (mixin classes) but scaled to a multiple-class granularity. We describe mixin layers from a programming language viewpoint, discuss checking the consistency of a mixin layer composition, and analyze the langua ..."
Abstract - Cited by 178 (18 self) - Add to MetaCart
Abstract. Mixin layers are a technique for implementing layered object-oriented subclasses (mixin classes) but scaled to a multiple-class granularity. We describe mixin layers from a programming language viewpoint, discuss checking the consistency of a mixin layer composition, and analyze the language support issues involved. 1
(Show Context)

An Algebra for Feature-Oriented Software Development

by Sven Apel, Christian Lengauer, Don Batory, Bernhard Möller, Christian Kästner
"... Feature-Oriented Software Development (FOSD) provides a multitude of formalisms, methods, languages, and tools for building variable, customizable, and extensible software. Along different lines of research different ideas of what a feature is have been developed. Although the existing approaches h ..."
Abstract - Cited by 126 (48 self) - Add to MetaCart
Feature-Oriented Software Development (FOSD) provides a multitude of formalisms, methods, languages, and tools for building variable, customizable, and extensible software. Along different lines of research different ideas of what a feature is have been developed. Although the existing approaches have similar goals, their representations and formalizations have not been integrated so far into a common framework. We present a feature algebra as a foundation of FOSD. The algebra captures the key ideas and provides a common ground for current and future research in this field, in which also alternative options can be explored.

Jiazzi: New-Age Components for Old-Fashioned Java

by Sean McDirmid , Matthew Flatt, Wilson C. Hsieh , 2001
"... We present Jiazzi, a system that enables the construction of largescale binary components in Java. Jiazzi components can be thought of as generalizations of Java packages with added support for external linking and separate compilation. Jiazzi components are practical because they are constructed ou ..."
Abstract - Cited by 116 (13 self) - Add to MetaCart
We present Jiazzi, a system that enables the construction of largescale binary components in Java. Jiazzi components can be thought of as generalizations of Java packages with added support for external linking and separate compilation. Jiazzi components are practical because they are constructed out of standard Java source code. Jiazzi requires neither extensions to the Java language nor special conventions for writing Java source code that will go inside a component. Our components are expressive because Jiazzi supports cyclic component linking and mixins, which are used together in an open class pattern that enables the modular addition of new features to existing classes. This paper describes Jiazzi, how it enhances Java with components, its implementation, and how type checking works. An implementation of Jiazzi is available for download.
(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.
(Show Context)

Aspectual Feature Modules

by Sven Apel, Thomas Leich, Gunter Saake, Ieee Computer Society - IEEE Trans. Software Engineering (TSE , 2008
"... Abstract—Two programming paradigms are gaining attention in the overlapping fields of software product lines (SPLs) and incremental software development (ISD). Feature-oriented programming (FOP) aims at large-scale compositional programming and feature modularity in SPLs using ISD. Aspect-oriented p ..."
Abstract - Cited by 89 (56 self) - Add to MetaCart
Abstract—Two programming paradigms are gaining attention in the overlapping fields of software product lines (SPLs) and incremental software development (ISD). Feature-oriented programming (FOP) aims at large-scale compositional programming and feature modularity in SPLs using ISD. Aspect-oriented programming (AOP) focuses on the modularization of crosscutting concerns in complex software. Although feature modules, the main abstraction mechanisms of FOP, perform well in implementing large-scale software building blocks, they are incapable of modularizing certain kinds of crosscutting concerns. This weakness is exactly the strength of aspects, the main abstraction mechanisms of AOP. We contribute a systematic evaluation and comparison of FOP and AOP. It reveals that aspects and feature modules are complementary techniques. Consequently, we propose the symbiosis of FOP and AOP and aspectual feature modules (AFMs), a programming technique that integrates feature modules and aspects. We provide a set of tools that support implementing AFMs on top of Java and C++. We apply AFMs to a nontrivial case study demonstrating their practical applicability and to justify our design choices. Index Terms—Feature-oriented programming, aspect-oriented programming, software product lines, incremental software development, collaboration-based design, separation of concerns, crosscutting modularity.
(Show Context)

A Taxonomy of Variability Realization Techniques

by Mikael Svahnberg, Jilles Van Gurp, Jan Bosch - SOFTWARE—PRACTICE AND EXPERIENCE , 2001
"... ..."
Abstract - Cited by 81 (2 self) - Add to MetaCart
Abstract not found

Classbox/J: Controlling the scope of change in Java

by Alexandre Bergel, Stéphane Ducasse, Oscar Nierstrasz - OOPSLA 2005 , 2005
"... Unanticipated changes to complex software systems can introduce anomalies such as duplicated code, suboptimal inheritance rela-tionships and a proliferation of run-time downcasts. Refactoring to eliminate these anomalies may not be an option, at least in certain stages of software evolution. Classbo ..."
Abstract - Cited by 80 (7 self) - Add to MetaCart
Unanticipated changes to complex software systems can introduce anomalies such as duplicated code, suboptimal inheritance rela-tionships and a proliferation of run-time downcasts. Refactoring to eliminate these anomalies may not be an option, at least in certain stages of software evolution. Classboxes are modules that restrict the visibility of changes to selected clients only, thereby offering more freedom in the way unanticipated changes may be implemented, and thus reducing the need for convoluted design anomalies. In this paper we demonstrate how classboxes can be implemented in statically-typed languages like Java. We also present an extended case study of Swing, a Java GUI package built on top of AWT, and we document the ensuing anomalies that Swing introduces. We show how Classbox/J, a prototype implementation of classboxes for Java, is used to provide a cleaner implementation of Swing using local refinement rather than subclassing.

A Case Study Implementing Features using AspectJ

by Christian Kästner, Sven Apel, Don Batory - INTERNATIONAL SOFTWARE PRODUCT LINE CONFERENCE (SPLC) , 2007
"... Software product lines aim to create highly configurable programs from a set of features. Common belief and recent studies suggest that aspects are well-suited for implementing features. We evaluate the suitability of AspectJ with respect to this task by a case study that refactors the embedded data ..."
Abstract - Cited by 71 (23 self) - Add to MetaCart
Software product lines aim to create highly configurable programs from a set of features. Common belief and recent studies suggest that aspects are well-suited for implementing features. We evaluate the suitability of AspectJ with respect to this task by a case study that refactors the embedded database system Berkeley DB into 38 features. Contrary to our initial expectations, the results were not encouraging. As the number of aspects in a feature grows, there is a noticeable decrease in code readability and maintainability. Most of the unique and powerful features of AspectJ were not needed. We document where AspectJ is unsuitable for implementing features of refactored legacy applications and explain why. 1.

Resolving Feature Convolution in Middleware Systems

by Charles Zhang, Hans-arno Jacobsen - In OOPSLA , 2004
"... Middleware provides simplicity and uniformity for the development of distributed applications. However, the modularity of the architecture of middleware is starting to disintegrate and to become complicated due to the interaction of too many orthogonal concerns imposed from a wide range of applicati ..."
Abstract - Cited by 59 (6 self) - Add to MetaCart
Middleware provides simplicity and uniformity for the development of distributed applications. However, the modularity of the architecture of middleware is starting to disintegrate and to become complicated due to the interaction of too many orthogonal concerns imposed from a wide range of application requirements. This is not due to bad design but rather due to the limitations of the conventional architectural decomposition methodologies. We introduce the principles of horizontal decomposition (HD) which addresses this problem with a mixed-paradigm middleware architecture. HD provides guidance for the use of conventional decomposition methods to implement the core functionalities of middleware and the use of aspect orientation to address its orthogonal properties. Our evaluation of the horizontal decomposition principles focuses on refactoring major middleware functionalities into aspects in order to modularize and isolate them from the core architecture. New versions of the middleware platform can be created through combining the core and the flexible selection of middleware aspects such as IDL data types, the oneway invocation style, the dynamic messaging style, and additional character encoding schemes. As a result, the primary functionality of the middleware is supported with a much simpler architecture and enhanced performance. Moreover, customization and configuration of the middleware for a wide-range of requirements becomes possible.
(Show Context)