Metaobject Protocol Research Articles

Computational Theology

This paper analyses an amazingly close analogy between models of generalised trinitarin logics on the one hand side and class hierarchies in the field of object-oriented programming on the other, thus linking philosophy of religion and computer science. In order to bring out this analogy as clear and precise as possible, we utilise a metaobject protocol for the actual implementation of the theological models. These formal implementations lead to the insight that the analogy can be pushed even further, and we lay bare and analyse the close relation between the theological notion of subordination of divine persons and precedence in structures of multiple inheritance. The implementation of theoretical godheads finally leads to new metaobject programming techniques, thus underlining the cross-fertilisation between theology and computer science.

Transparent replication using metaprogramming in Cyan

• We describe the Cyan language and its metaobject protocol. • We show how to use the metaprogramming infrastructure of the Cyan language to create replicated applications. • We demonstrate the use of the proposed metaobjects in a relatively complex example. Replication can be used to increase the availability of a service by creating many operational copies of its data called replicas. Active replication is a form of replication that has strong consistency semantics, which are easier to reason about and program. However, creating replicated services using active replication still demands from the programmer the knowledge of subtleties of the replication mechanism. In this paper we show how to use the metaprogramming infrastructure of the Cyan language to shield the application programmer from these details, allowing easier creation of fault-tolerant replicated applications through simple annotations.

A new modular implementation for stateful traits

Abstract The term traits is overloaded in the literature. In this work we refer to traits as the stateless model and implementation described in Schaerli et al. articles. Traits provide a flexible way to support multiple inheritance code reuse in the context of a single inheritance language. The Pharo programming language includes the second implementation of stateless traits based on the original version of Schaerli's one. Even if it is the second iteration of such an implementation, it presents several limitations. First, it does not support state in traits. Second, its implementation is monolithic i.e., it is deeply coupled with the rest of the language kernel: it cannot be loaded nor unloaded. Furthermore, trait support impacts all classes, even classes not using traits. In addition, while the development tools include full support to work with classes, trait support is more limited because classes and traits do not present the same Metaobject Protocol (MOP). Finally, being monolithic and integrated in the language kernel, it is difficult to extend this current implementation. This article describes a new modular and extensible implementation of traits: it is easily loadable and unloadable as any other package. In addition, classes not using traits are not impacted. Finally, this new implementation includes a new and carefully designed Metaobject Protocol (MOP) that is compatible with both classes and traits. This allows one to reuse existing tools as they do not require special support for traits. Then, following the semantics proposed for stateful traits in [6] , we present a new implementation of stateful traits. This implementation is an extension of our new modular implementation. We implemented modular traits using specialized metaclasses as our main language extension mechanism. By replacing the implementation we reduced the Pharo Language Kernel size by 15%. This model and implementation are used in production since Pharo7.0 (January 2019).

Open Programming Language Interpreters

Context: This paper presents the concept of open programming language interpreters and the implementation of a framework-level metaobject protocol (MOP) to support them. Inquiry: We address the problem of dynamic interpreter adaptation to tailor the interpreter's behavior on the task to be solved and to introduce new features to fulfill unforeseen requirements. Many languages provide a MOP that to some degree supports reflection. However, MOPs are typically language-specific, their reflective functionality is often restricted, and the adaptation and application logic are often mixed which hardens the understanding and maintenance of the source code. Our system overcomes these limitations. Approach: We designed and implemented a system to support open programming language interpreters. The prototype implementation is integrated in the Neverlang framework. The system exposes the structure, behavior and the runtime state of any Neverlang-based interpreter with the ability to modify it. Knowledge: Our system provides a complete control over interpreter's structure, behavior and its runtime state. The approach is applicable to every Neverlang-based interpreter. Adaptation code can potentially be reused across different language implementations. Grounding: Having a prototype implementation we focused on feasibility evaluation. The paper shows that our approach well addresses problems commonly found in the research literature. We have a demonstrative video and examples that illustrate our approach on dynamic software adaptation, aspect-oriented programming, debugging and context-aware interpreters. Importance: To our knowledge, our paper presents the first reflective approach targeting a general framework for language development. Our system provides full reflective support for free to any Neverlang-based interpreter. We are not aware of any prior application of open implementations to programming language interpreters in the sense defined in this paper. Rather than substituting other approaches, we believe our system can be used as a complementary technique in situations where other approaches present serious limitations.

