Sharing Classes Between Families : Technical report

Class sharing is a new language mechanism for building extensible software systems. Recent work has separately explored two different kinds of extensibility: first, family inheritance, in which an entire family of related classes can be inherited, and second, adaptation, in which existing objects are extended in place with new behavior and state. Class sharing integrates these two kinds of extensibility mechanisms. With little programmer effort, objects of one family can be used as members of another, while preserving relationships among objects. Therefore, a family of classes can be adapted in place with new functionality spanning multiple classes. Object graphs can evolve from one family to another, adding or removing functionality even at run time. Several new mechanisms support this flexibility while ensuring type safety. Class sharing has been implemented as an extension to Java, and its utility for evolving and extending software is demonstrated with realistic systems.

[1]  Martin Odersky,et al.  An Overview of the Scala Programming Language , 2004 .

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

[3]  Kresten Krab Thorup.  Genericity in Java with Virtual Types , 1997, ECOOP.

[4]  Erik Ernst.  gbeta - a Language with Virtual Attributes, Block Structure, and Propagating, Dynamic Inheritance , 2000 .

[5]  Erik Ernst,et al.  Family Polymorphism , 2001, ECOOP.

[6]  Emin Gün Sirer,et al.  Corona: A High Performance Publish-Subscribe System for the World Wide Web , 2006, NSDI.

[7]  Peter Druschel,et al.  Pastry: Scalable, distributed object location and routing for large-scale peer-to- , 2001 .

[8]  Xin Qi,et al.  Nested Intersection for Scalable Software Composition (Technical Report) , 2006 .

[9]  Martin Odersky,et al.  A Statically Safe Alternative to Virtual Types , 1998, ECOOP.

[10]  Kathryn S. McKinley,et al.  Data flow analysis for software prefetching linked data structures in Java , 2001, Proceedings 2001 International Conference on Parallel Architectures and Compilation Techniques.

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

[12]  Michael R. Clarkson,et al.  Polyglot: An Extensible Compiler Framework for Java , 2003, CC.

[13]  Susan Eisenbach,et al.  Safe upgrading without restarting , 2003, International Conference on Software Maintenance, 2003. ICSM 2003. Proceedings..

[14]  Gavin M. Bierman,et al.  Mutatis Mutandis: Safe and predictable dynamic software updating , 2007, TOPL.

[15]  Benjamin C. Pierce,et al.  Higher-order intersection types and multiple inheritance , 1996, Mathematical Structures in Computer Science.

[16]  Thierry Coupaye,et al.  ASM: a code manipulation tool to implement adaptable systems , 2002 .

[17]  Fred P. Brooks,et al.  The Mythical Man-Month , 1975, Reliable Software.

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

[19]  Dominic Duggan,et al.  Type-based hot swapping of running modules , 2005, Acta Informatica.

[20]  Todd D. Millstein,et al.  Statically scoped object adaptation with expanders , 2006, OOPSLA '06.

[21]  Philip Wadler,et al.  Views: a way for pattern matching to cohabit with data abstraction , 1987, POPL '87.

[22]  Stephan Herrmann,et al.  Object Teams: Improving Modularity for Crosscutting Collaborations , 2002, NetObjectDays.

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

[24]  Sophia Drossopoulou,et al.  Tribe: a simple virtual class calculus , 2007, AOSD.

[25]  Mira Mezini,et al.  Conquering aspects with Caesar , 2003, AOSD '03.

[26]  Mads Torgersen.  Virtual types are statically safe , 1998 .

[27]  Emin Gün Sirer,et al.  Beehive: O(1) Lookup Performance for Power-Law Query Distributions in Peer-to-Peer Overlays , 2004, NSDI.

[28]  Tim Sweeney.  The next mainstream programming language: a game developer's perspective , 2006, POPL '06.

[29]  P. Kidwell,et al.  The mythical man-month: Essays on software engineering , 1996, IEEE Annals of the History of Computing.

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

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

[32]  Oscar Nierstrasz,et al.  Classbox/J: controlling the scope of change in Java , 2005, OOPSLA '05.

[33]  Ole Lehrmann Madsen,et al.  Virtual classes: a powerful mechanism in object-oriented programming , 1989, OOPSLA 1989.

[34]  Martin Odersky,et al.  Scalable component abstractions , 2005, OOPSLA '05.

[35]  Bruno C. d. S. Oliveira.  Modular Visitor Components: A Practical Solution to the Expression Families Problem , 2009, ECOOP 2009.

[36]  Xin Qi,et al.  Masked types for sound object initialization , 2009, POPL '09.

[37]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

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

[39]  Sophia Drossopoulou,et al.  Chai: Traits for Java-Like Languages , 2005, ECOOP.

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

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

[42]  Atsushi Igarashi,et al.  Foundations for Virtual Types , 1999, Inf. Comput..

[43]  Gary T. Leavens,et al.  MultiJava: modular open classes and symmetric multiple dispatch for Java , 2000, OOPSLA '00.

[44]  Mira Mezini,et al.  Component Integration with Pluggable Composite Adapters , 2002 .

[45]  W. Cook,et al.  A Virtual Class Calculus , 2005 .

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

[47]  Kim B. Bruce.  Safe Static Type Checking With Systems of Mutually Recursive Classes and Inheritance , 1997 .

[48]  Mirko Viroli,et al.  Variant path types for scalable extensibility , 2007, OOPSLA.

[49]  Sophia Drossopoulou,et al.  Refined Effects for Unanticipated Object Re-classification: Fickle3 , 2003, ICTCS.

[50]  John C. Reynolds,et al.  Design of the programming language FORSYTHE , 1997 .

[51]  Andrew C. Myers,et al.  Scalable extensibility via nested inheritance , 2004, OOPSLA.