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

Object-oriented development

Abstract: Object-oriented development is a partial-lifecycle software development method in which the decomposition of a system is based upon the concept of an object. This method is fundamentally different from traditional functional approaches to design and serves to help manage the complexity of massive software-intensive systems. The author examines the process of object-oriented development as well as the influences upon this approach from advances in abstraction mechanisms, programming languages, and hardware. The concept of an object is central to object-oriented development and so the properties of an object are discussed. The mapping of object-oriented techniques to Ada using a design case study is considered.

On multiple moving objects

Abstract: This paper explores the motion planning problem for multiple moving objects. The approach taken consists of assigning priorities to the objects, then planning motions one object at a time. For each moving object, the planner constructs a configuration space-time that represents the time-varying constraints imposed on the moving object by the other moving and stationary objects. The planner represents this space-time approximately, using two-dimensional slices. The space-time is then searched for a collision-free path. The paper demonstrates this approach in two domains. One domain consists of translating planar objects; the other domain consists of two-link planar articulated arms.

Using prototypical objects to implement shared behavior in object-oriented systems

Abstract: A traditional philosophical controversy between representing general concepts as abstract sets or classes and representing concepts as concrete prototypes is reflected in a controversy between two mechanisms for sharing behavior between objects in object oriented programming languages. Inheritance splits the object world into classes, which encode behavior shared among a group of instances, which represent individual members of these sets. The class/instance distinction is not needed if the alternative of using prototypes is adopted. A prototype represents the default behavior for a concept, and new objects can re-use part of the knowledge stored in the prototype by saying how the new object differs from the prototype. The prototype approach seems to hold some advantages for representing default knowledge, and incrementally and dynamically modifying concepts. Delegation is the mechanism for implementing this in object oriented languages. After checking its idiosyncratic behavior, an object can forward a message to prototypes to invoke more general knowledge. Because class objects must be created before their instances can be used, and behavior can only be associated with classes, inheritance fixes the communication patterns between objects at instance creation time. Because any object can be used as a prototype, and any messages can be forwarded at any time, delegation is the more flexible and general of the two techniques.

Program Development in Java: Abstraction, Specification, and Object-Oriented Design

Abstract: From the Publisher: Written by a world-renowned expert on programming methodology, this book shows how to build production-quality programs—programs that are reliable, easy to maintain, and quick to modify. Its emphasis is on modular program construction: how to get the modules right and how to organize a program as a collection of modules. The book presents a methodology effective for either an individual programmer, who may be writing a small program or a single module in a larger one; or a software engineer, who may be part of a team developing a complex program comprised of many modules. Both audiences will acquire a solid foundation for object-oriented program design and component-based software development from this methodology. Because each module in a program corresponds to an abstraction, such as a collection of documents or a routine to search the collection for documents of interest, the book first explains the kinds of abstractions most useful to programmers: procedures; iteration abstractions; and, most critically, data abstractions. Indeed, the author treats data abstraction as the central paradigm in object-oriented program design and implementation. The author also shows, with numerous examples, how to develop informal specifications that define these abstractions—specifications that describe what the modules do—and then discusses how to implement the modules so that they do what they are supposed to do with acceptable performance. Other topics discussed include: Encapsulation and the need for an implementation to provide the behavior defined by the specification Tradeoffs between simplicity and performanceTechniques to help readers of code understand and reason about it, focusing on such properties as rep invariants and abstraction functions Type hierarchy and its use in defining families of related data abstractions Debugging, testing, and requirements analysis Program design as a top-down, iterative process, and design patterns The Java programming language is used for the book's examples. However, the techniques presented are language independent, and an introduction to key Java concepts is included for programmers who may not be familiar with the language.

Recognizing partially visible objects using feature indexed hypotheses

Abstract: A common task in computer vision is to recognize the objects in an image Most computer vision systems do this by matching models for each possible object type in turn, recognizing objects by the best matches This is not ideal, as it does not take advantage of the similarities and differences between the possible object types The computation time also increases linearly with the number of possible objects, which can become a problem if the number is large This paper describes a new recognition method, the feature indexed hypotheses method, which takes advantage of the similarities and differences between object types, and is able to handle cases, where there are a large number of possible object types, in sub-linear computation time A two-dimensional occluded parts recognition system using this method is described

Implementation Techniques of Complex Objects

Abstract: Eflcient support for retrieval and update of complex objects is a unifying requirement of many areas of computing such as business, artificial intelligence, ofice automation, and computer aided design. In this paper, we investigate and analyze a range of alternative techniques for the storage of complex objects. These alternatives vary between the direct storage representation of complex objects and the fully decomposed storage representation of complex objects. Qualitative arguments for each of the strategies are discussed. Analytical results and initial implementation results based on fully decomposed schemes are presented.

A New Synthesis Algorithm for the MIMOLA Software System

