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