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

Object-Oriented Modeling and Design

Abstract: 1. Introduction. I. MODELING CONCEPTS. 2. Modeling as a Design Technique. 3. Object Modeling. 4. Advanced Object Modeling. 5. Dynamic Modeling. 6. Functional Modeling. II. DESIGN METHODOLOGY. 7. Methodology Preview. 8. Analysis. 9. System Design. 10. Object Design. 11. Methodology Summary. 12. Comparison of Methodologies. III. IMPLEMENTATION. 13. From Design to Implementation. 14. Programming Style. 15. Object-Oriented Languages. 16. Non-Object-Oriented Languages. 17. Databases. 18. Object Diagram Compiler. 19. Computer Animation. 20. Electrical Distribution Design System. 21. Future of Object-Oriented Technology. Appendix A: OMT Graphical Notation. Appendix B: Glossary. Index.

Object oriented design with applications

Abstract: Booch gives practical guidance for the construction of complex object-oriented design methods. A pioneer in the area, he draws on his extensive experience in developing very large software systems to illuminate both the complex challenges and potential problems developers often face.

Designing Object-Oriented Software

Abstract: Offers basic design principles, and a specific design process, that can be applied to any software programming effort, even those not using object-oriented programming languages or environments. Provides a model for the design process--responsibility-driven design--and tools, such as the hierarchy graph and the collaboration graph. Includes examples and exercises.

Surveying current research in object-oriented design

Abstract: The state of object-oriented is evolving rapidly This survey describes what are currently thought to be the key ideas Although it is necessarily incomplete, it contains both academic and industrial efforts and describes work in both the United States and Europe It ignores well-known ideas, like that of Coad and Meyer [34], in favor of less widely known projectsResearch in object-oriented design can be divided many ways Some research is focused on describing a design process Some is focused on finding rules for good designs A third approach is to build tools to support design Most of the research described in this article does all threeWe first present work from Alan Snyder at Hewlett-Packard on developing a common framework for object-oriented terminology The goal of this effort is to develop and communicate a corporate-wide common language for specifying and communicating about objectsWe next look into the research activity at Hewlett-Packard, led by Dennis de Champeaux De Champeaux is developing a model for object-based analysis His current research focuses on the use of a trigger-based model for inter-object communications and development of a top-down approach to analysis using ensemblesWe then survey two research activities that prescribe the design process Rebecca Wirfs-Brock from Tektronix has been developing an object-oriented design method that focuses on object responsibilities and collaborations The method includes graphical tools for improving encapsulation and understanding patterns of object communication Trygve Reenskaug at the Center for Industriforskning in Oslo, Norway has been developing an object-oriented design method that focuses on roles, synthesis, and structuring The method, called Object-Oriented Role Analysis, Syntheses and Structuring, is based on first modeling small sub-problems, and then combining small models into larger ones in a controlled manner using both inheritance (synthesis) and run-time binding (structuring)We then present investigations by Ralph Johnson at the University of Illinois at Urbana-Champaign into object-oriented frameworks and the reuse of large-scale designs A framework is a high-level design or application architecture and consists of a suite of classes that are specifically designed to be refined and used as a group Past work has focused on describing frameworks and how they are developed Current work includes the design of tools to make it easier to design frameworksFinally, we present some results from the research group in object-oriented software engineering at Northeastern University, led by Karl Lieberherr They have been working on object-oriented Computer Assisted Software Engineering (CASE) technology, called the Demeterm system, which generates language-specific class definitions from language-independent class dictionaries The Demeter system include tools for checking design rules and for implementing a design

Understanding object-oriented: a unifying paradigm

