Abstract
Most software component technologies fail to account for lightweight components (those for which a function call is too inefficient or semantically inappropriate) or generative components (those in which the component embodies a method of constructing code rather than ac- tual code). Macro-based systems such as the C++ Standard Template Li- brary are exceptions. They, however, have the disadvantage that compo- nents must be delivered largely in source form. In this paper, we present a component technology in which lightweight and generative components can be delivered in binary form. The technology is conceptually simple and is easily implemented with existing programming languages. Our basic idea was explained in part I of this paper: By giving a composi- tional semantics for a source language in a domain of meanings Code, components can be written in the form of macros, but communicated in terms of meanings. In the companion paper, we showed how higher-order values over Code can be used to write lightweight, generative compo- nents. There, we took Code to be string, so our components amounted to higher-order macros. In this paper, we define Code more abstractly, allowing components to be delivered in a form that does not resemble syntax, yet allows for them to be loaded dynamically and execute effi- ciently.
Partial support for the first and third authors was received from NSF under grant CCR-9619644.
This is a preview of subscription content, log in via an institution to check access.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Preview
Unable to display preview. Download preview PDF.
References
Don Batory, Bernie Lofaso, and Yannis Smaragdakis. JTS: Tools for implementing domain-specific languages. In Fifth Intl. Conf. on Software Reuse, June 1998.
A. Bawden. Quasiquotation in lisp. In In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (PEPM-99), pages 18–42, January 22–23 1999.
William Clinger and Jonathan Rees. Macros that work. In Proc. of the Conf. on Principles of Programming Languages (POPL), pages 155–160, 1991.
Krzysztof Czarnecki and Ulrich W. Eisenecker. Synthesizing objects. In Rachid Guerraoui, editor, 13th European Conference on Object-Oriented Programming (ECOOP ’99), pages 18–42, June 1999.
Krzysztof Czarnecki and Ulrich W. Eisenecker. Static metaprogramming in C++. In Generative Programming: Methods, Techniques, and Applications, chapter 8, pages 251–279. Addison-Wesley, 2000.
Dawson Engler. Incorporating applications semantics and control into compilation. In Proceedings of the Conference on Domain-Specific Languages, Santa Barbara, California, USA, October 15–17 1997.
Dawson R. Engler, Wilson C. Hsieh, and M. Frans Kaashoek. C: A language for high-level, efficient, and machine-independent dynaic code generation. In Conference Record of POPL ’96: The 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 131–144, St. Petersburg Beach, Florida, 21–24 January 1996.
J. Hummel, A. Azevedo, D. Kolson, and A. Nicolau. Annotating the java byte codes in support of optimization. In ACM 1997 Workshop on Java for Science and Engineering Computation, June 1997.
Sun Microsystems Incorporated. The java hotspot performance engine architecture: A white paper about sun’s second generation performance technology. Technical report, April 1999.
J. Jones and S. Kamin. Annotating java class files with virtual registers for performance. Concurrency: Practice and Experience, to appear.
Sam Kamin, Miranda Callahan, and Lars Clausen. Lightweight and generative components I: Source-level components. In First International Symposium on Generative and Component-Based Software Engineering (GCSE’99), September 28–30 1999.
Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Videira Lopes, Jean-Marc Loingtier, and John Irwin. Aspect-oriented programming. In Proc. European Conference on Object-Oriented Programming (ECOOP), volume LNCS 1241. Springer-Verlag, June 1997.
David R. Musser and Atul Saini. STL Tutorial and Reference Guide: C++ Programming with the Standard Template Library. Addison-Wesley Professional Computing Series, 1996.
Charles Simonyi. The death of computer languages, the birth of intentional programming. In NATO Science Committee Conference, 1995.
Marty Sirkin, Don Batory, and Vivek Singhal. Software components in a data structure precompiler. In Intl. Conf. on Software Eng., pages 437–446, 1993.
Walid Taha and Tim Sheard.Multi-stage programming with explicit annotations. In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (PEPM-97), volume 32, 12 of ACM SIGPLAN Notices, pages 203–217, New York, June 12–13 1997. ACM Press.
Todd Veldhuizen. Using C++ template metaprograms. C++ Report, 7(4):36–43, May 1995.
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2000 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Kamin, S., Callahan, M., Clausen, L. (2000). Lightweight and Generative Components II: Binary-Level Components. In: Taha, W. (eds) Semantics, Applications, and Implementation of Program Generation. SAIG 2000. Lecture Notes in Computer Science, vol 1924. Springer, Berlin, Heidelberg. https://doi.org/10.1007/3-540-45350-4_6
Download citation
DOI: https://doi.org/10.1007/3-540-45350-4_6
Published:
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-41054-6
Online ISBN: 978-3-540-45350-5
eBook Packages: Springer Book Archive