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

Empirical analysis of CK metrics for object-oriented design complexity: implications for software defects

Abstract: To produce high quality object-oriented (OO) applications, a strong emphasis on design aspects, especially during the early phases of software development, is necessary. Design metrics play an important role in helping developers understand design aspects of software and, hence, improve software quality and developer productivity. In this paper, we provide empirical evidence supporting the role of OO design complexity metrics, specifically a subset of the Chidamber and Kemerer (1991, 1994) suite (CK metrics), in determining software defects. Our results, based on industry data from software developed in two popular programming languages used in OO development, indicate that, even after controlling for the size of the software, these metrics are significantly associated with defects. In addition, we find that the effects of these metrics on defects vary across the samples from two programming languages-C++ and Java. We believe that these results have significant implications for designing high-quality software products using the OO approach.

Metropolis: an integrated electronic system design environment

Abstract: Today, the design chain lacks adequate support, with most system-level designers using a collection of unlinked tools. The implementation then proceeds with informal techniques involving numerous human-language interactions that create unnecessary and unwanted iterations among groups of designers in different companies or different divisions. The move toward programmable platforms shifts the design implementation task toward embedded software design. When embedded software reaches the complexity typical of today's designs, the risk that the software will not function correctly increases exponentially. The Metropolis project seeks to develop a unified framework that can cope with this challenge. Based on a metamodel with formal semantics that developers can use to capture designs, Metropolis provides an environment for complex electronic-system design that supports simulation, formal analysis, and synthesis.

Intermediary Objects as a Means to Foster Co-operation inEngineering Design

Abstract: In this paper we argue that co-operation is a particular way to co-ordinate an industrial activity and that it is particularly suited to collaborative design activity. Through a well documented case study of the development of a front truck axle, we point out several key features of co-operation in an industrial setting. We particularly pay attention to the interfaces between the actors involved in the collaborative process. We observed the pre-eminence of the representations and the objects created, manipulated, and finally we claim that they support knowledge creation and therefore allow the development of a common understanding of the design situation (i.e. the problem and the solution). We propose the concept of ``intermediary object'' as a conceptual framework for the involvement of objects in the design process. We demonstrate the power of this concept in the analysis and modelling of particular design situations and in the development of specific objects that foster co-operation in real design situations.

Predicting maintenance performance using object-oriented design complexity metrics

Abstract: The Object-Oriented (OO) paradigm has become increasingly popular in recent years. Researchers agree that, although maintenance may turn out to be easier for OO systems, it is unlikely that the maintenance burden will completely disappear. One approach to controlling software maintenance costs is the utilization of software metrics during the development phase, to help identify potential problem areas. Many new metrics have been proposed for OO systems, but only a few of them have been validated. The purpose of this research is to empirically explore the validation of three existing OO design complexity metrics and, specifically, to assess their ability to predict maintenance time. This research reports the results of validating three metrics, Interaction Level (IL), Interface Size (IS), and Operation Argument Complexity (OAC). A controlled experiment was conducted to investigate the effect of design complexity (as measured by the above metrics) on maintenance time. Each of the three metrics by itself was found to be useful in the experiment in predicting maintenance performance.

Object ownership and containment

Abstract: Object-oriented programming relies on inter-object aliases to implement but it is when mutable state interacts with aliasing that problems arise. Through aliasing an object's state can be changed without the object being aware of the changes, potentially violating the object's invariants. This problem is fundamentally unresolvable. Many idioms such as the Observer design pattern rely on it. Hence aliasing cannot be eliminated from object-oriented programming, it can only be managed. Various proposals have appeared in the literature addressing the issue of alias management. The most promising are based on alias encapsulation, which limits access to objects to within certain well-defined boundaries. Our approach called ownership types falls into this category. An object can specify the objects it owns, called its representation, and which objects can access its representation. A type system protects the representation by enforcing a well-defined containment invariant. Our approach is a formal one. Ownership types are cast as a type system using an minor extension to Abadi and Cardelli's object calculus with subtyping. With this formalisation we prove the soundness of our ownership types system and demonstrate that well-typed programs satisfy the containment invariant. In addition, we also provide a firm grounding to enable ownership types to be safely added to an object-oriented programming language with inheritance, subtyping, and nested classes, as well as offering a sound basis for future work. Our type system can model aggregate objects with multiple interface objects sharing representation and friendly functions which access multiple objects' private representations, among other examples, thus overcoming weaknesses in existing alias management schemes.