Abstract: The need to develop and maintain large complex software systems in a competitive and dynamic environment has driven interest in new approaches to software design and development. The problems with the classical waterfall model have been cataloged in almost every software engineering text [19,23]. In response, alternative models such as the spiral [2], and fountain [9] have been proposed.Problems with traditional development using the classical life cycle include no iteration, no emphasis on reuse, and no unifying model to integrate the phases. The difference in point of view between following data flows in structured analysis and building hierarchies of tasks in structured design has always been a major problem [4]. Each system is built from scratch and maintenance costs account for a notoriously large share of total system costs.The object-oriented paradigm addresses each of these issues.A look at the object-oriented software life cycle, as described by Meyer [5], Coad and Yourdon [4], and Henderson-Sellers and Edwards [9], identifies the three traditional activities of analysis, design, and implementation. However, each of the referenced descriptions eliminates the distinct boundaries between the phases.The primary reason for this blurring of boundaries is that the items of interest in each phase are the same: objects. Objects and the relationships between objects are identified in both the analysis and design phases. Objects and relationships identified and documented in the analysis phase serve not only as input to the design phase, but as an initial layer in the design. This continuity provides for a much more seamless interface between the phases. Analysts, designers and programmers are working with a common set of items upon which to build.A second reason for the blurring of these boundaries is that the object-oriented development process is iterative. Henderson-Sellers and Edwards further refine this idea by replacing the waterfall model of software development with a fountain model. Development reaches a high level only to fall back to a previous level to begin the climb once again.As an example of the blurring of the traditional boundaries of the life cycle phases, Coad and Yourdon recommend that classification relationships between objects be captured and documented during the object-oriented analysis (OOA) phase. This classification will be directly reflected in the class inheritance structure developed in the design and in the code. This classification is in no way required in order to document the system requirements. In other words, Coad and Yourdon are recommending a traditional design activity in the analysis phase.The blurring of the traditional design and implementation phases has been fueled by the development of encapsulation and abstraction mechanisms in object-oriented and object-based languages. For example, Meyer claims [14] that Eiffel is both a design and an implementation language. He goes on to say that software design is sometimes mistakenly viewed as an activity totally secluded from actual implementation. From his point of view, much is to be gained from an approach that integrates both activities within the same conceptual framework.The object-oriented design paradigm is the next logical step in a progression that has led from a purely procedural approach to an object-based approach and now to the object-oriented approach. The progression has resulted from a gradual shift in point of view in the development process. The procedural design paradigm utilizes functional decomposition to specify the tasks to be completed in order to solve a problem. The object-based approach, typified by the techniques of Yourdon, Jackson and Booth, gives more attention to data specifications than the procedural approach but still utilizes functional decomposition to develop the architecture of a system. The object-oriented approach goes beyond the object-based technique in the emphasis given to data by utilizing the relationships between objects as a fundamental part of the system architecture.The goal in designing individual software components is to represent a concept in what will eventually be an executable form. The Abstract Data Type (ADT) is the object-based paradigm's technique for capturing this conceptual information. The class is the object-oriented paradigm's conceptual modeling tool. The design pieces resulting from the object-oriented design technique represent a tighter coupling of data and functionality than traditional ADTs. These artifacts of the design process used in conjunction with a modeling-based decomposition approach yield a paradigm, a technique, which is very natural and flexible. It is natural in the sense that the design pieces are closely identified with the real-world concepts which they model. It is flexible in the sense of quickly adapting to changes in the problem specifications.Object-oriented remains a term which is interpreted differently by different people. Before presenting an overview of a set of techniques for the design process, we will give our perspective so the reader may judge the techniques in terms of those definitions. Briefly, we adapt Wegner's [27] definition for object-oriented languages to object-oriented design. The pieces of the design are objects which are grouped into classes for specification purposes. In addition to traditional dependencies between data elements, an inheritance relation between classes is used to express specializations and generalizations of the concepts represented by the classes.As natural and flexible as the object-oriented technique is, it is still possible to produce a bad design when using it. We will consider a number of general design criteria and will discuss how the object-oriented approach assists the designer in meeting these criteria. We will refer to a number of design guidelines developed specifically for the object-oriented design paradigm and will discuss how these properties reinforce the concepts of good design.The paradigm sprang from language, has matured into design, and has recently moved into analysis. The blurring of boundaries between these phases has led us to include topics in this article that are outside the realm of design, but which we consider important to understanding the design process. Since the paradigm sprang from language, we define the concepts basic to object-oriented programming in the following section.

A query algebra for object-oriented databases

Abstract: An algebra that synthesizes relational query concepts with object-oriented databases is defined. The algebra fully supports abstract data types and object identity, while providing associative access to objects. The operations take an abstract view of objects and access typed collections of objects through the public interface defined for the type. The algebra supports access to relationships implied by the structure of the objects, as well as the definition and creation of new relationships between objects. The operations create new objects with unique identities and can use object identity in the manipulation of objects. The support for object identity leads to new definitions for equality of results and operators that can manipulate the identities of objects. >

