Friday, 1 October 1993
This year's workshop on object-oriented reflection and metalevel architectures generated an unprecedented level of interest, with thiry-one submissions, and in excess of fifty people in attendance. This summary presents but a flavor of the issues that were addressed at the workshop. Instructions for obtaining electronic copies of the attendance list, and the position papers themselves, appear at the end of this summary.
Moderator: Dan Friedman
Presenter: Anurag Mendhekar
Respondents: John Simmons, Constantin Laufer
Anurag Mendhekar spoke on representing reflection in the lambda calculus. His system implements an operator reifying the current continuation of an expression, represented by its lexical context. This operator corresponds to Scheme's call/cc. Another operator is provided to reinstall the abstracted context. Only the context is reified, and there is no explicit tower. A calculus for the system is developed and proved correct relative to its operational semantics.
John Simmons spoke on extending computational reflective systems by making the interpreter first-class and extensible. The interpreter is represented as two procedures, a prelim and a dispatch . The dispatch does the main work of interpretation by dispatching on the type of the expression and performing the proper computation for it. The prelim allows additional actions to be performed before or after the dispatch. This representation extends the power of traditional reflective systems. It permits the addition of new special forms, the modification (by shadowing) of basic interpreter actions on constants, variables, and applications, and the inclusion of actions preceding or following the main computation.
Constantin Laufer spoke on implementing reflection in a statically typed system. Using Haskell, he implements a system providing reflection on expressions. Expressions are represented as pairs, containing both uncompiled and (lazily) compiled versions of the expression. The compiled version can be used for computation, the uncompiled version for reification. The reify and reflect operators provide reification and reflection, with the reify operator recursively handling motion up the implicit tower.
Moderator: Dan Friedman
Presenter: Jeff McAffer
Respondents: Carel Bekker, Patrick Steyaert
Jeff McAffer presented the CodA MOP, a framework for creating, controlling, and understanding concurrent computing environments. CodA is built atop Smalltalk-80. Its essential component is a simple, clear, and consistent interface protocol specification for basic system objects, such as schedulers, objects, and meta-objects. CodA uses the operational decomposition method of defining the metalevel. CodA embodies a complete system model which is independent of any implementation environment or language. Metadefinition, rather than meta-interpretation is emphasized.
Carel Bekker presented ALBEDO, a meta-object infrastructure for Smalltalk. ALBEDO adds support for a family of Maes-style meta-objects to Smalltalk-80. These meta-objects may be associated with any existing Smalltalk object. A library of meta-objects has been implemented using ALBEDO. Because meta-objects are distinct from the objects they are attached to, reusability, extensibility, and the understandability of the system are enhanced.
Patrick Steyeart took the view that rather than viewing extensibility as a consequence of a reflective architecture, we should instead consider extensibility as an a priori condition for the definition of reflection. He presented a two stage approach for introducing reflection into a hypothetical programming language, ASEL. The first stage is to define an open implementation for this language. The second stage is to make this open implementation explicit, or first-class.
Moderator: Pierre Cointe
Presenter: Hideaki Okamura
Respondent: Ken Wakita
Hideaki Okamura presented a paper discussing how shared resources can be modified in AL-1/D. The mechanism used employs the concept of grouping. Objects in a group share the resources that belong to the group. Examples of shared resources might be schedulers or garbage collectors. The paper also addressed how user-defined and default system resources cooperate.
Ken Wakita discussed how first-class messages, or message continuations provide object-oriented concurrent programming languages with extensibility in modeling and programming communication schemes such as asynchronous communication, multicasting, sophisticated synchronization constraints, inter-object synchronization, concurrency control, resource management, and the like. Despite this extensibility, the framework guarentees that no program can undermine the built-in communication primitives.
Moderator: Pierre Cointe
Presenter: Hidehiko Masuhara
Respondent: Takashi Tomokiyo
Hidehiko Masuhara discussed the design of an object-oriented reflective language for massively parallel processors. One of the major problems in massively parallel programming is dynamic resource management, such as load balancing and scheduling. Simple management policies sometimes lead to lackluster performance under unexpected conditions, while complicated ones, which are effective under any situation, often impose considerable overhead. What is needed is an ability to provide abstractions for a variety of policies. Reflective languages provide this flexibility.
Masuhara et. al.'s language is based on ABCL/R2, which is extended so that the user can control the parallel programming primitives. In this architecture, the user can build his or her own resource management system -- load-balancing, scheduling, etc. -- at the metalevel, controlling the policies of primitives such as object creation, object migration, and scheduling.
Takashi Tomokiyo presented the metalevel architecture of a parallel object-based language called OCore. This language has simple, statically typed semantics to make compiled programs more safe and efficient. An object has a single thread, called the normal thread, for normal operations. Exceptions are handled by an exception handling thread. Communication between objects is based on asynchronous, one-way message passing.
Classes in OCore are merely templates, as in C++, and are not themselves first-class objects. The metalevel architecture of OCore handles three kinds of events: state transition events, user-defined events, and exceptions. Certain elements of an object's internal representation are visible at the metalevel via pseudo-variables.
Moderator: Jacques Malenfant
Presenter: Shigeru Chiba
Respondents: Roger Burkhart, Roger Voss
There is growing evidence that users are chafing under the limitations that relatively closed languages such as C and C++ impose upon them. For instance, the current interest in runtime type information in the C++ community, and the widespread practice of building dynamic object systems atop C and C++, support the observation that real-world problems demand first-class, dynamic access to metalevel information and mechanisms.
Shigeru Chiba described the language Open C++, which extends C++ to allow programmers to define their own method call and variable access mechanisms. He then showed how they used these Open C++ mechanisms to support distributed programming.
The second paper, by Roger Voss, illustrates the dilemma that faces the frustrated user who would like to have a hook into some part of a language's implementation to be able to solve a particular problem. Mr. Voss is confronted with the problem of class evolution in C++ class libraries. His proposal for addressing this issue requires a modification to the usual C++ v-table-based dispatching scheme. In non-reflective languages, even a simple change can entail a protracted struggle with various standards committees.
Roger Burkhart discussed request functions for C. A request function is a new kind of C function that creates a context, which is a set of data concerning the function call, that is made accessible to the program. The primary point of this "conservative" extension is to have a means, readily implementable in C, for building more comprehensive reflective facilities.
Moderator: Jacques Malenfant
Presenter: Erik Ruf
Respondent: Kenichi Asai
Erik Ruf feels that partial evaluation is far from the point where it could be used to efficiently implement reflective languages. In fact, existing partial evaluators are weak, bulky and inefficient. Moreover, there is a major flaw in the current work in partial evaluation for reflective languages. When reifying portions of the implementation information, decisions are made about the way this information will be represented. For instance, when reifying environments, it is standard practice to reify them as association lists. Currently, there is no way a partial evaluator will be able to get rid of this data structure and the resulting program (after partial evaluation) may get stuck with inefficient access to environments because the implementation decision survived the partial evaluation process.
Kenichi Asai reported on some experiments in partial evaluation using a reflective extension to Scheme that allowed reflective towers in which the interpreter at each level could be modified dynamically. Asai noted that they succeeded in applying partial evaluation, but in a static way (once and for all before the execution of the program).
During the discussion, Dan Friedman asked Mr. Ruf if he considers it impossible to build a partial evaluator that would be able to cope with the environment access problem discussed above. Friedman conjectured that with sufficient knowledge and complexity, an interpreter could deal explicitly with storage management and make it possible for the partial evaluator to generate code which would compare favorably with compiled code. Mr. Ruf conceded that he could imagine such an interpreter, but it would be quite a challenge to partial evaluate it using the current partial evaluation technology.
Moderator: Jacques Malenfant
Presenter: Barry Hayes
The final part of the session was devoted to a paper by Mr. Hayes on reflection and garbage collection. He claimed that the state of the art in garbage collectors is to provide "knobs" that allow users to feed in application level information that can be used profitably by the garbage collector. Unfortunately, these "knobs" are introduced in an ad hoc manner. Maybe reflection can help here, but it is also a challenge to open garbage collectors to users. While he noted that reflective garbage collectors could probably be implemented efficiently, the questions lie more on the side of the users. Will they be able to manipulate such a crucial part of the system profitably and correctly?
Moderator: Yasuhiko Yokote
Presenter: Mireille Fornarino
Respondents: H. Justin Coven, Ming Peng
Existing object-oriented languages provide relatively weak facilities for representing dynamic relationships among objects. Users, however, may build their own using reflection.
Mireille Fornarino described a CLOS/MOP-based meta-architectural solution to the problem of keeping track of dependencies between objects. They introduce links to define dependencies, metalinks to define the structure of links, controllers to invoke control procedures and manage interactions between instance-of-links, and generic functions to invoke the current controller. Links are created incrementally. Thanks to metalinks, users can extend and customize the behavior of links.
H. Justin Coven discussed how interconnections, the links among pieces of information, and control issues might may be addressed using reflection.
Ming Peng described an object-oriented system that illustrated how mechanisms to dynamically respesent interacting forces to address the "frame problem" might be consructed.
Moderator: Yasuhiko Yokote
Presenter: Gary Lindstrom
Respondents: John Gilbert, Francois Rousseau
Ubiquitous object support in truly open systems will require that we refactor our computing systems so that support now provided on a per-process basis is elevated to the level of permanent system service. Gary Linstrom proposed that module management be elevated to this level, and that these objects be cast themselves as first-class objects. His factoring draws on insights from the programming language as well as system architecture communities. Although many systems are (assumed to be) implemented in the context of a single programming language, their work investigates how to support multiple programming languages.
John Gilbert discussed the importance of reflective facilties in open-ended scientific, realtime, and multimedia applications. Here, he claimed, reflection is essential to facilitate computational resource management, software configuration, fault tolerance, and reuse.
Francois Rousseau illustrated how meta-information is vital to the construction of modern tools for browsing programming languages such as ClassTalk.
Reflection and meta-object programming provide an elegant and principled perspective on computation. The breadth of presentations at this workshop serve to illustrate the wide applicability to both applied and theoretical problems. These concepts, however, need to be clearly illustrated and explained to students, researchers and software engineers if this promising perspective of computation is going to have a major impact on mainstream computation. Everyone I know who has experienced computation through the exploration of even a simple metacircular interpreter has a different, deeper view of language semantics and computation.
We need to use common reference implementations such as TinyClos and Classtalk to illustrate applications and new ideas. Only if we communicate our ideas will others be able to understand the true benefits of Open Architectures. Failure to do so will leave reflection as a computational cult "going meta".
One need only look at how few schools teach Scheme, ML or Smalltalk to realize the challenge which we have if meta-programming is to be part of every software engineer's toolkit/thinking process. The well-attended and highly successful MOP tutorial earlier this week is an excellent beginning.
Just as objects are good for building programs and for aiding in their evolution, so too are they good for building programming languages and computing systems. Unfortunately, the reflection community has developed a not entirely undeserved reputation for abstruseness, even as meta-architectural ideas are increasingly being incorporated into real object-oriented languages, databases, and systems, such as IBM's SOM.
One of the more interesting discussions of the day raised the question of whether terms such as "reflection" and "metalevel" have unnecessarily confused the broader perception of our open object-oriented architectural agenda. Gregor Kiczales remarked that these are good terms, but we shouldn't lead with them. In any case, as the computing industry prepares to build its next-generation systems out of objects, it is imperative that we reach out and strive to more widely and clearly communicate our architectural vision.
Pierre Cointe E. des Mines de Nantes
Brian Foote (chair) U. of Illinois at UC
Dan Friedman Indiana University
Jacques Malenfant U. of Montreal
Dave Thomas OTI
Yasuhiko Yokote Sony CSL
Anonymous ftp to:
ftp://ftp.cpl.uiuc.edu/pub/washingon (184.108.40.206) pub/washington ftp://camille.is.s.u-tokyo.ac.jp (220.127.116.11) pub/oopsla93/reflection
or EMail to:
Join: firstname.lastname@example.org Post: email@example.com
To subscribe, send a request to firstname.lastname@example.org containing the word subscribe in the Subject: field. Don't say "please subscribe me" or "I want to subscribe" or anything else. Just use the one word "subscribe". If you want a human to read your mail, type "Re: <something>" in the subject. To unsubscribe, send a request to email@example.com containing a single word unsubscribe in the Subject: field.
[Foote 1994a] Object-Oriented Reflection and Metalevel Architectures Workshop Report, OOPSLA '93, Washington, DC Addendum to the Proceedings OOPS Messinger, Volume 5, Number 2, April 1994 Jerry L. Archibald and Mark C. Wilkes, editors