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

Apparatus and methods for providing data synchronization by facilitating data synchronization system design

Abstract: Object stores are used as building blocks to construct a system with variable complexity on a network. Typically, an object store comprises information (e.g., data) stored in object format, or objects. The objects and object stores are managed by an object version management mechanism that adapts to different object store types and optimizes resource consumption by each object store. Various data fields are used to indicate an object's version within an object store. Version information is used to compare the states among matching object replicas in matching object stores. Utilizing both the object store based system and the object version management mechanism, a data synchronization protocol is developed. The data synchronization protocol is capable of adapting to different types of object stores and the characteristics of network connection media to optimize data synchronization.

Planning Paths for Elastic Objects under Manipulation Constraints

Abstract: This paper addresses the problem of planning paths for an elastic object from an initial to a final configuration in a static environment. It is assumed that the object is manipulated by two actuators and that it does not touch the obstacles in its environment at any time. The object may need to deform to achieve a collision-free path from the initial to the final configuration. Any required deformations are automatically computed by the planner according to the principles of elasticity theory from mechanics. The problem considered in this paper differs significantly from that of planning for a rigid or an articulated object. In the first part of the paper, the authors point out these differences and highlight the reasons that make planning for elastic objects an extremely difficult task. The authors then present a randomized algorithm for computing collision-free paths for elastic objects under the above-mentioned restrictions of manipulation. The paper includes a number of experimental results. The work...

Dynamically generating multiple hierarchies of inter-object relationships based on object attribute values

Abstract: The described arrangements and procedures dynamically generate a data polyarchy from information received from a data store (e.g., a directory or database). The data polyarchy represents multiple hierarchies of inter-object relationships based on values of attributes of the objects. These multiple hierarchies are generated and represented in a manner that is independent of object naming and predetermined hierarchical data structures.

Modular tracking and profiling system

Abstract: An information management system for tracking and analyzing information relating to medical supply usage on a procedural level in a clinical setting includes a general purpose computer system with storage means, processing means, display means, and input means. Information management software installed on the general purpose computer includes node software objects providing a health care information management function. The node software object includes a clinical pathway node software object, a case management node software object, and a resource utilization tracking node software object. The clinical pathway node software object creates clinical pathway module software objects, including resource software objects and container software objects. The resource utilization tracking node software object performs an analysis to determine supply request and actual usage patterns on a procedural level over a given time period for a particular health care provider, by comparing the issued, consumed, returned, and scrapped amounts, and modifying the provider-specific procedural templates to more fully conform to the actual usage patterns based on the analysis.

A geometric approach to 3D object comparison

Abstract: Along with the development of 3D acquisition devices and methods and the increasing number of available 3D objects, new tools are necessary to automatically analyze, search and interpret these models. In this paper, we describe a novel geometric approach to 3D object comparison and analysis. To compare two objects geometrically, we first properly position and align the objects. After solving this pose estimation problem, we generate specific distance histograms that define a measure of the geometric similarity of the inspected objects. The geometric approach is very well-suited for structures with moderate variance, e.g. bones, fruits, etc. The strength of the approach is proven through the results of several tests that we performed on different data sets.

Detecting design flaws via metrics in object-oriented systems

Abstract: The industry is nowadays confronted with large-scale monolithic and inflexible object-oriented software. Because of their high business value, these legacy systems must be re-engineered. One of the important issues in re-engineering is the detection and location of design flaws, which prevent the efficient maintenance and further development of the system. In this paper, we present a metrics-based approach for detecting design problems, and we describe two concrete techniques for the detection of two well-known design flaws found in the literature. We apply our technique to an industrial case study and discuss the findings. The proposed technique indeed found real flaws in the system and the experiment suggests that, based on the same approach, further detection techniques for other common design flaws could be defined.

Formalizing fuzzy objects from uncertain classification results

