An Overview of the gDEEP Calculus

The goal of Feature-oriented Programming (FOP) is to modularize software systems in terms of features. A feature is an increment in functionality and refines the content of other features. A software system typically consists of a collection of different kinds of software artifacts, e.g. source code, build scripts, documentation, design documents, and performance profiles. We and others have noticed a principle of uniformity, which dictates that when composing features, all software artifacts can actually be refined in a uniform way, regardless of what they represent. Previous work did not take advantage of this uniformity; each kind of software artifact used a separate tool for composition, developed from scratch. We present gDEEP, a core calculus for features and feature composition which is language-independent; it can be used to compose features containing any kinds of artifact. This calculus allows us to define general algorithms for feature refinement, composition, and validation. We provide the formal syntax, operational semantics, and type system of gDEEP and explain how different kinds of software artifacts, including Java, Bali, and XML files, can be represented. A prototype tool and three case studies demonstrate the practicality of our approach.

[1]  Erik Ernst,et al.  Higher-Order Hierarchies , 2003, ECOOP.

[2]  Nissim Francez,et al.  A compositional approach to superimposition , 1988, POPL '88.

[3]  Dewayne E. Perry,et al.  Design of large-scale polylingual systems , 2004, Proceedings. 26th International Conference on Software Engineering.

[4]  Sophia Drossopoulou,et al.  Tribe: a simple virtual class calculus , 2007, AOSD.

[5]  Harold Ossher,et al.  Hyper/J/sup TM/: multi-dimensional separation of concerns for Java/sup TM/ , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[6]  Matthias Zenger,et al.  Type-Safe Prototype-Based Component Evolution , 2002, ECOOP.

[7]  Eelco Visser,et al.  Concrete syntax for objects: domain-specific language embedding and assimilation without restrictions , 2004, OOPSLA '04.

[8]  Philip Wadler,et al.  Featherweight Java: a minimal core calculus for Java and GJ , 1999, OOPSLA '99.

[9]  Sven Apel,et al.  Superimposition: A Language-Independent Approach to Software Composition , 2008, SC@ETAPS.

[10]  Sven Apel,et al.  When to use features and aspects?: a case study , 2006, GPCE '06.

[11]  Carlos José Pereira de Lucena,et al.  Refactoring product lines , 2006, GPCE '06.

[12]  Ole Lehrmann Madsen,et al.  Virtual classes: a powerful mechanism in object-oriented programming , 1989, OOPSLA 1989.

[13]  Roberto Erick Lopez-Herrejon,et al.  Evaluating Support for Features in Advanced Modularization Technologies , 2005, ECOOP.

[14]  Sven Apel,et al.  The role of features and aspects in software development: similarities, differences, and synergetic potential , 2007 .

[15]  Oscar Díaz,et al.  On Refining XML Artifacts , 2007, ICWE.

[16]  Matthew Flatt,et al.  Jiazzi: new-age components for old-fasioned Java , 2001, OOPSLA '01.

[17]  Kyo Chul Kang,et al.  Feature-Oriented Domain Analysis (FODA) Feasibility Study , 1990 .

[18]  Thomas Leich,et al.  FeatureC++: on the symbiosis of feature-oriented and aspect-oriented programming , 2005, GPCE'05.

[19]  Michal Antkiewicz,et al.  Mapping features to models: a template approach based on superimposed variants , 2005, GPCE'05.

[20]  Luca Cardelli,et al.  On understanding types, data abstraction, and polymorphism , 1985, CSUR.

[21]  Christian Prehofer,et al.  Feature-Oriented Programming: A Fresh Look at Objects , 1997, ECOOP.

[22]  Mira Mezini,et al.  An Overview of CaesarJ , 2006, LNCS Trans. Aspect Oriented Softw. Dev..

[23]  Riccardo Pucella Towards a formalization for COM part i: the primitive calculus , 2002, OOPSLA '02.

[24]  Martin Odersky,et al.  Scalable component abstractions , 2005, OOPSLA '05.

[25]  João Costa Seco,et al.  A Basic Model of Typed Components , 2000, ECOOP.

[26]  Wolfgang De Meuter,et al.  Efficient Layer Activation for Switching Context-Dependent Behavior , 2006, JMLC.

[27]  Thomas Leich,et al.  Pointcuts, advice, refinements, and collaborations: similarities, differences, and synergies , 2007, Innovations in Systems and Software Engineering.

[28]  Oscar Nierstrasz,et al.  A calculus for reasoning about software composition , 2005, Theor. Comput. Sci..

[29]  Oscar Díaz,et al.  Feature refactoring a multi-representation program into a product line , 2006, GPCE '06.

[30]  Mirko Viroli,et al.  Lightweight Family Polymorphism , 2005, APLAS.

[31]  Don S. Batory,et al.  From implementation to theory in product synthesis , 2007, POPL '07.

[32]  Thomas Leich,et al.  Aspectual mixin layers: aspects and features in concert , 2006, ICSE '06.

[33]  José Manuel Marqués Corral,et al.  Seamless development of software product lines , 2007, GPCE '07.

[34]  Don Batory,et al.  Scaling Step-Wise Refinement , 2004, IEEE Trans. Software Eng..

[35]  Oscar Nierstrasz,et al.  Classbox/J: controlling the scope of change in Java , 2005, OOPSLA '05.

[36]  Sven Apel,et al.  An Algebra for Feature-Oriented Software Development , 2007 .

[37]  Thomas Leich,et al.  Aspect Refinement Ð Unifying AOP and Stepwise Refinement , 2007, J. Object Technol..

[38]  William R. Cook,et al.  A virtual class calculus , 2006, POPL '06.

[39]  Yannis Smaragdakis,et al.  JTS: tools for implementing domain-specific languages , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[40]  Andrew C. Myers,et al.  Scalable extensibility via nested inheritance , 2004, OOPSLA.

[41]  Harold Ossher,et al.  Combination of inheritance hierarchies , 1992, OOPSLA '92.

[42]  Brian Campbell,et al.  Amortised Memory Analysis Using the Depth of Data Structures , 2009, ESOP.

[43]  DeLesley Hutchins,et al.  Eliminating distinctions of class: using prototypes to model virtual classes , 2006, OOPSLA '06.

[44]  Paul Clements,et al.  Software product lines - practices and patterns , 2001, SEI series in software engineering.

[45]  Martin Odersky,et al.  A Nominal Theory of Objects with Dependent Types , 2003, ECOOP.

[46]  Luc Bellissard,et al.  A Component Calculus for Modeling the Olan Configuration Language , 1997, COORDINATION.

[47]  Robert Bruce Findler,et al.  Modular object-oriented programming with units and mixins , 1998, ICFP '98.

[48]  William R. Cook,et al.  Safe composition of product lines , 2007, GPCE '07.

[49]  Roberto Erick Lopez-Herrejon,et al.  A disciplined approach to aspect composition , 2006, PEPM '06.

[50]  Yannis Smaragdakis,et al.  Mixin layers: an object-oriented implementation technique for refinements and collaboration-based designs , 2002, TSEM.

[51]  Jia Liu,et al.  Feature oriented refactoring of legacy applications , 2006, ICSE.

[52]  Mirko Viroli,et al.  Lightweight family polymorphism , 2008, J. Funct. Program..