Mixin layers: an object-oriented implementation technique for refinements and collaboration-based designs

A "refinement" is a functionality addition to a software project that can affect multiple dispersed implementation entities (functions, classes, etc.). In this paper, we examine large-scale refinements in terms of a fundamental object-oriented technique called collaboration-based design. We explain how collaborations can be expressed in existing programming languages or can be supported with new language constructs (which we have implemented as extensions to the Java language). We present a specific expression of large-scale refinements called mixin layers, and demonstrate how it overcomes the scalability difficulties that plagued prior work. We also show how we used mixin layers as the primary implementation technique for building an extensible Java compiler, JTS.

[1]  Urs Hölzle,et al.  Binary Component Adaptation , 1997, ECOOP.

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

[3]  Don S. Batory,et al.  Scalable software libraries , 1993, SIGSOFT '93.

[4]  E. E. Villarreal,et al.  Automated compiler generation for extensible data languages , 1994 .

[5]  Ira R. Forman,et al.  Composition of Before/After Metaclasses in SOM , 1994, OOPSLA.

[6]  Martin Odersky,et al.  Pizza into Java: translating theory into practice , 1997, POPL '97.

[7]  Stanley M. Sutton,et al.  N degrees of separation: multi-dimensional separation of concerns , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[8]  Don S. Batory,et al.  The design and implementation of hierarchical software systems with reusable components , 1992, TSEM.

[9]  Robin Milner,et al.  Definition of standard ML , 1990 .

[10]  Yannis Smaragdakis,et al.  Implementing Layered Designs with Mixin Layers , 1998, ECOOP.

[11]  Harold Ossher,et al.  Subject-oriented composition rules , 1995, OOPSLA.

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

[13]  Harold Ossher,et al.  Subject-oriented programming: a critique of pure objects , 1993, OOPSLA '93.

[14]  Andrew C. Myers,et al.  Parameterized types for Java , 1997, POPL '97.

[15]  James E. Rumbaugh,et al.  Getting Started: Using Use Cases to Capture Requirements , 1994, J. Object Oriented Program..

[16]  Harold Ossher,et al.  Combination of Inheritance Hierarchies , 1992, OOPSLA.

[17]  Brian Foote,et al.  Designing Reusable Classes , 2001 .

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

[19]  Cristina V. Lopes,et al.  Recent Developments in Aspect , 1998, ECOOP Workshops.

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

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

[22]  Don S. Batory Concepts for a database system compiler , 1988, PODS '88.

[23]  Theo D'Hondt,et al.  Nested Mixin-Methods in Agora , 1993, ECOOP.

[24]  Gang Chen,et al.  Design wizards and visual programming environments for generators , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[25]  Karl Lieberherr,et al.  Adaptive Object-Oriented Software: The Demeter Method with Propagation Patterns , 1995 .

[26]  A. Nico Habermann,et al.  Modularization and hierarchy in a family of operating systems , 1976, CACM.

[27]  Don S. Batory,et al.  Achieving Extensibility Through Product-Lines and Domain-Specific Languages: A Case Study , 2000, ICSR.

[28]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[29]  Yannis Smaragdakis,et al.  Implementing reusable object-oriented components , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[30]  Don S. Batory,et al.  Composition Validation and Subjectivity in GenVoca Generators , 1997, IEEE Trans. Software Eng..

[31]  Bjarne Stroustrup,et al.  The C++ programming language (3. ed.) , 1997 .

[32]  Ian M. Holland,et al.  Specifying Reusable Components Using Contracts , 1992, ECOOP.

[33]  Alexander Sverdlov Review of David L. Parnas' "Designing Software for Ease of Extension and Contraction" , 2004 .

[34]  Robert Bruce Findler,et al.  Modular object-oriented programming with units and mixins , 1998, ICFP '98.

[35]  Mira Mezini,et al.  Adaptive plug-and-play components for evolutionary software development , 1998, OOPSLA '98.

[36]  David Notkin,et al.  Using C++ Templates to Implement Role-Based Designs , 1996, ISOTAS.

[37]  John S. Heidemann,et al.  File-system development with stackable layers , 1994, TOCS.

[38]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[39]  Yannis Smaragdakis,et al.  JTS: tools for implementing domain-specific languages , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[40]  Yannis Smaragdakis,et al.  Mixin-Based Programming in C++ , 2000, GCSE.

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

[42]  David Notkin,et al.  Using role components in implement collaboration-based designs , 1996, OOPSLA '96.

[43]  Don Batoryi,et al.  Object-Oriented Frameworks and Product-Lines 1 , 2000 .

[44]  S. Tucker Taft,et al.  Ada 95 Reference Manual , 1995, Lecture Notes in Computer Science.

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

[46]  Boaz Patt-Shamir,et al.  Traversals of object structures: Specification and Efficient Implementation , 2004, TOPL.

[47]  Niklaus Wirth,et al.  What can we do about the unnecessary diversity of notation for syntactic definitions? , 1977, Commun. ACM.

[48]  Karsten Weihe,et al.  A software engineering perspective on algorithmics , 2001, CSUR.

[49]  Stephen N. Freund,et al.  Adding type parameterization to the Java language , 1997, OOPSLA '97.

[50]  Daniel Weise,et al.  Programmable syntax macros , 1993, PLDI '93.

[51]  David Notkin,et al.  Decoupling change from design , 1996, SIGSOFT '96.

[52]  Kent Beck Kent Beck's Guide to Better Smalltalk: CONSTRUCTING ABSTRACTIONS FOR OBJECT-ORIENTED APPLICATIONS , 1997 .

[53]  Ted J. Biggerstaff,et al.  The library scaling problem and the limits of concrete component reuse , 1994, Proceedings of 1994 3rd International Conference on Software Reuse.

[54]  David A. Moon Object-oriented programming with flavors , 1986, OOPSLA 1986.

[55]  Don Batory,et al.  Implementing large-scale object-oriented components , 1999 .

[56]  Don S. Batory,et al.  GENESIS: An Extensible Database Management System , 1988, IEEE Trans. Software Eng..

[57]  David A. Moon,et al.  Object-oriented programming with flavors , 1986, OOPLSA '86.

[58]  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.

[59]  S. Tucker Taft,et al.  Consolidated Ada Reference Manual Language and Standard Libraries , 2002, Lecture Notes in Computer Science.

[60]  David Lorge Parnas,et al.  Review of David L. Parnas' "Designing Software for Ease of Extension and Contraction" , 2004 .

[61]  Kent Beck,et al.  A laboratory for teaching object oriented thinking , 1989, OOPSLA 1989.

[62]  Martin Odersky,et al.  Making the future safe for the past: adding genericity to the Java programming language , 1998, OOPSLA '98.

[63]  Larry L. Peterson,et al.  A dynamic network architecture , 1992, TOCS.

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

[65]  Yannis Smaragdakis,et al.  Object-oriented frameworks and product lines , 2000, SPLC.

[66]  David Notkin,et al.  Role-oriented programming for software evolution , 1997 .

[67]  Ian M. Holland,et al.  Contracts: specifying behavioral compositions in object-oriented systems , 1990, OOPSLA/ECOOP '90.

[68]  Mira Mezini,et al.  Dynamic Object Evolution without Name Collisions , 1997, ECOOP.

[69]  Don S. Batory,et al.  Achieving extensibility through product-lines and domain-specific languages: a case study , 2000, TSEM.