E. Damiani, L. C. Jain, M. Madravio (Eds.)

Soft Computing in Software Engineering

Studies in Fuzziness and Soft Computing, Volume 159 Editor-in-chief Prof. Janusz Kacprzyk Systems Research Institute Polish Academy of Sciences ul. Newelska 6 01-447 Warsaw Poland E-mail: kacprzyk@ibspan.waw.pl

Further volumes of this series can be found on our homepage: springeronline.com

Vol. 143.1. Rutkowski New Soft Computing Techniques for System Modelling, Pattern Classification and Image Processing, 2004 ISBN 3-540-20584-5

Vol. 144. Z. Sun, G.R. Finnie Intelligent Techniques in E-Commerce, 2004 ISBN 3-540-20518-7

Vol. 145. J. Gil-Aluja Fuzzy Sets in the Management of Uncertainty, 2004 ISBN 3-540-20341-9

Vol. 146. J.A. Gamez, S. Moral, A. Salmer6n (Eds.) Advances in Bayesian Networks, 2004 ISBN 3-540-20876-3

Vol. 147. K. Watanabe, M.M.A. Hashem New Algorithms and their Applications to Evolutionary Robots, 2004 ISBN 3-540-20901-8

Vol. 148. C. Martin-Vide, V. Mitrana, G. Paun (Eds.) Formal Languages and Applications, 2004 ISBN 3-540-20907-7

Vol. 149. J.J. Buckley Fuzzy Statistics, 2004 ISBN 3-540-21084-9

Vol. 150.1. Bull (Ed.) Applications of Learning Classifier Systems, 2004 ISBN 3-540-21109-8

Vol. 151. T. Kowalczyk, E. Pleszczynska, F. Ruland (Eds.) Grade Models and Methods for Data Analysis, 2004 ISBN 3-540-21120-9

Vol. 152. J. Rajapakse, 1. Wang (Eds.) Neural Information Processing: Research and Development, 2004 ISBN 3-540-21123-3

Vol. 153. J. Fulcher, L.C. Jain (Eds.) Applied Intelligent Systems, 2004 ISBN 3-540-21153-5

Vol. 154. B. Liu Uncertainty Theory, 2004 ISBN 3-540-21333-3

Vol. 155. G. Resconi, J.L. Jain Intelligent Agents, 2004 ISBN 3-540-22003-8

Vol. 156. R. Tadeusiewicz, M.R. Ogiela Medical Image Understanding Technology, 2004 ISBN 3-540-21985-4

Vol. 157. R.A. Aliev, F. Fazlollahi, R.R. Aliev Soft Computing and its Applications in Business and Economics, 2004 ISBN 3-540-22138-7

Vol. 158. K.K. Dompere Cost-Benefit Analysis and the Theory of Fuzzy Decisions, 2004 ISBN 3-540-22154-9

Ernesto Damiani Lakhmi C. Jain Mauro Madravio (Eds.)

Soft Computing in Software Engineering

~ Springer

Prof. Ernesto Damiani E-mail: edamiani@crema.unimi.it

Mauro Madravio E-mail: mmadravio@crema.unimi.it

Universita Milano

Polo die Crema

Via Bramante 65

26013 Crema

Italy

Prof. Lakhmi C. Jain University of South Australia

Knowledge-Based Intelligent

Engineering Systems Centre

Mawson Lakes

5095 Adelaide

Australia

E-mail: l.jain@unisa.edu.au

ISSN 1434-9922

ISBN 978-3-642-53583-3 ISBN 978-3-540-44405-3 (eBook) DOI 10.1007/978-3-540-44405-3

Library of Congress Control Number: 2004106809

This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitations, broadcasting, reproduction on microfilm or in any other way, and storage in data banks. Duplication of this publication or parts thereof is permitted only under the provisions of the German copyright Law of September 9, 1965, in its current version, and permission for use must always be obtained from Springer-Verlag. Violations are liable to prosecution under the German Copyright Law.

Springer is a part of Springer Science+Business Media springeronline.com

