Showing papers on "Object-oriented design published in 1988"

Data integration by object management

Abstract: An object based data processing system including an extensible set of object types and a corresponding set of "object managers" wherein each object manager is a program for operating with the data stored in a corresponding type of object. The object managers in general support at least a standard set of operations. Any program can effect performance of these standard operations on objects of any type by making an "invocation" request. In response to an invocation request, object management services (which are available to all object managers) identifies and invokes an object manager that is suitable for performing the requested operation on the specified type of data. A mechanism is provided for linking data from one object into another object. A object catalog includes both information about objects and about links between objects. Data interchange services are provided for communicating data between objects of different types, using a set of standard data interchange formats. A matchmaker facility permits two processes that are to cooperate in a data interchange operation identify each other and to identify data formats they have in common. A facility is provided for managing shared data "resources", Customized versions of resources can be created and co-exist with standard resources. A resource retrieval function determines whether a customized or a standard resource is to be returned in response to each request for a resource.

Introduction to Systems Analysis and Design

Abstract: The system design environment systems some common information systems gathering information problem solving steps starting a project data flow diagrams describing data additional modelling method process description object modelling documentation designing a new system user interface design relational analysis database design program design productivity tools project management strategic planning quality assurance cases.

Generalized version control in an object-oriented database

Abstract: An important function of an engineering database management system is to support incremental and cooperative design in an orderly way. This calls for a version-control mechanism of some generality if it is to be appropriate to the design of complex objects. The authors consider the nature of design objects, and develop some functional requirements for version control of such objects. They outline the basic object-oriented database model, which they take as the foundation for their proposal. They then discuss the relationship between versions and the objects they exemplify, describe the mechanisms for the creation of versioned objects and the conversion of non-versioned objects to versioned form, study the impact on referencing and type checking in the object model, and arrive at a flexible notion of a context containing rules for version selection. Their implementation of some of these concepts is also described. >

The design and implementation of O2, an object-oriented database system

Abstract: This paper describes the design and implementation of the first version of the O2 object-oriented database system. The Altair project is currently designing and implementing a complete environment for developing data intensive applications. As a first step, we have implemented a quick prototype of an object-oriented DBMS. We report here on this implementation. The first part of the paper describes the system interface as seen by the application programmer, the second part describes the architecture of the system.

Transformation of data flow analysis models to object oriented design

Abstract: This paper describes a strategy to transform Data Flow Analysis into Object Oriented Design. This transformation is performed by extracting information from the Data Flow Model, by enriching with Design decision and by finally producing an Object Oriented Design Model. Semiformal transformation rules are described. Also a special notation is introduced to describe the Object Oriented Design Model. The Model used to represent Data Flow Analysis is the one originally proposed by Yourdon, complemented with Ward-Mellor's Real Time extensions (the “Essential Model”).

Mapping the design information representation terrain

Abstract: Some early results from an ongoing design representation technology survey and assessment are presented. The objectives were to provide a context for the evaluation of alternatives for representation of software design information and to serve as a catalyst for further research in the area. The scope of the problem and the survey approach are described. A rough 'technology map' of the design representation 'terrain' that resulted from the survey is discussed, along with some observations derived from the survey. >

On the recognition of parameterized objects

Abstract: Determining the identity and pose of oceluded objects from noisy data is a critical step in interacting intelligently with an unstructured environment. Previous work has shown that local measurements of position and surface orientation may be used in a constrained search process to solve this problem, for the case of rigid objects, either two-dimensional or three-dimensional. This paper considers the more general problem of recognizing and locating objects that can vary in parameterized ways. We consider two-dimensional objects with rotational, translational, or scaling degrees of freedom, and two-dimensional objects that undergo stretching transformations. We show that the constrained search method can be extended to handle the recognition and localization of such generalized classes of object families.

Synchronizing transactions on objects

Abstract: A method is discussed for synchronizing operations on objects when the operations are invoked by transactions. The technique, which is motivated by a desire to make use of possible concurrency in accessing objects, takes into consideration the granularity at which operations affect an object. A dynamic method is presented for determining the compatibility of an invoked operation with respect to operations in progress. In making decisions, it utilizes the state of the object, the semantics of the uncommitted operations, the actual parameters of the invoked operation, and the effect of the operations on the objects. One of the attractive features of this technique is that a single framework can be used to deal with the problem of synchronizing access to simple objects as well as compound objects, i.e. objects in which some components are themselves objects. >