Abstract: The MIMOLA software system is a system for the design of digital processors The system includes subsystems for retargetable microcode generation, automatic generation of self-test programs and a synthesis subsystem This paper describes the synthesis part of the system, which accepts a PASCAL-like, high-level program as specification and produces a register transfer structure Because of the complexity of this design process, a set of sub-problems is identified and algorithms for their solution are indicated These algorithms include a flexible statement decomposition, statement scheduling, register assignment, module selection and optimizations of interconnections and instruction word length

Design of a distributed object manager for the Smalltalk-80 system

Abstract: This paper describes the design of a distributed object manager which allows several Smalltalk-80 systems to share objects over a local-area network. This object manager is based on the following principles: location transparency and uniform object naming, unique object representation and use of symbolic links for remote access, possibility of object migration and distributed garbage collection. A version of the object manager has been implemented and is currently being integrated on a two nodes configuration.

An Expert-System Paradigm for Design

Abstract: level designer can become the detailed functional specification needed by a lower level. Within a design abstraction there are usually several possible alternative structures for a particular desired behavior. Each of these may exhibit differing cost performance characteristics and require different refinement and optimization techniques. These structures can be grouped into sets of similar characteristics called desrgn styles. Styles reflect varlous design approaches forced by different design constraints to achieve the same behavlor. A simple example Is the choice of ripple-carry addition versus carry-look-ahead. The ripple-carry adder is appropriate if space is at a higher premium than delay time. As each level is designed, constraints are produced which must be propagated to the designers at the lower levels. These constraints reflect design style declslons, or structural partitions of higher-level design constraints. Style decisions constrain the design styles and strategies of sub-section designers. An example is the decision to use pre-charged carry addition, forcing the use of appropriate implementation components. Structural partitioning refers to the dlvlding of global constraints such as time, power, or area into local constraints on these values. A requirement of 175nS as maximum cycle time makes demands on the critical path of operations in each cycle. As the design is implemented, this puts a partitioning constraint on the design of each functional component. Figure 1 shows the possible allocation of timing constraints in two stages of the design process. In the first case the allocation has simply divided the cycle time among the function units. In the second case (later in the design) a failure report from the multiply design task has forced a different allocation of time between the functional units. Iterative refinement of a design requires continuous performance monitoring relative to the design goals. This model assumes a simple approach similar to ‘Knobs’ and ‘Gauges’. A human operator monitoring a process closes the loop manually by reading the appropriate gauges and making adjustments to the knobs (parameters) controlling the process execution. We apply this same simple approach to controlling the design pro-

A distributed repository for immutable persistent objects

Abstract: Jasmine is an object-oriented system for programming-in-the-large. Jasmine describes software using system model objects. These objects are persistent (they have lifetimes of days or decades) and immutable (since system models act as historical records). This paper describes JStore, a distributed, replicated repository for system model objects. JStore provides robust, transactional, write-once storage.Designs are presented for the serialization, location, and replication of objects. Description procedures serialize objects for network transmission and permanent storage. An expanding ring multicast search algorithm locates saved objects. JStore replicates objects using a lazy replication algorithm built on top of the location mechanism. Decision procedures determine the replication policy used at each storage site.

The Odin system: an object manager for extensible software environments

Abstract: The purpose of a software environment is to support the creation and maintenance of computer software. This support takes the form of a set of computer programs called "software tools," which are used by a programmer to generate and manipulate software and information about software. The use of a software environment can be significantly simplified if the user's attention is focused on the information provided by the environment rather than the tools that create this information. The purpose of an "object manager" is to provide this focus by automating the process of tool invocation. An object manager will respond to a request for a piece of information, or "object", by invoking the minimal number of tools necessary to produce that object. If previously computed objects are automatically stored by the object manager for later re-use, significant improvements in response time can be achieved. In an extensible environment, the kinds of information potentially provided by the environment are easily extended through the addition of new tools that generate and manipulate new kinds of information. The added complexity of an object manager designed to support this extensibility is significant, but the current rapid rate of technological change makes this flexibility essential. In order to demonstrate the feasibility of efficient extensible object management in large software environments, an object manager called the Odin System was designed and implemented based on the results of this research.

A generalized object model

Abstract: Since the introduction of Smalltalk, the object-oriented paradigm has become a popular technique for the organization of data and programs. In this paradigm, objects (collections of data and programs) are organized in a class hierarchy. These classes collect similar objects and serve as a repository for methods (programs) shared by those objects. We present a new simple model of objects that allows multi-dimensional inheritance. Objects, in our model, behave like communicating processes in Hoare’s CSP language, but with a different message-passing mechanism. This leads to a simple formal semantics for objects and inheritance.

The benefits of bottom-up design

Abstract: This paper examines an inconsistency in generic 'top-down' design methods and standards employed in the implementation of reliable software. Many design approaches adopt top-down ordering when defining the structure, interfaces, and processing of a system. However, strict adherence to a top-down sequencing does not permit accurate description of a system's error handling functions. The design of a system's response to errors is becoming critical as the reliability requirements of systems increase. This paper describes how top-down methods such as Object Oriented Design and Structured Design do not adequately address the issues of error handling, and suggests using a bottom-up substep within these methods to eliminate the problem.