© Springer-Verlag Berlin Heidelberg 2004 Sof'tcover reprint of the hardcover 1st edition 2004

The use of general descriptive names, registered names trademarks, etc. in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant protective laws and regulations and therefore free for general use.

Typesetting: camera-ready by editors Cover design: E. Kirchner, Springer-Verlag, Heidelberg Printed on acid free paper 62/3020/M - 5 4 3 2 1 0

Foreword

Soft computing is playing an increasing role in the study of complex systems in science and engineering. There is a large spectrum of successful applications of soft computing in very different applications domains such as aerospace, communication, consumer appliances, electric power systems, process engineering, transportation, and manufacturing automation and robotics. It has taken a while to bring the early ideas of soft computing to an area and a discipline that seems to be more than appropriate for that. Here it is!

This book studies SOFT computing in SOFTware engineering environment. The book is HARD in terms of its results. It covers a range of core topics from software engineering that are soft from its very nature: selection of components, software design, software reuse, software cost estimation and software processes.

Soft computing differs from conventional (hard) computing in its ability to be tolerant of imprecision, uncertainty, partial truth, and approximation. The guiding principle of soft computing is: Exploit the tolerance for imprecision, uncertainty, partial truth, and approximation to achieve tractability, robustness and low solution cost. The role model for soft computing is the human mind. This seems to be a natural fit with software engineering, a human-based development activity based on sound engineering principles.

A recent survey by researchers reveals that "Software Engineering research tends to be quite self-contained, not relying on other disciplines for its thinking". This book bridges the gap! It brings software engineering together with innovative approaches and techniques such as fuzzy logic, neural computing, evolutionary computation, machine learning and probabilistic reasoning. If applied appropriately, this portfolio of techniques is able to tackle real world complex problems, involving imprecision, uncertainty and vagueness and high­dimensionality. The ideas and techniques of soft computing are facilitators to get new insights and to extend existing results in software engineering research.

This is an extremely valuable collection of research contributions in an extremely challenging area of research. I applaud the editors for carefully putting them together. I am excited to recommend the book to a large audience from both software engineering and soft computing.

Professor Guenther Ruhe University of Calgary

Canada

v

Table of Contents

Introduction: Soft Computing in Software Engineering Ernesto Damiani, Lakhmi C. jain, Mauro Madravio .............................................. IX

1 Fuzzy Selection of Software Components and of Web services Carlo Bellettini, Maria Grazia Fugini, Pierluigi Plebani .......................................... l

2 A Training Approach to Develop Reusable Software Components by Combining Adaptation Algorithms junda Chen, David Rine .............................................................................................. 3

3 Fuzzy Case-Based Reasoning Models for Software Cost Estimation Ali Idri ......................................................................................................................... 64

4 Automating Software Development Process Using Fuzzy Logic Francesco Marcelloni, Mehmet Aksit ....................................................................... 97

5 Many Maybes Mean (Mostly) the Same Thing Tim Menzies, Harhsinder Singh ............................................................................. 125

6 Soft Computing Based Effort Prediction Systems - A Survey Moshood Omolade Saliu, Moataz Ahmed .............................................................. 151

7 High-Level Design of Composite Systems Cesare Alippi, Vincenzo Piuri, Fabio Scotti ........................................................... 183

8 RHSP: an Information Representation Model Based on Relationship juan Llorens, jorge Morato, Gonzalo Genova ....................................................... 221

9 Neurofuzzy Analysis of Software Quality Data Witold Pedrycz, Merek Reformat, Nicolino Pizzi .................................................. 254

10 Linguistic Resources and Fuzzy Algebra in Adaptive Hypermedia Systems Luigi Di Lascio, Enrico Fischetti, Antonio Gisolfi, Vincenzo Loia and Aniello Nappi ........................................................................... 274

VII

Soft Computing in Software Engineering

Ernesto Damianil , Lakhmi Jain2 , and Mauro Madraviol

1 Department of Information Technology University of Milan

edamiani, mmadravio~crema.unimi.it 2 Knowledge-based Engineering Systems (KES) Center

