Computational Intelligence in Software Engineering

The following sections are included:

• CONTENTS

• PREFACE

This section is concerned with the development of software constructs and description or prediction their quality by exploiting various techniques of neurocomputing. The most outstanding features of neural networks such as learning, approximation and prediction abilities have been found highly appealing in many crucial tasks of software engineering including testing, organization of visualization of software modules, and inductive computing.

This section is comprised of four papers. First, von Mayerhauser et al. report on the use of neural networks in the problem of software testing with an intent of improving the level of test coverage. The use of self-organizing map in the essential problem of software reusability is studied by Merkl. The issue of prediction of software quality formulated in the setting of neural networks is studied by Khoshgoftaar and Allen. The paper by Partridge deals with inductive computing regarded as a new and attractive approach to the SE development. It reveals a number of interesting neural network-based implementation links.

This chapter explores the possibilities of using neural networks to support various software testing activities. They range from automated test generation to evaluation of automatically generated test cases for their effectiveness in meeting test criteria or finding faults. Our motivation is that it would be useful to have a mechanism that is able to learn, based on past history, to predict test cases are either likely to increase desired coverage items, or which test cases are likely to yield more coverage or failures versus those that are not going to increase coverage or fault exposure. rewrite previous sentence Such approaches show particular promise for large scale software as they do not require extensive structural analysis. In this chapter, we describe experiments involving the testing of a large software system and of a large VHDL design and summarize our assessment of the capabilities of neural networks for testing and their current limitations.

Society's reliance on large complex computer systems mandates high reliability. Reliable software is a necessary component. Controlling faults in software requires that one can predict problems early enough to take preventive action. Software metrics are a basis for such predictions. This study systematically presents a methodology for developing models that predict software quality factors with special emphasis on artificial neural network models. The individual details of this methodology may be familiar, but the whole modeling process must be integrated to produce successful predictions of software quality. We use two case studies to illustrate each step. One case study predicted the number of faults to be discovered in each module, and the other predicted whether each module would be considered fault-prone. The first case study was based on a sample of modules from a military command, control and communications system. We developed a quantitative neural network model, and for comparison, we developed a multiple linear regression model on the same data. The neural network approach produced a better quantitative model. The second case study was based on very large telecommunications system. We modeled modules reused with changes from the previous release, representing over seven million lines of code. We compared a classification neural network model with a nonparametric discriminant model, and found the classification neural network model was more accurate.

Software reuse is the process of building new systems from existing components instead of developing these systems from scratch. For a long time now software reuse is repeatedly acknowledged for playing an essential role in overcoming the so-called software crisis, i.e. the late delivery of then still faulty software products. Current development practice as for example object-oriented analysis, design, and programming should in principle assist the proliferation of the reuse idea. However, before existing components may be considered for reuse they have to be found in a software library. As ever in any area relying on the retrieval of particular objects from a large data store, the process of retrieval may turn out to be rather cumbersome, especially when a large number of objects is contained in the data store and the success of the whole operation is dependent on the retrieval of a small number of relevant objects. With this work we address the assistance of such a retrieval process by means of using a connectionist representation of the contents of the software library. More precisely, we rely on the self-organizing map for software library organization. What makes this model especially attractive for an information retrieval task such as software library organization is the topology preserving learning process leading to a highly intuitive similarity visualization.

In the past few decades a science of computing has begun to emerge from the conglomeration of ad hoc techniques, and partially understood principles that governed the production of software once it became a widespread activity. Great strides forward in hardware technology have outstripped the relatively slow development of a necessary, complementary, software technology. However, early realization of this need for a science to underpin software development has led to much effort towards producing it. A central plank of the resultant formal infrastructure is logical deduction. It is almost axiomatic within computing science proper that the basis for software science should be logic, and, moreover, it should be deductive logic. This chapter first justifies the claim that a deductive use of logic is seen as having an exclusive claim to be the basis for computing science. Even where the formal requirements are more relaxed, programming is invariably viewed as a deductive type of process – i.e. reasoning from the general to the particular. Second, it presents a number of computing activities, peripheral to the mainstream effort, that use a process of induction rather than deduction. Thirdly, it argues that there is now an undeniable claim for the developing science of computing to admit an inductive paradigm into the fold and to give it a place alongside the deduction-based one. Lastly, admission of this radical alternative is expected to have a profound effect on the future development of both computing science theory and practice. Some of these expected repercussions are outlined.

Evolutionary computing delivers an exciting opportunity to automate software development, especially at the phase of automatic programming. Evolutionary techniques have demonstrated their crucial role in the problems of global optimization which are omnipresent and highly visible in software design.

There are three papers in this sections. In the first, Skipper elaborates on the computer ZOO-an interesting artificial life simulator dealing with a family of breeding species-programs. In the second, genetic programming is used by Koza and al. in order to design electric circuits - an important endeavor developed along the line of automatic programming, Khoshgoftaar et al. discuss an application of genetic programming to the problem of software quality prediction.

