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

Object-Oriented Design

Abstract: Introduction. 1. Improving Design. 2. Developing the Multi-Layer, Multi-Component Model. 3. Designing the Problem Domain Component. 4. Designing the Human Interaction Component. 5. Designing the Data Management Component. 6. Applying OOD with OOPLs (or less than an OOPL). 7. Applying OOD Criteria. 8. OOD and CASE. 9. Getting Started with OOD. Appendix A. OOA Strategy Summary Appendix B. OOD Strategy Summary. Appendix C. An Example: OOA to OOD to OOP. Bibliography.

Objects and views

Abstract: Object-oriented databases have been introduced primarily to ease the development of database applications. However, the difficulties encountered when, for instance, trying to restructure data or integrate databases demonstrate that the models being used still lack flexibility. We claim that the natural way to overcome these shortcomings is to introduce a sophisticated view mechanism. This paper presents such a mechanism, one which allows a programmer to restructure the class hierarchy and modify the behavior and structure of objects. The mechanism allows a programmer to specify attribute values implicitly, rather than storing them. It also allows him to introduce new classes into the class hierarchy. These virtual classes are populated by selecting existing objects from other classes and by creating new objects. Fixing the identify of new objects during database updates introduces subtle issues into view design. Our presentation, mostly informal, leans on a number of illustrative examples meant to emphasize the simplicity of our mechanism.

Distributed, object-based programming systems

Abstract: The development of distributed operating systems and object-based programming languages makes possible an environment in which programs consisting of a set of interacting modules, or objects, may execute concurrently on a collection of loosely coupled processors. An object-based programming language encourages a methodology for designing and creating a program as a set of autonomous components, whereas a distributed operating system permits a collection of workstations or personal computers to be treated as a single entity. The amalgamation of these two concepts has resulted in systems that shall be referred to as distributed, object-based programming systems.This paper discusses issues in the design and implementation of such systems. Following the presentation of fundamental concepts and various object models, issues in object management, object interaction management, and physical resource management are discussed. Extensive examples are drawn from existing systems.

Integration of data between typed objects by mutual, direct invocation between object managers corresponding to object types

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. An 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.

Achieving generalized object recognition through reasoning about association of function to structure

Abstract: An attempt is made to demonstrate the feasibility of defining an object category in terms of the functional properties shared by all objects in the category. This form of representation should allow much greater generality. A complete system has been implemented that takes the boundary surface description of a 3D object as its input and attempts to recognize whether the object belongs to the category 'chair' and, if so, into which subcategory if falls. This is, to the authors' knowledge, the first implemented system to explore the use of a purely function-based definition of an object category (that is, no explicit geometric or structural model) to recognize 3D objects. System competence has been evaluated on a database of over 100 objects, and the results largely agree with human interpretation of the objects. >

Composite multimedia and active objects

Abstract: An object-oriented framework for composite multimedia is described. In analogy to constructing complex graphics entities from graphics primitives and geometric transformations, composite multimedia is constructed from multimedia primitives and temporal transformations. Active objects based on real-time processes are proposed as multimedia primitives. Their combination to form composite multimedia and the requisite temporal transformations are illustrated.

User interface for a relational database using a task object for defining search queries in response to a profile object which describes user proficiency

Abstract: A method and object-oriented architecture for interfacing a user to a relational database system The contour of the interface is defined by a profile object and a task object. The profile object, in response to user selection, defines one of multiple role objects with associated user proficiency and system behavioral characteristics. The task object responds to parameters derived from the profile object to generating a query for the relational database system. In one form, the task object includes one or more functional objects suitable to query the database. Representative functional objects are the domain object (used to formulate problem oriented queries), the analysis object (used to analyze the data extracted from the database), the report object (used to generate a user response format), and the link object (used to relate the components within the task object). The interface according to the invention matches the abilities of the user to the resources of the database system, manipulates problem oriented high-level queries, and provides an object oriented architecture readily amenable to object refinement.

An object-oriented framework for the integration of interactive animation techniques