University of South Australia lakhmi.jain~unisa.edu.au

Abstract. Software Engineering research involves a wide range of di­verse, and complex concepts, spanning from computer science to related disciplines such as economics and organizational studies. The Software Engineering field's diversity is indeed no wonder, because software devel­opment is a human intensive activity that takes place in environments where all kinds of knowledge are shared. On the other hand, complexity makes Software Engineering an ideal field of application for Soft Com­puting techniques. Soft Computing research addresses a set of related but distinct computing paradigms that include fuzzy logic, granular comput­ing, neural networks, and evolutionary computation. A common target of these paradigms is making human activities more tolerant of imprecision, uncertainty, and partial truth. The chapters collected in this book illus­trate the impact of soft computing techniques on software engineering research and practices dealing with a range of novel methods reshaping the software development process. Specifically, they show how Software Engineering tasks such as reuse-oriented classification (e.g. components' repositories), software diagnostic (e.g. bug detection and correction), ef­fort prediction (e.g. project costs and time estimation), planning (e.g. project scheduling) and others can be appropriately handled by means of soft computing techniques. Keywords: Soft computing, fuzzy logic, neural networks, genetic algo­rithms, software engineering, software knowledge.

1 Introduction

Designing and implementing complex software systems involves a number of human-intensive processes, some of them are costly and error-prone. Techniques and results obtained by Soft Computing research have a great potential to over­come many of these limitations and produce more powerful tools. Soft Comput­ing methods are characterized by paradigms that are tolerant of imprecision, uncertainty and partial truth. These paradigms have been developed to cope with, and in some cases, exploit such vagueness. Soft Computing applications to Software Engineering include the following seven main areas:

1. Fuzzy Object-oriented modelling and design: Fuzzy Object-oriented systems, fuzzy objects and fuzzy typing.

IX

2. Imprecision in the software process: uncertainty, vagueness and ambiguity in the software process management

3. Fuzzy logic in Software Development: Fuzzy rule-based systems for software design

4. Neural networks in Software Development: Pure neural networks and hybrid models)

5. Genetic algorithms in Software Development: Genetic algorithms and pro­gramming for software maintenance, evolutionary strategies for software de­velopment

6. Fuzzy Clustering in Software Development: Reuse-oriented clustering and classification of software artifacts

7. Probabilistic computing in Software Development: Bayesian and evidential models for user modelling in software design and testing.

These areas are covered by the set of chapters collected in this book, authored by leading researchers in the field. Namely, chapter 1, titled "Fuzzy Selection of Software Components and of Web services" deals with area of Fuzzy Clustering in Software Development; chapter 2, titled "A Training Approach to Develop Reusable Software Components by Combining Adaptation Algorithms" deals with area of Genetic Algorithms in Software Development, the chapter 3, ti­tled "Fuzzy Case-Based Reasoning Models for Software Cost Estimation" and chapter 5, titled "Many Maybes Mean (Mostly) the Same Thing" deal with area of Imprecision in the Software Process; chapter 4, titled "Automating Software Development Process Using Fuzzy Logic" and chapter 10, titled "Linguistic Re­sources and Fuzzy Algebra in Adaptive Hypermedia Systems" deal with area of Fuzzy Logic in Software Development; chapter 6, titled "Soft Computing Based Effort Prediction Systems A Survey", deals with area of Probabilistic Com­puting in Software Development; chapters 6 and 7, titled "High-Level Design of Composite Systems" and "RSHP: an Information Representation Model Based on Relationship" both deal with the area of Fuzzy Object-Oriented Modelling and Design and finally, chapter 9, titled "Neurofuzzy Analysis of Software Qual­ity Data" deals with area of Neural Networks in Software Development.

This makes this book a valuable reference for pratictioners as well as an updated source on ongoing interdisciplinary research.

