Showing papers on "Object (computer science) published in 1987"

Representation of collaborative multi-user activities relative to shared structured data objects in a networked workstation environment

Abstract: A multi-user collaborative system in which the contents as well as the current status of other user activity of a shared structured data object representing one or more related structured data objects in the form of data entries can be concurrently accessed by different users respectively at different workstations connected to a common link. The WYSIWIS user interface representation of the shared structured data object includes an ordered listing of such entries that are maintained by the structured data object and various attributes of each listed entry, inter alia, the type and class of entry; the revision number of the shared structured data object; the number of pages and revision number of each structured data object entry; the date of creation and last revision of each such entry; whether an entry can be accessed by a user and, if not, who has prevented such access to prevent concurrent editing; whether a local instance of an entry is present on a user's system; and a provision for miscellaneous notes or comments relative to each entry for view by other users. Means is provided for maintaining current information relative to the shared structured object and its entries on a user initiated demand updated basis invoked by a user operation, which operation requires updated information to properly implement the operation.

Data model issues for object-oriented applications

Abstract: Presented in this paper is the data model for ORION, a prototype database system that adds persistence and sharability to objects created and manipulated in object-oriented applications. The ORION data model consolidates and modifies a number of major concepts found in many object-oriented systems, such as objects, classes, class lattice, methods, and inheritance. These concepts are reviewed and three major enhancements to the conventional object-oriented data model, namely, schema evolution, composite objects, and versions, are elaborated upon. Schema evolution is the ability to dynamically make changes to the class definitions and the structure of the class lattice. Composite objects are recursive collections of exclusive components that are treated as units of storage, retrieval, and integrity enforcement. Versions are variations of the same object that are related by the history of their derivation. These enhancements are strongly motivated by the data management requirements of the ORION applications from the domains of artificial intelligence, computer-aided design and manufacturing, and office information systems with multimedia documents.

Dimensions of object-based language design

Abstract: The design space of object-based languages is characterized in terms of objects, classes, inheritance, data abstraction, strong typing, concurrency, and persistence. Language classes (paradigms) associated with interesting subsets of these features are identified and language design issues for selected paradigms are examined. Orthogonal dimensions that span the object-oriented design space are related to non-orthogonal features of real languages. The self-referential application of object-oriented methodology to the development of object-based language paradigms is demonstrated.Delegation is defined as a generalization of inheritance and design alternatives such as non-strict, multiple, and abstract inheritance are considered. Actors and prototypes are presented as examples of classless (delegation based) languages. Processes are classified by their degree of internal concurrency. The potential inconsistency of object-oriented sharing and distributed autonomy is discussed, suggesting that compromises between sharing and autonomy will be necessary in designing strongly typed object-oriented distributed database languages.

Distrbution and Abstract Types in Emerald

Abstract: Emerald is an object-based language for programming distributed subsystems and applications. Its novel features include 1) a single object model that is used both for programming in the small and in the large, 2) support for abstract types, and 3) an explicit notion of object location and mobility. This paper outlines the goals of Em-erald, relates Emerald to previous work, and describes its type system and distribution support. We are currently constructing a prototype implementation of Emerald.

Combining language and database advances in an object-oriented development environment

