Developing an object‐oriented framework for content‐based image retrieval

Content‐based image retrieval (CBIR) is a process of retrieving images from an image database by exploiting the content of the images (typically the querying of an image). CBIR avoids many problems associated with traditional ways of retrieving images by keywords. Thus, a growing interest in the area of CBIR has been established in recent years. In this paper, a novel object‐oriented framework (CBIRFrame) is built for CBIR applications development. We discuss the motivations for CBIRFrame before discussing its design in detail. Two applications of CBIRFrame are also briefly discussed to show the effectiveness of applying CBIRFrame to real applications. Finally, we outline the possible uses of the design of CBIRFrame for other types of domains, such as content‐based retrieval of video clips. Copyright © 2003 John Wiley & Sons, Ltd.     

A dependency constraint language to manage object‐oriented software architectures

This paper presents a domain‐specific dependency constraint language that allows software architects to restrict the spectrum of structural dependencies, which can be established in object‐oriented systems. The ultimate goal is to provide architects with means to define acceptable and unacceptable dependencies according to the planned architecture of their systems. Once defined, such restrictions are statically enforced by a tool, thus avoiding silent erosions in the architecture. The paper also presents results from applying the proposed approach to different versions of a real‐world human resource management system. Copyright © 2009 John Wiley & Sons, Ltd.     

Agents in object‐oriented software engineering

Software engineers of multi‐agent systems (MASs) are faced with different concerns such as autonomy, adaptation, interaction, collaboration, learning, and mobility, which are essentially different from classical concerns addressed in object‐oriented software engineering. MAS developers, however, have relied mostly on object‐oriented design techniques and programming languages, such as Java. This often leads to a poor separation of MAS concerns and in turn to the production of MASs that are difficult to maintain and reuse. This paper discusses software engineering approaches for MASs, and presents a new method for integrating agents into object‐oriented software engineering from an early stage of design. The proposed approach encourages the separate handling of MAS concerns, and provides a disciplined scheme for their composition. Our proposal explores the benefits of aspect‐oriented software development for the incorporation of agents into object‐oriented systems. We also illustrate our aspect‐oriented approach through the Portalware multi‐agent system, a Web‐based environment for the development of e‐commerce portals. Copyright © 2004 John Wiley & Sons, Ltd.     

Feature‐based approach to object‐oriented engineering of applications for reuse

Object‐oriented technology is gaining popularity among software engineers with the goal of building reusable and adaptable software. Unfortunately, however, most methods introduced so far are not domain‐oriented and do not address the issue of reuse directly. For these methods, software reuse is not the primary goal; it is only a by‐product. The feature‐oriented reuse method, FORM, is extended in this paper for improving the object‐oriented engineering of applications for reuse. FORM concentrates on analyzing and modeling commonalities and differences in the applications of a given domain in terms of capability, operating environment, domain technology, and implementation technique features. These features are used to systematically derive objects that are tied to the features, and to develop reusable and adaptable domain architectures. We found that FORM facilitates analysis of variability (and commonality) of software before engineering and implementation start, and with this understanding, adaptability and reusability can be built into software. Feature modeling has been found to be an effective method for identifying and modeling reusable objects. Copyright © 2000 John Wiley & Sons, Ltd.     

Productivity analysis of object‐oriented software developed in a commercial environment

The introduction of object‐oriented technology does not appear to hinder overall productivity on new large commercial projects, but nor does it seem to improve it in the first two product generations. In practice, the governing influence may be the business workflow, and not the methodology. Copyright © 1999 John Wiley & Sons, Ltd.     

BCOOPL: Basic concurrent object‐oriented programming language