A metric-based approach to enhance design quality through meta-pattern transformations

Abstract: During the evolution of object-oriented legacy systems, improving the design quality is. most often a highly demanded objective. For such systems which have a large number of classes and are subject to frequent modifications, detection and correction of design defects is a complex task. The use of automatic detection and correction tools can be helpful for this task. Various research approaches have proposed transformations that improve the quality of an object-oriented systems while preserving its behavior This paper proposes a framework where a catalogue of object-oriented metrics can be used-as indicators for automatically detecting situations where a particular transformation can be applied to improve the quality of an object-oriented legacy system. The correction process is based on analyzing the impact of various meta-pattern transformations on these object-oriented metrics.

Smart-Its: An Embedded Platform for Smart Objects

Abstract: Computer and communication hardware has become so small and inexpensive to consider their embedding in everyday objects As a consequence it is expected that networked smart objects will give rise to new types of application and in particular such that are more tightly coupled with activity in the physical world Recent years have seen many design examples for smart objects but for lack of a suitable platform it has remained difficult to study applications that involve networked operation of a diversity of such objects In the Smart-Its project we are addressing this concern with development of embedded technology designed for post hoc augmentation of everyday objects This paper describes our technology concept and the design of the 1G Smart-Its hardware/software platform

A brief history of the object-oriented approach

Abstract: Unlike other fads, the object-oriented paradigm is here to stay. The road towards an object-oriented approach is described and several object-oriented programming languages are reviewed. Since the object-oriented paradigm promised to revolutionize software development, in the 1990s, demand for object-oriented software systems increased dramatically; consequently, several methodologies have been proposed to support software development based on that paradigm. Also presented are a survey and a classification scheme for object oriented methodologies.

System and method for managing hierarchical objects

Abstract: A system and method for storing hierarchical objects. The system stores a list of hierarchies as a single object. The object includes all information relating to a particular data element. The data element may be a concept. The concept may include all related information such that if one or more portions of the data element are requested by a user, the entire data object including the requested portions is retrieved. A user may navigate forward and backward through the hierarchy and search for other information. The object is stored as a self-defining object such that all information relating to the data element is stored within the object.

Shared object memory with object management for multiple virtual machines

Abstract: A shared object memory system that includes a shared object memory for storing encapsulated software objects that are directly accessible by plural object application processes. The shared object memory is distinct from the process memories of the object application processes and does not include an execution model. A shared object memory manager provides management of objects within the shared object memory.

Complex object comparison in a fuzzy context

Abstract: The comparison concept plays a determining role in many problems related to object management in an Object-Oriented Database Model. Object comparison is appropriately managed in a crisp object-oriented context by means of the concepts of identity and value equality. However, when dealing with imprecise or imperfect objects, questions like ‘To which extent may two objects be the same one?’ or ‘How similar are two objects?’ have not a clear answer, because the equality concept becomes fuzzy. In this paper we present a set of operators that are useful when comparing objects in a fuzzy environment. In particular, we introduce a generalized resemblance degree between two fuzzy sets of imprecise objects and a generalized resemblance degree to compare complex fuzzy objects within a given class. q 2003 Elsevier Science B.V. All rights reserved.

Estimating the design effort of Web applications

Abstract: We focus on the effort needed for designing Web applications. The effort required for the design phase is an important part of the total development effort of a Web application, whose implementation can be (partially) automated by tools. We carried out an empirical study with the students of an advanced university class that used W2000, as the special-purpose object-oriented design notation for the design of Web applications. We investigated the impact of a number of attributes (e.g., size, complexity) of the W2000 design artifacts built during the design phase on the total effort needed to design Web applications and we identified a few attributes that may be related to the total design effort. In addition, we carried out a finer-grain analysis, by studying which of these attributes have an impact on the effort devoted to the steps of the design phase that are followed when using W2000.