Abstract: Object-oriented languages generally lack support for persistent objects—that is objects that survive the process or programming session. On the other hand, database systems lack the expressibility of object-oriented languages. Both persistence and expressibility are necessary for production application development.This paper presents a brief overview of VBASE, an object-oriented development environment that combines a procedural object language and persistent objects into one integrated system. Language aspects of VBASE include strong datatyping, a block structured schema definition language, and parameterization, or the ability to type members of aggregate objects. Database aspects include system support for one-to-one, one-to-many, and many-to-many relationships between objects, an inverse mechanism, user control of object clustering in storage for space and retrieval efficiency, and support for trigger methods.Unique aspects of the system are its mechanisms for custom implementations of storage allocation and access methods of properties and types, and free operations, that is operations that are not dispatched according to any defined type.During the last several years, both languages and database systems have begun to incorporate object features. There are now many object-oriented programming languages. [Gol1983, Tes1985, Mey 1987, Cox 1986, Str 1986]. Object-oriented database management systems are not as prevalent yet, and sometimes tend to use different terms (Entity-Relationship, Semantic Data Model), but they are beginning to appear on the horizon [Cat1983, Cop1984, Ston1986, Mylo1980]. However, we are not aware of any system which combines both language and database features in a single object-oriented development platform. This is essential since a system must provide both complex data management and advanced programming language features if it is to be used to develop significant production software systems. Providing only one or the other is somewhat akin to providing half a bridge: it might be made structurally sound, perhaps, but it is not particularly useful to one interested in getting across the river safely.Object-oriented languages have been available for many years. The productivity increases achievable through the use of such languages are well recognized. However, few serious applications have been developed using them. One reason has been performance, though this drawback is being eliminated through the development of compiled object languages. The remaining major negative factor, in our view, is the lack of support for persistence; the lack of objects that survive the processing session and provide object sharing among multiple users of an application.Database management systems, in contrast, suffer from precisely the opposite problem. While having excellent facilities for managing large amounts of data stored on mass media, they generally support only limited expression capabilities, and no structuring facilities.Both language and database systems usually solve this problem by providing bridges between the systems. Thus the proliferation of 'embedded languages', allowing language systems to access database managers. These bridges are usually awkward, and still provide only restricted functionality. Both performance and safety can be enhanced through a tighter coupling between the data management and programming language facilities.It is this lack of a truly integrated system which provided our inspiration at Ontologic, Inc. This paper reviews Ontologic's VBASE Integrated Object System and describes how it combines language and database functionality.

PAC, an Object Oriented Model for Dialog Design

Abstract: PAC is an implementation model that attempts to bridge the gap between the abstract sphere of theoretical models and the practical affairs of building user interfaces. It takes as a basis the vertical decomposition of human-computer interaction into semantic, syntactic and pragmatic layers as promoted by some theoretical models. However, PAC stresses the fact that these notions do not form strict monolithic layers but are distributed across related “chunks”, called interactive objects. For doing so, PAC recursively structures an interactive application in three parts: the Presentation, the Abstraction and the Control. The Presentation defines the the concrete syntax of the application whereas the Abstraction corresponds to the semantics. The Control maintains the mapping and the consistency between the abstract entities and their presentation to the user. The Presentation of an application is in turn decomposed into a set of interactive objects, entities specialized in man-machine communication. As for applications, an interactive object is organized according to the PAC model. PAC has been used for the construction of two interactive applications and is currently applied to the development of a User Interface Management System.

Generating an interpretation tree from a CAD model for 3D-object recognition in bin-picking tasks

Abstract: This article describes a method to generate 3D-object recognition algorithms from a geometrical model for bin-picking tasks. Given a 3D solid model of an object, we first generate apparent shapes of an object under various viewer directions. Those apparent shapes are then classified into groups (representative attitudes) based on dominant visible faces and other features. Based on the grouping, recognition algorithms are generated in the form of an interpretation tree. The interpretation tree consists of two parts: the first part for classifying a target region in an image into one of the shape groups, and the second part for determining the precise attitude of the object within that group. We have developed a set of rules to find out what appropriate features are to be used in what order to generate an efficient and reliable interpretation tree. Features used in the interpretation tree include inertia of a region, relationship to the neighboring regions, position and orientation of edges, and extended Gaussian images. This method has been applied in a task for bin-picking objects that include both planar and cylindrical surfaces. As sensory data, we have used surface orientations from photometric stereo, depth from binocular stereo using oriented-region matching, and edges from an intensity image.

Three dimensional object representation revisited

Abstract: Categories and shape prototypes are considered for a class ob object recognition problems where rigid and detailed object models are not available or do not apply. We propose a modeling system for generic objects to recognize different objects from the same category with only one generic model. We base our design of the modeling system upon the current psychological theories of categorization and human visual perception. The representation consists of a prototype represented by parts and their configuration. Parts are modeled by superquadric volumetric primitives which can be combined via Boolean operations to form objects. Variations between objects within a category are described by changes in structure and shape deformations of prototypical parts. Recovery of deformed supequadric models from sparse 3-D points is developed and some results are shown.