Applying object-oriented design to structured graphics

Abstract: Structured graphics are useful for building applications that use a direct manipulation metaphor. Object-oriented languages offer inheritance, encapsulation, and runtime binding of operations to objects. Unfortunately, standard structured graphics packages do not use an object-oriented model, and object-oriented systems do not provide general-purpose structured graphics, relying instead on low-level graphics primitives. An object-oriented approach to structured graphics can give application programmers the benefits of both paradigms. We have implemented a two-dimensional structured graphics library in C++ that presents an object-oriented model to the programmer. The graphic class defines a general graphical object from which all others are derived. The picture subclass supports hierarchical composition of graphics. Programmers can define new graphical objects either statically by subclassing or dynamically by composing instances of existing classes. We have used both this library and an earlier, non-object-oriented library to implement a MacDraw-like drawing editor. We discuss the fundamentals of the object-oriented design and its advantages based on our experiences with both libraries.

Mathemtical model of composite objects and its application for organizing engineering databases

Abstract: The authors introduce a clustering concept called component aggregation which considers assemblies having the same types of parts as equivalent objects. The notion of equivalent objects is used to develop a mathematical model of composite objects. It is shown that the set of equivalence classes of objects form a Boolean algebra whose minterms represent the objects that are not considered composite at the current viewing level. The algebraic structure of composite objects serves as a basis for developing a technique for organizing composite objects and supporting materialization of explosion views. The technique provides a clustering mechanism which partitions the database into meaningful and application-oriented clusters, and allows any desired explosion view to be materialized using a minimal set of stored views. A simplified relational database for design data and a set of frequent access patterns in design applications are outlined and used to demonstrate the benefits of database organizations based on the mathematical model of composite objects. >

An object oriented system implementing KNOs

Abstract: We discuss a distributed object-oriented system written in LISP that implements KNOs (KNowledge acquisition, dissemination and manipulation Objects). The system emphasizes advanced features like object autonomy, mobility and dynamic inheritance. The objects are active, independent entities that can travel in a local area network and protect themselves from external aggressions. A dynamic inheritance mechanism enables them to modify their behaviour during their lifetime. We give a description of our system, illustrate its functionality with selected examples, and discuss its advantages for software development and Office Information Systems.

Support for design processes in a structurally object-oriented database system

Abstract: Database support for engineering applications requires mechanisms appropriate for managing design processes. The DAMOKLES database system implements a structurally object-oriented data model providing complex objects, general relationships and object versions, and is thus well suited for design environments. In this paper, we describe design transactions in terms of the DAMOKLES data model as a flexible concept to enhance parallelism of design activities and enable controlled exchange of stored design information. Disjoint logical databases assigned to users or user groups are maintained to reflect the hierarchical structure of project organization. During a design transaction, the user may deal with any number of objects by checking them out into her/his private area from any other admissible database. The operational framework of the design transactions supported by the DAMOKLES system is described and a precise definition of the checkout/checkin semantics is given. Subsequently, some implementation aspects are surveyed.

Object memory and storage management in the Clouds kernel

Abstract: Clouds is a distributed object-based operating system designed to support fault tolerance, location independence, and an action/object programming environment. Some of the key issues in supporting Clouds are the availability of object memory, object location, and object recovery. Object memory provides a set of global, persistent, named address spaces for sorting objects. The address spaces resemble conventional segmentation schemes, but are persistent and thus replace both the computational and storage systems used in conventional schemes by a more powerful paradigm. The object location system provides transparent object operation invocation mechanisms throughout the distributed environment. The object recovery system supports recoverable objects through shadowing and two-phase commit techniques to allow atomicity of actions. The key issues in the design and implementation of the object memory and storage management system are briefly described. >

Process management and exception handling in multiprocessor operating systems using object-oriented design techniques

