Showing papers in "Theory and Practice of Object Systems in 1997"

Architectural support for quality of service for CORBA objects

Abstract: CORBA is a commercial standard for distributed object computing which shows great promise in the development of distributed programs. Its interface description language (IDL) enables objects to be developed independently of the underlying programming language, operating system, or computer architecture on which they will execute. While this is sufficient in many environments, programs deployed in a wide-area distributed system encounter conditions which are much more hostile and varying than those operating in a single address space or within a single local area network. In this paper we discuss four major problems we have observed in our developing and deploying wide-area distributed object applications and middleware. First, most programs are developed ignoring the variable wide area conditions. Second, when application programmers do try to handle these conditions, they have great difficulty because these harsh conditions are different from those of the local objects they are used to dealing with. Third, IDL hides information about the tradeoffs any implementation of an object must make. Fourth, there is presently no way to systematically reuse current technology components which deal with these conditions, so code sharing becomes impractical. In this paper we also describe our architecture, Quality of Service for CORBA Objects (QuO), which we have developed to overcome these limitations and integrate their solution by providing QoS abstractions to CORBA objects. First, it makes these conditions first class entities and integrates knowledge of them over time, space, and source. Second, it reduces their variance by masking. Third, it exposes key design decisions of an object's implementation and how it will be used. Fourth, it supports reuse of various architectural components and automatically generates others. © 1997 John Wiley & Sons, Inc.

A refactoring tool for Smalltalk

Abstract: Refactoring is an important part of the evolution of reusable software and frameworks. Its uses range from the seemingly trivial, such as renaming program elements, to the profound, such as retrofitting design patterns into an existing system. Despite its importance, lack of tool support forces programmers to refactor programs by hand, which can be tedious and error-prone. The Smalltalk Refactoring Browser is a tool that carries out many refactorings automatically, and provides an environment for improving the structure of Smalltalk programs. It makes refactoring safe and simple, and so reduces the cost of making reusable software. © 1997 John Wiley & Sons, Inc.

Building reliable distributed systems with CORBA

Abstract: New classes of large-scale distributed applications will have to deal with unpredictable communication delays, with partial failures, and with networks that partition. In addition, sophisticated applications such as teleconferencing, video-on-demand, and concurrent software engineering require a group communication abstraction. These paradigms are not adequately addressed by CORBA. CORBA mainly deals with point-to-point communication and offers no support for the development of reliable applications that exhibit predictable behavior in distributed systems. In this article, we present extensions to CORBA which provide group communication, reliability, and fault tolerance. We also describe Orbix+Isis and Electra—two CORBA object request brokers that support the implementation of reliable distributed applications and groupware. © 1997 John Wiley & Sons, Inc.

A formal model of views for object-oriented database systems

Abstract: The de nition of a view mechanism is an important issue for object-oriented database systems, in order to provide a number of features that are crucial for the development of advanced applications. Due to the complexity of the data model, the object-oriented paradigm introduces new problems in the de nition of a view mechanism. Several approaches have been de ned, each de ning a particular view mechanism tailored to a set of functionalities that the view mechanism should support. In particular, views can be used as shorthand in queries, can support the de nition of external schemas, can be used for content-dependent authorization, and, nally, can support some form of schema evolution. In this paper, we formally introduce a view model for object-oriented databases. Our view model is comparable to existing view models for what concerns the supported features; however, our model is the only one for which a formal de nition is given. This formal de nition of object-oriented view mechanisms is useful both for understanding what views are and as a basis for further investigations on view properties. The paper introduces the model, discussing all the supported features both from a theoretical and practical point of view. A comparison of our model with other models is also presented.

Law-governed regularities in object systems. Part 2: a concrete implementation

Abstract: Regularities, or the conformity to unifying principles, are essential to the comprehensibility, manageability, and reliability of large software systems and should, therefore, be considered an important element of their architecture. But the inherent globality of regularities makes them very hard to implement in traditional methods. We have argued in a previously published companion paper that this difficulty can be alleviated by means of law-governed architecture (LGA), under which a system designer can establish a desired regularity (of a certain kind) simply by declaring it formally and explicitly as the law of the system. Once such a law-governed regularity is declared, it is enforced by the environment in which the system is developed. This paper discusses the application of LGA to traditional, class-based, object-oriented languages, using the Eiffel language for specificity. We introduce here the formalism for specifying laws that govern systems written in this language, and give a sample of regularities that can be efficiently established by such laws. As a case study, we show how one can establish a kernelized architecture suitable for the construction of critical embedded software, such as the software embedded in an intensive care unit. © 1997 John Wiley & Sons, Inc.

T_Chimera: a temporal object-oriented data model

Abstract: Temporal data models are an active research area. However, although many temporal extensions have been proposed for the relational data model, there is no comparable amount of work in the context of object-oriented data models. This paper presents T―Chimera, a temporal extension of the Chimera object-oriented data model. The main contribution of this work is to define a formal temporal object-oriented data model and to address on a formal basis several issues deriving from the introduction of time in a semantically rich model like the object-oriented one. © 1997 John Wiley & Sons, Inc.

Maintenance of object-oriented systems during structural evolution

