Feature‐oriented engineering of PBX software for adaptability and reuseability

Incorporating a high level of adaptability and reusability into software is one challenge that all software engineers face. PBX (Private Branch Exchange) is one such system that requires a high level of adaptability and reusability because of rapidly expanding service features, ever changing communication technology, continuously evolving standards and diverse communication laws and standards in different countries. The software engineering community has made various efforts to address the problem of enhancing software adaptability and reusability. As a result, many programming concepts, such as information hiding, encapsulation, object orientation, abstract data type and modularization, have been developed. Although adequate application of these principles requires the domain or program family perspective, most methods, so far, have been oriented toward developing a single application. FORM (Feature‐Oriented Reuse Method), the domain‐based software reuse method applied in this paper, concentrates on analyzing and modeling commonalities and differences in applications of a given domain and using the analysis results to develop domain‐oriented architectures and software components. The model that captures commonalities and differences is called the ‘feature model’ and it is used for both the engineering of reusable domain artifacts and the development of actual application software with reusable artifacts. We found that FORM facilitates analysis of variability, as well as commonality, of software before the start of engineering and implementation. With this understanding, adaptability and reusability can be built into software. Also, feature modeling has been found to be an effective method for identifying objects. Copyright © 1999 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.     

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.     

A survey of concurrent object‐oriented languages

During the last decade object‐oriented programming has grown from marginal influence into widespread acceptance. During the same period, progress in hardware and networking has changed the computing environment from sequential to parallel. Multi‐processor workstations and clusters are now quite common. Unnumbered proposals have been made to combine both developments. Always the prime objective has been to provide the advantages of object‐oriented software design at the increased power of parallel machines. However, combining both concepts has proven to be notoriously difficult. Depending on the approach, often key characteristics of either the object‐oriented paradigm or key performance factors of parallelism are sacrificed, resulting in unsatisfactory languages. This survey first recapitulates well‐known characteristics of both the object‐oriented paradigm and parallel programming, and then marks out the design space of possible combinations by identifying various interdependencies of key concepts. The design space is then filled with data points: for 111 proposed languages we provide brief characteristics and feature tables. Feature tables, the comprehensive bibliography, and web‐addresses might help in identifying open questions and preventing re‐inventions. Copyright © 2000 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.     

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.     

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.     

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.     

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.     

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.     

Maintaining traceability links during object‐oriented software evolution

This paper presents a method to build and maintain traceability links and properties of a set of object‐oriented software releases. The method recovers an ‘as is’ design from C++ software releases, compares recovered designs at the class interface level, and helps the user to deal with inconsistencies by pointing out regions of code where differences are concentrated. The comparison step exploits edit distance and a maximum match algorithm. The method has been experimented with on two freely available C++ systems. Results as well as examples of applications to the visualization of the traceability information and to the estimation of the size of changes during maintenance are reported in the paper. Copyright © 2001 John Wiley & Sons, Ltd.     

Response to ‘Comments on: A cohesion measure for object‐oriented classes’

Indicating that CBMC does not satisfy the monotonic property in terms of the number of interactions, Xu and Zhou proposed an augmented definition of CBMC by adopting cut set instead of glue methods. The augmented CBMC clearly satisfies the monotonic property. However, CBMC is designed to overcome the problem with respect to the number of interactions and, therefore, focuses on the interaction pattern, especially, member connectivity. Consequently, it does not make sense to mention the monotonic property of CBMC with respect to interaction number. Moreover, the notion of glue methods allows several interpretations on the design quality of a class. However, that meaningful interpretation is not possible for the augmented definition due to the removal of the notion of glue methods. Copyright © 2001 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.     

Feature‐oriented programming: A new way of object composition

We propose a new model for flexible composition of objects from a set of features. Features are services of an object and are similar to classes in object‐oriented languages. In many cases, features have to be adapted in the presence of other features, which is also called the feature interaction problem. We introduce explicit interaction handlers which can adapt features to other features by overriding methods. When features are composed, the appropriate interaction handling is added in a way which generalizes inheritance and aggregation. For a set of features, an exponential number of different feature combinations is possible, based on a quadratic number of interaction resolutions. We present the feature model as an extension of Java and give two translations to Java, one via inheritance and the other via aggregation. We show that the feature model interacts nicely with several common language extensions such as type parameters, exceptions, and higher‐order functions. Copyright © 2001 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 analysis technique to increase testability of object‐oriented components

Object‐oriented component engineering is increasingly used for system development, partly because it emphasizes portability and reusability. Each time a component is used, it must be retested in the new environment. Unfortunately, the data abstraction that components usually use results in low testability. First, internal variables cannot be directly set. Second, even though a test input may trigger a fault, the failure does not propagate to the output. This paper presents a technique to increase object‐oriented component testability, thereby making it easier to detect faults. Components are often sealed so that source code is not available. The program analysis is performed at the Java component bytecode level. A component's bytecode is analysed to create a control and data flow graph, which is then used to increase component testability by increasing both controllability and observability. We have implemented this technique and applied it to several components. Experimental results reveal that fault detection can be increased by using our increasing testability process. Copyright © 2008 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.     

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.