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

Design Patterns: Elements of Reusable Object-Oriented Software

Abstract: The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns. The nice thing is, most experienced OOP designers will find out they've known about patterns all along. It's just that they've never considered them as such, or tried to centralize the idea behind a given pattern so that it will be easily reusable.

Design Patterns for Object-Oriented Software Development

Abstract: 1. Impact Of Object-Oriented Software Development On Software Quality Software Quality Attributes Measures for Producing High-Quality Software Reduced Complexity Through Structure Potentials of Object-Orientation for Improving Software Reusability 2. Concepts Of Object-Oriented Software Development Basic Concepts Provided by Object-Oriented Programming Languages Enhancing Software Reusability by an Appropriate Combination of Object-Oriented Concepts 3. Survey Of Design Pattern Approaches The Role of Design Patterns Object-Oriented Patterns Coding Patterns Framework Adaptation Patterns-Cookbook Recipes Formal Contracts Design Pattern Catalog 4. Metapatterns Metapatterns and (Application) Frameworks Class/Objects Interfaces and Interaction Metapatterns Class/Object Composition Metapatterns Impact of Composition Metapatterns on Template Methods When to Choose a Certain Composition Metapattern Capturing Object-Oriented Design with Metapatterns 5. Sample Application Of The Metapattern Approach Overview of ER++'s Domain Capturing ER++'s Core Design with Metapatterns Resulting Sample Adaptation of ET++ Summarizing Remarks 6. Implications For Software Development > Framework-Centered Software Development Limits of State -of-Art OOAD Methodologies Vision of a Hot-Spot-Driven Approach

Method and apparatus for dynamic update of an existing object in an object editor

Abstract: User interface objects are stored in a user interface object archive which is a database physically located in the shared library of an associated application program. In order to facilitate "localization", or preparation of an application developed in one language for use in an "area" or a locale which uses another language, the user interface objects are stored in a hierarchical locale tree within the archive. All objects are stored in the base or root of the hierarchy, but only those objects which require a translation are stored in an area associated with a more specific locale. At runtime, a complete collection of objects is assembled by starting at the desired locale and proceeding up the hierarchy level-by-level. Translated objects at lower levels of the hierarchy "override" those at higher levels so that the most complete translations of each object are obtained during this search. The user interface objects which are stored in an archive are actually created via a predefined "constructor" program, and, in order to allow newly-created user interface objects to use the predesigned constructor program, each user interface object is contained in a special "escort" object that interfaces with the constructor program. A user can edit an existing object, and change its class. This results in a new object of the new class being created. The existing attributes of the old object are transferred to the new object. Only the attributes known to the common base class or classes of the two objects are transferred. The new object is substituted for the old object, and the old object is deleted.

Cnc control system

Abstract: A machine tool control system that includes a controllable, movable tool for shaping a workpiece, a mechanism for receiving control instructions describing shaping functions to be performed on the workpiece, a processing unit and memory. The control system includes objects defined according to an object oriented design. One type of object is a model of a shaping process to be performed on a workpiece, including informational parameters regarding the physical dimensions of the shape resulting from the process. The process objects communicate through an object oriented messaging system to machine objects, which represent physical devices present on the CNC machine on which the control system operates. The system also includes object oriented motion control and exception handler objects, each of which may communicate with other object via object oriented messages. The control system permits easy modifications to the control system by persons with limited knowledge about the entire control system, and is readily adaptable to advances in new CNC machine tools.

Meta Patterns - A Means For Capturing the Essentials of Reusable Object-Oriented Design

Abstract: There is an undeniable demand to capture already proven and matured object-oriented design so that building reusable object-oriented software does not always have to start from scratch. The term design pattern emerged as buzzword that is associated as a means to meet that goal. Already existing approaches such as the catalog of design patterns of Erich Gamma et al. [5, 6] and Peter Coad's object-oriented patterns [3] differ in the applied notation as well as the way of abstracting from specific application domains.

An object-oriented design method for hypermedia information systems