A Formal Aspect-Oriented Method for Modeling and Analyzing Adaptive Resource Scheduling in Cloud Computing

Cloud computing has attracted much interest recently from both industry and academia. However, the scale and highly dynamic nature of cloud application imposes significant new challenges to resource management, and efficient resource scheduling schemes are highly demanded. In this paper, we propose a systematic method to address the reliability, running time, and failure processing of resource scheduling in cloud computing. A reflection mechanism is used to abstract the resource scheduling process as a metaobject. Petri nets are used to construct the base layer model, meta layer model, metaobject protocol, and other components, thus forming the resource scheduling model. The adaptive resource scheduling strategy is converted into CTL formulas, and the properties are analyzed. Meanwhile, an enforcement algorithm is proposed, which can guarantee the correct behavior of cloud computing while meeting the required reliability within deadline constraints. The operational semantics and related theories of Petri nets help prove its effectiveness and correctness. We have also performed a series of simulations to evaluate our approach. Results show that it can help reveal the structural and behavioral characteristics of cloud computing and improve the efficiency of resource management.

Petri nets-based method to model and analyse the self-healing web service composition

Service composition is an important means for integrating the individual web services to create new value added systems that can satisfy complex requirements. Such applications are subject to unexpected failure owing to the distributive and heterogeneous environment of web service. In this paper, we propose a Petri nets-based method to model and analyse the self-healing service composition. Aspect oriented programming is used to extract composition processes and self-healing strategy as the core and crosscutting concerns. A self-healing strategy of component and service composition is proposed, and the related operations of self-healing are abstracted as meta-objects by using reflection mechanism. Petri nets are used to construct the base layer model, meta layer model, meta-object protocol and other components, thus forming the self-healing model. The operational semantics and related theories of Petri nets help prove its effectiveness and correctness. A simulation example shows that our approach correctly describes the self-healing process of service composition, and contributes to improving the quality.

SPOT: A DSL for Extending Fortran Programs with Metaprogramming

Metaprogramming has shown much promise for improving the quality of software by offering programming language techniques to address issues of modularity, reusability, maintainability, and extensibility. Thus far, the power of metaprogramming has not been explored deeply in the area of high performance computing (HPC). There is a vast body of legacy code written in Fortran running throughout the HPC community. In order to facilitate software maintenance and evolution in HPC systems, we introduce a DSL that can be used to perform source-to-source translation of Fortran programs by providing a higher level of abstraction for specifying program transformations. The underlying transformations are actually carried out through a metaobject protocol (MOP) and a code generator is responsible for translating a SPOT program to the corresponding MOP code. The design focus of the framework is to automate program transformations through techniques of code generation, so that developers only need to specify desired transformations while being oblivious to the details about how the transformations are performed. The paper provides a general motivation for the approach and explains its design and implementation. In addition, this paper presents case studies that illustrate the potential of our approach to improve code modularity, maintainability, and productivity.

Interactive evolutionary modelling and simulation of discrete-event systems using prototypical objects

In this paper, we describe an alternative approach to the traditional class-based approach of building simulation models using object-oriented languages. We use the Discrete EVent Systems specification (DEVS) formalism implemented by prototypical objects. The main reason why we use prototype-based object orientation for simulation modelling is the fact that it offers the level of flexibility that we need for interactive evolutionary modelling and simulation, which is used for simulation-based development of systems without exact specifications. We introduce a reflective framework model that constructs, inspects and edits the models specified using DEVS. The meta-object protocol of this framework allows the models to be constructed from scratch and inspected and edited during run-time. Interactive evolutionary modelling and simulation is supported by a visual tool set which has been highly influenced by the user interface of Self, an object-oriented language based on prototypical objects.

Sub-Method Reflection.

