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

A Multibody Factorization Method for Independently Moving Objects

Abstract: The structure-from-motion problem has been extensively studied in the field of computer vision. Yet, the bulk of the existing work assumes that the scene contains only a single moving object. The more realistic case where an unknown number of objects move in the scene has received little attention, especially for its theoretical treatment. In this paper we present a new method for separating and recovering the motion and shape of multiple independently moving objects in a sequence of images. The method does not require prior knowledge of the number of objects, nor is dependent on any grouping of features into an object at the image level. For this purpose, we introduce a mathematical construct of object shapes, called the shape interaction matrix, which is invariant to both the object motions and the selection of coordinate systems. This invariant structure is computable solely from the observed trajectories of image features without grouping them into individual objects. Once the matrix is computed, it allows for segmenting features into objects by the process of transforming it into a canonical form, as well as recovering the shape and motion of each object. The theory works under a broad set of projection models (scaled orthography, paraperspective and affine) but they must be linear, so it excludes projective “cameras”.

An evaluation of the MOOD set of object-oriented software metrics

Abstract: This paper describes the results of an investigation into a set of metrics for object-oriented design, called the MOOD metrics. The merits of each of the six MOOD metrics is discussed from a measurement theory viewpoint, taking into account the recognized object-oriented features which they were intended to measure: encapsulation, inheritance, coupling, and polymorphism. Empirical data, collected from three different application domains, is then analyzed using the MOOD metrics, to support this theoretical validation. Results show that (with appropriate changes to remove existing problematic discontinuities) the metrics could be used to provide an overall assessment of a software system, which may be helpful to managers of software development projects. However, further empirical studies are needed before these results can be generalized.

Flexible Alias Protection

Abstract: Aliasing is endemic in object oriented programming. Because an object can be modified via any alias, object oriented programs are hard to understand, maintain, and analyse. Flexible alias protection is a conceptual model of inter-object relationships which limits the visibility of changes via aliases, allowing objects to be aliased but mitigating the undesirable effects of aliasing. Flexible alias protection can be checked statically using programmer supplied aliasing modes and imposes no runtime overhead. Using flexible alias protection, programs can incorporate mutable objects, immutable values, and updatable collections of shared objects, in a natural object oriented programming style, while avoiding the problems caused by aliasing.

Common object architecture supporting application-centric building automation systems

Abstract: An object-oriented building automation system architecture allows complex building automation applications to be developed and deployed as distributed objects across a network Applications are distributed in the form of objects that may in turn be made up of other application objects, assembly objects and standard objects All objects are inherited from a superclass that defines a command component and a view component The command component identifies those methods within the object that may be executed by other objects, and ultimately by the user through the user interface The view component identifies the attributes or data stored in the object that may be displayed on the user interface The view component encapsulates the information needed to display the object's data, so that the user interface can be a generic browser The standard objects encapsulate physically-constrained properties or human comfort-constrained properties Applications constructed from these objects can be revised and enhanced more easily because the embedded knowledge is preserved through encapsulation

Role model based framework design and integration

Abstract: Today, any large object-oriented software system is built using frameworks. Yet, designing frameworks and defining their interaction with clients remains a difficult task. A primary reason is that today's dominant modeling concept, the class, is not well suited to describe the complexity of object collaborations as it emerges in framework design and integration. We use role modeling to overcome the problems and limitations of class-based modeling. Using role models, the design of a framework and its use by clients can be described succinctly and with much better separation of concerns than with classes. Using role objects, frameworks can be integrated into use-contexts that have not been foreseen by their original designers.

Codesign of embedded systems: status and trends