Physics-Based Modeling for Heterogeneous Objects

Abstract: Heterogeneous objects are composed of different constituent materials. In these objects, material properties from different constituent materials are synthesized into one part. Therefore, heterogeneous objects can offer new material properties and functionalities. The task of modeling material heterogeneity (composition variation) is a critical issue in the design and fabrication of such heterogeneous objects. Existing methods cannot efficiently model the material heterogeneity due to the lack of an effective mechanism to control the large number of degrees of freedom for the specification of heterogeneous objects. In this research, we provide a new approach for designing heterogeneous objects. The idea is that designers indirectly control the material distribution through the boundary'conditions of a virtual diffusion problem in the solid, rather than directly in the native CAD (B-spline) representation for the distribution. We show how the diffusion problem can be solved using the B-spline shape function, with the results mapping directly to a volumetric B-Spline representation of the material distribution, We also extend this method to material property manipulation and time dependent heterogeneous object modeling. Implementation and examples, such as a turbine blade design and prosthesis design, are also presented. They demonstrate that the physics based B-spline modeling method is a convenient, intuitive, and efficient way to model object heterogeneity.

Software quality analysis with the use of computational intelligence

Abstract: Quality of individual objects composing a software system is one of the important factors that determine quality of this system. Quality of objects, on the other hand, can be related to a number of attributes, such as extensibility, reusability, clarity and efficiency. These attributes do not have representations suitable for automatic processing. There is a need to find a way to support quality related activities using data gathered during quality assurance processes, which involve humans. This paper proposes an approach, which can be used to support quality assessment of individual objects. The approach exploits techniques of Computational Intelligence that are treated as a consortium of granular computing, neural networks and evolutionary techniques. In particular, self-organizing maps and evolutionary-based developed decision trees are used to gain a better insight into the software data and to support a process of classification of software objects. Genetic classifiers—a novel algorithmic framework—serve as ‘filters’ for software objects. These classifiers are built on data representing subjective evaluation of software objects done by humans. Using these classifiers, a system manager can predict quality of software objects and identify low quality objects for review and possible revision. The approach is applied to analyze an object-oriented visualization-based software system for biomedical data analysis.

Central master data management

Abstract: Methods and apparatus, including computer program products, for sharing data. The technique includes creating at least one data object in a central system, the data object including a complete object definition, and dependencies to other objects, mapping at least one data object to other data objects in the central system, and distributing data objects from the central system to one or more client systems, where the one or more client systems.

Investigation of metrics for object-oriented design logical stability

Abstract: As changes are made to an object-oriented design, its structure and/or behavior may be affected. Modifications made to one class can have ripple effects on other classes in the design. The stability of an object-oriented design indicates its resistance to interclass propagation of changes that the design would have when it is modified There are two aspects of design stability: logical stability and performance stability. Logical stability is concerned with design structure, whereas performance stability is concerned with design behavior. In this study, the object-oriented design metrics proposed by Chidamber and Kemerer (1994) were adopted as candidate indicators of the logical stability of object-oriented designs. The objective was to investigate whether or not there are correlations between these metrics and the logical stability of classes. The experimental results indicated that WMC, DIT CBO, RFC, and LCOM metrics are negatively correlated with the logical stability of classes. However, no correlation was found between NOC metric and the logical stability of classes.

Schema server object model

Abstract: A schema model allows objects to be contextualized by using stored values that are used to localize the object. The values used for localizing each object that is to be localized are stored in a container class element that is associated with the object that is to be localized. The object having localized term values stored in a container class element is related to another object wherein the objects are related using one of a hierarchical term and an entry term relationship. The associate values allow a user to override by redefinition default values presented by a controlled vocabulary system. The user can further relate term objects by using hierarchical-, entry-, and related-term relationships. This arrangement allows users and systems to more effectively re-use standard data definitions.

