Invasive Software Composition

Invasive software composition (ISC) composes software components by program transformation. Standard composition treats components as immutable blackboxes and plugs them together as they are. Invasive software composition goes one step further and transforms components when they are embedded in a reuse context. In this way, components can be adapted more appropriately to reuse requirements. The components need not be adapted by hand, instead invasive composition operators do all the work.

[1]  Oscar Nierstrasz,et al.  A formal language for composition , 2000 .

[2]  Mary Shaw,et al.  Candidate Model Problems in Software Architecture , 1994 .

[3]  Ivar Jacobson,et al.  The unified modeling language reference manual , 2010 .

[4]  Satoshi Matsuoka,et al.  Analysis of inheritance anomaly in object-oriented concurrent programming languages , 1993 .

[5]  David Garlan,et al.  A formal basis for architectural connection , 1997, TSEM.

[6]  Randall B. Smith,et al.  Programming as an Experience: The Inspiration for Self , 1995, ECOOP.

[7]  Oege de Moor,et al.  Transformation in intentional programming , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[8]  Panagiotis D. Bamidis,et al.  Information System Interoperability in a Regional Health Care System Infrastructure: a pilot study using Health Care Information Standards , 2003, MIE.

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

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

[11]  Richard T. Snodgrass,et al.  Supporting Flexible and Efficient Tool Integration , 1986, Advanced Programming Environments.

[12]  Charles Richter,et al.  PARIS: a system for reusing partially interpreted schemas , 1987, ICSE '87.

[13]  Reinhard Wilhelm,et al.  Generation of Synchronization Code for Parallel Compilers , 1993, PLILP.

[14]  Oscar Nierstrasz,et al.  Component-oriented software development , 1992, CACM.

[15]  Thomas Ledoux,et al.  Safe metaclass programming , 1998, OOPSLA '98.

[16]  Wolfgang De Meuter,et al.  Using Reflective Logic Programming to Describe Domain Knowledge as an Aspect , 1999, GCSE.

[17]  Mary Shaw,et al.  Toward boxology: preliminary classification of architectural styles , 1996, ISAW '96.

[18]  Meinolf Sellmann,et al.  Symmetry Breaking , 2001, CP.

[19]  J. Ousterhout.  An Introduction To Tcl and Tk , 1997 .

[20]  D. Walker,et al.  A Calculus of Mobile Processes, Part Ii , 1989 .

[21]  Matthew S. Hecht,et al.  Flow Analysis of Computer Programs , 1977 .

[22]  Mary Shaw,et al.  An Introduction to Software Architecture , 1993, Advances in Software Engineering and Knowledge Engineering.

[23]  Ralf Lämmel,et al.  Functional meta-programs towards reusability in the declarative paradigm , 1998 .

[24]  T. A. Dolotta,et al.  UNIX time-sharing system: The programmer's workbench , 1978, The Bell System Technical Journal.

[25]  Christopher Alexander,et al.  The Timeless Way of Building , 1979 .

[26]  Andreas Ludwig,et al.  Metaprogramming in the Large , 2000, GCSE.

[27]  Oscar Nierstrasz,et al.  Requirements for a Composition Language , 1994, ECOOP Workshop.

[28]  Lodewijk Bergmans,et al.  The Composition-Filters Object Model* , 1998 .

[29]  Oscar Nierstrasz,et al.  Formalizing Composable Software Systems — A Research Agenda , 1997 .

[30]  Raymie Stata,et al.  Modular reasoning in the presence of subclassing , 1995, OOPSLA.

[31]  Uwe Aßmann,et al.  Cosy Compiler Phase Embedding with the CoSy Compiler Model , 1994, CC.

[32]  Shigeru Chiba,et al.  Avoiding Confusion in Metacircularity: The Meta-Helix , 1996, ISOTAS.

[33]  Takashi Masuda,et al.  Designing an Extensible Distributed Language with a Meta-Level Architecture , 1993, ECOOP.

[34]  Gerhard Weikum,et al.  The MENTOR workbench for enterprise-wide workflow management , 1997, SIGMOD '97.

[35]  Per Brinch Hansen,et al.  Monitors and concurrent Pascal: a personal history , 1993, HOPL-II.

[36]  Charles Simonyi,et al.  The Hungarian revolution , 1991 .