One of the central goals of computer science is to get computers to solve problems starting from only a high-level statement of the problem. The goal of automating the design process bears many similarities to the goal of automatically creating computer programs. The design process entails creation of a complex structure to satisfy user-defined requirements. The design process is usually viewed as requiring human intelligence. Indeed, design is a major activity of practicing engineers. For these reasons, the design process offers a practical yardstick for evaluating automated programming (program synthesis) techniques. In particular, the design (synthesis) of analog electrical circuits entails the creation of both the topology and sizing (numerical values) of all of a circuit's components. There has previously been no general automated technique for automatically designing an analog electrical circuit from a high-level statement of the circuit's desired behavior. This paper shows how genetic programming can be used to automate the design of both the topology and sizing of a suite of five prototypical analog circuits, including a lowpass filter, a tri-state frequency discriminator circuit, a 60 dB amplifier, a computational circuit for the square root, and a time-optimal robot controller circuit. All five of these genetically evolved circuits constitute instances of an evolutionary computation technique solving a problem that is usually thought to require human intelligence.

The Computer Zoo is an artificial life simulator and its purpose is to recreate life in a computer. It does so be breeding new species of little programs using evolution and natural selection. The programs are written in a specially designed programming language Czoo, which is more resistant to mutations than a traditional programming language. The mutant programs show spontaneous symbiosis, parasites, self-assembly of flocks of programs, punctuated equilibria, and traces of predatory behavior.

Because highly reliable software is becoming an essential ingredient in many systems, software developers apply various techniques to discover faults early in development, such as more rigorous reviews, more extensive testing, and strategic assignment of key personnel. Our goal is to target reliability enhancement activities to those modules that are most likely to have problems. This paper presents a methodology that incorporates genetic programming for predicting the order of software modules based on the expected number of faults. This is the first application of genetic programming to software engineering that we know of. We found that genetic programming can be used to generate software quality models whose inputs are software metrics collected earlier in development, and whose output is a prediction of the number of faults that will be discovered later in development or during operations. We established ordinal evaluation criteria for models, and conducted an industrial case study of software from a military communications system. Case study results were sufficiently good to be useful to a project for choosing modules for extra reliability enhancement treatment.

This section embraces a series of chapters that dwell on some aspects of granular computing. The diversity of the area is strongly reflected in the section. The first three papers revolve around the notion of objects; Gudwin and Gomide discuss object networks, Polkowski and Skowron are concerned with approximate reasoning exploiting the notions of rough sets, and Pedrycz and Sosnowski discuss a design with fuzzy objects regarded as a generalization of object-oriented design. In the sequel, the next three papers are focused on software management and quality: Ebert and Baisch look at a number of techniques (including fuzzy classifiers and neural networks) in the problem of cost-effective software project management. Gray and MacDonell discuss the use of various techniques of logic in the setting of quantifying software development effort. Peters and Raniaena elaborate on time-constrained software cost control system by exploiting techniques of rough sets and fuzzy logic. The design aspects of rale-based systems are studied by McCoy and Levaiy. Finally Cui and Kandel discuss a certain optimization problem arising in the area of databases.

The aim of this work is to introduce an approach based on a generalization of the object-oriented paradigm for system modeling and implementation. The key concept is object network, a set of connected places containing objects modeling the characteristics and properties of a given system. Object network has a naturally distributed structure, is derived from a general and formal approach for a theory of objects, and provides a framework particularly suitable for computational intelligence. An object network has both, formal and representational power needed to develop and to implement intelligent systems.

We propose an approach to approximate reasoning by systems of intelligent agents based on the paradigm of rough mereology. In this approach, the knowledge of each agent is formalized as an information system (a data table) from which similarity measures on objects manipulated by this agent are inferred. These similarity measures are based on rough mereological inclusions which formally render degrees for one object to be a part of another. Each agent constructs in this way its own rough mereological logic in which it is possible to express approximate statements of the type: an object x satisfies a predicate Ψ in degree r. The agents communicate by means of mereological functors (connectives among distinct rough mereological logics) propagating similarity measures from simpler to more complex agents; establishing these connectives is the main goal of negotiations among agents. The presented model of approximate reasoning entails such models of approximate reasoning like fuzzy controllers, neural networks etc. Our approach may be termed analytic, in the sense that all basic constructs are inferred from data.

Imprecision or vagueness can be involved in data at two different levels: it can be related either to the type of data i.e., fuzziness in the data themselves, or to the knowledge of data, i.e. uncertainty in the information about the data. In this paper we define the Fuzzy Object Oriented Data (FOOD) model by generalizing, step by step, its two-valued counterpart that is an Object Oriented (OO) data model. The primary intent of this study is to thoroughly analyze some ways of augmenting the fundamentals of the generic object-oriented approach by the technology of fuzzy sets. In contrast to the previous studies, our thrust is to retain the very nature of object-oriented design (and its advantages) as much as possible while maximizing benefits stemming from the introduced generalization of the model. A usefulness of the proposed approach is illustrated in a problem of vehicle classification.