Abstract: Ever increasing embedded system design complexity combined with a very tight time-to-market window has revolutionized the embedded-system design process. The concurrent design of hardware and software has displaced traditional sequential design. Further, hardware and software design now begins before the system architecture (or even the specification) is finalised. System architects, customers, and marketing departments develop requirement definitions and system specifications together. System architects define a system architecture consisting of cooperating system functions that form the basis of concurrent hardware and software design. Interface design requires the participation of both hardware and software developers. The next step integrates and tests hardware and software-this phase consists of many individual steps. Reusing components taken from previous designs or acquired from outside the design group is a main design goal to improve productivity and reduce design risk. It is argued that new methodologies and AD tools support an integrated hardware software codesign process.

Software components for a building automation system based on a standard object superclass

Abstract: A computer-implemented building automation system provides a computer software architecture that supports object-oriented system development. An application engineer designs an application to perform a building automation function that solves a problem or customer need in the context of a building automation system. In the object-oriented paradigm, standard objects are the fundamental building block used to construct an application. Based on predetermined physical relationships defined by physical laws associated with building automation functions, the present invention defines a fundamental set of control-based standard objects for constructing an application. An additional set of information-type standard objects have also been defined for use in conjunction with this set of control-based standard objects. Standard objects are interconnected by "pulling" or "pushing" information from one standard object to another standard object using common communication methods. Assembly objects and application objects are two additional types of user-defined standard objects for interconnecting standard objects, thereby constructing a building automation application.

Uniform object model having methods and additional features for integrating objects defined by different foreign object type systems into a single type system

Abstract: A uniform object model integrates objects defined by foreign type systems into a single integrated object oriented system. The type system for the integrated object oriented system supports a superset of features from foreign object systems. The uniform object model approach converts foreign objects into uniform object model objects defined by the integrated type system and layers onto the uniform object model objects additional members supported by the integrated type system. Adapters integrate foreign objects and data sources into the integrated object oriented system by implementing foreign objects as full fledged objects of the system. The foreign object adapters are bi-directional such that objects, registered in the system, are exposed to foreign object systems. During run time, clients obtain a connection to the data source adapter, which supports the target data source, to execute transactions in the target data source. When executing transactions in the target data source, the data source adapter operates as an object access mechanism by generating an object populated with data from the target data source. The data source adapters support a single predetermined dialect of a query language, regardless of the target data source, and generate a query statement compatible with the target data source. The data source adapters also support persistence of objects in the data sources.

Knowledge provider with logical hyperlinks

Abstract: A system and method is described for the efficient management and storage of documents in a multi-user environment by implementing a three-tiered content model for storage and a context resolution mechanism for retrieval. Source objects may logically reference target objects where the target objects dynamically exist in different versions. In particular, the content model contains three classes in a collection wherein each subsequent class inherits the properties of the previous class. The classes comprise logical objects, physical objects, and files. All physical objects in the same collection are necessarily versions of each other, and are simply instances of the logical object. A versioning system allows the creation of variants of objects in the same collection. Furthermore, a context resolution mechanism is used to retrieve the most accurate version of an object pursuant to certain user-supplied criteria in response to a call from a client front-end application.

An object-oriented representation for product and design processes

