Search

Ada95 is an object-oriented concurrent programming language. PDEFA is a distributed Ada95 system. In PDEFA, task and protected objects in Ada95 are turned into independent and service objects respectively, and run under the control of a daemon program. Independent and service objects in PDEFA are called parallel objects. An independent object performs operations of its own, while a service object provides service to other parallel objects. A daemon manages all parallel objects and regulates their creation and termination.

Proposes a recognition method by which 3D information of overlapped objects can be constructed, taking into account the fuzzy quantities of linearity and roundedness of image data. The recognition approach was based on grey-level image processing as well as color and binary image processing. Grey-level image data were used for classifying the image patterns into the specific candidate group. Then the other data are obtained by changing the attitude of the objects slightly, so that the 3D image data can be reconstructed for pattern recognition and understanding. An expert system for the pattern recognition and the understanding of objects is constructed based on a production system. The system gives commands to rotate the objects in a certain direction to increase the image information about the objects until they can be identified. >

Object-stacking is a model for structuring object-based systems and a mechanism for integrating multiple servers. The paper describes the object-stacking model and the structure of a distributed operating system based on this model. In object-stacking, objects are classified into stackable objects and bottom objects. These objects have uniform interfaces. Each stackable objects holds the identifiers of other stackable objects or bottom objects as lower objects. Functions of stackable objects are implemented by calling their lower objects. Bottom objects are provided by the system. Complex objects are created by stacking those objects. In object-stacking, each server provides a single high-level service, such as filtering, caching, masking, or grouping. These servers can be used together by stacking their objects. >

Objects are widely used to build distributed applications, since they provide a clean interface which may be used in handling remote communications between a client and a server. However there is still an open issue whether large objects and small objects should be handled in the same way from both the language and system points of view. The most widely supported view is the client/server model in which large objects (usually the remote server objects) are distinguished from small local objects used inside a server object. In this approach distribution is associated only to server objects bet not to local objects We believe that there actually exist at least two granularities of objects, but they should not be differentiated by the distribution property. Programming in the small and programming in the large are well known in centralized programming models, and define fine-grained passive entities to build and structure coarse-grained active applications. Distribution is an orthogonal property which may be applied to both types of objects. This results in defining fine-grained passive objects, which may be distributed as in the blackboard approach, used to build coarse-grained active objects or servers, which in turn may communicate using the client/server model. >

An object-oriented model is proposed, designed as a collection of layered components, for process-sensitive software engineering environments (PSEEs). In the model, three types of object (process objects, entity objects and service objects) are identified to abstract and reflect the behaviour in different aspects of a PSEE. An overview of object interaction patterns, which reflects and captures the relationships between these types of object, is presented. To support software development process distribution and concurrency effectively, we introduce the actor (concurrent object) concept into process objects and entity objects, which allows transparent message passing between objects without concern for location and synchronisation. >

In traditional computer-based message systems, messages are typically viewed as passive entities with no processing power. The users are thus responsible for explicitly creating, routing and processing each message instance. Messages, though, may be viewed as objects which can do processing on their own. With increasing interest in object-based systems, it is not difficult to envisage a system in which messages are viewed as objects with processing capabilities comparable to the objects in object-based systems. This paper explores the concept of 'messages as objects' and speculates on the significance and advantage of viewing messages as objects. Research issues in formal definition of an object-based message management system are discussed. >

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

The classical object model supports private data within objects and clean interfaces among objects, and by definition does not permit sharing of data among arbitrary objects. This is a problem for certain real-world applications, where the same data logically belongs 10 multiple objects and may be distributed over multiple nodes on the network. Rather than give up the advantages of encapsulated objects in modeling real-world entities, we propose a new object model that supports shared data in a distributed environment. The key is separating distribution of computation units from information hiding concerns. We introduce our new object model, describe a motivating example from the financial services domain, and then present a new language, PROFIT, based on the model.

This chapter deals with US and international regulatory framework that serves as the legal motivation to support for the safety culture by all members of the chain of responsibility for the oil spill industry. The chapter also discusses the important US and international regulatory framework that serves as the legal motivation for support for the safety culture by all members of the chain of responsibility for the oil spill industry. Oil spills are serious business in the International and US, and equate to real costs for companies sued for oil pollution. Internationally, various courts have entered a series of fines and imprisonments for environmental offenders, including criminal proceedings against senior harbor managers and the port authority. Two types of shipping states control ship owners and their vessels are Flag State and Port State. Training of employees from the mate to the master is the best way to ensure environmental compliance. Outside consultants can help the organization's officers and employees to gain the knowledge and understanding needed to institute a safety management system.