Abstract: The goal of our research has been to simplify the development of hypermedia information systems. Classical object-oriented methods are good at capturing the semantics of multimedia type hierarchies using inheritance and encapsulation. However, they are not good at describing the object interactions prevalent in hypermedia applications. Our approach has been to extend the model of an existing object-oriented method with a construct to explicitly capture object interactions. The result is an object-oriented method for the specification of hypermedia structures in information systems. >

Principles of Object-Oriented Software Development

Abstract: Part I: Designing Object-Oriented Systems 1. Introduction What is Object Orientation The Object-Oriented Software LifeCycle Paradigms of Programming An Overview of This Book Further Literature on O-OP 2. Object-Oriented Programming Computing Devices the Object Model Encapsulation and Inheritance in C++ Generic Types Canonical Classes DD> Benefits and Pitfalls Extensions to the Object Model 3. Object-Oriented Design The Process of Design Identifying Objects Contracts Design Guidelines 4. Software Engineering Perspectives Validating Software A Framework for Testing Object-Oriented Programs Metrics for Object-Oriented Design An Objective Sense of Style Towards a Formal Approach Part II: Object-Oriented Languages And Systems 5. Object-Oriented Programming Languages The Object Paradigm Comparing Smalltalk, Eiffel and C++ Design Dimensions of Object-Oriented Languages Prototypes-Delegation Versus Inheritance Meta-Level Architectures 6. Distribution And Concurrency A Modeling Perspective Objects and Processes Concurrent Extensions of C++ Inheritance on Process Requirements for Distribution 7. Composition Mechanisms Composition by Inheritance Interaction Through Delegation Indirect Cooperation Event Driven Control Part III: Foundations Of Object-Oriented Modeling 8. Abstract Data Types Abstraction and Types Algebraic Specification Decomposition-Modules Versus Objects Type Versus Classes 9. Polymorphism Abstract Inheritance The Subtype Relation Flavors of Polymorphism Type Abstraction Existential Types: Hiding Self-Reference 10. Behavioral Refinement Types as Behavior Verifying Behavioral Properties On the Notion of Behavioral Types Objects as Behavioral Types Specifying Behavioral Compositions Part IV: Object Oriented Application Frameworks 11. Libraries And Environments Application Development Library Design Methods and Tools Libraries for C++ 12. Hypermedia Frameworks The Concepts of Hypermedia A Hypermedia Model Multi-Paradigm Programming Heterogeneous Systems

Requirements for a Composition Language

Abstract: The key requirement for open systems is that they be flexible, or recomposable. This suggests that they must first of all be composable. Object-oriented techniques help by allowing applications to be viewed as compositions of collaborating objects, but are limited in supporting other kinds of abstractions that may have finer or coarser granularity than objects. A composition language supports the technical requirements of a componentoriented development approach by shifting emphasis from programming and inheritance of classes to specification and composition of components. Objects are viewed as processes, and components are abstractions over the object space. An application is viewed as an explicit composition of software components. By making software architectures explicit and manipulable, we expect to better support application evolution and flexibility. In this position paper we will elaborate our requirements and outline a strategy for the design and implementation of a composition language for the development of open systems.

Object based system for software maintenance

Abstract: A computer implemented system and method for automatically generating an executable version is based on component objects and events. Object-oriented language concepts of encapsulation, inheritance, and message passing are employed to simplify the specification and execution steps. Software maintenance includes the steps of assembling executable systems from defined component parts such as source code files and object code files. An object definition is provided for each software component containing a specification of its dependency upon other objects and processing methods that must be executed to create that object. An event definition is created for each process that is to be applied to the component objects. The event definition includes a specification of any prerequisite events and conditions for delivery of the event message. An object dependency interpreter is provided to recursively control the passing of events to the objects for action. It ensures that any prerequisite events are first executed and that any objects upon which the current object is dependent are processed before the present object. Inheritance is employed to simplify object definition through the definition of generic objects which the object dependency interpreter instantiates for processing. Mapped memory is used to store an object data structure containing the representation of component objects and event objects. Additional storage is used to retain component object file system status.

