An approach to analyzing the software process change impact using process slicing and simulation

https://doi.org/10.1016/j.jss.2010.11.919Get rights and content

Abstract

When a software process is changed, a project manager needs to perform two types of change impact analysis activities: one for identifying the affected elements of a software process which is affected by the change and the other for analyzing the quantitative impact of the change on the project performance. We propose an approach to obtain the affected elements of a software process using process slicing and developing a simulation model based on the affected elements to quantitatively analyzing the change using simulation. We suggest process slicing to obtain the elements affected by the change. Process slicing identifies the affected elements of a software process using a process dependency model. The process dependency model contains activity control dependencies, artifact information dependencies, and role replacement dependencies. We also suggest transformation algorithms to automatically derive the simulation model from the process model containing the affected elements. The quantitative analysis can be performed by simulating the simulation model. In addition, we provide the tool to support our approach. We perform a case study to validate the usefulness of our approach. The result of the case study shows that our approach can reduce the effort to identify the elements affected by changes and examine alternatives for the project.

Introduction

A software process needs to be changed for a variety of reasons such as a need for process improvement to increase quality, process tailoring, and unexpected situations (Guo and Seaman, 2008, Bandinelli et al., 1994). When a software process is changed, a project manager needs to answer several questions: “Which parts of the software process should be changed“, “How much effort is needed to implement the changes”, “Will the process change improve the performance of software process“, “Would alternative process changes offer a greater improvement”, and so on. To answer those questions, the project manager should perform the change impact analysis on a software process.

The change impact analysis consists of two parts: one for identifying the part of a software process which is affected by the change and the other for analyzing the quantitative impact of the change on the project performance such as cost and schedule. When one element of a software process is removed, the elements associated with the removed element may be removed together. For example, if one activity is deleted, then the artifacts produced by the activity should be deleted. Therefore, a project manager should identify the affected elements which are affected by the change to make the process be consistent. The project manager should quantitatively evaluate the change. The proposed change may significantly increase the cost of a project or deteriorate the quality of the project. If the change costs too much or causes a significant problem for the project performance, the project manager may look for alternatives or reject the change. Quantitatively analyzing the change impact requires the result of identifying the affected elements. To estimate the effort to implement the change, a project manager needs to know how many or which activities should be re-performed. To evaluate the change impact on the project performance, a project manager needs to apply one of the quantitative analysis methods such as simulation to the software process that reflects the change. Therefore, in order to analyze the change impacts of a software process, a project manager requires identifying the elements affected by the change and quantitatively evaluating the change based on the result of identifying the affected elements.

There are several approaches to support the change impact analysis of a software process. However, they do not fully support the change impact analysis of a software process. When a software process is changed, all the elements of a software process such as activity, artifact, and role are subject to change. Changing an element may affect others because of relationships between the elements. For example, changing an activity may affect the artifacts produced by the activity. The change of an artifact may affect other artifacts. During analyzing the impacts of the software process change, any types of elements in the software process should be analyzed. They also do not provide the method how to quantitatively evaluate the change based on the affected elements.

We propose an approach to analyzing the change impact of a software process using process slicing and simulation. This approach extends our previous work (Park et al., 2009). We devise process slicing to operate on a software process that can identify the elements affected by changes. Process slicing is performed using a process dependency model. We suggest automatic transformation to directly derive a simulation model based on the affected elements. The transformation is performed by two algorithms which transform a software process model into a Discrete EVent system Specification (DEVS)-hybrid simulation model. We also provide the tool environment to support our approach. The usefulness of our approach is validated using a real project data. The result shows that process slicing is applicable to real projects and the simulation is helpful to make a decision.

The proposed approach has several advantages. First, our approach can help a project manager to identify the affected elements for the changes of all the types of elements in a software process. A process dependency model contains all the relationships among the elements in a software process. Process slicing traverses the process dependency model and identifies the elements in the path as the affected elements during the traverse. Second, our approach can aid a project manager to identify the affected elements with fewer errors and less effort. Process slicing can be automatically performed, resulting in enabling a project manager to reduce the effort to identify the impacts of the change. Third, our approach also enables the project manager to obtain the simulation model based on the affected elements with less effort. During developing the simulation model, it is important to ensuring that the affected elements are correctly reflected the simulation model. Automatic transformation can ensure that all the elements in the affected elements are applied to the simulation model. Automatic transformation can also reduce the effort to develop and review the simulation model based on affected elements.

The remainder of this paper is organized as follows. Section 2 introduces background concepts. Section 3 describes how to perform process slicing and how to derive the simulation model. Section 4 shows a case study to validate our approach. Section 5 discusses related work and Section 6 summarizes the main results of this paper and gives a plan for future work.

Section snippets

Background

We utilize DEVS-Hybrid formalism to develop a simulation model.

Overview

Fig. 2 shows the overview of our approach. This approach consists of two parts: one for obtaining the affected elements using process slicing and the other for developing the simulation model based on the affected elements.