Model-Driven Development - From Object-Oriented Design to Actor-Oriented Design

Abstract: Most current software engineering is deeply rooted in procedural abstractions These say little about concurrency, temporal properties, and assumptions and guarantees in the face of dynamic system structure Actor-oriented design contrasts with (and complements) object-oriented design by empha- sizing concurrency and communication between com- ponents Components called actors execute and communicate with other actors While interfaces in object-oriented design (methods, principally) mediate transfer of the locus of control, interfaces in actor-ori- ented design (which we call ports) mediate communi- cation But the communication is not assumed to involve a transfer of control This paper explores the use of behavioral type systems in actor-oriented design

Method, system, and software for mapping and displaying process objects at different levels of abstraction

Abstract: A method, system, and software for mapping and displaying process objects at different levels of abstraction includes correlating business level objects to application level objects. Source data is associated with indications for both the relevant business level objects and the application level objects and stored in a database. The stored data is displayed associated with both the business level objects and the application level objects.

Object-oriented design with UML and Java

Abstract: Object-oriented Systems Analysis and Design Using UMLTools for Structured and Object-oriented DesignPrinciples of Object-Oriented ProgrammingAdvanced Object-Oriented Analysis and Design Using UMLUML and C++Ebook: Object-Oriented Systems Analysis and Design Using UMLPractical Object-oriented Development with UML and JavaJava DesignObject-Oriented Analysis and DesignObjectoriented Modeling and Design with UMLUML and Object-Oriented Design FoundationsObject-Oriented Analysis and Design for Information SystemsPractical Object-oriented Design with UMLJava the UML WayObject Oriented Analysis and Design Using UMLUML DistilledDeveloping Software with UMLPractical Object Oriented DesignThe Object PrimerObject -Oriented Analysis and Design Using UMLUML 2 and the Unified ProcessDesign PatternsSystems Analysis and DesignLearning PHP Design Patterns3D Discrete Element Workbench for Highly Dynamic Thermo-mechanical AnalysisObject-Oriented Analysis and Design with ApplicationsApplying UML and Patterns Training CourseAn Introduction to Object-oriented Systems Analysis and Design with UML and the Unified ProcessWhat Every Programmer Should Know about Object-oriented DesignUML @ ClassroomAPPLYING UML & PATTERNS 3RD EDITIONObject-oriented Systems Analysis and Design with UMLObject-oriented Systems Analysis and DesignObject-Oriented Design with UML and JavaPractical ObjectOriented Design With UmlDesigning Flexible Object-oriented Systems with UMLObject-Oriented Analysis and Design Using UMLFundamentals of Object-oriented Design in UMLObject-Oriented Software Engineering Using UML, Patterns, and Java: Pearson New International EditionHead First Object-Oriented Analysis and Design "Building on their classroom teaching experiences over the years, Dr Jeya Mala and Dr Geetha have deployed an innovative approach and student-friendly style to explain Object Oriented Analysis and Design concepts, thereby ensuring that the interest of the readers is maintained. The textbook covers case studies, activity models, and diagrams using the latest version of UML 2. The book contains adequate span to cover the curriculum requisites and rich pedagogical features to cater to the needs of undergraduate

Fuzzy location of a testable object in a functional testing tool

Abstract: A method, system and apparatus for locating a testable object in a functional testing tool is provided. The system can include a record process configured to produce both a test script and an object mapping, and a playback process configured to process the test script. An object manager can be coupled to the playback process and configured to locate among candidate objects in a GUI, a candidate object having a set of properties which partially matches another set of properties associated with a corresponding test object in the object mapping.

Using objected-oriented and UML tools for hardware design: A case study