Abstract: Concepts of fuzzy objects have been put forward by various authors (Burrough and Frank 1996) to represent objects with indeterminate boundaries. In most of these proposals the uncertainties in thematic aspects and the geometric aspects are treated separately. Furthermore little attention is paid to methods for object identification, whereas it is generally in this stage that the uncertainty aspects of objects become manifest. When objects are to be extracted from image data then the uncertainty of image classes will directly effect the uncertainty of the determination of the spatial extent of objects. Therefore a complete and formalized description of fuzzy objects is needed to integrate these two aspects and analyse their mutual effects. The syntax for fuzzy objects (Molenaar 1998), was developed as a generalization of the formal syntax model for conventional crisp objects by incorporating uncertainties. This provides the basic framework for the approach presented in this paper. However, the model still needs further development in order to represent objects for different application contexts. Moreover, the model needs to be tested in practice. This paper proposes three fuzzy object models to represent objects with fuzzy spatial extents for different situations. The Fuzzy-Fuzzy object (FF-object) model represents objects that have an uncertain thematic description and an uncertain spatial extent, these objects may spatially overlap each other. The Fuzzy-Crisp object (FC-object) model represents objects with an uncertain spatial extent but a determined thematic content and the Crisp-Fuzzy object (CF-object) model represents objects with a crisp boundary but uncertain content. The latter two models are suitable for representing fuzzy objects that are spatially disjoint. The procedure and criteria for identifying the conditional spatial extent and boundaries based upon fuzzy classification result are discussed and are formalized based upon the syntactic representation. The identification of objects by these models is illustrated by two cases: One from coastal geomorphology of Ameland, The Netherlands and one from land cover classification of Hong Kong.

Object modeling for user-centered development and user interface design: the wisdom approach

Abstract: ion Presentation Control PAC Aplication Conceptual Interface (ACI) Instantiation of a User Interface System Functional core Output Input User User Functional core Figure II.23 Conceptual Architectural Models for User-interface Objects In the late 1980s and early 1990s several approaches of implementation architectural models for interactive systems emerged. Unlike conceptual models, implementation models organize the interactive system as a set of software components and aim at practical software engineering considerations like reusability, maintainability, and performance. The Seeheim model [Bass, 1992] proposes a simple three-layer model (application, dialogue and presentation) of an interactive system, roughly coupling the semantic, syntactic and lexical functionality’s of the user interface. The application component models the domain-specific components, the dialogue component defines the structure of the dialogue between the user and the application and, finally, the presentation component is responsible for the external to internal mapping of basic symbols. The Seeheim model is considered a correct and useful model for specification of interactive systems [Duce et al., 1991]. However, its support for distribution, concurrency, resource management and performance is recognized to be insufficient. Background: A Brief Survey of Usability Engineering and Object Modeling 58 The Arch model [Pfaff and Haguen, 1985] is a revision of the Seeheim model aimed at providing a framework for understanding of the engineering tradeoffs, specifically, in what concerns evaluating candidate run-time architectures. The Arch model proposes a five-layer approach balanced around the dialogue component. The components of the Arch model are: • The interaction toolkit component implements the physical interaction with the end-user; • The presentation component provides a set of toolkit independent objects; • The dialogue component is responsible for task-level sequencing, providing multiple view consistency, and mapping the between domain specific and user interface specific formalisms; • The domain adapter component implements domain related tasks required but not available in the domain specific component; • The domain specific component controls, manipulates and retrieves domain data and performs other domain related functions. Application Dialogue Presentation Seeheim Model

System and method for retrieval of objects from object to relational mappings

Abstract: A retrieval system generates a retrieval query for batch reading of related objects when a source object is read from the database. The related objects include nested objects and/or many-to-many relationship objects. It generates a single retrieval query for each type in each level of nested objects using its parent query. Also it generates a retrieval query to retrieve a collection of target objects having many-to-many relationships with a collection of source objects.

Method and system for collaborative knowledge management

Abstract: A collaborative knowledge management system (CKMS) includes application interfaces collecting data objects from and providing data objects to respective application programs including, for example, word processing, spreadsheet, graphics, e-mail, general ledger, ERP and other programs and utilities. The data objects are associated with respective relationships identifying other data objects, applications and users (whereby users include, but are not limited to people, machines and software). A set of rules defines how the data objects are to react to various systems states and actions of the objects of the relationships. Objects may be stored in a common format, or lingua franca, so that diverse applications and users may form, share and interrelate knowledge provided by the data objects and collaborate in the creation of new data objects and define new relationships.

