Adaptive plug-and-play components for evolutionary software development

In several works on design methodologies, design patterns, and programming language design, the need for program entities that capture the patterns of collaboration between several classes has been recognized. The idea is that in general the unit of reuse is not a single class, but a slice of behavior affecting a set of collaborating classes. The absence of large-scale components for expressing these collaborations makes object-oriented programs more difficult to maintain and reuse, because functionality is spread over several methods and it becomes difficult to get the "big picture". In this paper, we propose Adaptive Plug and Play Components to serve this need. These components are designed such that they not only facilitate the construction of complex software by making the collaborations explicit, but they do so in a manner that supports the evolutionary nature of both structure and behavior.

[1]  Mira Mezini.  Maintaining the consistency of class libraries during their evolution , 1997, OOPSLA '97.

[2]  Jens Palsberg,et al.  Implementation of Adaptive Software , 1994 .

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

[4]  Karl J. Lieberherr,et al.  Assuring good style for object-oriented programs , 1989, IEEE Software.

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

[6]  Joseph Gil,et al.  Design Patterns and Language Design , 1998, Computer.

[7]  Karl J. Lieberherr,et al.  Preventive Program Maintenance in Demeter/Java , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[8]  Ralph E. Johnson,et al.  Frameworks = (components + patterns) , 1997, CACM.

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

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

[11]  Clemens A. Szyperski,et al.  Import is Not Inheritance - Why We Need Both: Modules and Classes , 1992, ECOOP.

[12]  Niklaus Wirth,et al.  The oberon system , 1989, Softw. Pract. Exp..

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

[14]  William R. Cook,et al.  Object-Oriented Programming Versus Abstract Data Types , 1990, REX Workshop.

[15]  Johan Jeuring,et al.  PolyP—a polytypic programming language extension , 1997, POPL '97.

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

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

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

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

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

[21]  Norman Wilde,et al.  Maintaining object-oriented software , 1993, IEEE Software.

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

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

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

[25]  Jens Palsberg,et al.  Efficient implementation of adaptive software , 1995, TOPL.

[26]  Boaz Patt-Shamir,et al.  A New Approach to Compiling Adaptive Programs , 1996, ESOP.

[27]  Søren Lauesen.  Real-Life Object-Oriented Systems , 1998, IEEE Softw..