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.
Chapter PDF
Similar content being viewed by others
References
Arnold, K. and Gosling, J. (1996). The Java Programming Language; Addison-Wesley.
Card, D. and Corner, E. (1994) Why Do So Many Reuse Programs Fail? IEEE Software, 11, 5, 114–115.
Chan, P. and Lee, R. (1997). The Java Class Libraries: An Annotated Reference; Addison-Wesley.
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.
Franz, M. (1997a). The Programming Language Lagoona: A Fresh Look at Object-Orientation. Software — Concepts and Tools, 18:1, 14–26.
Franz, M. (1997b). Dynamic Linking of Software Components IEEE Computer, 30:3, 74–81.
Goldberg, A. (1984) Smalltalk-80: The Interactive Programming Environment; Addison-Wesley.
Goldberg, A. and Robson, D. (1983). Smalltalk-80: The Language and its Implementation; Addison-Wesley.
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.
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.
Lindholm, T., Yellin, F., Joy, B., and Walrath, K. (1996) The Java Virtual Machine Specification; Addison-Wesley.
McIlroy, M.D. (1976) Mass Produced Software Components, in Software Engineering, Concepts and Techniques, Proceedings of the NATO Conferences, New York, 88–98.
Meyer, B. (1988) Object-Oriented Software Construction; Prentice-Hall.
Muys-Vasovic, J.-D. (1989) MacApp: An Object-Oriented Framework Application, in Tutorial Notes, Technology of Object-Oriented Languages and Systems (TOOLS) ’89.
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.
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.
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.
Wirth, N. (1988). The Programming Language Oberon. Software-Practice and Experience, 18: 7, 671–690.
Wirth, N. (1988). Type Extensions. ACM Transactions on Programming Languages and Systems, 10: 2, 204–214.
Wirth, N. and Gutknecht, J. (1992). Project Oberon: The Design of an Operating System and Compiler; Addison-Wesley.
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 1998 IFIP
About this chapter
Cite this chapter
Franz, M. (1998). On the architecture of software component systems. In: Horspool, R.N. (eds) Systems Implementation 2000. IFIP Advances in Information and Communication Technology. Springer, Boston, MA. https://doi.org/10.1007/978-0-387-35350-0_16
Download citation
DOI: https://doi.org/10.1007/978-0-387-35350-0_16
Publisher Name: Springer, Boston, MA
Print ISBN: 978-1-5041-2873-5
Online ISBN: 978-0-387-35350-0
eBook Packages: Springer Book Archive