FAD, a Powerful and Simple Database Language

Abstract: FAD is a powerful and simple language designed for a highly parallel database machine The basic concepts of the language are its data structures (which we call objects) and its programs (defined in terms of operators and predicates) The primary features of the language are (i) the support of complex objects with built-in notion of object identity; (ii) an abstract data type capability; (iii) a persistent object space; and (iv) the efficient support of iteration, conditionals, and set operations FAD is functional and uses low level operators and operator constructors This provides for the opportunity of dataflow execution in a parallel architecture FAD has been successfully implemented in (i) an interpreter working on a main memory database and (ii) integrated in a prototype of a database machine

Special purpose automatic programming for 3D model-based vision

Abstract: A method for the automatic construction of fast special purpose vision programs is described. The starting point for the automatic construction process is a description of a particular 3D object. The result is a fast special purpose program for recognizing and locating that object in images, without restriction on the orientation of the object in space. The method has been implemented and tested on a variety of images with good results. Some of the tests involved images in which the target objects appear in a jumbled pile. The current implementation is not fully optimized for speed. However, evidence is given that image analysis times on the order of a second or less can be obtained for typical industrial recognition tasks. (This time estimate excludes edge finding).

Metaclasses are first class: The ObjVlisp Model

Abstract: This paper shows how an attempt at a uniform and reflective definition resulted in an open-ended system supporting ObjVlisp, which we use to simulate object-oriented language extensions.We propose to unify Smalltalk classes and their terminal instances. This unification allows us to treat a class as a “first class citizen”, to give a circular definition of the first metaclass, to access to the metaclass level and finally to control the instantiation link. Because each object is an instance of another one and because a metaclass is a real class inheriting from another one, the metaclass links can be created indefinitely.This uniformity allows us to define the class variables at the metalevel thus suppressing the Smalltalk-80 ambiguity between class variables and instance variables: in our model the instance variables of a class are the class variables of its instances.

The Common Lisp object system: an overview

Abstract: The Common Lisp Object System is an object-oriented system that is based on the concepts of generic functions, multiple inheritance, and method combination. All objects in the Object System are instances of classes that form an extension to the Common Lisp type system. The Common Lisp Object System is based on a meta-object protocol that renders it possible to alter the fundamental structure of the Object System itself. The Common Lisp Object System has been proposed as a standard for ANSI Common Lisp and has been tentatively endorsed by X3J13.

Memory for Object Locations in Young and Elderly Adults

Abstract: The spatial memory of elderly and young adults was compared in two conditions: one in which common objects were displayed on a map, and one in which the objects were displayed in an actual environment (a large room) represented by the map. In the map condition, elderly adults had lower spatial memory scores than did young adults. In the room condition, however, the performance of elderly adults was not different from that of young adults. It was hypothesized that differences in the visual distinctiveness of the two contexts, map and room, were responsible for the interaction of age and task setting. An experiment using models of the map-room structures, models that differed in the visual distinctiveness of their components, confirmed this hypothesis.

Multimedia Information Management in an Object-Oriented Database System

Abstract: This paper describes the implementation of the Multimedia Information Manager (MIM) in the ORION object-oriented da- tabase system which is operational at MCC We describe design objectives and implementation techniques that have satisfied the design objectives Our design objectives in- clude extensibility, flexibility and efficiency in supporting the capture, storage, and presentation of many types of multi- media information We have achieved extensibility by providing an object-ori- ented framework for multimedia information management The framework consists of definitions of class hierarchies and a message passing protocol for not only the multimedia capture, storage, and presentation devices, but also the captured and stored multimedia objects Both the class hier- archies and the protocol may be easily extended and/or modified by system developers and end users as they see fit We have satisfied flexibility by supporting a variety of ways in which the end users may control the capture and presentation of multimedia information Our implementation has achieved storage efficiency by using a technique for sharing storage blocks among multiple versions of a multi- media object, while achieving data transfer performance by directly interfacing the MIM to certain low level components of the ORION storage subsystem