Method and apparatus for transforming objects in data models

Abstract: The invention is directed to a computer implemented system and apparatus for transforming objects in a first data model (source design objects) to objects in a second data model (target design objects) and synchronizing the two data models. The result of the transformation is that at least one of the target design objects is associated with a corresponding source design object. The system associates a unique identifier with each of the target design objects and source design objects, the unique identifier being associated with each map associated with each design object.

The cognitive consequences of object-oriented design

Abstract: The most valuable tools or methodologies supporting the design of interactive systems are those that simultaneously ease the process of design and improve the usability of the resulting system. We consider the potential of the object-oriented paradigm in providing this dual function. After briefly reviewing what is known about the design process and some important characteristics of object-oriented programming and design, we speculate on the possible cognitive consequences of this paradigm for problem understanding, problem decomposition, and design result. We conclude with research issues raised by our analysis.

Book review: Object-Oriented Simulation with Hierarchical, Modular Models by Bernard P. Zeigler (Academic Press)

Abstract: Bernard Zeigler's book, titled "Object-Oriented Simulation with Hierarchical, Modular Models" and subtitled "Intelligent Agents and Endomorphic Systems", will be most valuable to individuals interested in model development to support simulation within an object oriented environment. This book may be easily read by people not familiar with the simulation literature or Zeigler's previous work. Ideally one should have some familiarity with the basic notions of object oriented design or programming, but even that is not really necessary. This review will summarize the work presented in this book and then conclude with a short critique with regard to the authors stated objective, to make accessible to broad audience "... the concepts of reusable, multifacetted, multi-abstraction, model bases and endomorphic systems".

Object-Oriented Software

Abstract: From the Publisher: how it influences the way in which computer programs are written and used. The book explains the terms and techniques most frequently used to describe object-oriented programming and design. It also describes the benefits of object- oriented programming for both end-users and software.

OdeView: the graphical interface to Ode

Abstract: OdeView is the graphical front end for Ode, an object-oriented database system and environment. Ode's data model supports data encapsulation, type inheritance, and complex objects. OdeView provides facilities for examining the database schema (i.e., the object type or class hierarchy), examining class definitions, browsing objects, following chains of references starting from an object, synchronized browsing, displaying selected portions of objects (projection), and retrieving objects with specific characteristics (selection).OdeView does not need to know about the internals of Ode objects. Consequently, the internals of specific classes are not hardwired into OdeView and new classes can be added to the Ode database without requiring any changes to or recompilation of OdeView. Just as OdeView does not know about the object internals, class functions (methods) for displaying objects are written without knowing about the specifics of the windowing software used by OdeView or the graphical user interface provided by it.In this paper, we present OdeView, and discuss its design and implementation.

Efficient assembly of complex objects

Abstract: Although object-oriented database systems offer advantages over relational or record-oriented database systems, such as modeling facilities for complex objects, they are criticized for poor performance and query capabilities on set-oriented applications. The unacceptable performance is due in part t o the object-at-a-time processing typically used by object-oriented database systems. We believe tha t improved performance of object-oriented database systems depends partially on the efficient and selective retrieval of sets of complex objects from secondary storage. In this report, we present the method of complex object retrieval and assembly used in the Volcano query processing system and the Revelation project. We also present experimental results comparing set-oriented versus object-at-a-time complex object assembly.

Automatically generating visual syntax-directed editors

Abstract: Since inexpensive computers possessing sophisticated graphics were introduced in the late 1970s, program development research has focused on syntax-directed editors that are based on the grammars of their underlying languages. The system presented here automatically generates object-oriented, syntax-directed editors for visual languages, which are described by a family of editing operations.

An object-oriented and constraint-based knowledge representation system for design object modeling