We first describe how to perform process slicing to obtain the affected elements. We identify multi-dimensional dependencies from the software process such as the activity flow dependency, the artifact flow dependency, the role dependency, the assignment dependency, and the

Case study

In this section, we present the results of a case study that validate our approach. We illustrate that our approach supports obtaining the affected elements and quantitatively evaluating the changes using process slicing and simulation during process tailoring using real project data. We also evaluate the efficiency and effectiveness of process slicing using precision and recall, respectively.

Related work

Process slicing is similar to program slicing for a program. Traditionally, program slicing is an essential technique to support the change impact analysis of software systems at the source code level (Ferrante et al., 1985, Xu et al., 2005, Weiser, 1984, Ottenstein and Ottenstein, 1984, Horwitz et al., 1990). However, program slicing cannot fully cover the changes for all types of elements in a software process. For example, a program does not include the constituent such as a role in a

Conclusion

When a software process is changed, a project manager needs to perform two types of change impact analysis activities: one for identifying the affected elements of a software process which is affected by the change and the other for analyzing the quantitative impact of the change on the project performance such as cost and schedule. We proposed an approach to obtain the affected elements of a software process using process slicing and developing a simulation model based on the affected elements

Acknowledgments

This research was supported by the MKE (Ministry of Knowledge Economy), Korea, under the ITRC (Information Technology Research Center) support program supervised by the NIPA (National IT Industry Promotion Agency) (NIPA-2009-(C1090-0902-0032)). I really thank Dr. Jinhwan Jung who is a member of Defense Acquisition Program Administration (DAPA) in Korea for providing the project data and reviewing the result of the case study.

Seunghun Park is a Ph.D. candidate in the Computer Science Department in the College of Information Science & Technology of KAIST. His research focuses on software process, software process improvement, software project management, change impact analysis, and quantitative project management.

References (38)

  • K. Choi et al.

    An approach to a hybrid software process simulation using DEVS formalism

    Software Process Improvement and Practice

    (2006)
  • W. Dai et al.

    Lightweight query-based analysis of workflow process dependencies

    Journal of Systems and Software

    (2009)
  • S. Ajila

    Software maintenance: an approach to impact analysis of objects change

    Software-Practice and Experience

    (1995)
  • G. Antoniol et al.

    Recovering traceability links between code and documentation

    IEEE Transactions on Software Engineering

    (2002)
  • D. Avrilionis et al.

    OPSIS: a view mechanism for software processes which supports their evolution and reuse

  • S. Bandinelli et al.

    Computational reflection in software process modeling: the SLANG approach

  • S. Bandinelli et al.

    Policies and mechanisms to support process evolution in PSEES

  • S. Chou et al.

    Process program change control in a process environment

    Software Practice and Experience

    (2000)
  • Change impact analysis supporting tool, 2009, Korea Advanced Institute of Science and Technology (KAIST). Available at...
  • G. Cugola

    Tolerating deviations in process support systems via flexible enactment of process models

    IEEE Transactions on Software Engineering

    (1998)
  • B. Curtis et al.

    Process modeling

    Communications of the ACM

    (1992)
  • L. Deruelle et al.

    A change impact analysis approach For CORBA-based federated databases

  • Eclipse Process Framework Project at http://www.eclipse.org/epf,...
  • J. Ferrante et al.

    The program dependence graph and its use in optimization

    ACM Transactions on Programming Languages and Systems

    (1985)
  • K. Fisler et al.

    Verification and change-impact analysis of access-control policies

  • Y. Guo et al.

    A survey of software project managers on software process change

  • S. Horwitz et al.

    Interprocedural slicing using dependence graphs

    ACM Transactions on Programming Languages and Systems

    (1990)
  • M.L. Jaccheri et al.

    Techniques for process model evolution in EPOS

    IEEE Transactions on Software Engineering

    (1993)
  • D. Kang et al.

    A case retrieval method for knowledge-based software process tailoring using structural similarity

  • Cited by (19)

    • The effect of transactive memory systems on process tailoring in software projects: The moderating role of task conflict and shared temporal cognitions

      2020, Journal of Systems and Software
      Citation Excerpt :

      Teams that conduct tailoring tasks need to achieve superior performance of SPT. This is because performance, in terms of the quality of tailoring decisions and the efficiency of tailoring efforts, may influence project outcomes and results (Xu and Ramesh, 2008; Park and Bae, 2011). In the literature, most SPT research can be classified into two streams.

    • Change-Patterns Mapping: A Boosting Way for Change Impact Analysis

      2022, IEEE Transactions on Software Engineering
    View all citing articles on Scopus

    Seunghun Park is a Ph.D. candidate in the Computer Science Department in the College of Information Science & Technology of KAIST. His research focuses on software process, software process improvement, software project management, change impact analysis, and quantitative project management.

    Doo-Hwan Bae is a professor of computer science at KAIST. He received his Ph.D. at the Department of Computer Science in the University of Florida. He currently leads the Software Process Improvement Center, funded by Ministry of Knowledge Economy, Korea. His research interests include software process improvement, quantitative project management, software measurement, object-oriented software development, and embedded software design.

    View full text