This paper presents a metaobject protocol (MOP) for C++. This MOP was designed to bring the power of meta-programming to C++ programmers. It avoids penalties on runtime performance by adopting a new meta-architecture in which the metaobjects control the compilation of programs instead of being active during program execution. This allows the MOP to be used to implement libraries of efficient, transparent language extensions.

This paper presents a methodology for designing extensible languages for distributed computing.

Meta-levels are complex pieces of software with diverse demands in both the computation and interaction domains. Common techniques using just code to express behaviour fail to clearly assign responsibility for a particular behaviour's definition or to provide support for the reuse or integration of existing behaviour descriptions. The techniques of ne-grained decomposition of meta-level behaviour into objects and their subsequent composition into object models provides a framework for creating, reusing and integrating complex object behaviours. Using such a framework, we show that users can develop and integrate quite different object models while retaining a high degree of abstraction and fostering meta-level component reuse.

Parameter passing is one of the main problems in distributed object-oriented applications. The two simplest solutions - passing objects by global reference and passing complete copies of the object graphs - both have significant drawbacks. Instead, an intermediate amount of copying is often best. The problem is twofold: (i) compilers and operating systems can't automatically make the best decision on how much to copy; (ii) there hasn't been a good mechanism for the programmer to express the intermediate amount of copying that should be done. The contribution of this paper is to present a new mechanism that allows programmers to express in a natural and succinct way how much of the object graph should be copied to the remote context. The specifications are done using a very simple declarative meta-language -- GOOP -- that has graphs of classes as domain. Keywords: distribution, remote invocation, pass-by-copy, open implementation, adaptiveness. Supported by the Portuguese Fo...

Parallel and distributed programs often have hardware/problem specific optimizations for improving quality of the program such as efficiency and robustness. Those optimizations, unfortunately, degrade portability and re-usability as they are intertwined with the original algorithm description. Reflective languages, which provide the application programmer extensible and abstract implementation of the language, can describe such optimizations as extensions to the language. The separation of optimization descriptions gains portability and re-usability of both application programs and optimizations. However, the interpretive execution model of reflective languages imposes a large amount of performance overhead, which sometimes outweighs benefits of optimizations. Previous reflective languages prohibit some of operations being modified via reflection, so as to reduce the amount of interpretation overhead. The imperfection of this approach is that it still leaves a considerable amount of overhead, and it yields less flexible, unclear reflective architecture. This dissertation investigates design and compilation framework of meta-interpreters and meta-objects in an object-oriented concurrent language ABCL/R3. By using partial evaluation to compile reflective programs, ABCL/R3 achieves flexible and lucid reflective architecture and efficient execution at the same time. We design full-fledged meta-interpreters by examining several concurrent programming examples. A newly proposed delegation mechanism enables to define modular and scope controlled extensions to meta-interpreters. We design meta-objects by exploiting the notion of reader/writer methods in a concurrent object-oriented language Schematic, so that they can be effectively partially evaluated. The compilation frameworks of meta-interpreters and meta-objects basically translate concurrent object definitions into a sequential program, then apply partial evaluator for a sequential language, and generates a program in a (non-reflective) concurrent object-oriented language, in which base-level and meta-level objects are collapsed to single level objects. The efficiency of generated programs is demonstrated by several benchmark programs, in which our compiler exhibits performance close to non-reflective languages.

We view cooperating systems as being a set of systems that are distributed over a common communication network and that work towards solving a common task. This is achieved by coordinating and exchanging information and expertise. Such systems exclude conventional database systems since the knowledge these systems contain is buried within application code. In this paper, we overcome this problem by introducing a layer of special reflective, i.e. metalevel, objects which surround each local database system. These objects are used to capture domain and operational knowledge, and to describe, at least in part, remote systems and to monitor task-oriented activities. In this way,we can turn interconnected conventional database systems into a set of cooperating knowledge-based systems.

This paper describes a number of approaches to the development of more intelligent and more adaptable software. The paper introduces the notion of reflection and surveys two major styles: task and programming reflection. The paper then introduces a new form, viz operational reflection, based on the integration of these styles. This form of reflection is applied to cooperative environments and enables local database systems to be surrounded by a layer of metalevel software. This is used to capture domain and operational knowledge, and to describe, at least in part, remote systems and to monitor task-oriented activities. Thus we can turn a set of discrete database systems into a cooperative environment. Keywords: cooperation,reflection,metaobjects 1. Introduction 1.1. Intelligence in Information Systems How often, when using an information system, do we ask ourselves: "I wonder why it did that?" or "How on earth did that happen?". Unfortunately, the questions are rhetorical. We do not...

The paper presents a new reflective model, called Channel Reification, which can be used to implement communication abstractions. After a brief review of existing reflective models and how reflections can be used in distributed systems, channel reification is presented and compared to the widely used meta-object model. An application to protocol implementation, and hints on other channel applications are also given.