Abstract: We have previously developed a mathematical treatment of a calculus for class transformations that preserve or extend a set of objects. Methods for automating the maintenance of structural and behavioral consistency in systems based on evolving class structures have been provided for the object-preserving and object-extending transformations. This work extends the calculus of class transformations to include certain transformations that reflect not only the extension and reclassification of existing objects, but also structural changes (other than addition of attributes) in the original objects. Language-preserving transformations are a special case of transformations that change the structure of existing objects. If an object schema is decorated with concrete syntax, it defines not only a class structure, but also a language for describing the objects. When two schemas define the same language but different classes, the language may be used to guide the transportation of functionality between domains. The languagepreserving transformations defined here form the basis of a complete transformation system for a subset of class graphs powerful enough to express the regular languages. c 1997 John Wiley & Sons

Tool construction for the British Airways SEE with the O 2 ODBMS

Abstract: Software engineering environments (SEE) support the construction and maintenance of large-scale software systems. They integrate tools for the production and maintenance of documents such as requirements definitions, architecture definitions or user manuals. Very few SEE tools meet all the developers' requirements. Some requirements that are important in practice have not been appropriately addressed. These are inter-document consistency handling, version and configuration management and cooperative work. We claim that the reason for current tools not meeting these requirements is the fact that the required database support for maintaining documents is only now becoming available. The British Airways SEE meets these new requirements. Its tools were constructed using the O2 object database management system, which has been extended to become a database management system for software engineering. We discuss the experiences we made during tool construction for this SEE.

Design and implementation of Pep, a Java just-in-time translator

Abstract: Java, a new object-oriented member of the C family of languages, has become popular in part because it emphasizes portability. Portability is achieved by compiling programs to machine-independent bytecodes that can be interpreted on a Java virtual machine. Unfortunately, interpreted performance does not match native code performance. A just-in-time compiler can regain performance without sacrificing portability by turning the bytecodes into native code at runtime. This idea has a proven track record: Deutsch and Schiffman presented a dynamic Smalltalk compiler in 1984 [5], and the Self system currently sports a dynamic type-feedback based optimizing compiler [12]. To study the performance potential of Java with this state-of-the-art optimization technology, we built Pep, a just-in-time compiler from Java bytecodes to Self. Following translation by Pep, Java programs can execute on the Self virtual machine and benefit from the optimizations performed by Self's compiler. We describe the design and implementation of Pep, focusing on concepts and trade-offs, but also compare performance with the JDK 1.0.2 and 1.1 interpreters. © 1997 John Wiley & Sons, Inc.

Designing object systems for evolution

Abstract: First, we give an overview of several approaches to the evolution of object systems and discuss their potential to make a system better prepared for anticipated evolution. Then, we place our emphasis on unanticipated evolution where we find the flexibility of object coupling to be a crucial system property. We present the major concerns of object coupling and a set of flexible, design-oriented object coupling mechanisms. Each one of these mechanisms exhibits considerable flexibility regarding at least one of the concerns of object coupling. Flexible object coupling mechanisms raise the issue of run-time failures. Thus, these mechanisms should not be used extensively throughout the entire system, but only where they can be most effective. We introduce Design for Slippage, a small conceptual framework providing decision support for the application of flexible object coupling mechanisms.

Trader down under: Upside down and inside out

Abstract: In this article we present a new object-oriented design of a trader customized to the CORBA environment as a CORBA Service. Key design decisions include the separation of trader, service types, and service offers, the reuse of OMG's CORBA services, and the application of a fine-grain object model. Emphasis is also placed on the federation of traders by specifying interfaces for this purpose and a federation protocol. The fine-grain object model allows a wide range of implementations and configurations to satisfy different user requirements. This design is an object-oriented alternative to the trader specification to be adopted by the OMG.

Class-graph inference for adaptive programs

Abstract: Software generators can adapt components to changes in the architectures in which the components operate. The idea is to keep the architecture description separate and let the software generator mix it with specications of each component. Adaptation is done by regeneration: when the architecture changes, the components are regenerated. A software component will usually be written with a particular architecture in mind. This raises the question: how much has it committed to the particular structure of that architecture? To put it in a nutshell: How exible is a given software component? In this paper we study this question in the setting of Lieberherr’s adaptive programming. Lieberherr uses class graphs as the architecture and so-called adaptive programs as the software components. We present a polynomial-time class-graph inference algorithm for adaptive programs. The algorithm builds a representation of the set of class graphs with which a given adaptive program can work. It also decides if the set is non-empty, and if so it computes a particularly simple graph in the solution set. Several toy programs have been processed by a prototype implementation of the algorithm.

The GPR system: an architecture for integrating active and deductive rules on complex database objects

Abstract: This paper illustrates a prototype system, called GPRS, supporting the Generalized Production Rules (GPR) data-base language. The GPR language integrates, in a unified framework, active rules, which allow the specification of event driven computations on data, and deductive rules, which can be used to derive intensional relations in the style of logic programming. The prototype realizes the operational semantics of GPR using a unique rule-evaluation engine. The data model of reference is object based and the system is implemented on top of an object oriented DBMS. Hence, the GPRS prototype represents a concrete proposal of an advanced DBMS for complex objects that provides both active and deductive styles of rule programming. © 1997 John Wiley & Sons, Inc.