A new approach to finding objects in programs

Abstract: Software maintenance is difficult and costly because the maintainer must understand the existing relationships in the maintained code. The maintainer's job can be made considerably easier if the objects in the code (related groups of types, data, and procedures) are identified. In this paper, we discuss methods for identifying objects in programs, and present a new approach that relies on these key features. First, our internal program representation (IPR) lets us make a more precise identification of objects than previous methods allowed. Second, we introduce the idea of receiver-based object identification. Third, we introduce the idea of two-step object identification, which gives the user greater control in precisely identifying objects. Our object finding tool can be used with the other tools our IPR provides to create an integrated software maintenance environment.

Method and system for optimizing static and dynamic binding of presentation objects with the object data they represent

Abstract: A data processing system having an object oriented environment. The object oriented environment includes a plurality of graphic user interface objects and a plurality of application objects, each graphic user object having a unique identifier and a selected attribute and each application object having a preselected response. Graphic user interface objects associated with an application object are identified. A table is created specifying relationships between the graphic user interface objects and each graphic user interface object and the application object. Each time the application object is initialized, the table is used to specify objects within the application object.

Object-oriented techniques in hardware design

Abstract: We focus on using object-oriented techniques to improve the hardware design process. The advantages of these techniques for hardware design include: improved modifiability and maintainability of models; easy component instantiation with different parameters; quick composition of new components; the ability to identify and reuse common components; the ability to tailor general-purpose components to more specialized components; support of dynamic object creation and destruction; and the possibility of employing existing software synthesis and verification techniques. We illustrate the application of object-oriented techniques using a load-store, reduced instruction-set processor that contains a local memory. The instruction set consists of 22 instructions, which require one or two 16-bit words. Arithmetic is performed in two's complement. We use C++ to demonstrate the usefulness of object-oriented techniques, not to provide arguments for or against its use in hardware modeling and design. >

Sometimes Tomorrow is Sometime - Action Refinement in a Temporal Logic of Objects

Abstract: We address the hierarchical (vertical) decomposition, or abstract implementation, of object specification in temporal logic. Whereas previous approaches to refinement in the context of temporal logic such as those developed by Lamport and by Barringer, Kuiper and Pnueli are based on a single logic that accommodates different levels of action granularity, our approach is based on relating different logics corresponding to different levels of granularity. More precisely, we map abstract actions (propositions) to concrete objects (theories) and, through inference rules that relate the different logics, derive properties of the abstracted actions from the behaviour of the corresponding objects. In this way, we keep a tighter control of action granularity and interference, enabling us to maintain the use of the “next” operator and make the development of reactive systems more tractable.

Booktwo of Object-Oriented Knowledge: The Working Object : Object-Oriented Software Engineering : Methods and Management

Abstract: The system design environment systems some common information systems gathering information problem solving steps starting a project data flow diagrams describing data additional modelling method process description object modelling documentation designing a new system user interface design relational analysis database design program design productivity tools project management strategic planning quality assurance cases.

System and method for adding new waitable object types to object oriented computer operating system

Abstract: An object based operating system for a multitasking computer system provides objects which represent the architecture or interrelationships of the system's resources. Access to certain objects is required in order to use corresponding resources in the system. All objects have a consistent data structure, and a consistent method of defining the operations which apply to each type of object. As a result, it is relatively easy to add new types of system objects to the operating system. Waitable objects are used to synchronize the operation of one or more processes with one another or with specified events. The system provides routines for generating new types of waitable objects, and thereby generating a modified operating system, without modifying other aspects of the operating system's kernel.

System and method for visually programming iteration