An object-oriented framework for modelling design data

Abstract: The conceptual requirements for an object-oriented representation formalism for CAD data are identified, and implemented in terms of DOM, a framework of concrete primtives for design object modelling. DOM provides adaptable, domain-independent mechanisms for the modelling of design objects, with constructs for describing evolution (versions), re-use (instantiation), component structure, dynamic schema extensibility, and multiple views (representations) of design objects.

U$ina Prototynical Obiects to Imolement Shared Behavior in Obiect Oriented Systems

Abstract: A traditional philosophical controversy between representing general concepts as abstract sets or classes and representing concepts as concrete prowrypes is reflected in a controversy between two mechanisms for sharing behavior between objects in object oriented progrJmmtng languages. l,~,~rance ,pUts the object world into c/asses, which encode behavior shared among a group of ins~,,ces, which represem individual membe~ of these sets. The class/instanee distinction is not needed if the alternative of asing prototypes is adopted. A prototype repre~ms the d4au/t behavior for a concept, and new objects can re-use part of the lw~wledge uored in the prototype by saying how the new object diHers from the prototype. The prototype approach seems to hold some advantages for representing default knowledge, and incrementally and dynamically modifying concepts. Delegation is the mechanism for implementing this in object oriented languages. After checking its idiosyncratic behavior, an object can forward a message to prototypes to invoke more general knowledge. Because class objects must be oreaw.d before their instances can be used. arid behavior can only be associar~l with classes, inheritance fixes the communication patterns between objects at instance creation dine. Because any object can be used as a prototype, and any messages can be forwarded at any time, delegation is the tno~ flexible and general of the two techniques.

VLSI Data-Management

Abstract: With the field of Computer Aided Circuit Design moving into the realm of "intelligent systems", the logical representation of design data becomes of the utmost importance. The present paper starts out with showing how the multiview and hierarchical structure of the VLSI design data can explicitely be exploited to increase design efficiency. It soon becomes obvious that a versatile datamodel is needed to represent the structure of the data. We define a semantic datamodel and show how it is applied to produce a useful schema. Finally, we show how an object oriented design data manager is constructed and how it is capable of satisfying the requirements of (interactive) efficiency and of transparent handling of the data at a high level of abstraction.

Object management and sharing in autonomous, distributed databases

Abstract: An important current trend in information management is from a record-based to an object-based orientation. In particular, existing record-oriented database management systems fulfill many of the requirements of traditional database application domains, but they fall short of providing facilities well-suited to applications in office information systems, design engineering databases, and artificial intelligence systems. In an object-oriented system: information units of various modalities, levels of granularity, and levels of abstraction have individual identity; semantic primitives for object classification and inter-relation are explicitly part of the system; and objects can be active as well as passive. The purpose of the research project described here is to devise and experimentally test concepts, techniques and mechanisms to support a distributed object management system, termed the Distributed Personal Knowledge Manager (DPKM). DPKM is an adaptive tool for the non-computer expert; it is intended to allow end-users to define, manipulate, and evolve collections of information. DPKM handles various forms of information/knowledge in an integrated manner; this includes symbolic data, meta-data, derived data (rules), behavioral information (procedures), constraints, and mixed modality information. An individual DPKM also serves as an access port to other (external) information resources. This research specifically focuses on the following issues. an information model to support the integrated specification of various forms of data/knowledge1; an end-user interface providing a layered view of knowledge, multi-media information input and output, and prescriptive user guidance1, 2;an efficient mechanism for internally organizing and evolving DPKM databases3;a multi-level networking/communication mechanism to support inter-DPKM information exchange, sharing, coordination, and access control4, 5. In the approach taken in this research, each data/knowledge base is a logical context (node) in a logical network. Associated with each context is a collection of information objects and mappings. The objects model units of potentially shareable information at different levels of abstraction; these are: symbolic (or atomic) objects, abstract objects, object classifications via enumeration (enumerated sets) or via selection predicate (predicate sets), constraints on inter-object relationships (generic mappings), and behavioral objects (procedures). Mappings specify relations among instances of objects. It is significant to note that information objects classically distinguished in database terms as “schema” and “data” are treated here within a uniform framework. An extensible set of operations supports the manipulation and sharing of objects. An experimental prototype implementation of DPKM is under development, based on an interconnected network of personal workstations and computers. It is intended that the DPKM project will examine applications in a variety of domains, but it will principally focus on the researcher and design engineer for the purposes of initial experimental application and testing.

Modelling Design Descriptions

Abstract: An overview of the representation scheme employed by the MOLE modelling system is presented. The kind-slot-filler relationship is outlined, together with two types of inheritance mechanism for the construction of hierarchically structured design descriptions.