Composition of Object-Oriented Software Design Models

Abstract: In practice, object-oriented design models have been less useful throughout the lifetime of software systems than they should be Design models are often large and monolithic, and the structure of designs is generally quite different from that of requirements As a result, developers tend to discard the design, especially as the system evolves, since it is too difficult to keep its relationship to requirements and code accurate, especially when both are changing This thesis identifies a number of key, well-defined problems with current object-oriented design methods and proposes new techniques to solve them The new techniques present a different approach to designing systems, based on flexible decomposition and composition The existing decomposition mechanisms of object-oriented designs (based on class, object, interface and method) are extended to include decomposing designs in a manner directly aligning design with requirements specifications Composition mechanisms for designs are extended to support the additional decomposition mechanisms The approach closely aligns designs with both requirements specifications and with code It is illustrated how this approach permits the benefits of designs to be maintained throughout a system’ s lifetime

Meta-modeling Design Patterns: application to pattern detection and code synthesis

Abstract: Design Patterns have been quickly adopted by the object-oriented community, in particular since the publication of "Design Patterns: Elements of Reusable Object-Oriented Software". They offer elegant and reusable solutions to recurring problems of design. Their use increases productivity and development quality. However, these solutions, at the boundary of programming languages and design models, suffer from a lack of formalism. For this reason, their application remains empirical and manually performed. This position paper presents how a meta-model can be used to obtain a representation of design patterns and how this representation allows both automatic code generation and design patterns detection.

Multi-view software evolution: a UML-based framework for evolving object-oriented software

Abstract: It is well-known that uncontrolled change to software can lead to increasing evolution costs caused by deteriorating structure and compromised system qualities. For complex systems, the need to carefully manage system evolution is critical. In this paper we outline an approach to managing evolution of object-oriented (OO) software. The approach is based on a goal-directed, cyclic process, in which OO models are transformed and quantitatively evaluated in each cycle. Evaluation criteria guide developers in choosing between alternative transformations in each cycle. The process, transformations, and evaluation techniques can be used to develop systems from a set of baseline models.

Moving Objects: Logical Relationships and Queries

Abstract: In moving object databases, object locations in some multi-dimensional space depend on time. Previous work focuses mainly on moving object modeling (e.g., using ADTs, temporal logics) and ad hoc query optimization. In this paper we investigate logical properties of moving objects in connection with queries over such objects using tools from differential geometry. In an abstract model, object locations can be described as vectors of continuous functions of time. Using this conceptual model, we examine the logical relationships between moving objects, and between moving objects and (stationary) spatial objects in the database. We characterize these relationships in terms of position, velocity, and acceleration. We show that these fundamental relationships can be used to describe natural queries involving time instants and intervals. Based on this foundation, we develop a concrete data model for moving objects which is an extension of linear constraint databases. We also present a preliminary version of a logical query language for moving object databases.

Persistent objects in the Fleet system

Abstract: Fleet is a middleware system implementing a distributed repository for persistent Java objects. Fleet is primarily targeted for supporting highly critical applications: in particular, the objects it stores maintain correct semantics despite the arbitrary failure (including hostile corruption) of a limited number of Fleet servers and, for some object types, of clients allowed to invoke methods on those objects. Fleet is designed to be highly available, dynamically extensible with new object types, and scalable to large numbers of servers and clients. In this paper, we describe the design of Fleet objects, including how new objects are introduced into the system, how they are named, and their default semantics.

Instructional design based on reusable learning objects: applying lessons of object-oriented software engineering to learning systems design