Reflection has proved to be a powerful feature to support the design of development environments and to extend languages. However, the granularity of structural reflection stops at the method level. This is a problem since without sub-method reflection developers have to duplicate efforts, for example to introduce transparently pluggable type-checkers or fine-grained profilers. In this paper we present Persephone, an efficient implementation of a sub-method meta-object protocol (MOP) based on AST annotations and dual methods (a compiled method and its meta-object) that reconcile AST expressiveness with bytecode execution. We validate the MOP by presenting TreeNurse, a method instrumentation framework and TypePlug, an optional, pluggable type system which is based on Persephone.

A Lua-based AOP Infrastructure

In this paper we describe an aspect-oriented infrastructure to handle dynamic AOP based on the Lua language. This infrastructure is composed of AspectLua, a Lua extension that allows the declaration of aspects, and a meta-object protocol, LuaMOP, that unifies the introspective and reflective mechanisms provided by Lua. Aspects are defined in isolation using AspectLua and then they are weaved through LuaMOP. An important feature of AspectLua is to allow the association of aspects with undeclared elements of the application code (anticipated join points). Furthermore, it combines a range of features to make AOP easier and powerful.

A Lua-based AOP infrastructure

AbstractIn this paper we describe an aspect-oriented infrastructure to handle dynamic AOP based on the Lua language. This infrastructure is composed of AspectLua, a Lua extension that allows the declaration of aspects, and a meta-object protocol, LuaMOP, that unifies the introspective and reflective mechanisms provided by Lua. Aspects are defined in isolation using AspectLua and then they are weaved through LuaMOP. An important feature of AspectLua is to allow the association of aspects with undeclared elements of the application code (anticipated join points). Furthermore, it combines a range of features to make AOP easier and powerful.

A MOP based constructive reflective state metamodel

Construction, management and extension of state space is crucial for many applications, Combining with frequent change of requirement of state space, these applications are rather complicated. Synthesizing techniques of refection architecture, MOP mechanism and metamodel, this paper advances a MOP(Meta Object Protocol) based constructive state metamodel, which defines construct and rules for building models with extensible structure for state space. Based on this metamodel, modeling with extension of state space that adopts decorator pattern and role object pattern is discussed. An implementation of modeling based on this metamodel is presented. With appropriate extension, models based on this metamodel can dynamically adapt state space change.

XVF

Object serialization and object inspector user interfaces are concerns that can be orthogonally implemented using introspection via meta-object protocols (MOP). The C++ language lacks a formal meta-object protocol, although some are available as source pre-processors. A full MOP is not necessary for many classes of problems where basic introspection is useful. This paper describes a technique: extensible visitation of objects as a basic introspection primitive.

Reflective fault-tolerant systems: from experience to challenges

This paper presents research work performed on the development and the verification of dependable reflective systems based on MetaObject Protocols (MOPS). We describe our experience, we draw the lessons learned from both a design and a validation viewpoint, and we discuss some possible future trends on this topic. The main originality of this work relies on the combination of both design and validation issues for the development of reflective systems, which has led to the definition of a reflective framework for the next generation of fault-tolerant systems. This framework includes: 1) the specification of a MetaObject Protocol suited to the implementation of fault-tolerant systems and 2) the definition of a general test strategy to guide its verification. The proposed approach is generic and solves many issues related to the use and evolution of system platforms with dependability requirements. Two different instances of the specified MOP have been implemented in order to study the impact of the MOP architecture in the development of a reflective fault-tolerant system. As far as the test strategy is concerned, a different testing level is associated with each reflective mechanism defined in the MOP. For each testing level, we characterize the test objectives and the required test environments. According to this experience, several new research challenges are finally identified.

Aspect-oriented programming using reflection and metaobject protocols

Some of the original inspiration for Aspect-Oriented Programming (AOP) [KLM97] draws from the research in dynamic, reflective object-oriented languages and metaobject protocols (MOPs) [KdB91]. A MOP lets the programmer delve “under the covers” and programmatically affect basic language mechanisms such as dynamic method dispatch and class instantiation. These powerful facilities enable the sort of crosscutting metaprogramming that AOP strives to deliver. We believe that there are two reasons why research on providing aspect-oriented programming features to the programmer has strayed from its metaobject protocol roots:

Reflective State pattern with dynamic constructiveness