Abstract: A method, program product, and system create visual representations of iterator link objects. A graphical user interface of the present invention enables users to visually program iterative applications without having to use a programming language. The graphical user interface includes an iterator link object which is capable of removably linking a source object having multiple elements to a target object. On the occurrence of a trigger event, an action iterates over each individual element of the source object and is targeted to the target object. Therefore, the present invention enables the user to visually link multiple source objects to a target object. Furthermore, by utilizing more than one iterator link object, linked objects can be chained linked to other linked objects.

Codesign from cospecification

Abstract: Describes an object-oriented codesign specification approach designed to eliminate the bias introduced from using more commonplace software or hardware specification languages. The goal is to investigate automated partitioning of behavior into hardware and software. The design methodology allows gradual, continuous repartitioning of codesign operations during design. For instance, designers might start with an all-software implementation and check the implementation's functionality: they might then refine the implementation over time to a mixed hardware-software implementation. At the system level, the authors use an object-oriented approach to identify the basic objects and associated functions of a system. They divide them into three groups: hardware, software, and codesign . They represent the codesign group's objects and functions using a prototype codesign specification language, Object-Oriented Functional Specifications (OOFS), which lets one describe system state in objects and write object methods as pure functions. Thus, the authors can describe complex systems without biasing the implementation toward hardware or software. >

On formal specification of design tasks

Abstract: In the development of a design system, a formal specification can play an important role providing a precise description of both the static and the dynamic aspects of the system. Static aspects not only include domain knowledge about properties of design objects and relations between these properties, but also domain knowledge about requirements of design objects and relations between these requirements. Dynamic aspects include strategic knowledge about steps undertaken in the design process. In this paper, a logical framework for design tasks is presented which incorporates the notion of a meta-level architecture to explicitly represent declarative knowledge on the dynamics of reasoning processes. Based on this logical framework a generic task model of design is presented, describing the essential structure of the design task, in which the dynamic modification of design object descriptions and requirements is explicitly defined.

Constructive Solid Geometry

Abstract: This chapter describes constructive solid geometry (CSG) as the creation of complex three-dimensional objects from various combinations of primitive objects. The operations used are analogous to the operations of Boolean algebra. The UNION is the logical OR of two objects. The INTERSECTION is the logical AND of two objects. The DIFFERENCE is the subtraction of one object from another. The chapter discusses the real solid objects, the problems of CSG are greatly simplified. It also discusses that all the surface combinations that have to be looked at to determine which ones to be visible after a CSG operation, the computer code becomes pretty lengthy and complicated. The function clip_test scans through a list of clipping objects, determining whether the current point on an object surface is within the boundaries specified. The function is passed two parameters: first the address of the first entry in the object's list of clipping objects; second the parameter testpoint, which is the intersection between the ray and the object that was found just prior to this function being called.

Design for X—A Core Area of Design Methodology

Abstract: SUMMARY A design system to support designers using the different ‘design for X’ approaches is discussed and described in detail. This system allows the engineer to work in an object-oriented fashion faster than before and to analyze components using a knowledge-based approach.

Computer aided design support device

Abstract: A support device for a computer aided design system to improve efficiency in design work by achieving automatic recognition of associated design programs and automatic data transfer between the steps of a process of design, comprises a first, a second and a third design applications to be executed independently, a first, a second and a third design data bases to be called out by the design applications, and a management part connected to the data bases for managing the entire process. A design structure management file of the management part manages a hierarchical structure of the objects of design and when a modification of contents of design is made to one of the applications specifies a part or parts to which the modification is to be reflected. An identification file of the management part decides a direction of data transfer between the applications.

Design of object-oriented simulations in C++

Abstract: An object-oriented simulation (OOS) consisting of a set of object classes written in C++ can be used to create simulation models and packages. The simulations built with these tools possess the benefits of an object-oriented design, including the use of encapsulation, inheritance, polymorphism, run-time binding, and parameterized typing. These concepts are illustrated by creating a set of object frames which encapsulate simulation requirements. Simulation modeling is contained within a set of modeling frameworks. A network queuing simulation language is developed which has several notable features not available in other non-OOS languages. OOS provides full accessibility to the base language, faster executions, portable models and executables, a multi-vendor programming language, and a growing variety of complementary development tools.

