Extracting Reusable Software Architectures: A Slicing-Based Approach

Dept. of Comput. Sci. & Eng., Fukuoka Inst. of Technol.
01/2000; DOI: 10.1109/CSMR.2000.827330
Source: DBLP


An alternative approach to developing reusable components from scratch is to recover them from existing systems. Although numerous techniques have been proposed to recover reusable components from existing systems, most have focused on implementation code, rather than software architecture. In this paper, we apply architectural slicing to extract reusable architectural elements (i.e., components and connectors) from the existing architectural specification of a software system. Unlike traditional program slicing, which operates on the source code of a program to provide the low-level implementation details of the program, architectural slicing directly operates on the architectural specification of a software system, and therefore can provide useful knowledge about the high-level architecture of the system. 1 Introduction Software reusability is widely accepted as the key to improving both the quality of software and the productivity of software engineers. Software reuse can take man...

Download full-text


Available from: Jianjun Zhao, Sep 21, 2015
  • Source
    • "In this context, researchers have proposed using dynamic program slicing techniques to decompose large architectures into manageable portions. These techniques not only facilitate comprehending large architectures, but also help perform impact analysis and reliability prediction based on architectural models [19], [30], [45], [46]. Besides, architecture model slicing can also be used to compute various types of metrics to characterize software architectures . "
    [Show abstract] [Hide abstract]
    ABSTRACT: This paper proposes a technique for dynamic slicing of UML architectural models. The presence of related information in diverse model parts (or fragments) makes dynamic slicing of Unified Modeling Language (UML) models a complex problem. We first extract all relevant information from a UML model specifying a software architecture into an intermediate representation, which we call a Model Dependency Graph (MDG). For a given slicing criterion, our slicing algorithm traverses the constructed MDG to identify the relevant model parts that are directly or indirectly affected during the execution of a specified scenario. One novelty of our approach is computation of dynamic slice based on the structural and behavioral (interactions only) UML models as against independently processing separate UML models, and determining the implicit interdependencies among different model elements distributed across model views. We also briefly discuss a prototype tool named Archlice, which we have developed to implement our algorithm.
    Full-text · Article · Nov 2011 · IEEE Transactions on Software Engineering
  • Source
    • "Our approach to using architecture slicing for debugging identifies the following relationships in addition to the control and data flow relationship used in [11]. • Inheritance Relationship: Components can inherit from other components and slices with inherited components should include all derived architectural elements and properties. "

    Full-text · Conference Paper · Jan 2010
  • Source
    • "The basic property of the approach proposed here is the handling of macros. Generally speaking, the method is usable for the same purposes as C/C++ slicing: change impact analysis [11], program decomposition [12], software re-use [13] [14], debugging [15] and regression testing [16] [17]. Dependencies added by the macro slices provide more accurate analysis and hence better results. "
    [Show abstract] [Hide abstract]
    ABSTRACT: Of the very few practical implementations of program slicing algorithms, the majority deal with C/C++ programs. Yet, preprocessor-related issues have been marginally addressed by these slicers, despite the fact that ignoring (or only partially handling) these constructs may lead to serious inaccuracies in the slicing results and hence in the program analysis task being performed. Recently, an accurate slicing method for preprocessor-related constructs has been proposed, which–when combined with existing C/C++ language slicers–can provide more complete slices and hence a more successful analysis of programs written in one of these languages. In this paper, we present our approach which combines the two slicing methods and, via practical experiments, describe its benefits in terms of the completeness of the resulting slices.
    Full-text · Article · May 2009 · Science of Computer Programming
Show more