Compositional type-checking for delta-oriented programming

Delta-oriented programming is a compositional approach to flexibly implementing software product lines. A product line is represented by a code base and a product line declaration. The code base consists of a set of delta modules specifying modifications to object-oriented programs. The product line declaration provides the connection of the delta modules with the product features. This separation increases the reusability of delta modules. In this paper, we provide a foundation for compositional type checking of delta-oriented product lines of Java programs by presenting a minimal core calculus for delta-oriented programming. The calculus is equipped with a constraint-based type system that allows analyzing each delta module in isolation, such that that also the results of the analysis can be reused. By combining the analysis results for the delta modules with the product line declaration it is possible to establish that all the products of the product line are well-typed according to the Java type system.

[1]  Davide Ancona,et al.  Polymorphic bytecode: compositional compilation for Java-like languages , 2005, POPL '05.

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

[3]  Don S. Batory,et al.  Feature Models, Grammars, and Propositional Formulas , 2005, SPLC.

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

[5]  Stanley M. Sutton,et al.  N degrees of separation: multi-dimensional separation of concerns , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[6]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[7]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

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

[9]  C. Krueger,et al.  Eliminating the adoption barrier , 2002, IEEE Software.

[10]  Ina Schaefer,et al.  Compositional Type-Checking for Delta-Oriented Programming (version with Appendix) , 2011 .

[11]  Mads Torgersen.  The Expression Problem Revisited , 2004, ECOOP.

[12]  Don Batory,et al.  Scaling step-wise refinement , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[13]  Lorenzo Bettini,et al.  IFJ: a Minimal Imperative Variant of FJ , 2010 .

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

[15]  William R. Cook,et al.  A machine-checked model of safe composition , 2009, FOAL '09.

[16]  Gary T. Leavens,et al.  MiniMAO1: Investigating the Semantics of Proceed , 2005 .

[17]  Klaus Ostermann,et al.  Dynamically Composable Collaborations with Delegation Layers , 2002, ECOOP.

[18]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[19]  Sven Apel,et al.  Type safety for feature-oriented product lines , 2010, Automated Software Engineering.

[20]  Sven Apel,et al.  A Case Study Implementing Features Using AspectJ , 2007, 11th International Software Product Line Conference (SPLC 2007).

[21]  Oscar Nierstrasz,et al.  Traits: A mechanism for fine-grained reuse , 2006, TOPL.

[22]  Gunter Saake,et al.  On the impact of the optional feature problem: analysis and case studies , 2009, SPLC.

[23]  Einar Broch Johnsen,et al.  Dynamic Classes: Modular Asynchronous Evolution of Distributed Concurrent Objects , 2009, FM.

[24]  Don S. Batory,et al.  Safe composition of non-monotonic features , 2009, GPCE '09.

[25]  Ina Schaefer,et al.  A prototypical Java-like language with records and traits , 2010, PPPJ.

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

[27]  Gunter Saake,et al.  Code generation to support static and dynamic composition of software product lines , 2008, GPCE '08.

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

[29]  Sven Apel,et al.  Granularity in software product lines , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[30]  Bruno De Fraine,et al.  Essential AOP: The a calculus , 2010, TOPL.

[31]  Ina Schaefer,et al.  Implementing software product lines using traits , 2010, SAC '10.

[32]  Gary T. Leavens,et al.  MiniMAO: An imperative core language for studying aspect-oriented reasoning , 2006, Sci. Comput. Program..

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

[34]  Ina Schaefer,et al.  Pure delta-oriented programming , 2010, FOSD '10.

[35]  Viviana Bono,et al.  Delta-Oriented Programming of Software Product Lines , 2010, SPLC.

[36]  Bruno De Fraine,et al.  StrongAspectJ: flexible and safe pointcut/advice bindings , 2008, AOSD.

[37]  Matthew J. Parkinson,et al.  The java module system: core design and semantic definition , 2007, OOPSLA.

[38]  Sven Apel,et al.  Feature featherweight java: a calculus for feature-oriented programming and stepwise refinement , 2008, GPCE '08.