A Form-based Metamodel for Software Composition

In recent years considerable progress has been made to facilitate the specification and implementation of software components. However, it is far less clear what kind of language support is needed to enable a flexible and reliable software composition approach. Object-oriented programming languages seem to already offer some reasonable support for component-based programming (e.g., encapsulation of state and behavior, inheritance, late binding). Unfortunately, these languages typically provide only a fixed and restricted set of mechanisms for constructing and composing compositional abstractions. In this article, we will present a generic meta-level framework for modeling both objectand component-oriented programming abstractions. In this framework, various features, which are typically merged in traditional object-oriented programming languages, are all replaced by a single concept: the composition of forms. Forms are first-class, immutable, extensible records that allow for the specification of compositional abstractions in a language-neutral and robust way. Thus, using the meta-level framework, we can define a compositional model that provides the means both to bridge between different object models and to incorporate existing software artifacts into a unified composition system.

[1]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[2]  Guy L. Steele,et al.  Common Lisp the Language , 1984 .

[3]  Uday S. Reddy,et al.  Objects as closures: abstract semantics of object-oriented languages , 1988, LISP and Functional Programming.

[4]  Luca Cardelli,et al.  A Semantics of Multiple Inheritance , 1984, Information and Computation.

[5]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[6]  William R. Cook,et al.  A denotational semantics of inheritance , 1989 .

[7]  Luca Cardelli,et al.  Operations on Records , 1989, Mathematical Foundations of Programming Semantics.

[8]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[9]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[10]  Larry Wall,et al.  Programming Perl , 1991 .

[11]  Robin Milner,et al.  A Calculus of Mobile Processes, II , 1992, Inf. Comput..

[12]  Gilad Bracha,et al.  Modularity meets inheritance , 1992, Proceedings of the 1992 International Conference on Computer Languages.

[13]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[14]  Ole Lehrmann Madsen,et al.  Object-oriented programming in the BETA programming language , 1993 .

[15]  Tom Mens,et al.  A survey on formal models for OO , 1994 .

[16]  Kim B. Bruce A paradigmatic object-oriented programming language: Design, static typing and semantics , 1994, Journal of Functional Programming.

[17]  Benjamin C. Pierce,et al.  Simple type-theoretic foundations for object-oriented programming , 1994, Journal of Functional Programming.

[18]  Jens Palsberg,et al.  A Denotational Semantics of Inheritance and Its Correctness , 1994, Inf. Comput..

[19]  Oscar Nierstrasz,et al.  Component-oriented software technology , 1995 .

[20]  John C. Mitchell,et al.  A Delegation-based Object Calculus with Subtying , 1995, FCT.

[21]  Oscar Nierstrasz,et al.  Using Metaobjects to Model Concurrent Objects with PICT , 1996, LMO.

[22]  M A R C V A N L I M B E R G H E N,et al.  Encapsulation and composition as orthogonal operators on mixins: a solution to multiple inheritance problems , 1996 .

[23]  Cédric Fournet,et al.  The reflexive CHAM and the join-calculus , 1996, POPL '96.

[24]  Mitchell Wand,et al.  Modeling Subobject-based Inheritance , 1996, ECOOP.

[25]  Davide Ancona,et al.  An Algebraic Approach to Mixins and Modularity , 1996, ALP.

[26]  Markus Lumpe,et al.  Synchronizing Concurrent Objects in the Pi-Calculus , 1997, LMO.

[27]  Johannes Sametinger,et al.  Software Engineering with Reusable Components , 1997, Springer Berlin Heidelberg.

[28]  Luca Cardelli,et al.  Comparing Object Encodings , 1997, TACS.

[29]  Laurent Dami,et al.  A Lambda-Calculus for Dynamic Binding , 1998, Theor. Comput. Sci..

[30]  Emil Sekerinski,et al.  A Study of The Fragile Base Class Problem , 1998, ECOOP.

[31]  Matthias Felleisen,et al.  Classes and mixins , 1998, POPL '98.

[32]  Vitaly Shmatikov,et al.  A Core Calculus of Classes and Mixins , 1999, ECOOP.

[33]  Jean-Guy Schneider,et al.  Components, Scripts, and Glue: A conceptual framework for software composition , 1999 .

[34]  Markus Lumpe A Pi-Calculus Based Approach to Software Composition , 1999 .

[35]  Mark Lutz,et al.  Learning Python , 1999 .

[36]  하수철,et al.  [서평]「Component Software」 - Beyond Object-Oriented Programming - , 2000 .

[37]  Oscar Nierstrasz,et al.  Explicit Namespaces , 2000, JMLC.

[38]  Davide Sangiorgi,et al.  Communicating and Mobile Systems: the π-calculus, , 2000 .

[39]  Franz Achermann,et al.  Forms, Agents and Channels: Defining Composition Abstraction with Style , 2002 .

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

[41]  Uwe Aßmann,et al.  Invasive Software Composition , 2003, Springer Berlin Heidelberg.

[42]  Markus Lumpe,et al.  Form-based software composition , 2003 .