Abstract Behavior Types: a foundation model for components and their composition

The notion of Abstract Data Type (ADT) has served as a foundation model for structured and object oriented programming for some thirty years. The current trend in software engineering toward component based systems requires a foundation model as well. The most basic inherent property of an ADT, i.e., that it provides a set of operations, subverts some highly desirable properties in emerging formal models for components that are based on the object oriented paradigm. We introduce the notion of Abstract Behavior Type (ABT) as a higher-level alternative to ADT and propose it as a proper foundation model for both components and their composition. An ABT defines an abstract behavior as a relation among a set of timed-data-streams, without specifying any detail about the operations that may be used to implement such behavior or the data types it may manipulate for its realization. The ABT model supports a much looser coupling than is possible with the ADT's operational interface, and is inherently amenable to exogenous coordination. We propose that both of these are highly desirable, if not essential, properties for models of components and their composition. To demonstrate the utility of the ABT model, we describe Reo: an exogenous coordination language for compositional construction of component connectors based on a calculus of channels. We show the expressive power of Reo, and the applicability of ABT, through a number of examples.

[1]  Lawrence S. Moss,et al.  On the Foundations of Corecursion , 1997, Log. J. IGPL.

[2]  Edward A. Lee,et al.  Ptolemy: A Framework for Simulating and Prototyping Heterogenous Systems , 2001, Int. J. Comput. Simul..

[3]  Frank S. de Boer,et al.  A Compositional Model for Confluent Dynamic Data-Flow Networks , 2000, MFCS.

[4]  Robin Milner,et al.  A Calculus of Mobile Processes, II , 1992, Inf. Comput..

[5]  S. Shelah,et al.  Annals of Pure and Applied Logic , 1991 .

[6]  Farhad Arbab,et al.  A coordination language for mobile components , 2000, SAC '00.

[7]  Michael D. Ernst,et al.  An overview of JML tools and applications , 2003, International Journal on Software Tools for Technology Transfer.

[8]  Martin Wirsing,et al.  Making Components Move: A Separation of Concerns Approach , 2002, FMCO.

[9]  René Boel,et al.  Discrete Event Systems , 2000 .

[10]  K. Rustan M. Leino,et al.  An Extended Static Checker for Modular-3 , 1998, CC.

[11]  Jan J. M. M. Rutten,et al.  Universal coalgebra: a theory of systems , 2000, Theor. Comput. Sci..

[12]  Lawrence S. Moss,et al.  Coalgebraic Logic , 1999, Ann. Pure Appl. Log..

[13]  Farhad Arbab,et al.  Effective modeling of software architectural assemblies using constraint automata , 2003 .

[14]  Bertrand Meyer,et al.  Eiffel: The Language , 1991 .

[15]  Jan J. M. M. Rutten.  Elements of Stream Calculus (An Extensive Exercise in Coinduction) , 2001, MFPS.

[16]  Edward A. Lee,et al.  Overview of the Ptolemy project , 2001 .

[17]  Gary T. Leavens,et al.  JML: notations and tools supporting detailed design in Java , 2000 .

[18]  Beth Stearns,et al.  Applying Enterprise JavaBeans: Component-Based Development for the J2EE Platform , 2003 .

[19]  Roberto Bruni,et al.  Recent Trends in Algebraic Development Techniques , 2002, Lecture Notes in Computer Science.

[20]  Horst Reichel,et al.  An approach to object semantics based on terminal co-algebras , 1995, Mathematical Structures in Computer Science.

[21]  Jon Sigel,et al.  CORBA Fundamentals and Programming , 1996 .

[22]  Davide Sangiorgi,et al.  Asynchronous process calculi: the first- and higher-order paradigms , 2001, Theor. Comput. Sci..

[23]  Richard Grimes,et al.  Professional Dcom Programming , 1997 .

[24]  Farhad Arbab,et al.  Reo: A Channel-based Coordination Model for Component Composition , 2005 .

[25]  Bart Jacobs,et al.  Inheritance and Cofree Constructions , 1996, ECOOP.

[26]  Joost N. Kok,et al.  Towards a Uniform Topological Treatment of Streams and Functions on Streams , 1985, ICALP.

[27]  Alan Snyder.  Encapsulation and inheritance in object-oriented programming languages , 1986, OOPSLA 1986.

[28]  Manfred Broy,et al.  The algebra of stream processing functions , 2001, Theor. Comput. Sci..

[29]  Clemens A. Szyperski,et al.  Component software - beyond object-oriented programming , 2002 .