All these chapters share the common goal of helping software engineering re­searchers and practitioners to understand some of the soft-computing techniques from a knowledge-management perspective, applying them to open issues in soft­ware engineering. Also, they contain a valuable review of the results achieved by some of the main research group working in this area. In the remainder of this introduction, we comment briefly on two research areas where soft-computing techniques are proving applicable, providing pointers to some of the past and ongoing work in this field taking place at the Software Engineering Lab of the University of Milan at Crema (http://ra.crema.unimi.it). Namely, Section 2 deals with component adaptation and automatic software maintenance via evolutionary computation, while Section 3 deals with imprecise descriptions of software features and their use for components' classification and retrieval.

x

2 Evolutionary Software Maintenance

Evolutionary Software Maintenance includes techniques for inexpensive, large scale synthesis and optimization of software components. Evolution, as opposed to classical manual adaptation techniques, ensures a substantial reduction of software maintenance efforts and increased reusability. Investigation on using evolutionary computation to maintain and adapt software components is rel­atively recent. Evolution and maintenance share notions such as modularity, sensitivity to changing requirements, issues of context and control of and types of variability that have for the most part been studied independently by workers in software engineering and evolutionary computation. Today, few dispute the importance of evolvability defined as the capacity to vary robustly and adap­tively over time or generations in digital and natural systems. Thanks to the pioneering work of Parnas and Dijkstra in software engineering, related issues have been identified in software systems design, including functional decompo­sition, information hiding, modularity, requirements change. The first attempts aimed at the synthesis and optimization of software components via evolution­ary techniques were applied to control [6] , [7]. Automatic evolution of business components looks even more attractive, because the effort required by manual modification of components to adapt them to new applications is a major cause of failure for software reuse projects [2]. Evolving software components can au­tomatically adapt themselves to new business situations, e.g. to changes in the interfaces of other components. Several methods have been proposed to mod­ify components automatically instead of manually, often combined with fuzzy classification and retrieval techniques [3], [4]. In [10] a technique is presented aimed at a reduction of maintenance efforts through evolutionary optimization of an existing component. Software components tuning requires fault scenar­ios to be available for evaluating the components' performance. Fault scenarios are sets of states, coded as vectors of environment and input values, that are used to uncover possible faulty or unsatisfactory operation of the components. An adaptation method is used to modify the components behavior in order to improve its response to the environment, as represented by fault scenarios. The aim of this research area is exploiting evolutionary techniques to attain a greater generality and robustness of software components with respect to variations in operational environment. These results are obtained at the expense of time re­quired for the tuning process. However, on one side the speed-up ensured by increased parallelism can adequately compensate for the additional overhead. On the other hand, the cost of the computational resources involved is negligible in comparison with the cost of a human maintainer.

3 Fuzzy Techniques for Software Reuse

Fuzzy techniques can help in handling a well-known source of uncertainty: the classification of artifacts (components, design documentation and others) and their retrieval according to their behavioral properties. Behavioral classifica­tion is inherently imprecise, due to the fact that any components may exhibit

XI

several behaviors, depending on the application viewpoint. The paper [5] pro­poses a technique for software classification and retrieval based on descriptors constructed from the code and its accompanying documentation. Descriptors are composed by term pairs named features, interpreted as open class key­words [11] describing the component functionalities. Features are assigned a relevance weight between Oand 1 by means of a weighting function operating on the code, its documentation and other design artifacts exported in standard semi-structured formats[13]. The list of features in a descriptor has an associated weights vector that can be interpreted as a fuzzy set. In our approach, this fuzzy set is the basis for components classification and retrieval under uncertainty. In [8] we considered the architecture of a complete Software Information Base (SIB) repository, whose descriptors are classes indexed by fuzzy sets. Our re­trieval model enables to pose imprecise queries against the repository asking for a set of characteristics expected from the component. While a SQL-like fuzzy query language is sometimes necessary [5] , imprecise queries can be posed, in their simplest form, by entering lists of weighted features, describing the charac­teristics of the needed component. The basic retrieval mechanism relies on fuzzy matching between the fuzzy set associated to the query and the fuzzy sets of the repository descriptors. After a query is performed, returned candidates are ranked according to the degree of adaptability to the searched component(s). Classification and retrieval are assisted by a Thesaurus[12] containing unique terms and fuzzy synonymy values. Terms are taken from descriptors, or added by the user in charge of maintaining the environment, or incrementally extracted from software and its documentation. The retrieval mechanism is ameliorated along the system life-cycle by observing the user reactions to query answers from the system. In [9] a technique is proposed which, exploiting the composition of fuzzy characteristic functions, implements an adaptive system, tunable with use along time. Problems connected to the definition of a full query language for the repository are discussed in [10]. A multiple descriptor of code components taking into account several behavioral characteristics is a viable approach to deal with this imprecision source. In [14] the different skills and profiles of software de­velopers using the repository are taken into account. The result is a customized environment that remains simple enough to avoid the need for a formal grammar and semantics definition of a component description language.

Acknowledgments The authors are would like to thank David Rine for his encouragement and precious suggestions. Thanks are also due to Mariagrazia Fugini and Andrea Tettamanzi for joint research work and many interesting dis­cussions on these topics

References

1. A. Bottari and G. Degli Antoni, A. Tettamanzi: Thning fuzzy software components with a distributed evolutionary engine. roc. ACM Symposium on Applied Computing (SAC'98), February 1998

XII

2. J. Chen and D. Rine. Testing trainable software components by combining genetic algorithms and backpropagation algorithms. In Proceedings of the IEEE Conference on Multivalued Logic Symposium, May 1997.

3. E. Damiani and M. G. Fugini., "Automatic Thesaurus Construction Supporting Fuzzy Re- trieval of Reusable Components", Proc. ACM Symposium on Applied Computing (SAC'95), February 1995.

4. E. Damiani and M. G. Fugini. Fuzzy techniques for software reuse. In Proceedings of the ACM Symposium on Applied Computing (SAC '96), February 1996.

5. E. Damiani, M.G. Fugini and A. Fusaschi, A Descriptor Based Approach to 0-0 Code Reuse IEEE Computer Vol.30 n.10, (1997), pp. 73-80.

6. C. L. Karr. Design of an adaptive fuzzy logic controller using a genetic algorithm. In R. K. Belew and L. B. Booker, editors, Proceedings of the Fourth International Conference on Genetic Algorithms, San Mateo, CA, 1991.

7. C. Z. Janikow. A genetic algorithm for learning fuzzy controllers. In Proceedings of the ACM Symposium on Applied Computing (SAC 94), New York, 1994.

8. E. Damiani and M.G. Fugini, Dynamic Service Identification in A Distributed Envi­ronment, Journal of Advanced Computational Intelligence (JACI), Vol.3 n.8 (2000)

9. E. Damiani and M.G. Fugini, Design and Code Reuse Based on Fuzzy Classification of Components International Journal on Applied Software Technology, (IJAST) vol. 1. n. 3/4, (1995) pp. 291-303

10. E. Damiani, G. Degli Antoni and A. Tettamanzi DEE: a Tool for Genetic Tuning of Software Components on a Distributed Network of Workstations, International Journal on Applied Software Technology, (IJAST), Vol. 3 n. 2/3, (1998), pp.127-144.

11. S. Faustle, M.G. Fugini and E. Damiani, Retrieval of Reusable Components Using Functional Similarity Software Practice and Experience, (SPE) vol. 26 n.5, (1996), pp. 491-530.

12. E. Damiani, M.G. Fugini and C.Bellettini, A Hierarchy-Aware Approach to Faceted Classification of Object Oriented Components ACM Trans. on Software Engineering Methodologies, (TOSEM), Vol. 8 n.3 (1999) pp.215-262.

13. C. Bellettini, E. Damiani and M.G. Fugini: Querying UML/XML Design Informa­tion. Proceedings of Flexible Query Answering Systems Conference (FQAS) 2000: 538-549

14. C. Bellettini, E. Damiani and M.G. Fugini: Software reuse in-the-small: automating group rewarding. Information and Software Technology 43(11): 651-660 (2001)

XIII