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

Detection strategies: metrics-based rules for detecting design flaws

Abstract: In order to support the maintenance of an object-oriented software system, the quality of its design must be evaluated using adequate quantification means. In spite of the current extensive use of metrics, if used in isolation metrics are oftentimes too fine grained to quantify comprehensively an investigated design aspect (e.g., distribution of system's intelligence among classes). To help developers and maintainers detect and localize design problems in a system, we propose a novel mechanism - called detection strategy - for formulating metrics-based rules that capture deviations from good design principles and heuristics. Using detection strategies an engineer can directly localize classes or methods affected by a particular design flaw (e.g., God Class), rather than having to infer the real design problem from a large set of abnormal metric values. We have defined such detection strategies for capturing around ten important flaws of object-oriented design found in the literature and validated the approach experimentally on multiple large-scale case-studies.

Object Invariants in Dynamic Contexts

Abstract: Object invariants describe the consistency of object-oriented data structures and are central to reasoning about the correctness of object-oriented software. Yet, reasoning about object invariants in the presence of object references, methods, and subclassing is difficult. This paper describes a methodology for specifying and verifying object-oriented programs, using object invariants to specify the consistency of data and using ownership to organize objects into contexts. The novelty is that contexts can be dynamic: there is no bound on the number of objects in a context and objects can be transferred between contexts. The invariant of an object is allowed to depend on the fields of the object, on the fields of all objects in transitively-owned contexts, and on fields of objects reachable via given sequences of fields. With these invariants, one can describe a large variety of properties, including properties of cyclic data structures. Object invariants can be declared in or near the classes whose fields they depend on, not necessarily in the class of an owning object. The methodology is designed to allow modular reasoning, even in the presence of subclasses, and is proved sound.

Object invariants in dynamic contexts

Abstract: Object invariants describe the consistency of object-oriented data structures and are central to reasoning about the correctness of object-oriented software. Yet, reasoning about object invariants in the presence of object references, methods, and subclassing is difficult. This paper describes a methodology for specifying and verifying object-oriented programs, using object invariants to specify the consistency of data and using ownership to organize objects into contexts. The novelty is that contexts can be dynamic: there is no bound on the number of objects in a context and objects can be transferred between contexts. The invariant of an object is allowed to depend on the fields of the object, on the fields of all objects in transitively-owned contexts, and on fields of objects reachable via given sequences of fields. With these invariants, one can describe a large variety of properties, including properties of cyclic data structures. Object invariants can be declared in or near the classes whose fields they depend on, not necessarily in the class of an owning object. The methodology is designed to allow modular reasoning, even in the presence of subclasses, and is proved sound.

Evaluating the effect of a delegated versus centralized control style on the maintainability of object-oriented software

Abstract: A fundamental question in object-oriented design is how to design maintainable software. According to expert opinion, a delegated control style, typically a result of responsibility-driven design, represents object-oriented design at its best, whereas a centralized control style is reminiscent of a procedural solution, or a "bad" object-oriented design. We present a controlled experiment that investigates these claims empirically. A total of 99 junior, intermediate, and senior professional consultants from several international consultancy companies were hired for one day to participate in the experiment. To compare differences between (categories of) professionals and students, 59 students also participated. The subjects used professional Java tools to perform several change tasks on two alternative Java designs that had a centralized and delegated control style, respectively. The results show that the most skilled developers, in particular, the senior consultants, require less time to maintain software with a delegated control style than with a centralized control style. However, more novice developers, in particular, the undergraduate students and junior consultants, have serious problems understanding a delegated control style, and perform far better with a centralized control style. Thus, the maintainability of object-oriented software depends, to a large extent, on the skill of the developers who are going to maintain it. These results may have serious implications for object-oriented development in an industrial context: having senior consultants design object-oriented systems may eventually pose difficulties unless they make an effort to keep the designs simple, as the cognitive complexity of "expert" designs might be unmanageable for less skilled maintainers.

Active learning system for object fingerprinting

Abstract: Object fingerprinting and identification is a critical part of effective visual surveillance systems. In this paper, we present an approach to actively learn the object models in order to fingerprint the objects. Our approach uses a view-based classifier cascade that actively learns to recognize the generic class of the object. Salient features unique to the specific instance of the selected class of objects are modeled using fuzzy attribute relational graphs. These graphs are also adapted to represent object information gathered from multiple views. Preliminary results are quite promising and extensive studies are underway to ascertain the use of the system in more complicated scenarios.

Learning to Detect Objects in Images via a Sparse, Part-Based Representation

Abstract: We study the problem of detecting objects in still, gray-scale images. Our primary focus is the development of a learning- based approach to the problem that makes use of a sparse, part-based representation. A vocabulary of distinctive object parts is automatically constructed from a set of sample images of the object class of interest; images are then represented using parts from this vocabulary, together with spatial relations observed among the parts. Based on this representation, a learning algorithm is used to automatically learn to detect instances of the object class in new images. The approach can be applied to any object with distinguishable parts in a relatively fixed spatial configuration; it is evaluated here on difficult sets of real-world images containing side views of cars, and is seen to successfully detect objects in varying conditions amidst background clutter and mild occlusion. In evaluating object detection approaches, several important methodological issues arise that have not been satisfactorily addressed in previous work. A secondary focus of this paper is to highlight these issues and to develop rigorous evaluation standards for the object detection problem. A critical evaluation of our approach under the proposed standards is presented.

Towards a Global Architecture for Learning Objects: A Comparative Analysis of Learning Object Content Models

Abstract: This paper investigates basic research issues that need to be addressed in order to reuse learning objects in a flexible way. We review a number of learning object content models that define learning objects and their components in a more or less precise way. A comparative analysis is made of these models in order to address questions about repurposing learning objects in a different context. The content models are mapped on our general model for learning objects to facilitate the comparison.

Cognitive activities of abstraction in object orientation: an empirical study

Abstract: Alongside the widespread support for adopting object orientation there are reports on difficulties in learning object oriented programming and design. This indicates the need for refining the research on cognitive difficulties in a way that will offer guidelines for better designing respective education. The presented findings of our study relate to general issues of object-oriented design and in particular to the abstraction issue with its various manifestations. Based on students' solutions we extracted a cognitive task analysis taxonomy regarding abstraction and inheritance. We discuss possible implications of our results for the teaching of object orientation and for further needed research.

Systems and methods for rendering and increasing portability of document-based user interface software objects

Abstract: Systems and methods for rendering document-based user interface software objects are disclosed. User interface software objects may be represented in a document object model on a first computer system. These objects may then be communicated to a second computer system on which they are similarly rendered through use of a document object model on a second computer system. A document on a first computer system may also be updated to reflect either user input through a user interface software object included in the document, or changes induced by server side logic. The updates may be incrementally communicated to and rendered in a second computer system. Location-neutral user interface software objects may be developed without regard to whether the software object will ultimately reside on a client or server computer system, wherein the user interface software object is equally capable of being supported on either one of a client or server computer system.

Methods of manipulating information objects and of accessing such objects in a computer environment

Abstract: The invention relates to a method which is used in a computer environment in order to produce a current view from at least one source information object that can vary. The inventive method is characterised in that it comprises the following steps: a reference of the view in relation to the source information object is established and stored; a user implements at least one information object modification tool in order to produce a transformed information object from the source information object; a difference information set that is representative of the modification actions performed by the user with the tool(s) is recorded in a memory element; and a current view is produced from the current version of each source information object and said difference information set. The invention also relates to methods of allocating relevancy scores to the information objects, so that information objects can be accessed using such scores, for the management of references between information objects depending on whether or not modifications have been made to said information objects by the user, in order to: access selectively a derived information object created from a start information object; access information objects that are connected to others with directed links in a customised manner; access selectively one of a plurality of information objects from a start information object; display a customised information object obtained from a start information object; and, finally, manipulate information using a graphic user interface.

Viewpoint-invariant image matching and generation of three-dimensional models from two-dimensional imagery

Abstract: A method and system for characterizing features in a source multifeatured three-dimensional object, and for locating a best-matching three-dimensional object from a reference database of such objects by performing a viewpoint invariant search among the reference objects. The invention further includes the creation of a three-dimensional representation of the source object by deforming a reference object.

Integration of three dimensional scene hierarchy into two dimensional compositing system

Abstract: A hierarchy of (2D) visual objects and (3D) scene objects are integrated for seamless processing to render (2D) images including a (2D) view of a (3D) scene on a (2D) computer display. The processing of the (3D) model objects and (2D) visual objects in the visual hierarchy is integrated so that the processing is readily handed off between (3D) and (2D) operations. Further the number of transitions between processing visual (2D) objects and (3D) model objects when creating a display image has no architectural limit. A data structure integrates computer program objects for creating (3D) images and (2D) images in a visual tree object hierarchy having visual (2D) objects or (3D) scene objects pointing to (3D) model objects. The data structure comprises an object tree hierarchy, one or more visual (2D) objects, and one or more (3D) reference or scene objects pointing to (3D) model objects. The visual (2D) objects define operations drawing a (2D) image. The (3D) reference or scene objects define references pointing to objects with operations that together draw a two-dimensional view of a three-dimensional scene made up of one or more (3D) models. The (3D) reference or scene objects point to (3D) model objects and a camera object. The camera object defines a two-dimensional view of the (3D) scene. The (3D) model objects draw the (3D) models and define mesh information used in drawing contours of a model and material information used in drawing surface texture of a model. The material information for the surface texture of a model may be defined by a visual (2D) object, a (3D) reference or scene object or a tree hierarchy of visual (2D) objects and/or (3D) reference scene objects.

Quantifying the quality of object-oriented design: the factor-strategy model

Abstract: The quality of a design has a decisive impact on the quality of a software product; but due to the diversity and complexity of design properties (e.g., coupling, encapsulation), their assessment and correlation with external quality attributes (e.g., maintenance, portability) is hard. In contrast to traditional quality models that express the "goodness" of design in terms of a set of metrics, the novel Factor-Strategy model proposed by This work, relates explicitly the quality of a design to its conformance with a set of essential principles, rules and heuristics. This model is based on a novel mechanism, called detection strategy, that raises the abstraction level in dealing with metrics, by allowing to formulate good-design rules and heuristics in a quantifiable manner, and to detect automatically deviations from these rules. This quality model provides a twofold advantage: (i) an easier construction and understanding of the model as quality is put in connection with design principles rather than "raw numbers"; and (ii) a direct identification of the real causes of quality flaws. We have validated the approach through a comparative analysis involving two versions of a industrial software system.

Binding to business objects and web services

Abstract: A system and method for method facilitating design-time data binding of business object(s) and/or web service(s) is provided. Developer(s) can specify their own class(es) that do not require specific inheritance, interface implementation or default public constructors. The system includes a binding component that generates control information associated with control(s) based, at least in part, upon binding information associated with an entity (e.g., object, business object and/or web service). The system further includes a control generator that generates control(s) of a form associated with the entity based upon the generated by the binding component. The binding component can utilize public property(ies) of the entity (e.g., object, business object and/or web service). The entity can represent a hierarchy of objects that drill down (e.g., endlessly), including circular relationships. At design-time, a user (e.g., developer) can drag the root of an object (e.g., a business object and/or a web service) onto a form. Control(s) associated with the form are created by the system based on a schema of the object.

Design Patterns Explained: A New Perspective on Object-Oriented Design (2nd Edition) (Software Patterns Series)

Abstract: Leverage the quality and productivity benefits of patterns-without the complexity! Design Patterns Explained, Second Edition is the field's simplest, clearest, most practical introduction to patterns. Using dozens of updated Java examples, it shows programmers and architects exactly how to use patterns to design, develop, and deliver software far more effectively.You'll start with a complete overview of the fundamental principles of patterns, and the role of object-oriented analysis and design in contemporary software development. Then, using easy-to-understand sample code, Alan Shalloway and James Trott illuminate dozens of today's most useful patterns: their underlying concepts, advantages, tradeoffs, implementation techniques, and pitfalls to avoid. Many patterns are accompanied by UML diagrams.Building on their best-selling First Edition, Shalloway and Trott have thoroughly updated this book to reflect new software design trends, patterns, and implementation techniques. Reflecting extensive reader feedback, they have deepened and clarified coverage throughout, and reorganized content for even greater ease of understanding. New and revamped coverage in this edition includes Better ways to start "thinking in patterns" How design patterns can facilitate agile development using eXtreme Programming and other methods How to use commonality and variability analysis to design application architectures The key role of testing into a patterns-driven development process How to use factories to instantiate and manage objects more effectively The Object-Pool Pattern-a new pattern not identified by the "Gang of Four" New study/practice questions at the end of every chapterGentle yet thorough, this book assumes no patterns experience whatsoever. It's the ideal "first book" on patterns, and a perfect complement to Gamma's classic Design Patterns. If you're a programmer or architect who wants the clearest possible understanding of design patterns-or if you've struggled to make them work for you-read this book.

Feature-based design for heterogeneous objects

Abstract: Heterogeneous objects are objects composed of different constituent materials. In these objects, multiple desirable properties from different constituent materials can be synthesized into one part. In order to obtain mass applications of such heterogeneous objects, efficient and effective design methodologies for heterogeneous objects are crucial. In this paper, we present a feature based design methodology to facilitate heterogeneous object design. Under this methodology, designers design heterogeneous objects using high-level design components that have engineering significance. These high level components are form features and material features. In this paper, we first examine the relationships between form features and material features in heterogeneous objects. We then propose three synthesized material features in accordance with our examination of these features. Based on these proposed features, we develop a feature based design methodology for heterogeneous objects. Two enabling methods for this design methodology, material heterogeneity specification within each feature and combination of these material features, are developed. A physics (diffusion) based B-spline method is developed to (1) allow design intent of material variation be explicitly captured by boundary conditions, (2) ensure smooth material variation across the feature volume. A novel method, direct face neighborhood alteration, is developed to increase the efficiency of combining heterogeneous material features. Examples of using this feature based design methodology for heterogeneous object design, such as a prosthesis design, are presented.

Understanding class evolution in object-oriented software

Abstract: In the context of object-oriented design, software systems model real-world entities abstractly represented in the system classes. As the system evolves through its lifecycle, its class design also evolves. Thus, understanding class evolution is essential in understanding the current design of the system and the rationale behind its evolution. In this paper, we describe a taxonomy of class-evolution profiles, a method for automatically categorizing a system's classes in one (or more) of eight types in the taxonomy, and a data-mining method for eliciting co-evolution relations among them. These methods rely on our UMLDiff algorithm that, given a sequence of UML class models of a system, surfaces the design-level changes over its lifecycle. The recovered knowledge about class evolution facilitates the overall understanding of the system class-design evolution and the identification of the specific classes that should be investigated in more detail towards improving the system-design qualities. We report on two case studies evaluating our approach.

Portlet template based on a state design pattern

Abstract: A method for designing object-oriented software for implementing portlets, and an associated computer system and computer program product. The portlets are available to a user of the software who clicks on a link of a first page to identify an action object of an Action class and a state object of a State class. The software includes the State class, the Action class, and program code. The State class includes a method for displaying a view of a page. The Action class includes an actionPerformed method for performing an action and a setState method for setting the state object into the session. The program code is adapted to execute: the actionPerformed method of the action object to perform the action; the setState method of the action object to set the state object; and the method of the state object to display a view of a second page.

Modeling the life cycle of individual data objects

Abstract: A method, as well as a computer program product that implements the method, is provided for user modeling, within a computer system, of a lifecycle of uniquely identified computer data objects that are members of a computer data object family. The method includes receiving a user-defined triggering event occurring in a software application system. The method also includes receiving user-defined permissible states for one or more object attributes that may be present for a uniquely identified computer data object that is a member of the data object family, as well as user-defined permissible transitions between the defined permissible states. The method also includes receiving a user-defined action to be performed on a uniquely identified computer data object that is a member of the computer data object family, when the user-defined triggering event occurs and causes a permissible state transition to occur.

Toward reuse of object-oriented software design models

Abstract: In software reuse, which is an important approach to improving the practice of software engineering, many factors may hinder reusing software artifacts. Among those factors are the availability of software artifacts at a different level of abstraction and a method to classify and retrieve them. This paper proposes an approach based on faceted classification scheme for the classification and retrieval of software design artifacts, namely Object-Oriented Design Models, thus facilitating their reuse. Six facets, Domain, Abstractions, Responsibilities, Collaborations, Design View, and Asset Type have been defined to constitute the classification and the retrieval attributes. Each of the facets describes one aspect of an Object-Oriented design model. It contains a number of predefined terms chosen through the analysis of various software systems specifications. The selected terms of each facet are arranged on a conceptual graph to aid the retrieval process. A design artifact is classified by associating with it a software descriptor through the selection of one or more terms from each facet. The role of a descriptor is to emphasize the important structural and behavioral properties of a design artifact and also to document the artifacts associated with the design model. The associated similarity-based retrieval mechanism helps users to search for candidate design artifacts that best match their target specification. The similarity analysis is based on the estimation of the conceptual distance between the terms in a query descriptor and the terms in the specified descriptors of various design models in a software repository. A case study is presented to illustrate the classification and the retrieval process.

System and method for business object discovery

Abstract: A method and system discovers object definitions by receiving an object and a collaboration code, and determining an object definition for the object based upon the collaboration code.

Ontological representation of learning objects: building interoperable vocabulary and structures

Abstract: The ontological representation of learning objects is a way to deal with the interoperability and reusability of learning objects (including metadata) through providing a semantic infrastructure that will explicitly declare the semantics and forms of concepts used in labeling learning objects. This paper reports the preliminary result from a learning object ontology construction project, which includes an in-depth study of 14 learning objects and over 500 components in these learning objects. An analysis of the types of components and terms used in these objects reveals that most terms fell into the form and subject categories few pedagogical terms were used. Drawing findings from literature and case study, the authors use a matrix to show relationships in learning objects and relevant knowledge and technologies. Strategies and methods in ontology development and implementation are also discussed.

Object-oriented modeling and synthesis of SystemC specifications

Abstract: The constantly increasing complexity of today's systems demands specifications on highest levels of abstraction. In addition to a transition towards the system-level more elaborate techniques are necessary to close a growing productivity gap. Our solution to this problem is the application of the object-oriented programming paradigm together with the de facto industry standard SystemC. In this paper we show that this approach is feasible and present the integration of SystemC into a continuous object-oriented design flow. The design flow includes modeling with UML, hardware/software partitioning and synthesis of object-oriented specifications. We support our claim by results from a case study.

Interaction Design for Complex Problem Solving: Developing Useful and Usable Software

Abstract: Barbara Mirel’s book is interesting and stimulating in many respects. The author addresses the important issue of the development of software to support the various kinds of complex decision-making processes performed by professionals from diverse fields. The author is concerned with complexity as the essential characteristic of the kind of decisions that are to be supported by the software. In her introduction, Mirel introduces the concept of the complexity of the decision-making process. In addition to providing a general and abstract discussion of the concept of complex decision-making processes, Mirel illustrates it through a lengthy quotation from Tolstoy’s novel War and Peace. I greatly enjoyed this; it reminded me of the deepest source of enjoyment I found in 19th century Russian novels—the complexity and consequent realism of their plots and characterizations. The appositeness of the quotation was enhanced by the discussion of a complex visual presentation of the French Army’s strength and location at various stages of the 1812–1813 Russian campaign, as prepared by Minard in 1861 (pp. xxxvi–xxxvii).

Method of providing shared objects and node-specific objects in a cluster file system

Abstract: A method of providing shared objects and node-specific objects in a cluster file system is described and provided. The method includes providing to a particular shared object an attribute, whereas the particular shared object can be a container-type shared object. The attribute indicates any object created in the particular shared object (including its sub-divisions or sub-containers) from this point in time will be designated as node-specific. Furthermore, when a node causes a file system operation that is node-specific to be performed by accessing the particular shared object, the file system operation is performed in an alternate directory corresponding to the node. The alternate directory supports a node-specific object. The shared objects and the node-specific objects can be directories. Additionally, the shared objects and the node-specific objects can be files.

Application of UML for hardware design based on design process model

Abstract: We address a problem of reusing and customizing soft IP components by introducing a concept of design process - a series of common, well-defined and well-proven domain-specific actions and methods performed to achieve a certain design aim. We especially examine system-level design processes that are aimed at designing a hardware system by integrating soft IPs at a high level of abstraction. We combine this concept with object-oriented hardware design using UML and metaprogramming paradigm for describing generation of domain code.

Partitioning a model in modeling environments

Abstract: Methods and systems for partitioning objects in modeling environments are disclosed. The modeling environments enable users to partition an object (parent object) to include other objects (child objects). The parent object may reference the child objects (referenced objects). The child objects may be subsystems in the hierarchy of the parent object or modules (or units) in the partitioning of the parent object. The child objects may be encapsulated so that changes in the parent object do not affect the child objects. The partition of the parent object may allow users to load and compile the parent object incrementally. The partition of the parent object may also allow users to generate code for the parent object incrementally.