Abstract: FREEDOM (Framework for Representing and Elaborating Design Object Models), a system for design object modeling, is presented. An object model, represented as a set of objects in this system, is not a mere data structure but an active entity which works to solve design problems. The knowledge representation provided in the system, based on the object-oriented paradigm, makes it possible to describe constraints in declarative form. A class hierarchy is represented with links, and a class-instance relation can be changed dynamically. These features are useful for top-down refinement. The problem-solving mechanism of the system is based on constraint-satisfaction techniques. Constraints are declared statically and can be added to the objects dynamically. An object has a function, to keep its state satisfying given constraints. By this function, values of attributes and classes of objects that satisfy design requirements can be found. The constraint-satisfaction method is based on the technique of constraint logic programming and constraint propagation among objects. FREEDOM is implemented using the ESP language on a PSI machine. >

From data types to object types

Abstract: A semantic basis for object-oriented approaches is presented. It provides a mathematical model for objects, object types, and societies of interacting objects, includ­ ing static and dynamic aspects. The model covers complex objects and object types, providing a deeper understanding of specialization, inheritance, generalization, aggrega­ tion and interaction by object sharing, both in terms of structure and dynamics. The presented theory of object types draws some analogies from algebraic data type theory. Categories of objects and object types are defined. Both are shown to be cocomplete. Based on these results, structural relationsships as well as dynmnic interaction between objects are expressed in a uniform way.

Views in object-oriented databases

Abstract: Object-oriented database systems (ooD8Ss) are supposed to offer at least the functionality available in commercial relational DBSs of today. One important consequence of this is that ooDBSs have to provide a separation of the global (conceptual) database schema from a particular task's individual external schema ("subschema"). This is more than just an "upward compatibility" argument, there are good reasons for views in ooDBSs: among them are support for multiple levels of detail. security and authorization, and database support in a heterogeneous environment, to name just a few . In a relational DBS , views are the means by which such external schemata are derived from the logical database schema: a query defines the extent of the view-relation. In the relational context. views can not be freely updated. We describe an object model and query language that provides view definition capabilities and show that updating object views is much more feasible than in the case of relational views. The key property of the query language operators leading to this result is object preservation.

Parallelism in object-oriented programming languages

Abstract: Parallelism in object-oriented systems is discussed. The most appealing way to insert parallelism in an object framework is to associate execution capacity with objects. This approach introduces active objects. Synchronous and asynchronous communication between active objects are described using examples of existing languages. A second dimension of parallelism comes from accommodating several activities within the same object. The synchronization techniques for the internal activities are described. The presented examples are written in a highly parallel language, called Parallel Objects. A distinctive characteristic of PO is the possibility of inheritance for the specification of concurrency internal to objects. >

An iterative-design model for reusable object-oriented software

Abstract: We present an iterative-design approach for reusable object-oriented software that augments existing design methods by incorporating iteration into the design methodology and focuses on the set of problems within the domain, encouraging reuse of existing design information. The model has five separate stages which are described, before an example design is outlined using the model with sample code constructs in C++. Our results have shown a high degree of code reuse when using the model, directly attributable to two distinct design stages. An analysis of these results is also presented.

A Synthesis of Complex Objects and Object-Orientation.

Abstract: Complex Object models, semantic or knowledge representation models on the one side, and objectoriented models on the other side are currently considered candidates for future databases. Either of them have their particular strongpoints and weaknesses, such that up to now no single model could be identified to suit all needs. Database models provide limitted structuring capabilities and too poor semantics and object-oriented approaches suffer from their navigational one-object-at-a-time style of operation. In this paper we show, how the approaches can be mixed into a single, coherent approach that eliminates all of these deficiencies and nevertheless preserves their advantages: flexibility through powerful structuring primitives, rich semantics, and encapsulation, and efficiency through optimizable descriptive, set-oriented query and update languages. We call this symbiosis of Complex Objects with the object-oriented paradigm “Complex-Object-Orientation”.

Graphical specification of object oriented systems

Abstract: The graphical notation Objectcharts, introduced in this paper, allows a developer to precisely specify the behaviour of object classes and to reason about the behaviour of particular configurations of objects.Objectcharts combine object oriented analysis and design techniques and Harel's statecharts to give a diagrammatic specification technique for object oriented systems.

A Design Space and Design Rules for User Interface Software Architecture