This chapter emphasizes the solution for oil spills, as it is no longer considered an unavoidable “accident” of environmental conditions or a function of a catastrophic event. With the implementation of the entry into force of the International Safety Management Code, amendments to the International Convention on Standards of Training, Certification and Watchkeeping for Seafarers, and amendments to SOLAS and to the International Convention for the Prevention of Pollution from Ships have reduced oil spills. The Prevention Through People (PTP) program developed a systems approach to deal with the entirety of a safe operating system and the influence of all participants and stakeholders. These include governmental agencies, regulatory bodies, industry management, crew, classification societies, and all others in the chain of responsibility. The US Coast Guard developed five goals, as a frame of reference for organizing specific objectives and activities to be implemented by subsequent industry plans. The polluter pays principle translates into four primary concerns—who pays, for what, who responds, and with what system of response. Clean-up measures should use techniques designed to minimize harms to the environment and the value of these resources to humans.

This chapter will consider the design of embedded and real-time control systems. It covers: Reactive control system concepts. Decomposition of controllers: horizontal, hierarchical (chain of responsibility pattern) and phase (state pattern) decompositions. Architectures for fault-tolerance and scheduling. Implementation of controllers as input device/output device coordination contracts.

Despite all the attention to Big Data and the claims that it represents a “paradigm shift” in science, we lack understanding about what are the qualities of Big Data that may contribute to this revolutionary impact. In this paper, we look beyond the quantitative aspects of Big Data (i.e. lots of data) and examine it from a sociotechnical perspective. We argue that a key factor that distinguishes “Big Data” from “lots of data” lies in changes to the traditional, well-established “control zones” that facilitated clear provenance of scientific data, thereby ensuring data integrity and providing the foundation for credible science. The breakdown of these control zones is a consequence of the manner in which our network technology and culture enable and encourage open, anonymous sharing of information, participation regardless of expertise, and collaboration across geographic, disciplinary, and institutional barriers. We are left with the conundrum—how to reap the benefits of Big Data while re-creating a trust fabric and an accountable chain of responsibility that make credible science possible.

We present a general approach for modeling temporal aspects of objects in a logic programming framework. Change is formulated in the context of a database which stores explicitly a record of all changes that have occurred to objects and thus (implicitly) all states of objects in the database. A snapshot of the database at any given time is an object-oriented database, in the sense that it supports an object-based data model. An object is viewed as a collection of simple atomic formulas, with support for an explicit notion of object identity, classes and inheritance. The event calculus is a treatment of time and change in first-order classical logic augmented with negation as failure. The paper develops a variant of the event calculus for representing changes to objects, including change in internal state of objects, creation and deletion of objects, and mutation of objects over time. The concluding sections present two natural and straightforward extensions, to deal with versioning of objects and schema evolution, and a sketch of implementation strategies for practical application to temporal object-oriented databases. ©1996 IEEE.

Publisher Summary This chapter discusses the multipartite arrangements related to contracting. The first part of the chapter examines some of the different types of arrangement and relationships that may be made in the course of engineering and other commercial contracts. The structure and nature of relationships are of great importance because it tells us about various things. These are the allocation of obligations, the level at which obligations are carried out, the chain of instructions, communications, who bears what liability, and to whom liabilities and duties are owed. The most common structure of an engineering contract is one in which responsibilities and liabilities flow down in a chain from the employer to the contractor, and from the contractor to sub-contractors, and so on. The chain of responsibility plays an essential role in contracts. The legal point about it is that the main contractor remains fully responsible to the employer, and cannot step aside or refuse to accept liability. However, it should be borne in mind that such chains can be broken. The chapter deals with this topic as well. A major part of the chapter discusses various legal questions related to multipartite arrangements and detailed answers are provided for these.

The paper describes the SysMan approach to interactive configuration management of distributed software components (objects). Domains are used to group objects to apply policy and for convenient naming of objects. Configuration Management involves using a domain browser to locate relevant objects within the domain service; creating new objects which form a distributed service; allocating these objects to physical nodes in the system and binding the interfaces of the objects to each other and to existing services. Dynamic reconfiguration of the objects forming a service can be accomplished using this tool. Authorisation policies specify which domains are accessible by which managers and which interfaces can be bound together.

Objects model phenomena and a phenomenon is usually a component. Information characterizing a component is encapsulated and accessible only by its methods. The relations between components are modeled explicitly by means of associations or references. A relation is also a phenomenon and objects can model this type of phenomena too. Components are usually related conceptually in diverse and subtle ways: Some relations are implicitly given and some are local to other more basic relations. Such kinds of relations are important for understanding the organization and cooperation of objects and may be supported in object-oriented analysis, design, and programming: An implicit association describes a relation between an object and objects local to this enclosing object, and a complex association describes an explicit relation between local objects in different enclosing objects. Such associations are described by classes and the objects have the usual properties including methods and attributes.