A small, object‐oriented language is introduced: BCOOPL (Basic Concurrent Object‐Oriented Programming Language). This language is specifically targeted to support component‐oriented programming. The main design goal of BCOOPL was to provide a small, but powerful set of language features that supports the construction of high‐quality components through well‐established software engineering practices, which include the separation of interfaces and implementations, weakly‐coupled objects, and abstraction. A number of design patterns based on these principles is actually built in the language. In particular, the observer, the mediator and the bridge are supported directly. This provides a strong foundation on which higher level component specification languages can be built. BCOOPL has a long research history. Its roots can be traced back to path expressions, and the concurrent object‐oriented programming languages Procol and Talktalk. As a result, BCOOPL only integrates essential language features that blend well and have proven their value in practice. Copyright © 2000 John Wiley & Sons, Ltd.     

A methodology to infer and refactor an object‐oriented model from C applications

When analyzing legacy code, generating a high‐level model of an application during the reverse engineering process helps the developers understand how the application is structured and how the dependencies relate the different software entities. Within the context of procedural programming languages (such as C), the existing approaches to get a model of the code require documentation and/or implicit knowledge that stakeholders acquire during the software building. These approaches use the code itself to build a syntactic model where we see the different software artifacts, such as variables, functions, and modules. However, there is no supporting methodology to detect and analyze if there are relationships/dependencies between those artifacts, such as which variable in a module is declared using an abstract data type described in another one, or which are the functions that are using parameters typed with an abstract data type; or any design decision taken by original developers, such as how the developer has implemented functions in different modules. On the other hand, current developers use object‐oriented (OO) paradigm to implement not only business applications but also useful methodologies/tools that allow semiautomatic analysis of any application. We must remark the legacy procedural code still has worth and is working in several industries, and as any evolving code, the developers have to be able to perform maintenance tasks minimizing the limitations offered by the language. Based on useful properties that the OO paradigm (and their supporting analysis tools) provide, such as UML models, we propose M2K as a methodology to generate a high‐level model from legacy procedural code, mainly written in Ansi C. To understand how C‐based applications were implemented is not a new problem in software reengineering. However, our contribution is based on building an OO model and suggesting different refactorings that help the developer to improve it and to eventually guide a new implementation of the target application. Specifically, the methodology builds cohesive software entities mapped from procedural code and makes the coupling between C entities explicit in the high‐level model. The result of our methodology is a set of refactored class candidates: a structure that groups a set of variables and a set of functions obtained from the C applications. Based on the class candidate model, we propose refactorings based on OO design principles to improve the design of the application. The most relevant design improvements were obtained with algorithm abstraction by applying the strategy pattern, attributes/methods relocalization, variables types generalization, and removing/renaming methods/attributes. Besides a methodology and the supporting tool, we provide 14 case studies based on real projects implemented in C, and we showed how the results validate our proposal.     

System testing for object‐oriented systems with test case prioritization

This paper presents an approach to generate test cases from UML 2.0 sequence diagrams and subsequently prioritize those test cases using model information encapsulated in the sequence diagrams. The test cases generated according to the proposed approach satisfy the scenario coverage criterion and are suitable for system‐level testing. For prioritizing test cases, three different prioritization metrics are proposed. The values of these prioritization metrics can be analytically computed from the model information only. This paper also presents an approach to generate test data using a concept called rule‐based matrix. The prioritization metrics are used to control the number of test data without compromising the test adequacy. The effectiveness of the proposed approach has been verified using two industrial designs. Copyright © 2009 John Wiley & Sons, Ltd.     

Investigating the use of analysis contracts to improve the testability of object‐oriented code

A number of activities involved in testing software are known to be difficult and time consuming. Among them is the definition and coding of test oracles and the isolation of faults once failures have been detected. Through a thorough and rigorous empirical study, we investigate how the instrumentation of contracts could address both issues. Contracts are known to be a useful technique in specifying the precondition and postcondition of operations and class invariants, thus making the definition of object‐oriented analysis or design elements more precise. It is one of the reasons the Object Constraint Language (OCL) was made part of the Unified Modeling Language. Our aim in this paper is to reuse and instrument contracts to ease testing. A thorough case study is run where we define OCL contracts, instrument them using a commercial tool and assess the benefits and limitations of doing so to support the automated detection of failures and the isolation of faults. As contracts can be defined at various levels of detail, we also investigate the cost and benefit of using contracts at different levels of precision. We then draw practical conclusions regarding the applicability of the approach and its limitations. Copyright © 2003 John Wiley & Sons, Ltd.     