Abstract: There is currently a lot of interest in the concept of learning objects. Learning objects are discrete units of learning resources based on agreed standards. The idea behind learning objects is to promote greater reuse of resources within new instructional systems development. The main work in learning objects has primarily focussed on defining the technical requirements and standards for computer based learning objects. The technology itself is not likely to bring the benefits promised by reusable objects without a change in methods used by practicing instructional designers. The instructional design implications of the learning object approach is examined to determine the adaptation required in instructional design methodologies. Object-oriented software engineering is proposed as a useful basis for new thinking in instructional design methodology.

Mapping persistent data in multiple data sources into a single object-oriented component

Abstract: A method, apparatus and article of manufacture is provided for mapping persistent data objects residing in multiple data sources into a single, reusable software component accessible to an object-oriented programming language application performed by the computer, for multi-database access to data that may be physically distributed and stored in disparate DBMSs, each stored in an electronic storage device coupled to the computer. The method has steps for identifying data objects in multiple data sources, employing a multi-database software facility for connecting to the data sources containing the data objects, and registering the data objects with the multi-database software facility, creating a single virtual data object consolidating multiple attributes from the registered data objects, and establishing a connection to the multi-database software facility for referencing the virtual data object as though it was a single real data object. It also has a step for wrapping this virtual data object as a reusable software component accessible directly from object-oriented programming language applications.

OO design patterns, design structure, and program changes: an industrial case study

Abstract: A primary expected benefit of object-oriented (OO) methods is the creation of software systems that are easier to adapt and maintain. OO design patterns are especially geared to improve adaptability, since patterns generally increase the complexity of an initial design in order to ease future enhancements. For design patterns to really provide benefit, they must reduce the cost of future adaptation. The evidence of improvements in adaptability through the use of design patterns and other design structures consists primarily of intuitive arguments and examples. There is little empirical evidence to support claims of improved flexibility of these preferred structures. In this case study, we analyze 39 versions of an evolving industrial OO software system to see if there is a relationship between patterns, other design attributes, and the number of changes. We found a strong relationship between class size and the number of changes-larger classes were changed more frequently. We also found two relationships that we did not expect: (1) classes that participate in design patterns are not less change prone-these pattern classes are among the most change prone in the system, and (2) classes that are reused the most through inheritance tend to be more change prone. These unexpected results hold up after accounting for class size, which had the strongest relationship with changes.

Object oriented provisioning server object model

Abstract: A provisioning server object model and method is detailed that manages configuration and tasking of devices, elements, or links of networks. The provisioning server object model and method utilizes an object oriented design and object cache that allows the provisioning server to generate configuration responses for network elements, command lists, network state, and import and export configuration information in an efficient manner. The provisioning server object model and method also allows for dynamic updates of configuration components by identifying stale configuration components and managing their dynamic updating in response to configuration change events that affect the underlying input files and information databases.

Hazard analysis in object oriented design of dependable systems

Abstract: Mass produced products are becoming more and more complex, which forces the designers to model the functionality early in the design process. UML Use cases was found to be a useful method for this purpose at Volvo Cars and is currently used for modeling all functions implemented in the electrical network. When using Use cases in the design of complex safety critical systems, there is still an uncovered demand for early hazard analysis at a functional level. This work integrates a modified functional hazard assessment method and Use cases. The analysis generates valuable results used as design requirements and dependability analysis input. The methods results have exceeded our expectations. An example is included, showing how the method works.

Method, system, program, and computer readable medium for indexing object oriented objects in an object oriented database

Abstract: Provided is a method, system, program, and database structures for indexing objects oriented objects in an object oriented database. An object data structure is provided including a plurality of object oriented objects, wherein each object includes a key value, and wherein each object is associated with an object index. A node data structure is provided including nodes, wherein each node represents one object in the object store and includes one object index used to access the object represented by the node in the object store. The nodes in the node data structure are organized according to the key values in the objects represented by the nodes. The node data structure is used to access the objects in the object store.

Method, system, and program for maintaining a database of data objects

Abstract: Provided is a method, system, and program for maintaining a database of data objects. A first data object implemented in a first programming language including attributes and attribute values for a class is received. The first data object is transformed to a second data object implemented in a second programming language, wherein the second data object includes the attributes and attribute values of the class included in the first data object. The second data object is added to the database, wherein the database is capable of storing multiple data objects implemented in the second programming language.