Cost-effective software project management has the serious need to focus resources on those areas with highest criticality. The article focuses on two areas important for practical application of criticality-based predictions in real projects, namely the selection of a classification technique and the use of the results in directing management decisions. The first part is comprehensively comparing and evaluating five common classification techniques (Pareto classification, classification trees, factor-based discriminant analysis, fuzzy classification, neural networks) for identifying critical components. Results from a current large-scale switching project are included to show practical benefits. Knowing which technique should be applied the second area gains even more attention: What are the impacts for practical project management within given resource and time constraints? Several selection criteria based on the results of a combined criticality and history analysis are provided together with potential decisions.

Software metrics are measurements that are made of software development processes and the resulting products. Once recorded they can be used as variables (both dependent and independent) in models for project management purposes, including prediction, monitoring, and assessing the development process. The most common types of these software metric models are those used for predicting the development effort required for a software system, usually in terms of developer hours/days, based on size, complexity, developer characteristics, and other relevant metrics. Despite the well-known, and considerable, financial and strategic benefits that can be acquired from developing accurate and usable models of effort estimation, there are a number of problems that have not yet been overcome by those using the traditional techniques of formal and linear regression models. These include taking full consideration of the non-linearities and interactions inherent in complex real-world processes such as software development and the lack of stationarity in such processes (as people, tools, and methodologies change). Other problems include over-commitment to precisely specified values, the small quantities of data often available, and the inability to use whatever knowledge is available where numerical values are unknown or are only known in some approximate manner. The usefulness of alternative techniques, especially that of fuzzy logic modeling, are investigated, some comparisons between the techniques are made, and some recommendations are suggested regarding the use of fuzzy logic for project management.

This paper introduces a rough set approach to constructing rules for a time-constrained feedback control system for software cost estimation. Decision rules capture dependencies between function points, project duration requirement, aggregation of granulations of multi-criteria evaluations of software development technologies with the Choquet integral, and magnitude of relative error in cost estimation. These rules spring from an approximate reasoning approach to making decisions about adjustments in the application of software development technologies for a particular software product. The method of rule derivation comes from rough sets. A fuzzy measure model of the importance of various coalitions of software technologies is introduced. The approximate character of the reasoning stems from the inherent imprecision of measurements of processing complexity. The approach is illustrated relative to software cost estimates for a collection of twenty-five software projects. The contribution of this paper is a formal description of a time-constrained software cost feedback control system based on an approximate reasoning approach to assessing software cost.

A rule based expert system program was used to model a fighter pilot's task and procedure execution. This model was developed to be incorporated into an intelligent cognitive decision support system to help maintain an estimate of pilot situation awareness, workload and general man-machine system performance. This model could be applied to augment operator procedures and information flow. Validation of the model was accomplished through direct comparison of critical predicted measures of merit against observed pilot performance in a high fidelity manned fighter simulation.

In this study, highly accurate, noniterative, closed form approximation formulas for calculating the expected number of block hits by a query in a database system are developed. The error bounds of the new formulas have been obtained in a thorough error analysis. The error bounds show that the approximations suggested in this study are almost identical to the exact value of the expected number and the accuracy of the approximations can be improved as the number of blocks in a database increases.

This paper proposes a novel way of looking at the concept of programs and programming by focusing on a recent development in the method of implementing the process structures necessary to operate intelligent robots and describing its characteristics in the context of Software Engineering. While still proven effective only in a new breed of robotics, there is a possibility the methodology is applicable to a wider range of embedded computing, realtime processes, and potentially to some parts of information processing, particularly if it is combined with evolutionary computational techniques such as GA. The approach could potentially become a crucial programming paradigm, forcing a new way of looking at the very concept of programming.

This section introduces a non-Cartesian approach to software engineering, which is inspired by competences and the notion of a non-Cartesian robot. The article in this section suggests how the paradigms of non-Cartesian robotics can beneficially influence software engineering.

A competence consists of sensory input from one or more sensors coupled with one or more actuators providing a means of responding to specific situations. Each competence is carried out by a separate processor that runs asynchronously (there is no form of communication between processors, no shared global memory, no central control), A non-Cartesian robot has a complex but hierarchical, non-deterministic structure which derives its intelligence through a process of self-organization among competences. Non-Cartesian robots are a direct result of research concerning situated robotics which stems from the work of Brooks.

This paper includes an extensive bibliography concerning Computational Intelligence (CI) and Software Engineering (SE). It summarizes a list of pertinent World Wide Web resources that deal both with Software Engineering and the key components of CI such as neural networks, evolutionary computing, and fuzzy set technology. The paper highlights several main trends manifesting quite evidently in the development of the entire area.

The following sections are included:

• Index