Abstract: This paper argues for the adoption of object-oriented design and UML tools for nonsoftware designs, i.e., systems, hardware and algorithms: This is a controversial position. It presents a case study, the design of a heating, ventilation, and air conditioning system, using UML tools. This case study also shows the incremental elaboration used to progress from the requirements model, to the analysis model, to the design model, etc. The paper finally discusses some difficulties that must be overcome in order to apply UML tools to system designs. © 2002 Wiley Periodicals, Inc. Syst Eng 6: 28–48, 2003.

Finding Boundary Objects in SE and HCI: An Approach Through Engineering-oriented Design Theories.

Abstract: This paper outlines an approach of using engineeringoriented design theories to build bridges between software engineering and human–computer interaction. The main thrust of the approach is to try to use design theories to create “boundary objects”, which are intellectual tools that are shared by both disciplines and enable cooperation. The approachis illustrated and supported by relating it to ongoing domain-bridging work which is exploring the application of cognitive support theories to SE research problems.

System and method for moving graphical objects on a computer controlled system

Abstract: A user interface method and system for positioning graphical objects in the display area of a free form system. A selected object may operate in a first state where it can be moved to different positions within the display area. The selected object may further operate in a second state where movement of the selected object causes other graphical objects within its path of movement to also move. The state of the selected object is indicated by a visually distinct presentation of the graphical object, for example when in the first state the graphical object is shown to have shadow to provide the visual clue that it is “above” the other graphical objects in the display area. A user may dynamically switch between states based on signals provided to the system.

Software componentization for building a software product

Abstract: A componentization schema representing files from which an operating system or other software product is built. According to the schema, a component object represents one or more of the files. The component object has a manifest that identifies the component and specifies any dependencies between the component and other objects. Grouping objects according to the dependencies specified in manifests permits building the software product. A feature object defined by at least one component object represents a feature of the software product and a product object defined by at least one feature object represents the software product.

A Formal Library for Aiding Metrics Extraction

Abstract: This paper presents a library of measures, named FLAME – A Formal Library for Aiding Metrics Extraction, which is mainly used to formalize object-oriented design metrics definitions The library itself is formalized with the Object Constraint Language upon the UML meta-model The combination of FLAME functions together with the UML meta-model allow unambiguous metrics definitions, which in turn help increasing tool support for objectoriented metrics extraction When applied to the object-oriented design, the metrics definitions performed with FLAME make available a set of comparisons among different models, leading to recommendations and conclusions for the developers These assumptions can help improving the quality of object-oriented design, as well as they indirectly help in the enhancement of this methodology, contributing to the progress of the overall software life cycle

Session bean implementation of a system, method and software for creating or maintaining distributed transparent persistence of complex data objects and their data relationships

Abstract: The invention provides systems, methods and software for creating or maintaining distributed transparent persistence of complex data objects and associated data stores. In one aspect, the invention also relates to an application programming object capable of creating or maintaining distributed transparent persistence of data objects or data object graphs without the necessity of inserting any byte codes or modification of the object graph. Virtually any java object or object graph can be transparently persisted. Further, copies of a data graph or of a portion of the data graph can be automatically reconciled and changes persisted without any persistence coding in the object model.

Code generation from UML statecharts

Abstract: The Unified Modeling Language (UML) statechart diagram is a powerful tool for specifying the dynamic behavior of reactive objects. Generating code from statechart diagrams is a challenging task due to its dynamic nature and because many of the statechart concepts are not supported by the object oriented programming languages. Most of the approaches for implementing UML statecharts diagram either suffer from maintenance problems or implement only a subset of UML statecharts. This paper proposes a new approach to generate efficient and compact executable code from the UML statechart diagram in an object-oriented language like Java using design patterns. In our approach, each state in the statechart becomes a class, which encapsulates all the transitions and actions of the state. The events that have transitions are thus made explicit without using any if or case statement, which leads to a readable , compact and efficient code. The resultant code is easy to maintain. By representing states as objects, we extend the state design pattern to implement the sequential substates and concurrent substates using the concept of object composition and delegation. We also propose an approach to implement compound transitions (fork/join) and history nodes. The proposed approach makes elegant handling of most of the statechart features.