POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
C: a language for high-level, efficient, and machine-independent dynamic code generation
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Software components in a data structure precompiler
ICSE '93 Proceedings of the 15th international conference on Software Engineering
Multi-stage programming with explicit annotations
PEPM '97 Proceedings of the 1997 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
The STL Tutorial and Reference Guide: C++ Programming with the Standard Template Library
The STL Tutorial and Reference Guide: C++ Programming with the Standard Template Library
Lightweight and Generative Components I: Source-Level Components
GCSE '99 Proceedings of the First International Symposium on Generative and Component-Based Software Engineering
JTS: Tools for Implementing Domain-Specific Languages
ICSR '98 Proceedings of the 5th International Conference on Software Reuse
Incorporating application semantics and control into compilation
DSL'97 Proceedings of the Conference on Domain-Specific Languages on Conference on Domain-Specific Languages (DSL), 1997
Optimizing marshalling by run-time program generation
GPCE'05 Proceedings of the 4th international conference on Generative Programming and Component Engineering
Source-level optimization of run-time program generators
GPCE'05 Proceedings of the 4th international conference on Generative Programming and Component Engineering
Hi-index | 0.00 |
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 actual code). Macro-based systems such as the C++ Standard Template Library are exceptions. They, however, have the disadvantage that components 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 compositional 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 components. 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 efficiently.