Active objects in hybrid

Abstract: Most object-oriented languages are strong on reusability or on strong-typing, but weak on concurrency. In response to this gap, we are developing Hybrid, an object-oriented language in which objects are the active entities. Objects in Hybrid are organized into domains, and concurrent executions into activities. All object communications are based on remote procedure-calls. Unstructured sends and accepts are forbidden. To this the mechanisms of delegation and delay queues are added to enable switching and triggering of activities. Concurrent subactivities and atomic actions provided for compactness and simplicity. We show how solutions to many important concurrent problems, such a pipelining, constraint management and “administration” can be compactly expressed using these mechanisms.

The historical relational data model (HRDM) and algebra based on lifespans

Abstract: Critical to the design of an historical database model is the representation of the “existence” of objects across the temporal dimension — for example, the “birth,” “death,” or “rebirth” of an individual, or the establishment or dis-establishment of a relationship. The notion of the “lifespan” of a database object is proposed as a simple framework for expressing these concepts. An object's lifespan is simply those periods of time during which the database models the properties of that object. In this paper we propose the historical relational data model (HRDM) and algebra that is based upon lifespans and that views the values of all attributes as functions from time points to simple domains. The model that we obtain is a consistent extension of the relational data model, and provides a simple mechanism for providing both time-varying data and time-varying schemes.

A categorical programming language

Abstract: A theory of data types based on category theory is presented. We organize data types under a new categorical notion of F,G-dialgebras which is an extension of the notion of adjunctions as well as that of T-algebras. T-algebras are also used in domain theory, but while domain theory needs some primitive data types, like products, to start with, we do not need any. Products, coproducts and exponentiations (i.e. function spaces) are defined exactly like in category theory using adjunctions. F,G-dialgebras also enable us to define the natural number object, the object for finite lists and other familiar data types in programming. Furthermore, their symmetry allows us to have the dual of the natural number object and the object for infinite lists (or lazy lists). We also introduce a programming language in a categorical style using F,G-dialgebras as its data type declaration mechanism. We define the meaning of the language operationally and prove that any program terminates using Tait's computability method.

Obstacle avoidance system.

Abstract: A system for avoiding obstacles in the path of a vehicle including a sensor assembly (24) having a field of view (575) with a plurality of sectors (576, 578, 580) for detecting the distance of objects within each sector. The system further includes an element (528) for identifying obstructed sectors in which objects are detected within a predetermined range and selects an unobstructed sector close in alignment to the direction of the path to designate around the object a clear path which is close to the original path.

Expert system with three classes of rules

Abstract: EXPERT SYSTEM WITH THREE CLASSES OF RULES ABSTRACT An expert system wherein the rules are of three classes: 1) retrieval rules, which each associate one of several attributes to an object in accordance with the values of inputs; 2) analysis rules, which selectively associate an attribute with an object, and which are somewhat analogous to the natural-language inference rules which would be used in communications between domain experts; and 3) action rules, which selectively carry out the output and control actuation options, based on the attributes associated with objects by the other rules. Preferably only the action rules can enable execution of an external command procedure. Preferably each of each of the action rules requires no logical operations other than a test for association between an attribute and an object. Preferably none of the action rules can associate an attribute with an object. Preferably only the retrieval rules include numeric operations.

Combinatorial data analysis : optimization by dynamic programming

Abstract: Preface 1 Introduction 2 General Dynamic Programming Paradigm 3 Cluster Analysis 4 Object Sequencing and Seriation 5 Heuristic Applications of the GDPP 6 Extensions and Generalizations Appendix: Available Programs Bibliography Author Index Subject Index

System and method for generating an object module in a first format and then converting the first format into a format which is loadable into a selected computer

