GLoo: A Framework for Modeling and Reasoning About Component-Oriented Language Abstractions

  • Markus Lumpe
Part of the Lecture Notes in Computer Science book series (LNCS, volume 4063)


The most important contribution to the success or failure of a software project comes from the choice of the programming languages being used and their support in the target environment. The choice of a suitable implementation language is not a guarantor for success, but an unsuitable language may result in a long, error-prone, and costly implementation, often resulting in an unstable product. In this paper, we present GLoo, a framework for modeling and reasoning about open-ended language mechanisms for object- and component-oriented software development. At the heart of GLoo is a small dynamic composition language that provides abstractions to (i) define and/or import reusable software components, (ii) introduce new compositional language abstractions, and (iii) build executable and reusable component-oriented specifications. To demonstrate its flexibility and extensibility, we then present an encoding of the traits concept as an example of how to add support for a new and readily available language abstraction to the GLoo framework.


Form Context Dynamic Binding Trait Composition Multiple Inheritance Semantic Extension 
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.


Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.


  1. 1.
    Abadi, M., Cardelli, L., Curien, P.-L., Lèvy, J.-J.: Explicit Substitutions. In: Proceedings of the 17th Annual ACM Symposium on Principles of Programming Languages (FSE 1990), San Francisco, California, pp. 31–46. ACM, New York (1990)Google Scholar
  2. 2.
    Achermann, F.: Forms, Agents and Channels: Defining Composition Abstraction with Style. PhD thesis, University of Bern, Institute of Computer Science and Applied Mathematics (January 2002)Google Scholar
  3. 3.
    Achermann, F., Nierstrasz, O.: Explicit Namespaces. In: Weck, W., Gutknecht, J. (eds.) JMLC 2000. LNCS, vol. 1897, pp. 77–89. Springer, Heidelberg (2000)CrossRefGoogle Scholar
  4. 4.
    Aßmann, U.: Invasive Software Composition. Springer, Heidelberg (2003)MATHGoogle Scholar
  5. 5.
    Dami, L.: A Lambda-Calculus for Dynamic Binding. Theoretical Computer Science 192, 201–231 (1998)MATHCrossRefMathSciNetGoogle Scholar
  6. 6.
    DeRemer, F., Kron, H.H.: Programming in the Large versus Programming in the Small. IEEE Transactions on Software Engineering SE–2(2), 80–86 (1976)CrossRefMathSciNetGoogle Scholar
  7. 7.
    Dybvig, K.: The Scheme Programming Language, 3rd edn. MIT Press, Cambridge (2003)Google Scholar
  8. 8.
    Fisher, K., Reppy, J.: Statically typed traits. Technical Report TR-2003-13, University of Chicago (December 2003)Google Scholar
  9. 9.
  10. 10.
    Goldberg, A., Robson, D.: Smalltalk-80: The Language. Addison-Wesley, Reading (1989)MATHGoogle Scholar
  11. 11.
    Koster, C.H.A., Stahl, H.-M.: Implementing Portable and Efficient Software in an Open-Ended Language. Informatics Department, Nijmegen University, Nijmegen, The Netherlands (1990)Google Scholar
  12. 12.
    Lehman, M.M., Perry, D.E., Ramil, J.C.F., Turski, W.M., Wernik, P.: Metrics and Laws of Software Evolution – The Nineties View. In: Proceedings of Fourth International Symposium on Software Metrics, Metrics 1997, Albuquerque, New Mexico, pp. 20–32 (November 1997), also as In: Eman, K.E., Madhavji, N.M. (eds.), Elements of Software Process Assessment and Improvement, ch.17. IEEE CS Press, Los Alamitos (1999) Google Scholar
  13. 13.
    Lumpe, M.: A π-Calculus Based Approach to Software Composition. PhD thesis, University of Bern, Institute of Computer Science and Applied Mathematics (January 1999)Google Scholar
  14. 14.
    Lumpe, M.: A Lambda Calculus With Forms. In: Gschwind, T., Aßmann, U., Nierstrasz, O. (eds.) SC 2005. LNCS, vol. 3628, pp. 83–98. Springer, Heidelberg (2005)CrossRefGoogle Scholar
  15. 15.
    Lumpe, M., Schneider, J.-G.: A Form-based Metamodel for Software Composition. Science of Computer Programming 56, 59–78 (2005)MATHCrossRefMathSciNetGoogle Scholar
  16. 16.
    Lutz, M.: Programming Python. O’Reilly & Associates, Sebastopol (1996)MATHGoogle Scholar
  17. 17.
    Nierstrasz, O., Achermann, F.: A Calculus for Modeling Software Components. In: de Boer, F.S., Bonsangue, M.M., Graf, S., de Roever, W. P. (eds.) FMCO 2002. LNCS, vol. 2852, pp. 339–360. Springer, Heidelberg (2003)CrossRefGoogle Scholar
  18. 18.
    Nierstrasz, O., Dami, L.: Component-Oriented Software Technology. In: Nierstrasz, O., Tsichritzis, D. (eds.) Object-Oriented Software Composition, pp. 3–28. Prentice Hall, Englewood Cliffs (1995)Google Scholar
  19. 19.
    Nierstrasz, O., Meijler, T.D.: Requirements for a Composition Language. In: Ciancarini, P., Nierstrasz, O., Yonezawa, A. (eds.) ECOOP-WS 1994. LNCS, vol. 924, pp. 147–161. Springer, Heidelberg (1995)Google Scholar
  20. 20.
    Nierstrasz, O., Schneider, J.-G., Lumpe, M.: Formalizing Composable Software Systems – A Research Agenda. In: Proceedings the 1st IFIP Workshop on Formal Methods for Open Object-based Distributed Systems, pp. 271–282. Chapmann & Hall, Sydney (1996)Google Scholar
  21. 21.
    Ousterhout, J.K.: Scripting: Higher Level Programming for the 21st Century. IEEE Computer 31(3), 23–30 (1998)Google Scholar
  22. 22.
    Sametinger, J.: Software Engineering with Reusable Components. Springer, Heidelberg (1997)MATHGoogle Scholar
  23. 23.
    Schärli, N., Ducasse, S., Nierstrasz, O., Black, A.: Traits: Composable Units of Behavior. In: Cardelli, L. (ed.) ECOOP 2003. LNCS, vol. 2743, pp. 248–274. Springer, Heidelberg (2003)CrossRefGoogle Scholar
  24. 24.
    Schneider, J.-G.: Components, Scripts, and Glue: A conceptual framework for software composition. PhD thesis, University of Bern, Institute of Computer Science and Applied Mathematics (October 1999)Google Scholar
  25. 25.
    Steele, G.L.: Common Lisp the Language, 2nd edn. Digital Press, Thinking Machines, Inc. (1990)Google Scholar
  26. 26.
    Szyperski, C.: Component Software: Beyond Object-Oriented Programming, 2nd edn. Addison-Wesley / ACM Press (2002)Google Scholar
  27. 27.
    Thomas, D.: Programming Ruby – The Pragmatic Programmers Guide. In: The Pragmatic Bookshelf, LLC, 2nd edn. (2005)Google Scholar
  28. 28.
    Ungar, D., Smith, R.B.: SELF: The Power of Simplicity. In: Proceedings OOPSLA 1987. ACM SIGPLAN Notices, vol. 22, pp. 227–242 (December 1987)Google Scholar
  29. 29.
    Wall, L., Christiansen, T., Orwant, J.: Programming Perl, 3rd edn. O’Reilly & Associates, Sebastopol (2000)MATHGoogle Scholar
  30. 30.
    Wegner, P.: OOPSLA 1987 Panel P2: Varieties of Inheritance. SIGPLAN Not. 23(5), 35–40 (1988)CrossRefGoogle Scholar
  31. 31.
    Welch, B.B.: Practical Programming in Tcl and Tk, 2nd edn. Prentice Hall PTR, Englewood Cliffs (1997)Google Scholar

Copyright information

© Springer-Verlag Berlin Heidelberg 2006

Authors and Affiliations

  • Markus Lumpe
    • 1
  1. 1.Department of Computer ScienceIowa State UniversityAmesUSA

Personalised recommendations