Abstract: We present an interactive modeling and animation system that facilitates the integration of a variety of simulation and animation paradigms. This system permits the modeling of diverse objects that change in shape, appearance, and behaviour over time. Our system thus extends modeling tools to include animation controls. Changes can be effected by various methods of control, including scripted, gestural, and behavioral specification. The system is an extensible testbed that supports research in the interaction of disparate control methods embodied in controller objects. This paper discusses some of the issues involved in modeling such interactions and the mechanisms implemented to provide solutions to some of these issues.The system's object-oriented architecture uses delegation hierarchies to let objects change all of their attributes dynamically. Objects include displayable objects, controllers, cameras, lights, renderers, and user interfaces. Techniques used to obtain interactive performance include the use of data-dependency networks, lazy evaluation, and extensive caching to exploit inter- and intra-frame coherency.

Design of software systems based on axiomatic design

Abstract: The ability to utilize fully automated flexible manufacturing systems (FMS) or develop reliable computer-integrated manufacturing (CIM) systems will depend on our ability to develop reliable and reusable software for large complex systems on a timely basis. To date, software design has not gone very far beyond the ad hoc trial-and-error stage. Consequently, the development of software is slow, expensive, unreliable, and unmanageable. The purpose of this paper is to provide a scientific basis for designing software. The approach used here is that of axiomatic design, which is based on two design axioms: the Independence Axiom and the Information Axiom. The axiomatic approach is based on the recognition of the following common elements in design: the existence of independent domains (i.e. the consumer domain, the functional domain, the physical domain, and the process domain); the need to map between various domains during the design process; the decomposition of the characteristic vectors (i.e. functional requirements, design parameters, and process variables) in their respective domains; the zig-zagging required between the domains for decomposition; and the need to satisfy the design axioms during the design process. The axiomatic approach discussed in this paper provides decision making tools for software design in addition to systematic means of knowledge and data representation, synthesis and analysis of software, and the construction of the module-junction structure diagram.

Effective clustering of complex objects in object-oriented databases

Abstract: Clustering is an effective mechanism for retrieving complex objects. Many object-oriented database management systems have suggested variant clustering schemes to improve their performance. Two issues may compromise the effectiveness of a clustered structure , i.e., object updates and multiple relationships. Updates may destroy the initially cIustered structure, and in a multiple relationship environment, clustering objects based on one relationship may sacrifice others. This paper investigates the updating effects and suggests a dynamic reclustering scheme to reorganize related objects on the disk. A cost model is introduced to estimate the benefit and overhead of reclustering. Reorganizations are performed only when the overhead can be justified. For environments in which multiple relationships among objects exist, the paper proposes a leveled clustering scheme to order related objects into a clustering sequence. Our simulation results show that the leveled clustering scheme has a better access time compared with a single-level clustering scheme.

The design of a system for distributing shared objects

Abstract: The primary motivation for the work described in this paper is to design a platform for building applications that are intended for use by a group of people. The paper introduces the requirements for applications in which people use workstations on a local area network to share information and to communicate with one another. The paper discusses how we addressed these requirements in the context of three example applications a departmental database, a room booking program and a shared spreadsheet.

From objects to classes: algorithms for optimal objection-oriented design

Abstract: Introduces a novel, axiomatically defined, object-oriented data model called the Demeter kernel model; and secondly, presents abstraction and optimisation algorithms and their relationships for designing classes from objects in the kernel model. The authors analyse several computational problems underlying the class design process, which is divided into two phases; a learning phase and an optimisation phase. This study focuses on approximation algorithms for the optimisation phase and aims to lead to a better understanding and a partial automation of the object-oriented design process. The algorithms and the theory presented have been implemented in the C++Demeter System, a CASE tool for object-oriented design and programming. >

Virtual object management system for managing virtual objects which correspond to real objects under a user defined hierarchy

Abstract: An object management system is equipped with a single real object management system for managing a real file object such as data and a program based on a real directory object in a hierarchical structure, and also at least a single virtual object management system for managing a virtual file object corresponding to said file object based upon a virtual directory object which is independent of the directory object in a hierarchical structure.