Assessing the Changeability of two Object-Oriented Design Alternatives—a Controlled Experiment

Abstract: An important motivation for the object-oriented paradigm is to improve the changeability of the software, thereby reducing lifetime development costs. This paper describes the results of controlled experiments assessing the changeability of a given responsibility-driven (RD) design versus an alternative control-oriented “mainframe” (MF) design. According to Coad and Yourdon's OO design quality principles, the RD design represents a “good” design. The MF design represents a “bad” design. To investigate which of the designs have better changeability, we conducted two controlled experiments—a pilot experiment and a main experiment. In both experiments, the subjects were divided in two groups in which the individuals designed, coded and tested several identical changes on one of the two design alternatives. The results clearly indicate that the “good” RD design requires significantly more change effort for the given set of changes than the alternative “bad” MF design. This difference in change effort is primarily due to the difference in effort required to understand how to solve the change tasks. Consequently, reducing class-level coupling and increasing class cohesion may actually increase the cognitive complexity of a design. With regards to correctness and learning curve, we found no significant differences between the twobdesigns. However, we found that structural attributes change less for the RD design than for the MF design. Thus, the RD design may be less prone to structural deterioration. A challenging issue raised in this paper is therefore the tradeoff between change effort and structural stability.

View integration of behavior in object-oriented databases

Abstract: Database schemas are often not defined by a single person but by several future users of the database who define their possibly different views on the proposed database schema. These views are collected and integrated during the subsequent design step of view integration . In object-oriented databases, view integration must handle the integration of the structure and the behavior of objects. Whereas integration of object structure has been treated in the realm of semantic data models in the past, integration of object behavior has received little attention so far. Behavior is usually defined at two levels of detail: by activities, which correspond to methods in object-oriented languages, and by object life-cycles, which represent the overall behavior of objects during their life time. This paper presents an approach to integrate object life-cycles in object-oriented database schemas using a notation based on Petri nets. We will introduce different methods of integration depending on identified semantic correspondences between the object types in the views.

System and method for object persistence life-cycle and object caching integration

Abstract: A system for integrating object changes occurring to an object in a first object storage system with a second object storage system The system operates by first receiving from a first object storage systems a notification of an event relating to an object in the first object storage system The system sets up a representation of the object in a second object storage system in response to the notification and determines object changes made to the object in the first object storage system by using the representation in the second object storage system Finally, the system determines object changes with the representation in the second storage system

Java power tools: model software for teaching object-oriented design

Abstract: The Java Power Tools or JPT is a Java toolkit designed to enable students to rapidly develop graphical user interfaces in freshman computer science programming projects. Because it is simple to create GUIs using JPT, students can focus on the more fundamental issues of computer science rather than on widget management. In a separate article[4], we will discuss with examples how the JPT can help freshman students to learn about the basics of algorithms, data structures, classes, and interface design. In this article, we will focus on how the JPT itself can be used as an extended case study of object-oriented design principles in a more advanced course.The fundamental design principles of the JPT are that the elements of a graphical user interface should be able to be combined recursively as nested views and that the communication between these views and the internal data models should be as automatic as possible. In particular, in JPT, the totality of user input from a complex view can be easily converted into a corresponding data model and any input errors will be detected and corrected along the way. This ease of communication is achieved by using string objects as a lingua franca for views and models and by using parsing when appropriate to automatically check for errors and trigger recovery. The JPT achieves its power by a combination of computer science and software design principles. Recursion, abstraction, and encapsulation are systematically used to create GUI tools of great flexibility. It should be noted that a much simpler pedagogical package for Java IO was recently presented in [9].

Secure network objects

Abstract: We describe the design and implementation of secure network objects, which provide security for object-oriented network communication. The design takes advantage of objects and subtyping to present a simple but expressive programming interface for security, supporting both access control lists and capabilities. The implementation of this design fits nicely within the structure of the existing network objects system; we discuss its internal components, its performance, and its use in some applications.