Abstract: : The architecture of a user interface software system can be described in terms of a fairly small number of key functional and structural choices. This report presents a design space that identifies these key choices and classifies the alternatives available for each choice. The design space is a useful framework for organizing and applying design knowledge. The report presents a set of design rules expressed in the terms of the design space. These rules can help a software designer to make good structural choices based on the functional requirements for a user interface system. Extension of this work might eventually provide automated assistance for structural design.

Management of complex structural engineering objects in a relational framework

Abstract: To structure the development of an integrated building design environment, the global representation of the design data may best be organized in terms of hierarchies of objects. In structural engineering design we deal with large sets of independent but interrelated objects. These objects are specified by data. For an engineering design data base the system must be able to model the objects composing the design as well as to manage effectively the design data. The data base management system therefore needs to have some knowledge of the intended use of the data, and must provide an abstraction mechanism to represent and manipulate objects. Much recent research in engineering data bases focuses on object management for specific tasks but gives little attention to the shareability of the underlying information. This paper describes an architecture for the management of complex engineering objects in a sharable, relational framework. Potential application of this approach to object management for structural engineering analysis and design is discussed.

Introduction—object-oriented design

Abstract: Object-oriented, a buzzword of the late 1980s, has evolved into an accepted technology that has recognized benefits for the software development process. In its progression from a purely procedural approach, software development reached a data-driven—object-based—approach, and has grown beyond that to the object-oriented approach.The impact of the object-oriented approach is not limited to the design portion of the software development life cycle—its effects are evident at every phase. One of the strengths of the object model is that it provides a unifying element that is common to every phase of the life cycle. This uniformity provides a smooth transition from one phase to the next.The article by Henderson-Sellers and Edwards presents a revision of the traditional life cycle based on the object-oriented approach. It discusses the unique view of the design process and describes how it works: the process takes a specified problem and decomposes it. The resulting product forms the framework for a computer-based solution to the problem. Object-oriented techniques begin this decomposition process in the analysis phase and carry it on into the design phase. A modeling paradigm is used for the decomposition process: The top layer of an object-oriented system is a model of the real-life situation for which the software system is being created. The underlying layers provide the implementation of this model.The “pieces” produced by object-oriented techniques are as unique as the design perspective. Its obvious similarities to and subtle differences from abstract data type (ADT) technology have led to much discussion of objects and classes in terms of ADTs. The unique coupling of data and behavior in the object-oriented components provides much more than a syntactic distinction from the usual ADT. Added to the modeling approach, it produces a recognizably different approach to systems development.The term object-oriented is defined differently by different people. Many professionals agree with the basics of Wegner's definition1 that object-oriented includes three concepts: objects, classes, and class inheritance. Some would add a variety of other requirements including such concepts as polymorphism, dynamic binding, encapsulation, etc. The article by Korson and McGregor provides an overview of these concepts, leaving room for the reader to decide which to include and which to exclude; it also provides an overview of the basic concepts of object-oriented design.The production of software in an increasingly competitive environment is making reuse a priority of software professionals. The popularity of the object-oriented technique is due, in part, to its support for reuse. Two important factors influence reuse: First, it is necessary to have a set of high-quality components that are worth reusing. Second, the components must be well-defined, easy to integrate, and efficient. Meyer's article presents some experiences in developing the classes for the Eiffel library; it also discusses characteristics of the library. For components to be reused, the designer must have the means to locate a component which models an entity in the current problem. Not only must the component be located, but often necessary supporting pieces must be found as well. The article by Gibbs et al. provides information on the management of classes and the software components of the object-oriented paradigm.Tom DeMarco, in a recent interview,2 declared parallel computing to be the emerging new paradigm. According to DeMarco object-oriented techniques will be an integral partner in this emergence. DeMarco observed that designing with objects preserves the natural parallelism in a problem. Agha addresses models for parallel objects, presenting an overview of the problem and focusing on the actor model as a possible solution. He presents examples of design issues when using the actor model. He also considers a basic reflective design architecture.The importance of well-defined and well-managed abstractions in the software development process is discussed in the articles by Meyer and by Gibbs et al as they explore what has come to be called the software base, the set of software components from which future products will be built.The unique components developed by object-oriented methods are characterized by an interface that is separate from the implementation of that behavior. The designer is free to concentrate on modeling the problem at hand either by developing specific classes or by locating and reusing existing classes that model some subset of the needed behavior. Meyer focuses on what he quotes McIlroy as terming a “software components subindustry,”3 presenting a case study of the development of the Eiffel libraries.The final article in this special issue, by Henderson-Sellers and Edwards discusses modifications to the traditional life cycle supported by the object-oriented approach. The modified life cycle recognizes the iterative nature of the development process and incorporates that characteristic into its model.Wirfs-Brock and Johnson present a sampling of current research into several aspects of object-oriented design. Their survey includes efforts to improve reusability through design technique and paradigm-specific tools. The works are representative of the broad spectrum of research activity currently under way.We would like to thank the authors in this special issue for their hours of work both in developing their own articles and for the time spent evaluating and commenting upon the other articles.

