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

Identification of Move Method Refactoring Opportunities

Abstract: Placement of attributes/methods within classes in an object-oriented system is usually guided by conceptual criteria and aided by appropriate metrics. Moving state and behavior between classes can help reduce coupling and increase cohesion, but it is nontrivial to identify where such refactorings should be applied. In this paper, we propose a methodology for the identification of Move Method refactoring opportunities that constitute a way for solving many common feature envy bad smells. An algorithm that employs the notion of distance between system entities (attributes/methods) and classes extracts a list of behavior-preserving refactorings based on the examination of a set of preconditions. In practice, a software system may exhibit such problems in many different places. Therefore, our approach measures the effect of all refactoring suggestions based on a novel entity placement metric that quantifies how well entities have been placed in system classes. The proposed methodology can be regarded as a semi-automatic approach since the designer will eventually decide whether a suggested refactoring should be applied or not based on conceptual or other design quality criteria. The evaluation of the proposed approach has been performed considering qualitative, metric, conceptual, and efficiency aspects of the suggested refactorings in a number of open-source projects.

Object identification with tactile sensors using bag-of-features

Abstract: In this paper, we present a novel approach for identifying objects using touch sensors installed in the finger tips of a manipulation robot. Our approach operates on low-resolution intensity images that are obtained when the robot grasps an object. We apply a bag-of-words approach for object identification. By means of unsupervised clustering on training data, our approach learns a vocabulary from tactile observations which is used to generate a histogram codebook. The histogram codebook models distributions over the vocabulary and is the core identification mechanism. As the objects are larger than the sensor, the robot typically needs multiple grasp actions at different positions to uniquely identify an object. To reduce the number of required grasp actions, we apply a decision-theoretic framework that minimizes the entropy of the probabilistic belief about the type of the object. In our experiments carried out with various industrial and household objects, we demonstrate that our approach is able to discriminate between a large set of objects. We furthermore show that using our approach, a robot is able to distinguish visually similar objects that have different elasticity properties by using only the information from the touch sensor.

YADE‐OPEN DEM: an open‐source software using a discrete element method to simulate granular material

Abstract: Purpose – YADE‐OPEN DEM is an open‐source software based on the discrete element method, (DEM) which uses object oriented programming techniques. The purpose of this paper is to describe the software architecture.Design/methodology/approach – The DEM chosen uses position, orientation, velocity and angular velocity as independent variables of simulated particles which are subject to explicit leapfrog time‐integration scheme (Lagrangian method). The three‐dimensional dynamics equations based on the classical Newtonian approach for the second law of motion are used. The track of forces and moments acting on each particle is kept at every time step. Contact forces depend on the particle geometry overlap and material properties. The normal, tangential and moment components of interaction force are included.Findings – An effort is undertaken to extract the underlying object oriented abstractions in the DEM. These abstractions are implemented in C++, conform to object oriented design principles and use design pa...

Typestate-oriented programming

Abstract: Objects model the world, and state is fundamental to a faithful modeling. Engineers use state machines to understand and reason about state transitions, but programming languages provide little support for reasoning about or implementing these state machines, causing software defects and lost productivity when objects are misused.We propose Typestate-Oriented Programming as a natural extension to the object paradigm, where objects are modeled not just in terms of classes, but in terms of changing states. Each state may have its own representation and methods which may transition the object into a new state. A flow-sensitive, permission-based type system helps developers track which state objects are in. First-class typestates are a powerful abstraction that will help developers model and reuse objects more efficiently and correctly.

Utilizing object-object and object-scene context when planning to find things

Abstract: In this paper, our goal is to search for a novel object, where we have a prior map of the environment and knowledge of some of the objects in it, but no information about the location of the specific novel object. We develop a probabilistic model over possible object locations that utilizes object-object and object-scene context. This model can be queried for any of over 25,000 naturally occurring objects in the world and is trained from labeled data acquired from the captions of photos on the Flickr website. We show that these simple models based on object co-occurrences perform surprisingly well at localizing arbitrary objects in an office setting. In addition, we show how to compute paths that minimize the expected distance to the query object and show that this approach performs better than a greedy approach. Finally, we give preliminary results for grounding our approach in object classifiers.

Multi-touch object inertia simulation

Abstract: The inertia system provides a common platform and application-programming interface (API) for applications to extend the input received from various multi-touch hardware devices to simulate real-world behavior of application objects. To move naturally, application objects should exhibit physical characteristics such as elasticity and deceleration. When a user lifts all contacts from an object, the inertia system provides additional manipulation events to the application so that the application can handle the events as if the user was still moving the object with touch. The inertia system generates the events based on a simulation of the behavior of the objects. If the user moves an object into another object, the inertia system simulates the boundary characteristics of the objects. Thus, the inertia system provides more realistic movement for application objects manipulated using multi-touch hardware and the API provides a consistent feel to manipulations across applications.