[37]  C. Johnson,et al.  In Unix Programmer''s Manual , 1978 .

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

[39]  Jesper Andersson.  A deployment system for pervasive computing , 2000, Proceedings 2000 International Conference on Software Maintenance.

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

[41]  Howard Gilbert.  Let a Hundred Flowers Bloom. , 2004 .

[42]  Michael Schumacher,et al.  The STL++ Coordination Language: A Base for Implementing Distributed Multi-agent Applications , 1999, COORDINATION.

[43]  T. B. Dinesh,et al.  An extensible language for the generation of parallel data manipulation andcontrol packages , 1995 .

[44]  Louis Marie Johannes Bergmans,et al.  Composing Concurrent Objects , 1994 .

[45]  Mary Shaw,et al.  Abstractions for Software Architecture and Tools to Support Them , 1995, IEEE Trans. Software Eng..

[46]  Oscar Nierstrasz,et al.  Components, Scripts and Glue , 2000 .

[47]  Oscar Nierstrasz,et al.  Research directions in software composition , 1995, CSUR.

[48]  Peter Sestoft,et al.  Partial evaluation and automatic program generation , 1993, Prentice Hall international series in computer science.

[49]  Karl J. Lieberherr,et al.  Adaptive object-oriented programming using graph-based customization , 1994, CACM.

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

[51]  Claude Wiatrowski,et al.  Visual object-oriented programming using Delphi , 1996 .

[52]  John R. Gilbert,et al.  Aspect-Oriented Programming of Sparse Matrix Code , 1997, ISCOPE.

[53]  David Garlan,et al.  Acme-Based Software Architecture Interchange , 1999, COORDINATION.

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

[55]  David Scott Warren,et al.  Memoing for logic programs , 1992, CACM.

[56]  David Garlan,et al.  MELDing data flow and object-oriented programming , 1987, OOPSLA 1987.

[57]  Jeannette M. Wing,et al.  A New Definition of the Subtype Relation , 1993, ECOOP.

[58]  Don S. Batory,et al.  The GenVoca model of software-system generators , 1994, IEEE Software.

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

[60]  Mira Mezini,et al.  PIROL: a case study for multidimensional separation of concerns in software engineering environments , 2000, OOPSLA '00.

[61]  Lynn Andrea Stein.  Delegation is inheritance , 1987, OOPSLA 1987.

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

[63]  Flemming Nielson,et al.  Semantics with applications - a formal introduction , 1992, Wiley professional computing.

[64]  Dennis Gannon,et al.  Active Libraries: Rethinking the roles of compilers and libraries , 1998, ArXiv.

[65]  Ciaran Mchale,et al.  Synchronisation in Concurrent, Object-oriented Languages: Expressive Power, Genericity and Inheritan , 1994 .

[66]  Claus Lewerentz,et al.  Formal Development of Reactive Systems: Case Study Production Cell , 1995 .

[67]  Uwe Aßmann,et al.  Meta-programming grey-box connectors , 2000, Proceedings 33rd International Conference on Technology of Object-Oriented Languages and Systems TOOLS 33.

[68]  M.L. Griss,et al.  Software reuse architecture, process, and organization for business success , 1997, Proceedings of the Eighth Israeli Conference on Computer Systems and Software Engineering.

[69]  Don S. Batory,et al.  Software components in a data structure precompiler , 1992, Proceedings of 1993 15th International Conference on Software Engineering.

[70]  Pattie Maes,et al.  Concepts and experiments in computational reflection , 1987, OOPSLA '87.

[71]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

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

[73]  Leon J. Osterweil,et al.  A mechanism for environment integration , 1990, TOPL.

[74]  James R. Cordy,et al.  A Syntactic Theory of Software Architecture , 1995, IEEE Trans. Software Eng..

[75]  Shigeru Chiba,et al.  OpenJava: A Class-Based Macro System for Java , 1999, Reflection and Software Engineering.

[76]  Naranker Dulay,et al.  A constructive development environment for parallel and distributed programs , 1994, Proceedings of 2nd International Workshop on Configurable Distributed Systems.

[77]  Siobhán Clarke,et al.  Subject-oriented design: towards improved alignment of requirements, design, and code , 1999, OOPSLA '99.