Heung Seok Chae

An approach to developing domain requirements as a core asset based on commonality and variability analysis in a product line

The methodologies of product line engineering emphasize proactive reuse to construct high-quality products more quickly that are less costly. Requirements engineering for software product families differs significantly from requirements engineering for single software products. The requirements for a product line are written for the group of systems as a whole, with requirements for individual systems specified by a delta or an increment to the generic set. Therefore, it is necessary to identify and explicitly denote the regions of commonality and points of variation at the requirements level. In this paper, we suggest a method of producing requirements that will be a core asset in the product line. We describe a process for developing domain requirements where commonality and variability in a domain are explicitly considered. A CASE environment, named DREAM, for managing commonality and variability analysis of domain requirements is also described. We also describe a case study for an e-travel system domain where we found that our approach to developing domain requirements based on commonality and variability analysis helped to produce domain requirements as a core asset for product lines.

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.

Applying agglomerative hierarchical clustering algorithms to component identification for legacy systems

Context: Component identification, the process of evolving legacy system into finely organized component-based software systems, is a critical part of software reengineering. Currently, many component identification approaches have been developed based on agglomerative hierarchical clustering algorithms. However, there is a lack of thorough investigation on which algorithm is appropriate for component identification. Objective: This paper focuses on analyzing agglomerative hierarchical clustering algorithms in software reengineering, and then identifying their respective strengths and weaknesses in order to apply them effectively for future practical applications. Method: A series of experiments were conducted for 18 clustering strategies combined according to various similarity measures, weighting schemes and linkage methods. Eleven subject systems with different application domains and source code sizes were used in the experiments. The component identification results are evaluated by the proposed size, coupling and cohesion criteria. Results: The experimental results suggested that the employed similarity measures, weighting schemes and linkage methods can have various effects on component identification results with respect to the proposed size, coupling and cohesion criteria, so the hierarchical clustering algorithms produced quite different clustering results. Conclusions: According to the experimental results, it can be concluded that it is difficult to produce perfectly satisfactory results for a given clustering algorithm. Nevertheless, these algorithms demonstrated varied capabilities to identify components with respect to the proposed size, coupling and cohesion criteria.

A cohesion measure for classes in object-oriented systems

Classes are the fundamental concepts in the object-oriented paradigm. They are the basic units of object-oriented programs, and serve as the units of encapsulation, which promotes the modifiability and the reusability of them. In order to take full advantage of the desirable features provided by classes, such as data abstraction and encapsulation, classes should be designed to have good quality. Because object-oriented systems are developed by heavily reusing the existing classes, the classes of poor quality can be a serious obstacle to the development of systems. We define a new cohesion measure for assessing the quality of classes. Our approach is based on the observations on the salient natures of classes which have not been considered in the previous approaches. A Most Cohesive Component (MCC) is introduced as the most cohesive form of a class. We believe that the cohesion of a class depends on the connectivity of itself and its constituent components. We propose the connectivity factor to indicate the degree of the connectivity among the members of a class, and the structure factor to take into account the cohesiveness of its constituent components. Consequently, the cohesion of a class is defined as the product of the connectivity factor and the structure factor. This cohesion measure indicates how closely a class approaches MCC; the closely a class approaches MCC, the greater cohesion the class has.

Improving cohesion metrics for classes by considering dependent instance variables

The existing cohesion metrics for classes do not consider the characteristics of dependent instance variables that are commonly used in a class and, thus, do not properly reflect the cohesiveness of the class. This paper presents an approach for improving the cohesion metrics by considering the characteristics of the dependent instance variables in an object-oriented program.

Modularization of the UML Metamodel Using Model Slicing

The UML metamodel has been increased in its size and complexity due to many needs for supporting various platforms and domains. The large size of the metamodel can prevent tool developers from understanding the UML metamodel and thus from developing UML-based tools. In this paper, we propose an approach to managing the complexity of the UML metamodel by modularizing the metamodel into a set of small metamodels for each UML diagram type. To that goal, we propose a slicing algorithm for extracting diagram-specific metamodels from the UML metamodel.

Automated scheduling for clone-based refactoring using a competent GA

Refactoring is a widely accepted technique to improve the software quality by restructuring its design without changing its behavior. In general, a sequence of refactorings needs to be applied until the quality of the code is improved satisfactorily. In this case, the final design after refactoring can vary with the application order of refactorings, thereby producing different quality improvements. Therefore, it is necessary to determine a proper refactoring schedule to obtain as many benefits as possible. However, there is little research on the problem of generating appropriate schedules to maximize quality improvement. In this paper, we propose an approach to automatically determine an appropriate schedule to maximize quality improvement through refactoring. We first detect code clones that are suitable for refactoring and generate the most beneficial refactoring schedule to remove them. It is straightforward to select the best from the exhaustively enumerated schedules. However, such a technique becomes NP‐hard, as the number of available refactorings increases. We apply a genetic algorithm (GA) to generate the best refactoring schedule within a reasonable time to cope with this problem. We compare the GA‐based approach with manual scheduling, greedy heuristic‐based, and exhaustive approaches for four open systems. The results show that the proposed GA‐based approach generates more beneficial schedules than the others. Copyright

A metamodel approach to architecture variability in a product line

Architecture describes the organizational structure of a system including components, interactions, and constraints. Reusable components, units of software systems, have been considered to support a considerable improvement in reducing development costs and time to market because their interfaces and functionality are explicitly defined. Instead of reusing an individual component, however, it is much more advantageous to reuse a whole design or architecture. A domain architecture, sharing a common software architecture across a product line, includes common components shared by all products and optional components exploited by a subset of the products. Variability, one of the key concepts in the development of domain architectures indicates the ability to derive various products from the product line. Clearly, we need to support variability during domain architecture development. In this paper, we suggest a metamodeling concept that enables a common under-standing of architecture variability. The domain architecture metamodel reflects the Object Management Groups (OMGTM) Reusable Asset Specification (RAS) which addresses the engineering elements of reuse. We describe a domain architecture in which commonality and variability are explicitly considered.

Mobile Agent based Load Balancing for RFID Middlewares

RFID middleware technology gains great attention recently due to its competitive business value. Due to the automatic identification and collection of information, RFID systems have been applied to various applications fields. Load balancing is a critical factor to provide a steady and fluent working environment for RFID middlewares. In this paper, we exploit the issues of load balancing for RFID middlewares, discuss load balancing policies which are compliant to RFID middlewares and propose a mobile agent based approach for RFID middleware for load balancing. A mobile agent, RFID load balancing agent (RLBA, for short) is proposed to gather global and local workload information for RFID middlewares and execute load balancing strategy. According to the load balancing policies, RLBA is composed of six components: load collector, load monitor, balancing trigger, middleware chooser, reader chooser, and reader reallocator. We also give the agent architecture and detailed design for RLBA. Mobile agent provides a decentralized and scalable approach for RFID middlewares to load balancing, which can enhance system availability and extensibility.

A Metamodeling Approach to Tracing Variability between Requirements and Architecture in Software Product Lines

Even in traditional single software product development, failure to manage changes in requirements can cause degeneration of the architecture and components. Traceability issues are even more important in the product line because the impact of changes in a product line can involve all the product line-based applications. Variability means the ability of a software system to be changed, customized or configured for use in a particular context and it should be managed at different levels of abstraction. In this paper, we suggest a metamodeling approach to support the tracing of the variability in requirements and architecture. Two metamodels representing the domain requirements and domain architecture with variability are proposed. Based on the proposed metamodels, we describe trace relationships between requirements and architecture with respect to variability.