Method and apparatus for system design

Abstract: A system level automation tool for system design using a computer is operable to generate a first set of objects each defining a portion of the system. The objects have a parent-child relationship wherein one or more child objects each define a portion of the parent object. A second set of implementable objects is associated with the first set of objects using a transitional mapping (TRAM) describing the relationships between the first and second sets of objects.

An object oriented model for parallel and reactive systems

Abstract: MO2 is an object-oriented model which integrates features of database management systems (DBMSs) and features of real-time systems. It allows for the definition of different kinds of relationships between objects: generalization/specialization, aggregation, and association. Its principal feature is the ability to distinguish passive objects and active objects. The passive objects react only through the activation of their methods. The active objects can have their own behavior and can evolve under the solicitation of various events independently of the activation of their methods. Various timing constraints can be specified on methods or method blocks. MO2 is able to model software objects as well as hardware objects. This model is suited for implementation in distributed environments and multiprocessor systems. >

A robot vision system for recognition of generic shaped objects

Abstract: Generic shape recognition is the problem of determining the pose and dimensions of objects for which only shape models are available and the object's size is unknown. One application domain for generic object recognition is the handling and sorting of postal objects. Because metrical information relating object features to one another is not available, the more common featurebased approaches are inadequate. Our system, INGEN (INference engine for GENeric object recognition), uses a data-driven approach to determine the pose and size of objects with generic shapes such as parallelepipeds and cylinders. This system successfully recognizes occluded objects in heaps. It also handles scenes which have irregularities in surfaces and edges—such irregularities are common to postal objects—as well as shadows and irregularities in the range data itself. The three most important parts of INGEN are (1) the procedures for constructing object hypotheses, computing their attributes, and evaluating how well they fit the data, (2) the geometric reasoning process which determines the size of object hypotheses by finding points of contact with other object hypotheses and also detects geometric inconsistencies in the scene interpretation, and (3) the recognition process which allows backtracking when object hypotheses are rejected due to insufficient support or geometric conflict with other object hypotheses. INGEN has been used successfully to guide a robot in removing postal objects from a pile. We show the results of these experiments.

Rule-Based Generation of Model Structures in Multifaceted Modeling and System Design

Abstract: A framework for aiding the construction of simulation models in system design problems is presented. The framework employs concepts of artificial intelligence and simulation modeling. A knowledge representation scheme called system entity structure expresses information about the structure of the system to be designed and its corresponding models. More specifically, the entity structure represents objects and their attributes, decompositions, and taxonomies. A knowledge base of production rules is defined for a given design domain and is incorporated in an expert system shell which recommends a feasible configuration of design objects from the system entity structure, based on specific design objectives, constraints, and requirements. This configuration is a basis for constructing a model of the system. The methodology for constructing the system entity structure and its corresponding rule base is presented. A case study based on a high level robot design problem is discussed to illustrate the conceptual ...

System for determination of the equivalence of two objects without compromising then done by a third object nominated by one and accetped by the other

Abstract: In an object oriented distributed system based on the client-server model, the client domains, the server domains and the objects are implemented in an improved manner such that a client domain determines whether a first and a second object implemented by a first and a second server domain are equivalent by requesting the first object to nominate a third object to make the determination, the second object to concur to the nomination, and the nominated third object to make the determination, thereby allowing the determination to be made without comprising the first and second objects and the first and second server domains' security.

Reflective object management in the Muse operating system

Abstract: Presents reflective object management as a set of facilities for handling objects with various properties such as grain-size and lifespan efficiently and naturally. The facilities are classes, variable-length identifiers, memory management, and efficient communication between objects. These facilities are based on the Muse object architecture and implemented on the Muse operating system. Reflective object management can define objects in such a way that there is no distinction between objects supported by operating systems and objects supported by programming languages in a multi-lingual environment. The authors also show their preliminary evaluation of the implementation. >

Evaluation and optimization of complex object selections