Dynamic demand calculation using captured data of real life objects

Abstract: Methods and system for managing demand for an object includes capturing information about the object through a mobile device associated with a user. The mobile device is configured to capture information about the object that include one or more of a spatial, temporal, topical and social attributes of the object. The identity of the object is verified and validated using this metadata captured by the user through the device from the real world object or its proxy. Upon successful verification and validation, the object and its metadata are automatically added to a wish list of the user. An aggregate list is generated using the attributes and metadata of the object from a plurality of users. The aggregate list defines a source of demand for the object. The object is tracked as it progresses through various phases of ownership cycle using dynamic demand calculations based on the information associated with the objects, the users and the aggregate lists.

Metric based testability model for object oriented design (MTMOOD)

Abstract: This paper does an extensive review on testability of object oriented software, and put forth some relevant information about class-level testability. Testability has been identified as a key factor to software quality, and emphasis is being drawn to predict class testability early in the software development life cycle. A Metrics Based Model for Object Oriented Design Testability (MTMOOD) has been proposed. The relationship from design properties to testability is weighted in accordance with its anticipated influence and importance. A suit of adequate object-oriented metrics useful in determining testability of a system has been proposed, which may be used to locate parts of design that could be error prone. Identification of changes in theses parts early could significantly improve the quality of the final product and hence decrease the testing effort. The proposed model has been further empirically validated and contextual interpretation has been drawn using industrial software projects.

Toward interactive learning of object categories by a robot: A case study with container and non-container objects

Abstract: This paper proposes an interactive approach to object categorization that is consistent with the principle that a robot's object representations should be grounded in its sensorimotor experience. The proposed approach allows a robot to: 1) form object categories based on the movement patterns observed during its interaction with objects, and 2) learn a perceptual model to generalize object category knowledge to novel objects. The framework was tested on a container/non-container categorization task. The robot successfully separated the two object classes after performing a sequence of interactive trials. The robot used the separation to learn a perceptual model of containers, which, which, in turn, was used to categorize novel objects as containers or non-containers.

Three-dimensional object recognition system and inventory system using the same

Abstract: A system recognizes an arrangement of an object and counts the number of objects, comprising: a sensor for measuring a distance between the sensor and an object; a moving mechanism for moving the sensor; and a computer that is connected with the sensor and includes an object information database, an object arrangement database; a sensor data integrating section; and the sensor an object comparison calculator adapted to create an object model based on the data.

HOP: Hierarchical object parsing

Abstract: In this paper we consider the problem of object parsing, namely detecting an object and its components by composing them from image observations. Apart from object localization, this involves the question of combining top-down (model-based) with bottom-up (image-based) information. We use an hierarchical object model, that recursively decomposes an object into simple structures. Our first contribution is the formulation of composition rules to build the object structures, while addressing problems such as contour fragmentation and missing parts. Our second contribution is an efficient inference method for object parsing that addresses the combinatorial complexity of the problem. For this we exploit our hierarchical object representation to efficiently compute a coarse solution to the problem, which we then use to guide search at a finer level. This rules out a large portion of futile compositions and allows us to parse complex objects in heavily cluttered scenes.

GATMO: A Generalized Approach to Tracking Movable Objects

Abstract: We present GATMO (Generalized Approach to Tracking Movable Objects), a system for localization and mapping that incorporates the dynamic nature of the environment while maintaining semantic labels. Objects in the environment are broken down into multiple mobility levels, from static (walls) to highly mobile (people), by maintaining a history of object movement. Object classification is accomplished through a multi-layer, multi-hypothesis approach that does not rely on any static features such as shape or size. Maps are stored in an efficient manner that incorporates a history of previous orientations of each object. GATMO is initialized with a static map; it subsequently changes the map over time as objects in the map change position.

Virtual machine tool interface for tracking objects

Abstract: Disclosed is a method and computer program product to track allocation of a plurality of objects in a heap. A data processing system, during an object allocation, prevents an object from being moved to another place in memory or being deleted. The data processing system prevents such activity concurrently with garbage collection on a second object not currently being allocated. The data processing system notifies a profiler of object information based on the object allocation via a callback function, wherein object information is a one-to-one mapping of the object address. The data processing system revives garbage collector processing of the object.

Object-oriented design: A goal-driven and pattern-based approach

