Abstract. Binary component adaptation (BCA) allows components to be adapted and evolved in binary form and on-the-fly (during program loading). BCA rewrites component binaries before (or while) they are loaded, requires no source code access and guarantees release-to-release compatibility. That is, an adaptation is guaranteed to be compatible with a new binary release of the component as long as the new release itself is compatible with clients compiled using the earlier release. We describe our implementation of BCA for Java and demonstrate its usefulness by showing how it can solve a number of important integration and evolution problems. Even though our current implementation was designed for easy integration with Sun’s JDK 1.1 VM rather than for ultimate speed, measurements show that the load-time overhead introduced by BCA is small, in the range of one or two seconds. With its flexibility, relative simple implementation, and low overhead, binary component adaptation could significantly

Object-oriented programming promises to increase programmer productivity through better reuse of existing code. However, reuse is not yet pervasive in today's object-oriented programs. Why is this so? We argue that one reason is that current programming languages and environments assume that components are perfectly coordinated. Yet in a world where programs are mostly composed out of reusable components, these components are not likely to be completely integrated because the sheer number of components would make global coordination impractical. Given that seemingly minor inconsistencies between individually designed components would exist, we examine how they can lead to integration problems with current programming language mechanisms. We discuss several reuse mechanisms that can adapt a component in place without requiring access to the component's source code and without needing to re-typecheck it.

Distributed Smalltalk (DS) is an implementation of Smalltalk that allows objects on different machines to send and respond to messages. It also provides some capability for sharing objects among users. The distributed aspects of the system are largely user transparent and preserve the reactive quality of Smalltalk objects. Distributed Smalltalk is currently operational on a network of Sun workstations. The implementation includes an incremental distributed garbage collector and support for remote debugging, access control, and object mobility. This paper concentrates on the important design issues encountered and some of the more interesting implementation details. Performance measurements of the current implementation are included. 1 Introduction Smalltalk [Ingalls 78, Goldberg and Robson 83] is a language and highly interactive programming environment originally developed for the Xerox family of personal workstations and now implemented on a variety of different hosts. The Smalltalk...

Genericity allows the substitution of types in a class. This is usually obtained through parameterized classes, although they are inflexible since any class can be inherited but is not in itself parameterized. We suggest a new genericity mechanism, type substitution, which is a subclassing concept that complements inheritance: any class is generic, can be "instantiated" gradually without planning, and has all of its generic instances as subclasses. 1 Introduction This paper proposes type substitution as a new genericity mechanism for statically typed object-oriented languages. With this concept we avoid type variables and second-order entities and obtain the natural complement of inheritance; both are subclassing mechanisms and they differ as follows. ffl Inheritance. Construction of subclasses by adding variables and procedures, and by replacing procedure bodies. ffl Type substitution. Construction of subclasses by substituting types. Type substitution is supportive of the real-li...

We develop a theory of statically typed object-oriented languages. It represents classes as labeled, regular trees, types as finite sets of classes, and subclassing as a partial order on trees. We show that our subclassing order strictly generalizes inheritance, and that a novel genericity mechanism arises as an order-theoretic complement. This mechanism, called class substitution, is pragmatically useful and can be implemented efficiently.

Programming languages often provide for various sorts of static type checking as a way of detecting invalid programs. However, statically checked type systems often require unnecessarily specific type information, which leads to frustratingly inflexible languages. Polymorphic type systems restore flexibility by allowing entities to take on more than one type. This thesis discusses polymorphism in statically typed programming languages. It provides precise definitions of the term "polymorphism" and for its varieties, "ad-hoc polymorphism", "universal polymorphism", "inclusion polymorphism", and "parametric polymorphism", and surveys and compares many existing mechanisms for providing polymorphism in programming languages. Finally, it introduces a new polymorphism mechanism, contextual polymorphism. Contextual polymorphism is a variant of parametric polymorphism that is based on contexts, which are abstractions of collections of declarations, and assertions, which link polymorphic routin...

Object oriented programming languages with subtyping facilitate the re-use of code which forms the top part of a call-graph. This style of code reuse, sometimes called inverted programming, cannot be simulated easily in traditional languages. We present a technique for achieving the same eect in the framework of a higher-order, polymorphic functional language without subtyping. Our method establishes a close relationship between the object-oriented concepts of class, \self", and subtyping and the functional concepts of algebraic data types and abstraction functions. The relationship can serve as a transformational semantics of object-oriented language elements. Keywords: Code Reuse, Subtyping, Parametric Polymorphism, Haskell, Abstraction Functions. Topic: Research 4600 Words 1 Introduction: Facets of Code-Reuse The biggest advantage of using an object-oriented programming language instead of a conventional one is the increased ability of reusing code. This work was motivated by ...

Smalltalk is an object-oriented programming language and highly interactive uniformly object-structured programming environment, originally developed for the Xerox family of personal workstations. The Smalltalk programming environment supports a single user on a single processor in a single object address space. This thesis describes the design and implementation of Distributed Smalltalk. Distributed Smalltalk extends the Smalltalk system to support the interaction of many users on many machines. It provides communication and interaction among geographically remote Smalltalk users, direct access to remote objects, the ability to construct distributed applications in the Smalltalk environment, and a degree of object sharing among users. Applications of Distributed Smalltalk include mail systems, remote computation servers, remote file servers, and collaborative software development. The distributed aspects of the system are largely user transparent and preserve the reactive quality of Smalltalk objects. A system is reactive to the degree that objects in the system can be easily presented for inspection or modification. Smalltalk is highly reactive in that all objects in the system can be so presented. Inheritance is a fundamental property of Smalltalk that allows objects to acquire behavior from other objects. In designing Distributed Smalltalk, we found that the interaction of inheritance and reactiveness was a major source of difficulty and that this interaction had significant impact on the design of a distributed system. Neither inheritance or reactiveness scaled well fro...

Abstract. Software Adaptation promotes the use of specific computational entities called adaptors that guarantee software components will interact in the right way, not only at the signature level, but also at the behavioral, semantic and service levels. Adaptation techniques have proceeded by computing adaptors for closed systems made up of a fixed set of components. This is not satisfactory when the systems may evolve, with components entering or leaving it at any time. To enable adaptation on such systems, we propose one implementation of adaptors under.NET platform and we show how using an ontology one adaptor can be improved in order to achieve a runtime adaptation at service level in a developed system when a component is missing or replaced by other. This capability will increase the Quality of Service (QoS), making the system be Fault Tolerant.