Language constructs and type systems for object oriented program components

  • Project funded by the German-Italian University Centre (Vigoni program 2008-2009)
  • Start date: 2009/01/01
  • End date: 2011/05/31
  • For more information on the project, please contact: Ferruccio Damiani or Arnd Poetzsch-Hefter


Synopsis

Most mainstream programming languages are object-oriented. Software development practice exposed as a major limitation of these languages the weak support for software evolution and dynamic reconfiguration. The problem can be identified with the fact that the class construct granularity level is often not appropriate for reuse and reconfiguration. Since classes play the primary role of generators of instances, they must provide a complete set of features describing an object. Therefore, on the one side, classes are often too coarse-grained to provide a minimal set of sensible reusable features, while, on the other side, they are often too fine-grained to provide a software fragment that can be deployed independently. Traits, pure units of reuse consisting only of methods, are a recently proposed feature for fine-grained reuse that is now part of full programming languages (like Squeak, Scala and Fortress). Unfortunately, no satisfactory proposal for coarse-grained reuse can be found in the literature. The goal of this project is to develop, in a Java-like setting, language features for coarse-grained reuse that smoothly integrate with advanced features for fine-grained reuse based on traits that are currently under development. We will focus on the notion of object oriented program component (a unit of coarse-grained reuse with contractually specified interfaces and explicit context dependencies only, that can be deployed independently and are subject to third-party composition). In our view, a component should have a clearly identified codebase (classes, traits, interfaces and component-related declarations) and, at runtime, consists of an evolving set of objects. We plan to exploit type-based techniques to devise composition mechanisms supporting compositional analysis of components (if component C uses components D and E, then C can be analyzed by inspecting C's implementation and D's and E's specifications).

Object-oriented languages play a central role in modern software implementation. The overall scientific goal of the project is to enhance object-oriented language technology towards support for coarse-grained reuse, software evolution and dynamic reconfiguration.

We aim to investigate and to develop, in a Java-like setting, language features for coarse-grained reuse that smoothly integrate with advanced features for fine-grained reuse based on traits. We will focus on the notion of object-oriented program components where components are the units of coarse-grained reuse with contractually specified interfaces and explicit context dependencies only, that can be deployed independently and are subject to third-party composition. In our view, a component should have a clearly identified codebase (classes, traits, interfaces and component-related declarations) and, at runtime, consists of an evolving set of objects. We plan to exploit type-based techniques to devise composition mechanisms supporting compositional analysis of components (if component C uses components D and E, then C can be analyzed by inspecting C's implementation and D's and E's specifications).

The project builds on recent advances in language technology, in particular in the following areas:

  • module and component systems for OO-languages
  • flexible fine-grained reuse techniques (like traits)
  • type systems for encapsulation (like ownership disciplines)
  • semantics and verification support for interface specifications
A well-founded language concept of OO-components that can be integrated into modern mainstream programming languages is an important innovation for improving software reliability and increasing productivity.


Publications

2014
  • Ferruccio Damiani, Johan Dovland, Einar Broch Johnsen, Ina Schaefer: Verifying traits: an incremental proof system for fine-grained reuse. Formal Asp. Comput. 26(4): 761-793 (2014). Electronic edition via DOI
2013
  • Lorenzo Bettini, Sara Capecchi, Ferruccio Damiani: On flexible dynamic trait replacement for Java-like languages. Sci. Comput. Program. 78(7): 907-932 (2013). Electronic edition via DOI
  • Lorenzo Bettini, Ferruccio Damiani, Kathrin Geilmann, Jan Schäfer: Combining traits with boxes and ownership types in a Java-like setting. Sci. Comput. Program. 78(2): 218-247 (2013). Electronic edition via DOI
  • Lorenzo Bettini, Ferruccio Damiani, Ina Schaefer: Compositional type checking of delta-oriented software product lines. Acta Inf. 50(2): 77-122 (2013). Electronic edition via DOI
  • Lorenzo Bettini, Ferruccio Damiani, Ina Schaefer, Fabio Strocco: TraitRecordJ: A programming language with traits and records. Sci. Comput. Program. 78(5): 521-541 (2013). Electronic edition via DOI
2012
  • Ferruccio Damiani, Olaf Owe, Johan Dovland, Ina Schaefer, Einar Broch Johnsen, Ingrid Chieh Yu: A transformational proof system for delta-oriented programming. SPLC (2) 2012: 53-60. Electronic edition via DOI
  • Ferruccio Damiani, Luca Padovani, Ina Schaefer: A formal foundation for dynamic delta-oriented software product lines. GPCE 2012: 1-10. Electronic edition via DOI
  • Ferruccio Damiani, Arnd Poetzsch-Heffter, Yannick Welsch: A type system for checking specialization of packages in object-oriented programming. SAC 2012: 1737-1742. Electronic edition via DOI
  • Ferruccio Damiani, Ina Schaefer: Family-Based Analysis of Type Safety for Delta-Oriented Software Product Lines. ISoLA (1) 2012: 193-207. Electronic edition via DOI
2011
  • Ferruccio Damiani, Johan Dovland, Einar Broch Johnsen, Ina Schaefer: Verifying traits: a proof system for fine-grained reuse. FTfJP@ECOOP 2011: 8:1-8:6. Electronic edition via DOI
  • Ferruccio Damiani, Ina Schaefer: Dynamic delta-oriented programming. SPLC Workshops 2011: 34. Electronic edition via DOI
  • Ina Schaefer, Lorenzo Bettini, Ferruccio Damiani: Compositional type-checking for delta-oriented programming. AOSD 2011: 43-56. Electronic edition via DOI
2010
  • Lorenzo Bettini, Ferruccio Damiani, Marco De Luca, Kathrin Geilmann, Jan Schäfer: A Calculus for Boxes and Traits in a Java-Like Setting. COORDINATION 2010: 46-60. Electronic edition via DOI
  • Lorenzo Bettini, Ferruccio Damiani, Ina Schaefer: Implementing software product lines using traits. SAC 2010: 2096-2102. Electronic edition via DOI
  • Lorenzo Bettini, Ferruccio Damiani, Ina Schaefer, Fabio Strocco: A prototypical Java-like language with records and traits. PPPJ 2010: 129-138. Electronic edition via DOI
  • Ina Schaefer, Lorenzo Bettini, Viviana Bono, Ferruccio Damiani, Nico Tanzarella: Delta-Oriented Programming of Software Product Lines. SPLC 2010: 77-91. Electronic edition via DOI
  • Ina Schaefer, Ferruccio Damiani: Pure delta-oriented programming. FOSD 2010: 49-56. Electronic edition via DOI