Abstract: We provide a general framework for declarative selection operations for complex object databases, based on the safe calculus for complex objects Within this framework, we consider a class of “single pass-evaluable” selection operations We show how such selection operations can be succinctly expressed by programs that use only very simple positive existential selections Also, a syntactic criterion is developed for the commutation of two such positive existential selections These two results are then jointly applied to the problem of optimizing complex object selections, which is much more complicated than in classical relational databases

Towards a type theory for active objects

Abstract: A key property of object-oriented languages is that they promote software reuse through inter-changeability or plug compatibility of software components that conform to the same message-passing interface. A characterization of such an interface is a type, and can be viewed as a constraint on the behaviour of an object. An object that conforms to the type meets the constraint. A subtype, in this view, is simply a stronger constraint: all objects that conform to a subtype also conform to the supertype. The nature of these constraints may vary, however, as may the rules for determining when one type is a subtype of another. The choice of characterization will depend on the computational model of a particular language and the way in which objects interact. We seek to develop a notion of type that will serve to characterize concurrent, active objects whose behaviour may not conform to a strict client/server model of interaction and communication.

Structured analysis and object-oriented design are compatible

Abstract: Some form or other of object-oriented design has become common, even standard, for the design of Ada programs. Some form or other of structured analysis is and has long been standard for the specification of software requirements. Recent discussions in the software development community advocate object-oriented analysis as being preferable to structured analysis, especially for Ada software development; such discussions further assert that structured analysis and object-oriented design are incompatible. Others have argued for the effectiveness of combined use of the two methods. The topic has become controversial.It is the thesis of this paper that structured analysis is a desirable way to specify software requirements, and that structured analysis and object-oriented design are compatible and work effectively together.

Roles: A Methodology for Representing Multifaceted Objects

Abstract: Most of the efforts in the object modeling arena have concentrated on modeling object structure and behavior, with the behavior of objects being delimited by static schema definitions Although very little has been accomplished in modeling object dynamics, it is widely accepted that the pattern of object interaction is not static, but evolves to adapt to environmental requirements and changes In this paper we argue in favor of a model for representing object dynamics whereby objects may be represented from diverse, distinct ontological perspectives with each perspective describing different states of an object within the same application domain

Preserving and generating objects in the LIVING IN A LATTICE rule language

Abstract: LIVING IN A LATTICE is presented as a rule-based query language for an object-oriented database model. The model supports complex objects, object identity, and is-a-relationships. The instances are described by object relations, which are functions from a set of objects to value sets and other object sets. The rule language is based on object-terms which provide an access to objects via is-a-relationships. Rules are divided into two classes: object-preserving rules manipulating existing objects and object-generating ones creating objects with properties derived from existing objects. The derived object sets are included in a lattice of object types. Some conditions are given under which the instances of the rule's heads are consistent, i.e., where the properties of the derived objects are functionally determined by the objects. >

An object-oriented rule-based approach to the dynamic modelling of information systems

Abstract: The problems inherent in the task of developing and maintaining large scale information systems have received wide coverage. The essential problem with these systems is their inflexibility to change, compounded by the fact that most contemporary software processes fail to adequately address the specific problem of system evolution. This paper argues that the development of information systems requires the adoption of a new paradigm which recognises the explicit separation of organisational policy from programming code. To this end the paper discusses a rule-based model which is used for the specification of all control aspects of an information system. The definition of this model is achieved within a framework which is based on an object-oriented approach. This framework requires the definition of objects on the basis of a binary relationship model and the identification of operations on these objects. The invocation of these operations is handled by the rule-model. Rules pertaining to the behaviour aspects of an object class may be viewed in terms of a network graphical notation. Such a network can be used for the dual purpose of factoring a rule-base as well as animating the behaviour of each object class.

A note on type composition and reusability

Abstract: With the increasing use of object-oriented approaches to the development of libraries of reusable software components, it is useful to look at various type constructions that affect the reusability of objects Though many people equate reusability with inheritance, another important form of reusability is the composition of one object from other objects This paper looks at several common ways of organizing objects and how these organizations can reduce the reusability of the object definitions