The Problematics of Testing Object-Oriented Software

Abstract: Within object-oriented methods, testing has received less attention than analysis, design, and coding. However, object-orientedness does not make testing obsolete and can even introduce new problems into the production of correct programs and their testing. Most work in testing has been done with "procedure-oriented" software in mind. Traditional methods, despite their efficiency, cannot be applied without adaptation to object-oriented systems. In an object-oriented system, the basic test unit is a class instead of a subprogram; hence, testing should focus on classes and objects. Moreover, it is not possible to test the operations of a class in isolation, as they interact with each other by modifying the state of the object which invokes them. However, some traditional techniques can still be applied, though indirectly. Sometimes, testing object-oriented software can benefit from objectoriented technology, for instance, by capitalizing on the fact that a superclass has already been tested, and by decreasing the effort to test derived classes, which reduces the cost of testing in comparison with a flat class structure. The object-oriented paradigm can also be a hindrance to testing, due to some aspects of its very nature: encapsulation, inheritance and polymorphism.

Object based computer system having representation objects for providing interpretative views onto a data object

Abstract: Object based computer system which has objects and object parts which are either (a) semantic, relating to stored data, or (b) presentation, relating to presentation of the semantic objects to the user. Multiple presentation objects, or viewers, can be linked to a particular semantic object so that an intelligible user's model of the system results. Representation objects provide particular forms of presentation of data of the semantic objects and may be linked so that alternative and multiple presentations of the data of a semantic object are possible.

Representing and maintaining process knowledge for large-scale systems development

Abstract: Discusses how the Remap system (representation and maintenance of process knowledge) uses a semiformal representation that supports the design and maintenance of large-scale software systems. The conceptual model relates design rationale knowledge to the resulting system, providing the primitives/ templates with which we can capture (often informal) design rationale information. The model's semantics are well defined, allowing automated reasoning with its components. By providing a complete design history, Remap enhances the understandability of designs and offers a mechanism for propagating changes in design decisions into changes in design solutions. >

Complex associations: abstractions in object-oriented modeling

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

Object extending method

Abstract: In an object extending method for use in an object-oriented data base system having an object having an attribute, a relation and a procedure and a definition object having definition information determining a structure of the object, information on changes in attribute, relation and procedure which accompany a change in the definition object is held as a parts object in the definition object, and data to be newly appended to the object as a result of the change in the definition object is held as a parts object in the object, so that work to change the object in accordance with a change in schema may be reduced.

Object Engineering: The Fourth Dimension

Abstract: * Essence of a Model * Class Relation Model Background * Contents Object Model * Conceptual Approach * Object-Oriented Programming Basic Notions Of The Class Relation Model * Class Relation Model Overview * Key Class Relation Premises Basic Notions Of The Structure Model * Class and Inheritance Concepts * Class Members * Correspondence between Attributes, Methods, relations and Classes * Inter-Class Dependency * Application Invariants * Visibility * Decomposition by Inheritance * Objects Operating Model * Introduction * Pre-and Post-conditions * Specifying the Object Lifecycle: Control Automation * Exception Programming: Pre- and Post-condition Extension Dynamic Model * Overview * representing the Processing Sequence (Object Flow) * Processing Scenarios * Trigger Automata * Events Structuring * Concepts * Software Structuring * Schemas * Structuring Domains * System Modeling * Modeling Rules * Handling Instances * Normal Form Laws * Correct and Valid Modeling * Design Rules * General Modeling Approach Methodology: Software Development Phases * Software Lifecycle Basics * Lifecycle Definition * User-oriented Approach: Iterative Analysis and Design Techniques Analysis * Purpose * Preliminary Analysis * Detailed Analysis * Example: Elevator System Design * Preliminary Design * Case Study: Databases * Case Study: Multi-tasking Applications * Using Genericity * Preparing Integration * Class Relation Design Approach (Review) * Example: Designing the Elevator Application