Abstract: In recent years, the influences of design patterns on software quality have attracted increasing attention in the area of software engineering, as design patterns encapsulate valuable knowledge to resolve design problems, and more importantly to improve the design quality. One of the key challenges in object-oriented design is how to apply appropriate design patterns during the system development. In this paper, design pattern is analyzed from different perspectives to see how it can facilitate design activities, handle non-functional requirement, solve design problems and resolve design conflicts. Based on the analysis, various kinds of applicability of design patterns are explored and integrated with a goal-driven approach to guiding developers to construct the object-oriented design model in a systematic manner. There are three benefits to the proposed approach: making it easy to meet requirements, helping resolve design conflicts, and facilitating improvement of the design quality.

Metrics to study symptoms of bad software designs

Abstract: Design of a software product largely influences its quality Good design is one of the pre-requisites of a high quality product Me-trics are usually used to assess the quality of software designs The metrics for object oriented design focus on design characteristics, such as abstraction, coupling, cohesion, inheritance, polymorphism and encapsulation and are applied at attribute, method, class, pack-age, file and systems levels Design metrics help the software de-signers to understand the problem areas in a design and to develop prediction models A number of studies have modeled relation-ships between object oriented metrics and reusability, defects and faults, maintainability, and effort, and cost savings So design me-trics can give an early indication of goodness of design and thus of the software product developed using that design If designers know symptoms of bad design then it is helpful for them to avoid the bad design In this paper, we have explored some of the symp-toms of bad design and studied metric relationships which high-light these symptoms

Systems and methods for transporting physical objects from real physical life into virtual worlds

Abstract: Systems and methods for transporting physical objects from real physical life into virtual worlds. Briefly stated, the method includes receiving characteristic and structure data from an object constructed in the real world. The characteristic and structure data is obtained from the object using a plurality of sensors placed in the vicinity of the object to sense the characteristics and structure of the object. The characteristic and structure data of the object is used to produce code necessary to create an equivalent representation of the object in a virtual world.

Unifying aspect- and object-oriented design

Abstract: The contribution of this work is the design and evaluation of a programming language model that unifies aspects and classes as they appear in AspectJ-like languages. We show that our model preserves the capabilities of AspectJ-like languages, while improving the conceptual integrity of the language model and the compositionality of modules. The improvement in conceptual integrity is manifested by the reduction of specialized constructs in favor of uniform orthogonal constructs. The enhancement in compositionality is demonstrated by better modularization of integration and higher-order crosscutting concerns.

Ontology Modeling and Object Modeling in Software Engineering

Abstract: A data model is a plan for building a database and is comparable to an architect's building plans There are two major methodologies used to create a data model: the EntityRelationship (ER) approach and the Object Model This paper will be discussed only the object model approach The goal of the data model is to certify that all data objects required by the database are completely and accurately represented Ontologies are objects of interest (Universal of discourse) The objective of this paper is to simplify object models compare with ontologies models There are some similarities between objects in object models and concepts sometimes called classes in ontologies Ontology can help building object model The object model is the center of data modeling; on the other hand ontology itself has the concept which is the basis of knowledge base Because ontologies are closely related to modern object-oriented software design, it is good attempt to adapt existing object-oriented software development methodologies for the task of ontology development Selected approaches originate from research in artificial intelligence; knowledge representation and object modeling are presented in this paper Some issues mentioned in this paper are related with their connection; some are addressed directly into the similarities or differences point of view of both This paper also presents the available tools, methods, procedures, language, reusability which shows the corporation with object modeling and ontologies

Modeling constraints improves software architecture design reasoning

Abstract: Requirements and project-related factors influence architectural design in intricate and multivariate ways. We are only beginning to understand some of the tacit but fundamental mechanisms involved in reasoning about design decisions, and one of them concerns the role of design constraints. This paper examines design constraints and how they shape design solutions. We introduce a design constraint model and an architectural design reasoning process for specifying design constraints and checking for design conflicts. We experiment with using logic for constraint verification with the Alloy tool.

Analyzing pixel data by imprinting objects of a computer-implemented network structure into other objects

Abstract: An analysis system analyzes digital images using a computer-implemented network structure that includes a process hierarchy, a class network and a data network. The data network includes image layers and object networks. Objects in a first object network are segmented into a first class, and objects in a second object network are segmented into a second class. One process step of the process hierarchy involves generating a third object network by imprinting objects of the first object network into the objects of the second object network such that pixel locations are unlinked from objects of the second object network to the extent that the pixel locations were also linked to objects of the first object network. The imprinting step allows object-oriented processing of digital images to be performed with fewer computations and less memory. Characteristics of an object of the third object network are then determined by measuring the object.

From Acoustic Object Recognition to Object Categorization by a Humanoid Robot