A case study: productivity and quality gains using an object‐oriented framework

The Neuro‐Oncology Information System (NOIS) supports researchers and other personnel throughout the United States engaged in brain tumor research. Graphical user interfaces that allow data input into the NOIS have been evolving over several years. This paper describes the design and implementation of the NOIS Input Forms as they migrated from a procedural approach to a static object‐oriented approach, and finally to a framework approach in which not only static components were reused, but also the patterns of interaction among the components. The paper documents a significant gain in productivity and quality that was realized when using the framework design paradigm. Copyright © 1999 John Wiley & Sons, Ltd.     

FC++: Functional tools for object‐oriented tasks

FC++ is a library for programming functionally in C++. Compared to other C++ functional programming libraries, FC++ is distinguished by its powerful type system which allows the manipulation of parametrically polymorphic functions (e.g., passing them as arguments to other functions and returning them as results). In this paper, we show how FC++ can be used in common object‐oriented programming tasks. We demonstrate FC++ implementations of several common design patterns (Adapter, Builder, Command, and more). Compared to conventional C++ implementations of these patterns, our implementations are either simpler (in that fewer classes/dependencies are needed), more efficient, or more type‐safe (thanks to parametric polymorphism and type inference). Copyright © 2002 John Wiley & Sons, Ltd.     

Deferring elimination of design alternatives in object‐oriented methods

While developing systems, software engineers generally have to deal with a large number of design alternatives. Current object‐oriented methods aim to eliminate design alternatives whenever they are generated. Alternatives, however, should be eliminated only when sufficient information to take such a decision is available. Otherwise, alternatives have to be preserved to allow further refinements along the development process. Too early elimination of alternatives results in loss of information and excessive restriction of the design space. This paper aims to enhance the current object‐oriented methods by modeling and controlling the design alternatives through the application of fuzzy‐logic‐based techniques. By using an example method, it is shown that the proposed approach increases the adaptability and reusability of design models. The method has been implemented and tested in our experimental CASE environment. Copyright © 2001 John Wiley & Sons, Ltd.     

Frameworks for incorporating semantic relationships into object‐oriented database systems

A semantic relationship is a data modeling construct that connects a pair of classes or categories and has inherent constraints and other functionalities that precisely reflect the characteristics of the specific relationship in an application domain. Examples of semantic relationships include part–whole, ownership, materialization and role‐of. Such relationships are important in the construction of information models for advanced applications, whether one is employing traditional data‐modeling techniques, knowledge‐representation languages or object‐oriented modeling methodologies. This paper focuses on the issue of providing built‐in support for such constructs in the context of object‐oriented database (OODB) systems. Most of the popular object‐oriented modeling approaches include some semantic relationships in their repertoire of data‐modeling primitives. However, commercial OODB systems, which are frequently used as implementation vehicles, tend not to do the same. We will present two frameworks by which a semantic relationship can be incorporated into an existing OODB system. The first only requires that the OODB system support manifest type with respect to its instances. The second assumes that the OODB system has a special kind of metaclass facility. The two frameworks are compared and contrasted. In order to ground our work in existing systems, we show the addition of a part–whole semantic relationship both to the ONTOS DB/Explorer OODB system and the VODAK Model Language. Copyright © 2003 John Wiley & Sons, Ltd.     

Role‐play virtual worlds for teaching object‐oriented design: the ViRPlay development experience

The use of game technology for building virtual learning environments is intended to improve the motivation and engagement of the student, borrowing such properties from their entertaining counterparts. Nevertheless, wrapping pedagogical contents in a virtual environment is no simple achievement, and requires a rigorous process of designing and validating the metaphors and mechanics included in the virtual learning system. In this paper we describe such design process exemplified in the construction of consecutive versions of ViRPlay, a 3D role play virtual environment for teaching object‐oriented design. We show how main mechanics were transferred from experiments in the real world and how such mechanics were evolved based on empirical evaluations. Copyright © 2011 John Wiley & Sons, Ltd.     