Abstract: The programming of the interrupt handling mechanisms, process switching primitives, scheduling mechanisms, and synchronization primitives of an operating system for a multiprocessor require both efficient code in order to support the needs of high-performance or real-time applications and careful organization to facilitate maintenance. Although many advantages have been claimed for object-oriented class hierarchical languages and their corresponding design methodologies, the application of these techniques to the design of the primitives within an operating system has not been widely demonstrated.To investigate the role of class hierarchical design in systems programming, the authors have constructed the Choices multiprocessor operating system architecture using the C++ programming language. During the implementation, it was found that many operating system design concerns can be represented advantageously using a class hierarchical approach, including: the separation of mechanism and policy; the organization of an operating system into layers, each of which represents an abstract machine; and the notions of process and exception management. In this paper, we discuss an implementation of the low-level primitives of this system and outline the strategy by which we developed our solution.

Transaction synchronisation in object bases

Abstract: In this paper we investigate the problem of synchronising transactions in an object base. An object base is a collection of objects, much the way a database is a collection of data. An object, for our purposes, consists of a collection of variables (whose values at any point in time comprise the state of that object) and a set of operations, called methods, that are the only means of accessing (sensing or modifying) the object's variablesThere is a certain sense in which a traditional database is an object base. It consists of “objects” (records, tuples or what have you) each of which has a state that can be accessed only through the operations Read and Write. The main difference is that in an object base, each object supplies its own methods and these are arbitrary. In particular, a method for a certain object may call methods of other objects to carry out its task. In contrast to certain models in which objects correspond to “levels of abstraction”, our model is completely general in this respect for example, it is permissible for a method of object A to call a method of object B which, in turn, may call some other method of object A againOne implication of this difference between data and object bases is that in the latter the assumption, commonly made in the former, that the operations which manipulate the state of the objects are short enough to be implemented serially (one at a time) is no longer valid. A related implication is that in object bases we are faced with the necessity of dealing with nested transactions, since the invocation of one method may result in further method invocationsAnother, less fundamental, difference between data and object bases is that, in addition to being of uniform type, the “objects” of a database are usually assumed to be of uniform size as well. In an object base one can imagine objects of widely differing sizes. A clock and the New York City telephone directory could be objects differing in size by orders of magnitude, yet co-existing in the same object baseIn spite of these differences it is possible to approach concurrency control in an object base in the following way. Each object is viewed as a database item. Further, each method invocation is treated as a group of Read or Write operations on those data items that were accessed as a result of that method invocation. With these analogies, any conventional database concurrency control method (two-phase locking, timestamp ordering, certification, and the whole lot) can be employed to synchronise concurrent transactions in the object base. This approach has the virtue of simplicity and may be well-suited to certain environments. It is, for example, the approach taken in the GemStone project and product (cf Maier and Stein [1987], Purdy et al [1987])We are interested in exploring approaches to concurrency control in object bases which take into account their special features and differences from databases. The hope is that this will lead to more efficient techniques. More specifically, we would like to consider mechanisms that Take into account the nested nature of transactionsAllow methods accessing an object to execute concurrently (but correctly) This seems especially important as multiprocessors become available, since forcing serial access to an object's methods restricts parallelism (bear in mind that each method could be a lengthy procedure)Are modular, in that each object is responsible for synchronizing the invocations of its own methods as it sees fitThe first two of these points have been considered by others as well. For example, Argus (cf Liskov and Scheifler [1983]) uses a synchronisation algorithm which is an adaptation of strict two-phase locking in a nested transaction environment. In addition, Argus allows multiple concurrent invocations of an object's methods1We believe that the third point is a novel idea, so we elaborate on it a bit. In accordance with (b), multiple invocations of an object's methods may be active simultaneously As these methods may operate on common data (the object's variables), they must be synchronised. That is, if we view the object's variables as a database, and the simultaneous method invocations as concurrent transactions, we have to solve the serialisability problem within a single object. We call this intra-object synchronisationIt is not difficult to see that simply ensuring serialisability within each object is not, in itself, enough to guarantee serialisability of the overall computation. For instance, then may be two transactions T1 and T2 each accessing objects A and B, so that in object A the concurrent computation of the two transactions' method executions serialises T1 before T2, while the reverse holds in object B.The effect of such an execution is not the same as running the two transactions serially in either order and the overall computation is therefore not serial, sable, even though the computation at each object is Thus, in addition to intra-object synchronisation, it is also necessary to exercise some inter-object synchronisation, whose goal will be to ensure the compatibility of the independent decisions made at each objectThe potential advantage of separating intra- from inter-object synchronisation is seen if one recalls our previous observation regarding the non-uniformity of objects in an object base. Accordingly, we may be able to allow each object use, for intra-object synchronisation, the most suitable algorithm depending on its semantics, the implementation of its methods and so on. For example, an object representing and Delete) might be implemented as a B-tree. Thus, one of the many special B-tree algorithms could be used for intra-object synchronisation by this object (cf Bayer and Schkolnick [1977], Ellis [1980], Kung and Lehman [1980], Kwong and Wood [1982], Lehman and Yao [1981], Manber and Ladner [1982], Samadi [1976]) That object would enjoy the efficiency of the special algorithm, even though that algorithm is not applicable to other types of objects. Of course, the viability of such a scheme depends on the existence of efficient inter-object synchronisation schemes that can be used with disparate intra-object synchronisation algorithms. Even though we have no definitive answer for this question, our work so far leaves us hopeful that this may indeed be possibleThe remainder of this paper is organised as follows. In Section 2 we present a formal model for representing executions in object bases, we also define what serialisable (i e correct) executions are in this context. In Section 3 we present an extension of the Serialisability Theorem of “classical” concurrency control, which relates the serialisability of an execution to the acyclicity of a graph. We exhibit the utility of this theorem by using it to derive simple proofs of the correctness of Nested Two-Phase Locking (a slight generalisation of the algorithm used in Argus) and Nested Timestamp Ordering (an algorithm proposed by Reed [1978]). We also present a corollary to this theorem that we feel justifies our hopes for modular synchronisation mechanisms. We conclude with a description of further work in Section 4This work draws on three main sources “classical” serialisability theory (e.g. Bernstein et al [1987], Papadimitriou [1986]), the theory of nested transactions (e.g. Beeri et al [1980], Lynch and Merritt [1986]), and object-oriented systems (e.g. Stefik and Bobrow [1986])

Extending the object-oriented paradigm for supporting complex objects

Abstract: In this paper a generalized object-oriented approach for complex object modeling in proponed, which is characterized by adding the concept of Meta-Class into the object-oriented paradigm for unifying the handling of object types and primary data models, and also characterized by integrating the modeling of object type hierachy and object configuration hierarchy. Concepts such as Compositional Relationship Object, Face, Object Configuration Schema Expression, Object Skeleton are introduced to specify object structure, to support high degree of object sharing and to offer high degree of data independence. Operations on the class hierarchy, the object configuration structures and the object instances are developed respectively with distinguished semantics. This approach provides an extended object-oriented framework for handling complex objects in any AI or database systems.

Objects, Object Types, and Object Identification

Abstract: The usefulness of category-theoretic concepts for a theory of object-oriented programming is advocated. Objects (in the latter sense) are defined as objects (in the category-theoretic sense) of a category OB. Colimits in OB are used to express aggregation of objects into complex objects as well as interaction between objects. Object types consist of an identification system, the object universe, and an instantiation system, describing the instances of the type. The main result of this paper gives a semantic basis for database-like identification by keys: the object universe can be specified uniquely (up to isomorphism) employing general principles of preservation of data, distinguishability by keys, and representability by keys.

Layered virtual machine/object-oriented design

Abstract: Layered Virtual Machine/Object-Oriented Design (LVM/OOD) is an Ada-oriented software design method that stresses a balance between data abstraction and functional decomposition. Data abstraction is the guiding principle for the determination of modules that establish the overall architecture of the system. Functional decomposition is the guiding principle for the determination of the step-by-step processing of the program that satisfies a software requirements specification. Graphics are used to portray both the architecture and the step-by-step processing.

Constraint analysis: A tool for explaining the semantics of complex objects

Abstract: Constraint analysis is a design tool for object-oriented database environments that makes use of knowledge about constraints to support the design of user views and the specification of propagation actions. The constraint analysis process is supported by the formal, uniform representation of schema constraints. The formal representation supports the ability to analyze and explain constraints; the uniform representation allows both inherent and explicit constraints to be analyzed in the same manner. Using constraint analysis, the effects of constraints can be made explicit at design time to support the flexible specification of database operations that maintain object integrity. This paper presents the constraint representation that supports the analysis and explanation process.

Implementation techniques for object oriented databases

Abstract: In past few years we saw the development of a number of object oriented database systems. However, few papers discussed performance sensitive implementation techniques. In this paper we concentrate on strategies for performing deep equality and duplicate elimination in structurally object oriented databases, which support direct representation and access of complex objects. The three main strategies considered here are: (a) hashing and tagging complex objects; (b) inferencing; (c) implementing complex object operators in the presence of duplicates.

Software optimization using user models

Abstract: As interactive computing has developed, a more comprehensive design methodology is required to produce high-performance software. To achieve this goal, consideration of user performance must be included as an integrated part of the development process. An approach that allows a software engineer to integrate user performance as a design dimension in interactive software system design is presented. This approach is used to study the design of a text editor. >

Transitioning from structured analysis to object-oriented design

Abstract: ION LEVELS J Events and TerminatorsJ

Process Management and Exception Handling in Multiprocessor Operating Systems Using Object-Oriented Design Techniques. Revised Sep. 1988

Abstract: The programming of the interrupt handling mechanisms, process switching primitives, scheduling mechanisms, and synchronization primitives of an operating system for a multiprocessor require both efficient code in order to support the needs of high-performance or real-time applications and careful organization to facilitate maintenance. Although many advantages have been claimed for object-oriented class hierarchical languages and their corresponding design methodologies, the application of these techniques to the design of the primitives within an operating system has not been widely demonstrated. To investigate the role of class hierarchical design in systems programming, the authors have constructed the Choices multiprocessor operating system architecture using the C++ programming language. During the implementation, it was found that many operating system design concerns can be represented advantageously using a class hierarchical approach, including: the separation of mechanism and policy; the organization of an operating system into layers, each of which represents an abstract machine; and the notions of process and exception management. In this paper, we discuss an implementation of the low-level primitives of this system and outline the strategy by which we developed our solution.

Customization by automated resource substitution

Abstract: An object based data processing system including an extensible set of object types and a corresponding set of "object managers" (196) wherein each object manager is a program for operating with the data stored in a corresponding type of object. The object managers in general support at least a standard set of operations. Any program can effect performance of these standard operations on objects of any type by making an "invocation" request. In response to an invocation request, object management services (194, 218) (which are available to all object managers) identifies and invokes an object manager that is suitable for performing the requested operation on the specified type of data. A mechanism is provided for linking data from one object into another object. An object catalog (252) includes both information about objects and about links between objects. Data interchange services (812) are provided for communicating data between objects of different types, using a set of standard data interchange formats. A matchmaker facility (810) permits two processes that are to cooperate in a data interchange operation identify each other and to identify data formats they have in common. A facility (222) is provided for matching shared data "resources". Customized versions of resources can be created and co-exist with standard resources. A resource retrieval function determines whether a customized or a standard resource is to be returned in response to each request for a resource.

Model-Based Vision System by Object-Oriented Programming

Abstract: : This paper presents an approach to using object-oriented programming for the generation of a object recognition program that recognizes a complex 3-D object within a jumbled pile. We generate a recognition program from an interpretation tree that classifies an object into an appropriate attitude group, which has a similar appearance. Each node of an interpretation tree represents a feature matching. We convert each feature extracting or matching operation into an individual processing entity, called an object. Two kinds of objects have been prepared: data objects and event objects. A data object is used for representing geometric objects (such as edges and regions) and extracting features from geometric objects. An event object is used for feature matching and attitude determination. A library of prototypical objects is prepared and an executable program is constructed by properly selecting and instantiating modules from it. The object-oriented programming paradigm provides modularity and extensibility. This method has been applied to the generation of a recognition program for a toy wagon. The generated program has been tested with real scenes and has recognized the wagon in a pile. Keywords: Robotics; Libraries.