Object-oriented software modeling of a Flexible Manufacturing System

Abstract: Flexible Manufacturing Systems play an important role in improving our manufacturing productivity. Simulation is emerging as a popular tool in modeling FMS for analyzing its performance in the area of production planning/scheduling. In this paper, we illustrate how to model a Flexible Manufacturing System in the object-oriented paradigm using an example. We present a systemtic approach to the design of object-oriented programming systems based on a combination of data modeling and event analysis techniques. An entity relationship approach is used as the basis for an initial decomposition of the system into objects. The design is refined by an analysis of the events the objects participate in. The design is implemented in Objective-C. Finally, we describe ways in which this model of an FMS can be extended to explore popular research questions in production planning and scheduling.

Object migration mechanisms to support updates in object-oriented databases

Abstract: Updates in object-oriented database systems are studied. It is pointed out that, owing to the richness of the object-oriented data model, updating an object may affect the object's position in the class lattice. Three types of update operations on objects are considered: adding, dropping, and modifying instance variables. An update may cause object migration, that is, the updated object may change its current class. As the user may not be aware of the side effects of the update, the system has to take some actions to complete the user's update. Classes in a database schema are classified into three types: static, partially dynamic, and dynamic. This classification is based on the way in which an object in a class may migrate. It is shown that the notion of object migration affects answering queries in temporal object-oriented databases. The history of an object will be distributed among several classes in the scheme. Two approaches to determine the class of an object's version are presented. >

A design tool for object oriented databases

Abstract: This paper describes a design methodology for an object oriented database, based on a semantic network. This approach is based on the assumption that semantic data models are more powerful and more easy to use than current proposed object oriented data models. They are especially more powerful in representing integrity constraints and various relationships. Object oriented data models are generally based only on class hierarchies and inheritance, plus their ability to represent the behaviour of objects. But this latter capability is generally provided through an algorithmic language which cannot be considered as a conceptual language. In this paper, we combine the two categories of data models and give a procedure on how to translate the conceptual model to the logical model.

Reuse in software engineering: an object-oriented perspective

Abstract: The role of reuse within software engineering is examined. The benefits of reuse are stated, inhibitors to successful reuse are pointed out, and technical issues for achieving reuse are examined. Specific attention is paid to how object-oriented software engineering enhances or reduces the potential for reuse as compared with traditional (i.e. not based on objects or object-oriented concepts) software engineering. Three major activities for supporting reuse are described. The first is the intentional development of reusable artifacts, the second is the representation and classification of artifacts into repositories, and the last is the utilization of the artifacts from repositories. The object-oriented model is found to be significantly similar to the traditional model in many aspects. However, differences are found insofar as object-oriented design supports the design techniques of abstraction and factorization, which utilize object inheritance to yield reusable objects. >

Real-Time Detection Of Multi-Colored Objects

Abstract: Fast object recognition is critical for robots in the real world. However, geometry-based object recognition methods calculate the pose of the object as part of the recognition process and hence are inherently slow. As a result, they are not suitable for tasks such as searching for an object in a room. If pose calculation is eliminated from the process and a scheme is used that simply detects the likely presence of the object in a scene, considerable efficiency can be gained. This paper contains a discussion of the requirements of any searching task and presents a fast method for detecting the presence of known multi-colored objects in a scene. The method is based on the assumption that the color histogram of an image can contain object "signatures" which are invariant over a wide range of scenes and object poses. The resulting algorithm has been easily implemented in off-the-shelf hardware and used to build a robot system which can sweep its gaze over a room searching for an object.