Wrappers are mechanisms for introducing new behavior that is executed before and/or after, and perhaps even in lieu of, an existing method. This paper examines several ways to implement wrappers in Smalltalk, and compares their performance. Smalltalk programmers often use Smalltalk's lookup failure mechanism to customize method lookup. Our focus is different. Rather than changing the method lookup process, we modify the method objects that the lookup process returns. We call these objects method wrappers.Wehaveused method wrappers to construct several program analysis tools: a coverage tool, a class collaboration tool, and an interaction diagramming tool. We also show how we used method wrappers to construct several extensions to Smalltalk: synchronized methods, assertions, and multimethods. Wrappers are relatively easy to build in Smalltalk because it was designed with reflective facilities that allow programmers to intervene in the lookup process. Other languages differ in the degree to which they can accommodate change. Our experience testifies to the value, power, and utility of openness.

... written in itself. It offers important advantages such as large portability, dynamicity, a fully unified world, graphical user interface builders, connection to databases, powerful development tools, etc. In this paper we discuss the trait that underlies all these features: Reflection. We quote one of its definitions and in the first part of this paper go through the di erent reflective aspects of Smalltalk. We expand ve major aspects in detail: meta-operations, the classes/metaclasses model, the reified compiler, message sending and the behavioral representation through the reification of the executive stack frame of each process. We illustrate their use with significant applications, based both on our industrial and research experiences. In the second part of the paper, we introduce and fully develop pre/post conditions in Smalltalk, dealing with extensions of the model, the compiler, and the development environment.

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.

This paper presents the design and implementation of the GARF system, an objectoriented platform that helps programming fault-tolerant distributed applications in a modular way. The originality of GARF is to separate a distributed object into several objects, the complexity of distribution and fault-tolerance being encapsulated in reusable classes. The use of those classes by the GARF system is based on a run-time mechanism of invocation redirection, where most other systems use inheritance, a compile-time mechanism. Our runtime, which supports the GARF object model, is written in Smalltalk. It is presented in detail, as well as the reusable classes that support fault-tolerance. Fault-tolerant objects are implemented using groups of replicated objects. Our Dependable Object Toolkit provides group management facilities at the object level. Object groups are built on top of the Isis toolkit, which provides group management facilities at the Unix process level. Our mapping of object group...

Abstract An essential motivation behind concurrent object-oriented programming is to exploit the software reuse potential of object-oriented features in the development of concurrent systems. Early attempts to introduce concurrency to object-oriented languages uncovered interferences between object-oriented and concurrency features that limited the extent to which the benefits of object-oriented programming could be realized for developing concurrent systems. This has fostered considerable research into languages and approaches aiming at a graceful integration of object-oriented and concurrent programming. We will examine the issues underlying concurrent object-oriented programming, examine and compare how different approaches for language design address these issues. Although it is not our intention to make an exhaustive survey of concurrent object-oriented languages, we provide a broad coverage of the research in the area. Considerable research activity in the past few years has concentrated on the design of concurrent

. GARF is an object-oriented programming environment aimed to support the design of reliable distributed applications. Its computational model is based on two programming levels: the functional level and the behavioral level. At the functional level, software functionalities are described using passive objects, named data objects, in a centralized, volatile, and failure free environment. At the behavioral level, data objects are dynamically bound to encapsulators and mailers which support distribution, concurrency, persistence and fault tolerance. Encapsulators wrap data objects by controlling how the latter send and receive messages, while mailers perform communications between encapsulators. This paper describes how the GARF computational model enables to build flexible and highly modular abstractions for the design of reliable distributed applications. 1 Introduction Transparency has been recognized to be a worthwhile goal in the design of distributed systems. A user of a transpa...

As applications become larger and more complex, it is frequently the case that system components require varying models of computation. The use of different computational models is not well supported by standard object-oriented mechanisms and systems. Typical mechanisms implicitly encapsulate meta-level (i.e., computational) semantics along with the base-level (i.e., domain) behaviour. Objects defined using one model cannot easily be executed under another and so cannot be reused. A major problem is the inclusion of base-level language constructs in the meta-level architecture design. Meta-levels typically only facilitate concepts which are similar to those in the original base-level language and so cannot describe widely differing models of execution. We present a meta-level architecture founded on the novel principle of fine-grained, operational decomposition of the meta-level into objects. Unlike others, our approach bases the design of the architecture on the operations which occur during object execution (e.g., send, lookup) rather than the structural nature of an object’s representation (e.g., class, method). This clearly separates the elements of the meta-level from those of the base-level language and so opens the meta-level to more radical change. The power of this approach is shown via several markedly different object

ions pour la Programmation Concurrente dans GARF 1 Benoit Garbinato, Xavier D'efago, Rachid Guerraoui, Karim R. Mazouni Laboratoire de Syst`emes d'Exploitation D'epartement d'Informatique Ecole Polytechnique F'ed'erale de Lausanne Lausanne, Suisse e-mail: garf@lse.epfl.ch R'esum'e: GARF est un environnement `a objets permettant la programmation modulaire d'applications distribu'ees r'esistantes aux pannes. Cet article pr'esente la biblioth`eque de classes offertes au programmeur par GARF, pour g'erer l'expression de la concurrence et de son controle. La mise en oeuvre des m'ecanismes introduisant la concurrence, ainsi que plusieurs classes proposant divers types de controle de concurrence intra-objet, sont pr'esent'ees. L'extension de certaines de ces classes au controle de concurrence inter-objets est 'egalement expos'ee. Abstract: GARF is an object-oriented environment that allows the programming of fault-tolerant distributed applications in a modular way. This paper presents the ...

Abstract. Supporting read-only and side effect free execution has been the focus of a large body of work in the area of statically typed programming languages. Read-onlyness in dynamically typed languages is difficult to achieve because of the absence of a type checking phase and the support of an open-world assumption in which code can be constantly added and modified. To address this issue, we propose Dynamic Read-Only references (DRO) that provide a view on an object where this object and its object graph are protected from modification. The readonly view dynamically propagates to aggregated objects, without changing the object graph itself; it acts as a read-only view of complex data structures, without making them read-only globally. We implement dynamic read-only references by using smart object proxies that lazily propagate the read-only view, following the object graph and driven by control flow and applied them to realize side-effect free assertions. 1

Abstract not found