Abstract: A system for generating program object modules or decks of object code for selected computing systems is provided. The object module is generated from a conventional source program. The system has a compiler for generating an object module from the source program which module has the necessary instructions for executing the desired program in the selected computing system but these instructions are arranged in a first format which is not loadable or readable into the selected computing system. The present system has a converter for converting this first instruction format into a second instruction format which is loadable into the selected computing system. The present system is particularly advantageous when the instructions in the first format are arranged in an order unrelated to the function of the instructions in the object module while the instructions in the second or converted format are arranged in a plurality of sections, each of the sections containing instructions performing a related function in the program of the object module.

Reconfigurable computing device

Abstract: The invention pertains mainly to a reconfigurable computing device. The main object of the invention is a computer comprising redundant elements. The computer according to the present invention can function when there is a failure of one of the elements that constitute it. In this case, the redundant element takes the place of the malfunctioning element. Should the computer according to the present invention be in a critical stage, i.e. a situation where any interruption in computation would have serious consequences, the reconfiguring of the system is postponed to a later instant corresponding to the end of the critical stage. The invention applies mainly to the performing of digital computations.

Using Types and Inheritance in Object-Oriented Programming

Abstract: To be a good object-oriented programmer, you should use types and inheritance wisely. ThiS tutorial will help you do so.

EMERALD: An object-based language for distributed programming

Abstract: Distributed systems have become more common, however constructing distributed applications remains a very difficult task. Numerous operating systems and programming languages have been proposed that attempt to simplify the programming of distributed applications. We present a programming language called Emerald that simplifies distributed programming by extending the concepts of object-based languages to the distributed environment. Emerald supports a single model of computation: the object. Emerald objects include private entities such as integers and Booleans, as well as shared, distributed entities such as compilers, directories, and entire file systems. Emerald objects may move between machines in the system, but object invocation is location independent. The uniform semantic model used for describing all Emerald objects makes the construction of distributed applications in Emerald much simpler than in systems where the differences in implementation between local and remote entities are visible in the language semantics. Emerald incorporates a type system that deals only with the specification of objects--ignoring differences in implementation. Thus two different implementations of the same abstraction may be freely mixed in an Emerald program. Emerald has been implemented. The compiler accepts the responsibility of providing an efficient implementation from object definitions, generating multiple implementations tuned to different usage patterns from the same source code. We discuss these implementation considerations and provide performance data to justify our claim that Emerald can be efficiently implemented.

CAD-Based 3D Object Representation for Robot Vision

Abstract: This article explains that most existing vision systems rely on models generated in an ad hoc manner and have no explicit relation to the CAD/CAM system originally used to design and manufacture these objects. The authors desire a more unified system that allows vision models to be automatically generated from an existing CAD database. A CAD system contains an interactive design interface, graphic display utilities, model analysis tools, automatic manufacturing interfaces, etc. Although it is a suitable environment for design purposes, its representations and the models it generates do not contain all the features that are important in robot vision applications. In this article, the authors propose a CAD-based approach for building representations and models that can be used in diverse applications involving 3D object recognition and manipulation. There are two main steps in using this approach. First, they design the object's geometry using a CAD system, or extract its CAD model from the existing database if it has already been modeled. Second, they develop representations from the CAD model and construct features possibly by combining multiple representations that are crucial in 3D object recognition and manipulation.

An Object Modelling Technique for Conceptual Design

Abstract: Our Object Modeling Technique is a software engineering technique for collecting and representing information about requirements and designs. It enforces the object-oriented notions of modularity, separation of implementation details from external behavior, and abstract data types. We have successfully applied the Object Modeling Technique to support conceptual design, followed by implementation using both conventional programming languages and an object-oriented language.

Method and apparatus for assisting layout design

Abstract: A layout design assisting system operates in the following steps. A drawing of a layout area for installing a plurality of layout objects is displayed on a display unit. The operator specifies one of the displayed layout objects. Another layout object which interferes with the specified layout object is found in the layout area. An economical loss imposed on the specified layout object attributable to the other layout object is evaluated. Examination is conducted as to whether or not the other layout object can be relocated so that it does not interfere with the specified layout object. The specified layout object, the other layout object, the economical loss and the examination result are displayed on the display unit.