Type-Safe Prototype-Based Component Evolution

Component-based programming is currently carried out using mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the programming language level. We propose a simple prototype-based model for first-class components on top of a class-based object-oriented language. The model is formalized as an extension of Featherweight Java. Our calculus includes a minimal set of primitives to dynamically build, extend, and compose software components, while supporting features like explicit context dependencies, late composition, unanticipated component extensibility, and strong encapsulation. We present a type system for our calculus that ensures type-safe component definition, composition, and evolution.

[1]  David B. MacQueen.  Modules for standard ML , 1984, LFP '84.

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

[3]  Randall B. Smith,et al.  Self: The power of simplicity , 1987, OOPSLA 1987.

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

[5]  Gilad Bracha,et al.  The programming language jigsaw: mixins, modularity and multiple inheritance , 1992 .

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

[7]  David Garlan,et al.  A Formal Approach to Software Architectures , 1992, IFIP Congress.

[8]  Alexander L. Wolf,et al.  Acm Sigsoft Software Engineering Notes Vol 17 No 4 Foundations for the Study of Software Architecture , 2022 .

[9]  Craig Chambers,et al.  The cecil language: specification and rationale , 1993 .

[10]  Urs Hölzle,et al.  Integrating Independently-Developed Components in Object-Oriented Languages , 1993, ECOOP.

[11]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[12]  Matthias Felleisen,et al.  A Syntactic Approach to Type Soundness , 1994, Inf. Comput..

[13]  David Garlan,et al.  Exploiting style in architectural design environments , 1994, SIGSOFT '94.

[14]  Naranker Dulay,et al.  Specifying Distributed Software Architectures , 1995, ESEC.

[15]  Xiaolei Qian,et al.  Correct Architecture Refinement , 1995, IEEE Trans. Software Eng..

[16]  Clemens A. Szyperski.  Independently Extensible Systems - Software Engineering Potential and Challenges , 1996 .

[17]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[18]  Mary Shaw,et al.  Software architecture - perspectives on an emerging discipline , 1996 .

[19]  M.P.J. Stevens,et al.  Specification and analysis , 1996 .

[20]  Martín Abadi,et al.  A Theory of Objects , 1996, Monographs in Computer Science.

[21]  Robert T. Monroe,et al.  Acme: an architecture description interchange language , 2010, CASCON.

[22]  Luca Cardelli,et al.  Program fragments, linking, and modularization , 1997, POPL '97.

[23]  Dale Rogerson,et al.  Inside COM , 1997 .

[24]  Davide Ancona,et al.  A theory of mixin modules: basic and derived operators , 1998, Mathematical Structures in Computer Science.

[25]  Matthias Felleisen,et al.  Units: cool modules for HOT languages , 1998, PLDI.

[26]  Wolfgang Weck,et al.  Compound types for Java , 1998, OOPSLA '98.

[27]  Claudio V. Russo.  Types for Modules , 2004, Electronic Notes in Theoretical Computer Science.

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

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

[30]  Davide Ancona,et al.  A Primitive Calculus for Module Systems , 1999, PPDP.

[31]  J. Gregory Morrisett,et al.  Type-safe linking and modular assembly language , 1999, POPL '99.

[32]  Brian Postow.  Book review: A Theory of Objects by Martin Abadi and Luca Cardelli (Springer-Verlag, 1996): Series--Monographs in Computer Science , 1999, SIGA.

[33]  Günter Kniesel.  Type-Safe Delegation for Run-Time Component Adaptation , 1999, ECOOP.

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

[35]  Richard N. Taylor,et al.  A Classification and Comparison Framework for Software Architecture Description Languages , 2000, IEEE Trans. Software Eng..

[36]  Guy L. Steele,et al.  Java Language Specification, Second Edition: The Java Series , 2000 .

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

[38]  Martin Odersky,et al.  Objects + Views = Components? , 2000, Abstract State Machines.

[39]  Claudio V. Russo.  First-Class Structures for Standard ML , 2000, Nord. J. Comput..

[40]  Matthias Felleisen,et al.  Programming languages for reusable software components , 2000 .

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

[42]  Wolfgang Weck,et al.  Generic Wrappers , 2000, ECOOP.

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

[44]  V. Sreedhar.  ACOEL on CORAL A COmponent Requirement and Abstraction Language , 2001 .

[45]  Matthew Flatt,et al.  Mixing COP and OOP , 2001 .

[46]  Davide Ancona,et al.  True Modules for Java-like Languages , 2001, ECOOP.

[47]  A. Watson,et al.  OMG (Object Management Group) architecture and CORBA (common object request broker architecture) specification , 2002 .

[48]  David Notkin,et al.  Architectural Reasoning in ArchJava , 2002, ECOOP.

[49]  Benjamin C. Pierce,et al.  Types and programming languages: the next generation , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[50]  Viviana Bono,et al.  Coordinating Mobile Object-Oriented Code , 2002, COORDINATION.

[51]  Davide Ancona,et al.  A calculus of module systems , 2002, J. Funct. Program..

[52]  Tom Hirschowitz,et al.  Mixin modules in a call-by-value setting , 2002, TOPL.

[53]  Massachusett Framingham,et al.  The Common Object Request Broker: Architecture and Specification Version 3 , 2003 .

[54]  Peter H. Golde,et al.  C# Language Specification , 2003 .