Abstract: We report on the development of a knowledge representation model, which is based on the SHARED object model reported in Shared Workspaces for Computer-Aided Collaborative Engineering (Wong, A. and Sriram, D., Technical Report, IESL 93-06, Intelligent Engineering Systems Laboratory, Department of Civil Engineering, MIT, March, 1993) and Research in Engineering Design (Wong, A. and Sriram, D., SHARED: An Information Model for Cooperative Product Development, 1993, Fall, 21-39). Our current model is implemented as a layered scheme, that incorporates both an evolving artifact and its associated design process. To represent artifacts as they evolve, we define objects recursively without a pre-defined granularity on this recursive decomposition. This eliminates the need for translations between levels of abstraction in the design process. The SHARED model extends traditional OOP in three ways: 1. by allowing explicit relationship classes with inheritance hierarchies; 2. by permitting constraints to be associated with objects and relationships; and 3. by comparing `similar' objects at three different levels (form, function and behavior). Five primitive objects define the design process: goal, plan, specification, decision and context. Goal objects achieve function, introduce constraints, introduce new artifacts or modify existing ones, and create subgoals. Plan objects order goals and link a product hierarchy to a process hierarchy. Specification objects define user inputs as constraints. Decision objects relate goals to user decisions and context objects describe the design context. Operators that are applied to design objects collectively form a representation of the design process for a given context. The representation is robust enough to effectively model four design paradigms [described in Journal of CAD (Gorti, S. and Sriram, R. D., Symbol to Form Mapping: a Framework for Conceptual Design, 1996, 28 (11), 853–870)]: top-down decomposition, step-wise refinement, bottom-up composition and constraint propagation. To demonstrate this, we represent the designs of two TV remote controllers in the SHARED architecture. The example reveals that certain aspects of artifact knowledge are essentially context-independent and that this representation can be a foundation for robust knowledge-based systems in design.

System and method for defining and managing reusable groups software constructs within an object management system

Abstract: A system for maintaining an object repository within an object management system where the objects are software constructs and the system provides a set of tools for creating packages of the objects that can be reused as well as monitored as they are changed or recombined. The packages themselves become new objects for the repository to store. The set of relationships within a package is also stored as are any relationships between any of the objects within the object management system object repository.

Locating objects in wide-area systems

Abstract: Locating mobile objects in a worldwide system requires a scalable location service. An object can be a telephone or a notebook computer, but also a software or data object, such as a file or an electronic document. Our service strictly separates an object's name from the addresses where it can be contacted. This is done by introducing a location-independent object handle. An object's name is bound to its unique object handle, which, in turn, is mapped to the addresses where the object can be contacted. To locate an object, we need only its object handle. We present a scalable location service based on a worldwide distributed search tree that adapts dynamically to an object's migration pattern to optimize lookups and updates.

A metaobject architecture for fault-tolerant distributed systems: the FRIENDS approach

Abstract: The FRIENDS system developed at LAAS-CNRS is a metalevel architecture providing libraries of metaobjects for fault tolerance, secure communication, and group-based distributed applications. The use of metaobjects provides a nice separation of concerns between mechanisms and applications. Metaobjects can be used transparently by applications and can be composed according to the needs of a given application, a given architecture, and its underlying properties. In FRIENDS, metaobjects are used recursively to add new properties to applications. They are designed using an object oriented design method and implemented on top of basic system services. This paper describes the FRIENDS software-based architecture, the object-oriented development of metaobjects, the experiments that we have done, and summarizes the advantages and drawbacks of a metaobject approach for building fault-tolerant systems.

Methods and apparatus for declarative programming techniques in an object oriented environment

Abstract: An object oriented software environment permits, through declarative programming techniques, customization of functionality of an object. The object oriented software environment includes a plurality of objects, wherein each object contains at least one method. A user of the object oriented software environment submits one or more declarative statements to augment the functionality of a method on an object. In response, the object oriented software environment associates the declarative statements to the method identified on the object such that when the method on the object is called, the declarative statements, associated with the object, are executed in addition to the methods on the object. The declarative programming technique permits augmenting the functionality of a method on an object with “rules.” In addition, two or more methods may be associated together to generate an event that propagates from one method to another method. The programming techniques disclosed also permit integration of declarative, compiled and scripting approaches to integrate three styles of applications program development.

Design pattern recovery in object-oriented software

Abstract: An approach to recover object oriented design patterns from design and code is presented. The pattern recovery process is based on a multi-stage filtering strategy to avoid combinatorial explosion on large software systems. To maintain independence from the language and the case tools adopted in developing software, both design and code are mapped into an intermediate representation. The multi-stage searching strategy allows to safely determine pattern candidates. To assess the effectiveness of the pattern recovery process a portable environment written in Java has been developed. Based on this environment, experimental results on public domain and industrial software were obtained and are discussed in the paper. Evidence is shown that, by exploiting information about method calls as a further constraint beyond the structural ones, the number of false positives is reduced.

Distribution modeling and evaluation of product design problems

Abstract: This paper proposes a framework for the modeling and evaluation of product design problems in a computer network-oriented design environment. The framework is intended to integrate designer-specified mathematical models for multidisciplinary and multiobjective design problems. The goal is to provide the ability to rapidly construct integrated design problem models to facilitate collaborative design work, improve product quality and reduce development time. Ultimately, it should allow specialized engineering applications and design problem models to operate under a common design environment. A product design problem is modeled in terms of interacting objects, called modules, each representing a specific aspect of the problem. Modules interact with one another through services that allow the exchange of information. Modules can encapsulate engineering models and data or software applications. The method is extended using a standard network communication protocol to create a distributed object-based modeling and evaluation framework for design problems.

Slicing objects using system dependence graphs

Abstract: We present an SDG for object oriented software that is more precise than previous representations and is more efficient to construct than previous approaches. The new SDG distinguishes data members for different objects, provides a way to represent object parameters, represents the effects of polymorphism on parameters and parameter bindings, represents incomplete classes efficiently, and provides a way to represent class libraries. Based on this system dependence graph, we introduce the concept of object slicing and an algorithm to implement this concept. Object slicing enables the user to inspect the statements in the slice, object-by-object, and is helpful for debugging and impact analysis.

Advanced Object-Oriented Analysis and Design Using UML

Abstract: From the Publisher: Composed of updated versions of James Odell's articles from The Journal of Object-Oriented Programming, ROAD, and Object Magazine, this book works to convey the essence of object-oriented programming and software building through the Unified Modeling Language (UML). The author provides concise but in-depth pieces on structural issues, dynamic issues, business rules, object complexity, object aggregation, design templates, and the process of objects.

Design of class hierarchies based on concept (Galois) lattices

Abstract: Building and maintaining the class hierarchy has been recognized as an important but one of the most difficult activities of object-oriented design. Concept (or Galois) lattices and related structures are presented as a framework for dealing with the design and maintenance of class hierarchies. Because the design of class hierarchies is inherently an iterative and incremental process, we designed incremental algorithms that update existing Galois lattices as the result of adding, removing, or modifying class specifications. A prototype tool incorporating this and other algorithms has been developed as part of the IGLOO project, which is a large object-oriented software engineering joint research project involving academic and industrial partners. The tool can generate either the concept lattice or several variant structures incrementally by incorporating new classes one by one. The resulting hierarchies can be interactively explored and refined using a graphical browser. In addition, several metrics are computed to help evaluating the quality of the hierarchies. Experiments are presented to better assess the applicability of the approach.

Design Patterns as Language Constructs.

Abstract: Design patterns are useful for the design of object oriented systems. The power of design patterns stems from their ability to provide generic solutions to reappearing problems that can be specialized for particular situations. The implementation of design patterns however, has received little attention. We identify four problems associated with their implementation using conventional object oriented languages. First, the traceability of a design pattern in the implementation is often insufficient; the design pattern is "lost". Second, because several patterns require an object to forward messages to other objects to increase flexibility, the self problem often occurs. Third, because the pattern implementation is mixed with the domain class, the reusability of pattern implementations is often limited. Finally, implementing design patterns may present significant implementation overhead for the software engineer. Often, a potentially large number of simple methods must be implemented with trivial behavior. A solution to these problems is presented in the context of the layered object model (LayOM). LayOM provides language support for the explicit representation of design patterns in the programming language. LayOM is an extended object oriented language which contains several components that are not part of the normal object model, such as states, categories and layers. Layers are used to represent design patterns at the level of the programming language. Example layer types for eight design patterns are presented. Because LayOM is an extensible language, the software engineer may extend the language model with abstractions for other design patterns

System and method for mapping a design model to a common repository with context preservation

Abstract: Disclosed is a system for mapping objects defined in a design model, such as an object oriented design model defined using a design language such as the Universal Modeling Language (UML), to a data model accessible to an application development tool. A design model is provided that includes at least two models. A first model includes a first class and a second model includes a second class. The first class and second class have the same name, and the first class and second class have at least one different attribute and method. The first model, the first class, and attributes and methods therein are mapped to a first data structure that indicates that the first class is included with the first model. The second model, the second class, and attributes and methods therein are mapped to a second data structure that indicates that the second class is included with the second model. In this way, the first class and the second class are distinguished according to their model in the data structures.

Communication system for distributed-object building automation system

Abstract: A distributed computer-implemented building automation system for supporting applications that interact with building automation devices. The building automation system has a first device and a second device interconnected across a network channel. A common object superclass stored in a computer readable memory defines a plurality of common objects through instantiation such that the common objects have attributes for storing data and have methods for processing stored data. A source object residing on the first device performs a first control method such that a first attribute of the source object is changed. A destination object residing on the second device performs a second control method using the first attribute of the source object. A surrogate object connected between the source object and the destination object has a value for the first attribute and represents the source object on the second device. The second object has access to the value of the first attribute for performing the second method.

Automated support for modeling OO software

Abstract: We explore how automated tools might support the dynamic modeling phase of object oriented software development. We use the Object Modeling Technique as a guideline and notational basis, but in principle our approach is not tied to any particular OO methodology. We assume, however, that dynamic modeling exploits scenarios (as in OMT) describing examples of using the system being developed. Our techniques can easily be adopted for various scenario representations, such as sequence diagrams or collaboration diagrams in UML.

Apparatus and method for providing access to multiple object versions

Abstract: According to the present invention, an apparatus and method for providing access to multiple object versions allows the system administrators to control which version of a given object is referenced by existing related objects. By providing an option for the system user to select and access different object versions, object upgrade policies can be flexible and accommodate the various needs of different object-oriented systems. The object versioning mechanism of the present invention provides several different options when modifying an existing object to create a new version. The various embodiments of the present invention provide a versioning mechanism to manage version updates for objects in an object-oriented system. The versioning mechanism disclosed herein implements the methods of the present invention by making a copy of an existing object whenever a new version of the existing object is to be introduced into an object-oriented system. After the copy of the existing object has been made, the existing object or the copy of the existing object can be modified to reflect the desired changes and to provide an updated version of the object. Whether the existing object or the copy of the existing object is modified depends on the specific system policy or objectives to be achieved. In addition, according to the desired system policy, the unmodified version of the object can be removed from the system, if desired. Alternatively, if both objects remain in the system, access to one or both of the objects may be further restricted by disabling all or at least some of the methods on the objects.

Coupling metrics for object-oriented design

Abstract: We describe and evaluate some recently innovated coupling metrics for object-oriented (OO) design. The Coupling Between Objects (CBO) metric of Chidamber and Kemerer (1991) is evaluated empirically using five OO systems, and compared with an alternative OO design metric called SAS, which measures the number of associations between a class and its peers. The NAS metric is directly collectible from design documents such as the Object Model of OMT. Results from all systems studied indicate a strong relationship between CBO and NAS, suggesting that they are not orthogonal. We hypothesised that coupling would be related to understandability, the number of errors and error density. So relationships were found for any of the systems between class understandability and coupling. Only limited evidence was found to support our hypothesis linking increased coupling to increased error density. The work described in this paper is part of the 'Metrics for OO Programming Systems' (MOOPS) project, which aims to evaluate existing OO metrics, and to innovate and evaluate new OO analysis and design metrics, aimed specifically at the early stages of development.

Design components: towards software composition at the design level

Abstract: Component-based software development has proven effective for systems implementation in well-understood application domains, but is still insufficient for the creation of reusable and changeable software architectures. Design patterns address these shortcomings by capturing the expertise that is necessary for reusable design solutions. However, there is so far no methodical approach to providing these conceptual design building blocks in a tangible and composable form. To address this limitation, we introduce the notion of design components, reified design patterns fit for software composition. In this paper, we define design components and explain their constituents and services. Furthermore, we detail the activities of design composition and illustrate them as a process within a four-dimensional design space. Moreover, we describe a prototype of a design composition environment. A case study helps illustrating our approach.

A Comprehensive Investigation of Quality Factors in Object-Oriented Designs: an Industrial Case Study

Abstract: This paper aims at empirically exploring the relationships between most of the existing design coupling, cohesion, and inheritance measures for object-oriented (OO) systems, and the fault-proneness of OO system classes. The underlying goal of this study is to better understand the relationship between existing design measurement in OO systems and the quality of the software developed. In addition, we aim at assessing whether such relationships, once modeled, can be used to effectively drive and focus inspections or testing. The study described here is a replication of an analogous study conducted in a university environment with systems developed by students. In order to draw more general conclusions and to (dis)confirm the results obtained there, we now replicated the study using data collected on an industrial system developed by professionals. Results show that many of our findings are consistent across systems, despite the very disparate nature of the systems under study. Some of the strong dimensions captured by the measures in each data set are visible in both the university and industrial case study. For example, the frequency of method invocations appears to be the main driving factor of fault-proneness in all systems. However, there are also differences across studies, which illustrate the fact that, although many principles and techniques can be reused, quality does not follow universal laws and quality models must be developed locally, wherever needed.

Application framework for constructing building automation systems

Abstract: The building automation application framework defines an object-oriented class hierarchy in which a standard object superclass defines a plurality of different standard objects that may be assembled by a system designer into larger and more complex building automation systems. The standard objects include a view component that handles implementation details of displaying that object's contents on a standardized or generic user interface browser. The standard object also includes a command component that identifies to other objects what methods may be invoked by that object, thereby relieving the system developer from attending to this programming detail. The application framework defines a building automation model that is application-centric, as opposed to device-centric. Applications are constructed by interconnecting standard objects, assemblies formed from standard objects, and other application objects.

Method of developing a software system using object oriented technology

Abstract: A method of developing a software system using Object Oriented Technology and frameworks. The problem of allowing an object to acquire and lose ability and function and to modify responsibilities on an object dynamically or, in other words, to allow an object to acquire and lose the ability to do things dynamically, is addressed. This problem is solved with a framework to be used for developing a software system, e.g. for a business application. The framework comprises a number of classes which are to be processed by a computer system. The framework further comprises a Life Cycle as a description of state transitions through which an object can proceed as it is processed by an application. This is applicable in the technical field of application development of software systems, e.g. for a business application as Financial or Logistic and Distribution, wherein it is the purpose of frameworks to provide significant portions of the application that are common across multiple implementations of the application in a general manner, easy to extend for specific implementation.

Method and system for propagating object properties in a desktop publishing program

Abstract: A desktop publishing software program configured to propagate object content-defining and format-defining object properties so that user-defined object properties automatically propagate to other objects in the document. Object property propagation allows the author of the document to edit a number of linked objects by editing just one of the objects. To enable object property propagation, the desktop publishing software program includes a propagation table for each predefined layout. Each document is constructed from a number of components, and multiple instances of the same component may occur in a document. Each object has a name including an identifier and an instance code. The desktop publishing software program supports the following object property propagation rules, which may be applied to content properties and format properties separately: (1) do not propagate to any other objects; (2) propagate to objects in the same component whose identifiers belong to the same content or format group; (3) propagate to objects in the same document whose identifiers belong to the same content or format group; (4) propagate to objects in other components of the same document with the same identifiers and instance codes; and (5) propagate to objects in the same document whose identifiers belong to the same content or format group and save the object property in a registry so that the object property propagates to other documents as well.