The notion of location of part objects is introduced, yielding a reference to the containing object. Combined with locally defined objects and classes (block structure), singularly defined part objects, and references to part objects, it is a powerful language mechanism for defining objects with different aspects or roles. The use of part objects for inheritance of code is also explored.

This paper gives semantic foundations of (correct) implementation as a relationship between an "abstract" object and a community of "base" objects. In our aproach, an object is an "observed process". Objects and object morphisms constitute a category OB in which colimits reflect object aggregation and interaction between objects. Our concept of implementation allows for composition, i.e. by composing any number of (correct) implementation steps, a (correct) entire implementation is obtained. We study two specific kinds of implementation, extension and encapsulation, in more detail and investigate their close relationship to object morphisms. Our main technical result is a normal form theorem saying that any regular implementation, i.e. one composed of any number of extensions and encapsulations, in any order, can be done in just two steps: first an extension, and then an encapsulation.

A computer based method for performing a command via a voice user interface on a subset of objects. The subset is selected from a set of objects, each having an object type. At least one taggable field is associated with the object type and has a corresponding value. The set of objects is stored in the computer memory. An utterance is received from the user and includes a command, an object type selection, a taggable field selection, and a value for the taggable field. Responsive to the utterance, at least one object is retrieved from the set of objects, the object of the type selected by the user and having a value in the taggable field selection that matches the taggable field value received from the user. The command is performed on the object. The object consists of text which is converted to voice output.

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

The Rete Match Algorithm is an efficient method for companng a large collection of patterns to a large collection of objects. It finds all the objects that match each pattern The algorithm was developed for use in production system interpreters, and it has been used for systems containing from a few hundred to more than a thousand patterns and objects. This article presents the algorithm in detail It explains the basic concepts of the algorithm, it describes pattern and object representations that are appropriate for the algorithm, and it describes the operations performed by the pattern matcher.

In object-oriented systems, an object may recursively reference any number of other objects. The references, however, do not capture any special relationships between objects. An important semantic relationship which may be superimposed on a reference is the IS-PART-OF relationship between a pair of objects. A set of objects related by the IS-PART-OF relationship is collectively called a composite object. An earlier paper [KIM87b] presented a model of composite objects which has been implemented in the ORION object-oriented database system at MCC. Although the composite-object feature has been found quite useful, the model suffers from a number of serious shortcomings, primarily because it overloads a number of orthogonal semantics on the references. In this paper, first we present a more general model of composite objects which does not suffer from these shortcomings. Further, [KIM87b] made an important contribution by exploring the use of composite objects as a unit for versions, physical clustering, and concurrency control. The extended model of composite objects necessitates non-trivial changes to the results of [KIM87b]. This paper describes the new results on the use of composite objects as a unit of not only versions, physical clustering and concurrency control, but also authorization.

A vision machine must locate possible objects before it can identify them. In simple images, where the objects and illumination are known, locating possible objects can be part of, and secondary to, identification. In complex, natural images it is more efficient to use a quick and simple method to locate possible objects first, and then to selectively identify them. This parallels the strategy normally used by the human visual system. We present a theory for how possible objects, called "blobs", will be represented in an image, and explore some measures of importance for these candidate objects. An example algorithm based on this theory can quickly generate a list of possible object locations for the identification computation. We discuss the implementation of this example algorithm on a standard image processing system.

Our objective is to have a logical framework for natural representation and manipulation of complex objects. We start with an analysis of semantic modeling of complex objects, and attempt to understand what are the fundamental aspects which need to be captured. A logic, called C-logic, is then presented which provides direct support for what we believe to be basic features of complex objects, including object identity, multi-valued labels and a dynamic notion of types. C-logic has a simple first-order semantics, but it also allows natural specification of complex objects and gives us a framework for exploring efficient logic deduction over complex objects.

The development of PRADIS was started in early 1968 as a vehicle to implement and evaluate new schemes of man-machine-interaction, data base organization, and hidden-line detection which were being developed in our laboratory. With time it evolved into a rather elaborate programming system for generation, construction, manipulation, and perspective display of arbitrary three-dimensional objects. All relevant object types such as polyhedrons or groups of polyhedrons with convex or concave structure, objects that are described by analytical expression, as well as the most general case of objects that are bounded by arbitrarily curved surfaces can be handled. Different modes of defining and inputting objects and different-hidden-line suppression algorithms have been individually developed and implemented for these various types. Man-machine-communication has been facilitated by defining a simple command language for the user. The execution of any command can be initiated by pointing to the respective instruction in a command menu. Additionally, a keyboard (or the console typewriter) can be used for specification of parameters or the description of objects by analytical equations. Subroutines for scaling, translation, and rotation are part of the system as well as program modules which enable the user to construct three-dimensional objects by drawing two-dimensional views of them.