An illustrative example of refactoring object‐oriented source code with aspect‐oriented mechanisms

This paper describes a refactoring process that transforms a Java source code base into a functionally equivalent AspectJ source code base. The process illustrates the use of a collection of refactorings for aspect‐oriented source code, covering the extraction of scattered implementation elements to aspects, the internal reorganization of the extracted aspects and the extraction of commonalities to super‐aspects. Copyright © 2007 John Wiley & Sons, Ltd.     

Fault prediction considering threshold effects of object‐oriented metrics

Software product quality can be enhanced significantly if we have a good knowledge and understanding of the potential faults therein. This paper describes a study to build predictive models to identify parts of the software that have high probability of occurrence of fault. We have considered the effect of thresholds of object‐oriented metrics on fault proneness and built predictive models based on the threshold values of the metrics used. Prediction of fault prone classes in earlier phases of software development life cycle will help software developers in allocating the resources efficiently. In this paper, we have used a statistical model derived from logistic regression to calculate the threshold values of object oriented, Chidamber and Kemerer metrics. Thresholds help developers to alarm the classes that fall outside a specified risk level. In this way, using the threshold values, we can divide the classes into two levels of risk – low risk and high risk. We have shown threshold effects at various risk levels and validated the use of these thresholds on a public domain, proprietary dataset, KC1 obtained from NASA and two open source, Promise datasets, IVY and JEdit using various machine learning methods and data mining classifiers. Interproject validation has also been carried out on three different open source datasets, Ant and Tomcat and Sakura. This will provide practitioners and researchers with well formed theories and generalised results. The results concluded that the proposed threshold methodology works well for the projects of similar nature or having similar characteristics.     

Object‐oriented design of the subsumption architecture

The subsumption architecture is a layered mediator invented by Rodney Brooks for behaviour‐based control of robots. The layers are minimally dependent and use minimal communication. We develop an object‐oriented software design for the subsumption architecture, and demonstrate that each layer can be used as a slot for a set of plug‐and‐play components that implement different microstrategies for achieving a particular goal. Guidelines for the development of specific layers and components of a subsumption architecture are also presented. Copyright © 2001 John Wiley & Sons, Ltd.     

A cohesion measure for object‐oriented classes

In object‐oriented systems, cohesion refers to the degree of the relatedness of the members in a class and strong cohesion has been recognized as a highly desirable property of classes. We note that the existing cohesion measures do not take into account some characteristics of classes, and thus often fail to properly reflect the cohesiveness of classes. To cope with such a problem, we propose a new cohesion measure where the characteristics of classes are incorporated. Our cohesion measure takes into account the members that actually have impact on the cohesiveness of a class, and is defined in terms of the degree of the connectivity among those members. We develop a cohesion measurement tool for C++ programs, and perform a case study on a well‐known class library in order to demonstrate the effectiveness of our new measure. By performing principal component analysis, we also demonstrate that our measure captures a new aspect of class properties which is not captured by the existing cohesion measures. Copyright © 2000 John Wiley & Sons, Ltd.     

A quality of service driven concurrency framework for object‐based middleware

Threads play a key role in object‐based middleware platforms. Implementers of such platforms can select either kernel or user‐level threads, but neither of these options are ideal. In this paper we introduce Application Scheduler Contexts (ASCs) which flexibly combine both types of thread and thereby attempt to exploit the advantages of each. Multiple ASCs can co‐exist, each with their own concurrency semantics and scheduling policy. ASCs also support quality of service (QoS) configurability, and define their own QoS schema. We show how ASCs can be efficiently implemented and how they can usefully be exploited in middleware environments. We also provide a quantitative evaluation that demonstrates the feasibility of the ASC concept in performance terms. Copyright © 2002 John Wiley & Sons, Ltd.