[30]  Luís Soares Barbosa,et al.  Components as coalgebras , 2001 .

[31]  Lodewijk Bergmans,et al.  Composing crosscutting concerns using composition filters , 2001, CACM.

[32]  Farhad Arbab,et al.  A Coinductive Calculus of Component Connectors , 2002, WADT.

[33]  J. Rutten.  Coalgebra, concurrency, and control , 1999 .

[34]  Robin Milner,et al.  A Calculus of Mobile Processes, II , 1992, Inf. Comput..

[35]  F. Arbab,et al.  Coordination through Channel Composition , 2002, COORDINATION.

[36]  Frank D. Valencia,et al.  Formal Methods for Components and Objects , 2002, Lecture Notes in Computer Science.

[37]  Bernhard Rumpe,et al.  Modeling dynamic component interfaces , 1998, Proceedings. Technology of Object-Oriented Languages. TOOLS 26 (Cat. No.98EX176).

[38]  Nicholas Carriero,et al.  Coordination languages and their significance , 1992, CACM.

[39]  G. G. Stokes.  "J." , 1890, The New Yale Book of Quotations.

[40]  Ruth Breu,et al.  Reusable Specification Components , 1988, MFCS.

[41]  Jacob Gore.  Object structures: building object-oriented software components with Eiffel , 1996 .

[42]  Farhad Arbab,et al.  Coordination Models and Languages , 1998, Adv. Comput..

[43]  Martin Wirsing,et al.  A Formal Method for the Systematic Reuse of Specification Components , 1991, Methods of Programming.

[44]  H. Peter Gumm,et al.  Covarieties and Complete Covarieties , 1998, CMCS.

[45]  Manfred Broy,et al.  A Logical Basis for Component-Based Systems Engineering , 1999 .

[46]  Jan J. M. M. Rutten,et al.  Automata and Coinduction (An Exercise in Coalgebra) , 1998, CONCUR.

[47]  Farhad Arbab,et al.  The IWIM Model for Coordination of Concurrent Activities , 1996, COORDINATION.

[48]  Edward A. Lee,et al.  Dataflow process networks , 1995, Proc. IEEE.

[49]  Bertrand Meyer,et al.  Reusable Software: The Base Object-Oriented Component Libraries , 1994 .

[50]  K. Rustan M. Leino,et al.  ESC/Java User's Manual , 2000 .

[51]  M. Jackson.  What do you mean? , 1989, Geriatric nursing.

[52]  Robin Milner,et al.  Elements of interaction: Turing award lecture , 1993, CACM.

[53]  Farhad Arbab,et al.  A transition system semantics for the control-driven coordination language MANIFOLD , 2000, Theor. Comput. Sci..

[54]  Jan J. M. M. Rutten,et al.  Automata, Power Series, and Coinduction: Taking Input Derivatives Seriously , 1999, ICALP.

[55]  B. Jacobs,et al.  A tutorial on (co)algebras and (co)induction , 1997 .

[56]  Jan Rutten.  An application of coinductive stream calculus to signal flow graphs , 2003 .

[57]  Farhad Arbab,et al.  A Logical Interface Description Language for Components , 2000, COORDINATION.

[58]  Manfred Broy,et al.  Specification and Development of Interactive Systems , 2001, Monographs in Computer Science.

[59]  Amir Pnueli,et al.  A really abstract concurrent model and its temporal logic , 1986, POPL '86.

[60]  Edward A. Lee,et al.  A framework for comparing models of computation , 1998, IEEE Trans. Comput. Aided Des. Integr. Circuits Syst..

[61]  Jeannette M. Wing,et al.  A behavioral notion of subtyping , 1994, TOPL.

[62]  Berndt Farwer,et al.  ω-automata , 2002 .

[63]  Davide Sangiorgi,et al.  Asynchronous process calculi: the first-order and higher-order paradigms (Tutorial) , 1999 .

[64]  Farhad Arbab,et al.  MoCha: A framework for coordination using mobile channels , 2001 .

[65]  Oscar Nierstrasz,et al.  A Calculus for Modeling Software Components , 2002, FMCO.

[66]  Bart Jacobs.  Coalgebraic Specifications and Models of Determinatistic Hybrid Systems , 1996, AMAST.

[67]  Sing Li,et al.  Professional Jini , 2000 .

[68]  Jan J. M. M. Rutten,et al.  Mathematical techniques for analyzing concurrent and probabilistic systems , 2004, CRM monograph series.