Advertisement

On the architecture of software component systems

  • M. Franz
Chapter
Part of the IFIP Advances in Information and Communication Technology book series (IFIPAICT)

Abstract

Current object-oriented development practice is centered around application frameworks. We argue that this approach is misleading, as it detracts from the ultimate goal of composing software out of “software components” originating from different sources. In particular, we suggest a model of software composition that is based on passing of “first-class messages” rather than on inheritance.

In most object-oriented programming languages, messages and the methods that get executed in response to receiving them are only “second class citizens”. In these languages, one can send a message to an object, but one cannot further manipulate the message itself as a data object. As a consequence, many of the operations that a naive observer might expect to be available are in fact not usually offered. Examples of such missing operations are the ability to store arriving messages in a data structure and execute them asynchronously later, perhaps in a different order, or the capability of forwarding a received message to another object without first having to decode it.

We are working on a system based on an experimental language that supports “first-class messages” efficiently. We argue that this additional language capability by itself suffices to simplify the design of extensible, component-oriented systems, and that it leads to a more uniform overall system architecture.

Keywords

Software components frameworks applets reusability first-class messages 

References

  1. Arnold, K. and Gosling, J. (1996). The Java Programming Language; Addison-Wesley.zbMATHGoogle Scholar
  2. Card, D. and Corner, E. (1994) Why Do So Many Reuse Programs Fail? IEEE Software, 11, 5, 114–115.CrossRefGoogle Scholar
  3. Chan, P. and Lee, R. (1997). The Java Class Libraries: An Annotated Reference; Addison-Wesley.Google Scholar
  4. Evered, M., Keedy, J.L., Schmolitzky, A., and Menger, G. (1997). How Well Do Inheritance Mechanisms Support Inheritance Concepts?, in Hanspeter Mössenböck (Ed.), Modular Programming Languages, Proceedings of the Joint Modular Languages Conference, JMLC’97, Springer Lecture Notes in Computer Science No. 1204, 252–266.CrossRefGoogle Scholar
  5. Franz, M. (1997a). The Programming Language Lagoona: A Fresh Look at Object-Orientation. Software — Concepts and Tools, 18:1, 14–26.Google Scholar
  6. Franz, M. (1997b). Dynamic Linking of Software Components IEEE Computer, 30:3, 74–81.CrossRefGoogle Scholar
  7. Goldberg, A. (1984) Smalltalk-80: The Interactive Programming Environment; Addison-Wesley.zbMATHGoogle Scholar
  8. Goldberg, A. and Robson, D. (1983). Smalltalk-80: The Language and its Implementation; Addison-Wesley.zbMATHGoogle Scholar
  9. Krall, A. and Vitek, J. (1997) On Extending Java, in Hanspeter Mössenböck (Ed.), Modular Programming Languages, Proceedings of the Joint Modular Languages Conference, JMLC’97, Springer Lecture Notes in Computer Science No. 1204, 321–335.CrossRefGoogle Scholar
  10. Krasner, G.E. and Pope, S.T. (1988) A Cookbook for using the Model-ViewController User Interface Paradigm in Smalltalk-89. Journal of Object-Oriented Programming, 1:3, 26–49.Google Scholar
  11. Lindholm, T., Yellin, F., Joy, B., and Walrath, K. (1996) The Java Virtual Machine Specification; Addison-Wesley.Google Scholar
  12. McIlroy, M.D. (1976) Mass Produced Software Components, in Software Engineering, Concepts and Techniques, Proceedings of the NATO Conferences, New York, 88–98.Google Scholar
  13. Meyer, B. (1988) Object-Oriented Software Construction; Prentice-Hall.Google Scholar
  14. Muys-Vasovic, J.-D. (1989) MacApp: An Object-Oriented Framework Application, in Tutorial Notes, Technology of Object-Oriented Languages and Systems (TOOLS) ’89.Google Scholar
  15. Odersky, M. and Wadler, P. (1997) Pizza into Java: Translating theory into practice, in Proceedings of POPL’97: The 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, ACM Press, 146–159.Google Scholar
  16. Raj, R.K., Tempero, E., Levy, H.M., Black, A.P., Hutchinson, N.C., and Jul, E. (1991) Emerald: A General-Purpose Programming Language. Software-Practice and Experience, 21:1, 91–118.CrossRefGoogle Scholar
  17. Wegner, P. and Zdonik, S.B. (1988). Inheritance as an Incremental Modification Mechanism, or, What Like Is and Isn’t Like, in ECOOP’88 Proceedings, Springer Lecture Notes in Computer Science, No. 322, 55–77.Google Scholar
  18. Wirth, N. (1988). The Programming Language Oberon. Software-Practice and Experience, 18: 7, 671–690.CrossRefzbMATHGoogle Scholar
  19. Wirth, N. (1988). Type Extensions. ACM Transactions on Programming Languages and Systems, 10: 2, 204–214.CrossRefzbMATHGoogle Scholar
  20. Wirth, N. and Gutknecht, J. (1992). Project Oberon: The Design of an Operating System and Compiler; Addison-Wesley.Google Scholar

Copyright information

© IFIP 1998

Authors and Affiliations

  • M. Franz
    • 1
  1. 1.Department of Information and Computer ScienceUniversity of CaliforniaIrvineUSA

Personalised recommendations