Abstract: Human beings have the remarkable ability to cat- egorize everyday objects based on their physical and functional properties. Studies in developmental psychology have shown that infants can form such object categories by actively interacting and playing with objects in their surroundings. It is infeasible to pre-program a robot with knowledge about every single object that might appear in a home or an office. If robots are to succeed in human inhabited environments, they would also need the ability to form object categories and relate them to one another. In this work, we present an approach to interactive object categorization in which the robot uses the natural sounds produced by objects to form object categories. The method is evaluated on an upper-torso humanoid robot which performs five different manipulation behaviors (grasp, shake, drop, push, and tap) on 36 common household objects (e.g., cups, balls, boxes, pop cans, etc.). Using unsupervised hierarchical clustering, the robot is able to form a hierarchical taxonomy of the objects that it interacts with. The results show that the formed categories capture certain physical properties of the objects and allow the robot to quickly recognize the correct category for a novel object after a single interaction with it.

Method and system for updating object data with respect to object specifications in a product life cycle management system

Abstract: The invention is directed to a Product Lifecycle Management (PLM) update process for updating objects with respect to specifications. The process invokes dependence relations between objects. It relies on building a directed graph, wherein objects are the nodes of the graph. An arc (also called “edge”) is directed from a second object to a first object, the latter depending on the second object according to dependence relations of the PLM system. Thus, the update can be carried by browsing the graph along the direction of the arcs in the graph. Owing to the reversion of the graph with respect to the dependence of objects, the simple solution of the invention guarantees that the update of an object occurs only when the ancestor object it depends on is up to date, and so on. This drastically reduces failures at update in practice.

Intelligent Design Objects (IDO): a cognitive approach for performance-based design

Abstract: Design is complex. This is because it involves conflicting goals that are often vague. Also, prior to the design it is generally not clear how important goals are relative to each other. And finally the amount of possible solutions is large in general. These bottlenecks are addressed in this thesis. A novel approach for design is proposed, where computation is used to reach most suitable solutions. The approach is based on a novel concept of the objects forming a design. This concept is termed intelligent design objects. Such objects exhibit intelligent behavior in the sense that they approach most desirable solutions for conflicting, vague goals put forward by a designer. That is, the objects know ‘themselves’ what to do to satisfy a designer’s goals. This is accomplished using methods from the domain of computational intelligence, as these are uniquely able to deal with the complexity of design mentioned above. The result from the approach is that designers and decision makers have great certainty about the satisfaction of their goals and are able to concentrate on second order aspects they were not aware of prior to the execution. The approach is implemented for two applications from the domain of architecture demonstrating its effectiveness. The thesis addresses to students, researchers and executives in the field of architecture, and other areas of design. It may be also interesting for researchers in the domain of computational intelligence, as it provides a formalism of intelligent design, and it exemplifies the use of these modern technologies in the design domain. Due to its generic nature, this formalism may have some significance in the development of the science of design.

Interactive learning of visually symmetric objects

Abstract: This paper describes a robotic system that learns visual models of symmetric objects autonomously. Our robot learns by physically interacting with an object using its end effector. This departs from eye-in-hand systems that move the camera while keeping the scene static. Our robot leverages a simple nudge action to obtain the motion segmentation of an object in stereo. The robot uses the segmentation results to pick up the object. The robot collects training images by rotating the grasped object in front of a camera. Robotic experiments show that this interactive object learning approach can deal with top-heavy and fragile objects. Trials confirm that the robot-learned object models allow robust object recognition.

The effect of task order on the maintainability of object-oriented software

Abstract: This paper presents results from a quasi-experiment that investigates how the sequence in which maintenance tasks are performed affects the time required to perform them and the functional correctness of the changes made. Specifically, the study compares how time required and correctness are affected by (1) starting with the easiest change task and progressively performing the more difficult tasks (Easy-First), versus (2) starting with the most difficult change task and progressively performing the easier tasks (Hard-First). In both cases, the experimental tasks were performed on two alternative types of design of a Java system to assess whether the choice of the design strategy moderates the effects of task order on effort and correctness. The results show that the time spent on making the changes is not affected significantly by the task order of the maintenance tasks, regardless of the type of design. However, the correctness of the maintainability tasks is significantly higher when the task order of the change tasks is Easy-First compared to Hard-First, again regardless of design. A possible explanation for the results is that a steeper learning curve (Hard-First) causes the programmer to create software that is less maintainable overall.

STEPNCMillUoA: a CNC system based on STEP-NC and Function Block architecture

Abstract: STEPNCMillUoA is the prototype of a new CNC system that utilises the STEP-NC data model and IEC 61499. STEP-NC provides a high-level data model and enables feature-based machining whereas the enabled layered Function Block architecture simplifies the design of the CNC controller. The architecture layers are responsible for data processing, storage and execution. The object-oriented Model-View-Control design pattern supports the system architecture and the design framework, in which simulation of the machining becomes natural and inherent part of the design process, with seamless transition from simulation to actual machining. This system possesses interoperability, portability, re-configurability and distribution characteristics. The system was tested through simulation and actual machining.