Advertisement

Abstracting Interaction Patterns: A Programming Paradigm for Open Distributed Systems

  • Gul A. Agha
Chapter
Part of the IFIP Advances in Information and Communication Technology book series (IFIPAICT)

Abstract

This paper discusses mechanisms addressing the complexity of building and maintaining Open Distributed Systems. It is argued that a new programming paradigm based on modular specification of interaction patterns is required to address the complexity of such systems. Our research is based on developing abstraction mechanisms to simplify the task of developing and maintaining open systems. We define actors as a model of concurrency for open systems. We then review a number of programming abstractions that are useful in modular specification and implementation of open systems. Such abstractions include activators, protocols, synchronizers, and actorspaces. We observe that defining such abstractions for complex interaction patterns requires a sort of system decomposition that is not supported by standard execution models of concurrent programming, including actors and process algebras. Rather, a suitable meta-architecture is needed to allow the implementation of abstract representations of interaction patterns. Currently there is no entirely satisfactory formal theory of meta-architectures.

Keywords

Actors concurrency object-oriented programming open systems real-time systems fault-tolerance coordination reflection. 

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. Agha, G. (1986). Actors: A Model of Concurrent Computation in Distributed Systems. MIT Press, Cambridge, Mass.Google Scholar
  2. Agha, G. (1990). Concurrent Object-Oriented Programming Communications of the ACM, 33 (9): 125–141.CrossRefGoogle Scholar
  3. Agha, G., Mason, I. A., Smith, S. F., and Talcott, C. L. (1996). A foundation for actor computation. Journal of Functional Programming. to appear.Google Scholar
  4. Agha, G. A. (1996). Modeling concurrent systems: Actors, nets, and the problem of abstraction and composition. In Billington, J. and Reisig, W., editors, Applications and Theory of Petri Nets 1996, LNCS 1091, pages 1–10, Osaka, Japan. Springer-Verlag.CrossRefGoogle Scholar
  5. Aksit, M., Wakita, K., Bosch, J., Bergmans, L., and Yonezawa, A. (1993). Abstracting object interactions using composition filters. In Guerraoui, R., Nierstrasz, O., and Riveill, M., editors, Object-Based Distributed Programming, volume 791 of Lecture Notes in Computer Science, pages 152–184. ECOOP, Springer-Verlag.Google Scholar
  6. Callsen, C. J. and Agha, G. A. (1994). Open Heterogeneous Computing in ActorSpace. Journal of Parallel and Distributed Computing, pages 289–300.Google Scholar
  7. Frolund, S. (1992). Inheritance of synchronization constraints in concurrent object-oriented programming languages. In Madsen, O. L., editor, Proceedings ECOOP 82, LNCS 615, pages 185–196, Utrecht, The Netherlands. Springer-Verlag.Google Scholar
  8. Frolund, S. (1996). Coordinating Distributed Objects: An Actor-Based Approach to Synchronization. MIT Press.Google Scholar
  9. Frolund, S. and Agha, G. (1993). A language framework for multi-object coordination. In Proceedings of ECOOP 1993 volume 707 of Lecture Notes in Computer Science. Springer Verlag.Google Scholar
  10. Frolund, S. and Agha, G. (1996). Abstracting interactions based on message sets. In Object-Based Models and Languages for Concurrent Systems, volume 924, pages 107–124. Springer-Verlag. Lecture Notes in Computer Science.Google Scholar
  11. Kim, W. and Agha, G. (1995). Efficient Support of Location Transparency in Concurrent Object-Oriented Programming Languages. In Supercomputing 85. IEEE.Google Scholar
  12. Nielsen, B. and Agha, G. (1996). Semantics for an actor-based real-time language. In Fourth International Workshop on Parallel and Distributed Real-Time Systems Honolulu. (to be published).Google Scholar
  13. Plotkin, G. (1975). Call-by-name, call-by-value and the lambda calculus. Theoretical Computer Science, 1: 125–159.CrossRefMathSciNetzbMATHGoogle Scholar
  14. Ren, S., Agha, G., and Saito, M. (1996). A modular approach for programming distributed real-time systems. Journal of Parallel and Distributed Computing. (to appear).Google Scholar
  15. Sami, Y. and Vidal-Naquet (1991). Formalization of the behavior of actors by colored petri nets and some applications. In Conference on Parallel Architectures and Languages Europe, PARLE’91.Google Scholar
  16. Sturman, D. and Agha, G. (1994). A protocol description language for customizing failure semantics. In The 13th Symposium on Reliable Distributed Systems, Dana Point, California. IEEE.Google Scholar
  17. Sturman, D. C. (1996). Modular Specification of Interaction Policies in Distributed Computing. PhD thesis, University of Illinois at Urbana-Champaign.Google Scholar
  18. Venkatasubramanian, N. and Talcott, C. L. (1995). Reasoning about Meta Level Activities in Open Distributed Systems. In Principles of Distributed Computing.Google Scholar

Copyright information

© IFIP International Federation for Information Processing 1997

Authors and Affiliations

  • Gul A. Agha
    • 1
  1. 1.Open Systems Laboratory Department of Computer ScienceUniversity of Illinois at Urbana-ChampaignUrbanaUSA

Personalised recommendations