After discussing the reflective method of structure and behavior in the State design pattern based on Role Object pattern and the Reflective pattern of software architecture, this paper proposes a reflective state pattern with dynamic constructiveness. This paper explains the meta level and the base level, which are two levels of this pattern, and specifies the relation of two levels by using Meta Object Protocol (MOP). Then it discusses mechanism of interception and reification for reflecting base, object from Meta object. Finally this paper gives an example of network server for applying the Reflective State pattern.

Heterogeneous and Multifaceted Multimedia Objects in DOOR/MM: A Role-Based Approach with Views

Although the distributed multimedia information system is getting popular nowadays, existing database systems do not offer adequate support to structural nor behavioral extension of multimedia objects. Moreover, the multifaceted nature of multimedia data has seldom been investigated. Besides the flexibility for multimedia authoring tools, dynamic extension and multifacet modeling can in general ease the task on integrating the multimedia information of heterogeneous formats over a distributed network. This paper presents the support of dynamic extension and multifacet modeling of multimedia objects in a client-server, object-role database system called DOOR. The resultant system, with multimedia functionalities, is named as DOOR/MM (DOOR with multimedia extensions). First, the underlying data model for DOOR is summarized. We then present the extension of the data model, by means of meta-object protocol (MOP), to implement the metaclasses for multimedia objects. In DOOR, objects are structured as a tree of roles. Each role may carry different properties and interact with other roles cooperatively. An object may acquire or drop multiple roles during its lifetime. Structural and behavioral extensions of multimedia objects are achieved by dynamic role playing. Multifaceted interfaces of an multimedia object are modeled by means of views on roles. In particular, we discuss different ways of using views to model different abstraction levels of the heterogeneous multimedia resources. Throughout the paper, examples such as text, bitmap, MIDI, and 3D graphic objects are used to demonstrate the significance of our approach.

Towards seamless computing and metacomputing in Java

SUMMARY Due to its platform-independent execution model, its support for networking, multithreading and mobile code, Java has given hope that easy Internet-wide high-performance network computing was at hand. Numerous attempts have then been made at providing a framework for the development of such metacomputing applications. Unfortunately, none of them addresses seamless sequential, multithreaded and distributed computing , i.e. the execution of the same application on a multiprocessor shared-memory machine as well as on a network of workstations, or on any hierarchical combination of both. In this paper we first identify four requirements for the development of such metacomputing frameworks. We then introduce Java// (pronounced Java Parallel), a 100% Java library that provides transparent remote objects as well as asynchronous two-way calls, high reuse potential and high-level synchronization mechanisms. We also present the metaobject protocol (MOP) Java// is built on and describe a distributed collaborative raytracing test application built using Java//. ©1998 John Wiley & Sons, Ltd.

Adding Support for Persistence to CLOS via Its Metaobject Protocol

Language-level support for object persistence frees programmers from having to confront a broad class of database issues from within their applications. By virtue of its metaobject protocol, CLOS is a language whose semantics can be tailored by individual programmers. We used the metaobject protocol to extend CLOS with support for object persistence. Our goal was to obtain a version of CLOS with persistence to which we could easily port a commercial geometric CAD modeling system. We describe the design and implementation of our persistence extension and highlight the strengths and weaknesses exhibited by the CLOS metaobject protocol during our experiment. For many aspects of the implementation we found that the metaobject protocol was ideal. In other cases we had to choose among paying a large performance penalty, extending the protocol, and bypassing the protocol by modifying the language implementation directly.

Parallel object-oriented programming for parallel simulations

This paper presents the development of a parallel object-oriented language which is an extension of C++, called C++//. C++// offers reusability, flexibility and extensibility in concurrent programming through a set of language primitives (indeed a Meta-Object Protocol), independent of any parallel paradigm. It permits us to build libraries of nearly all concurrent programming models. One of them, presented here, is an MIMD model based on data-flow synchronizations (wait-by-necessity). C++// runtime main concern is versatility so its implementation is in fact an interface to any low-level runtime support. C++// is used to define and implement prosit, an object-oriented framework for distributed discrete event simulation. In the paper, we highlight the features which are crucial for the development of this generic simulation environment, mainly expressiveness, end-user adaptation and a strong reuse potential. All those important features are directly provided by the use of C++//. prosit and C++// are part of the Sloop project developments.