% esel99.bib %%%%% 1999 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @INPROCEEDINGS{AK99:ISACC, author = {Edward B. Allen and Taghi M. Khoshgoftaar}, month = mar, year = 1999, title = {Assessing Software Dependability with the Help of Software Quality Models: {A} Report on Work in Progress}, booktitle = {Conference Proceedings: International Software Assurance Certification Conference}, pages = {{Paper G1.}}, note = {Proceedings available from Reliable Software Technologies, Sterling, VA USA.}, publisher = {}, address = {Chantilly, Virginia USA}, organization = {Information Technology Association of America}, annote = {}, isbn = {}, inlibrary = {}, abstract = {Software is increasingly used in safety-critical and mission-critical systems. This paper is a report on work in progress to find practical means for certification that a software system will never fail. ``Does the software behave perfectly?'' % We use the word ``dependability'' to convey the probabilistic idea that software is ``unlikely to fail''. Accordingly, we adopt statistical testing as a dependability assessment approach. % In this paper, we focus on the dependability of each module of a large system, as if they were separate programs. We present the concept that results from a software quality model can be used to reduce the number of statistical tests that must succeed to achieve a dependability target. % Open issues for future research are also discussed.}, keywords = {Certification, Dependability, Software Reliability, Software Testing, Testability, Software Quality Modeling} } @INPROCEEDINGS{AK99:METRICS, author = {Edward B. Allen and Taghi M. Khoshgoftaar}, month = nov, year = 1999, title = {Measuring Coupling and Cohesion: {A}n Information-Theory Approach}, booktitle = {Proceedings of the Sixth International Software Metrics Symposium}, pages = {119--127}, address = {Boca Raton, Florida USA}, organization = IEEECS, annote = {coupling, intramodule coupling, cohesion at system level}, abstract = {The design of software is often depicted by graphs that show components and their relationships. For example, a structure chart shows the calling relationships among components. Object-oriented design is based on various graphs, as well. Such graphs are abstractions of the software, devised to depict certain design decisions. Coupling and cohesion are attributes that summarizes the degree of interdependence or connectivity among subsystems and within subsystems, respectively. When used in conjunction with measures of other attributes, coupling and cohesion can contribute to an assessment or prediction of software quality. A graph may be an abstraction of a software system and a subgraph may represent a software module (subsystem). This paper proposes information theory-based measures of coupling and cohesion of a modular system. These measures have the properties of system-level coupling and cohesion defined by Briand, Morasca, and Basili. Coupling is based on relationships between modules. We also propose a similar measure for intramodule coupling based on an intramodule abstraction of the software, rather than intermodule, but intramodule coupling is calculated in the same way as intermodule coupling. We define cohesion in terms of intramodule coupling, normalized to between zero and one. We illustrate the measures with example graphs. Preliminary analysis showed that the information-theory approach has finer discrimination than counting.}, keywords = {Software Metrics, Coupling, Cohesion, Information Theory, Entropy, Excess Entropy} } @INPROCEEDINGS{AK99:RQD, author = {Edward B. Allen and Taghi M. Khoshgoftaar}, editor = {Hoang Pham and Ming-Wei Lu}, month = aug, year = 1999, title = {Measurement of Software Design Cohesion}, booktitle = {Proceedings: Fifth {ISSAT} International Conference on Reliability and Quality in Design}, pages = {158--163}, note = {Invited paper.}, address = {Las Vegas, Nevada USA}, organization = {International Society of Science and Applied Technologies}, annote = {see AK99:FAU6}, keywords = {Software Metrics, Software Design, Software Quality, Information Theory} } @MASTERSTHESIS{Deng99:MS, author = {Jianyu Deng}, month = dec, year = 1999, title = {Classification of Software Quality Using Tree Modeling with the {S-Plus} Algorithm}, note = {Advised by Taghi M. Khoshgoftaar.}, address = {Boca Raton, Florida}, school = {Florida Atlantic University}, keywords = {Regression Trees, Classification Trees, Software Metrics, Fault-Prone Modules, S-Plus} } @INPROCEEDINGS{EKCA99:FLAIRS, author = {Matthew P. Evett and Taghi M. Khoshgoftaar and Pei-Der Chien and Edward B. Allen}, editor = {Amruth N. Kumar and Ingrid Russell}, month = mar, year = 1999, title = {Using Genetic Programming to Determine Software Quality}, booktitle = {Proceedings of the Twelfth International {FLAIRS} Conference}, pages = {113--117}, publisher = {AAAI Press}, address = {Menlo Park, California USA}, organization = {American Association for Artificial Intelligence}, isbn = {0-57735-080-4} } @INPROCEEDINGS{EKCA99:GECCO, author = {Matthew P. Evett and Taghi M. Khoshgoftaar and Pei-Der Chien and Edward B. Allen}, editor = {John Koza and others}, month = jul, year = 1999, title = {Modelling Software Quality with {GP}}, booktitle = {Proceedings: Genetic and Evolutionary Computation Conference}, publisher = {Morgan Kaufman}, address = {Orlando, Florida USA} } @ARTICLE{GKA99:IJSEKE, author = {K. Ganesan and Taghi M. Khoshgoftaar and Edward B. Allen}, month = {}, year = 1999, title = {Case-Based Software Quality Prediction}, journal = IJSEKE, volume = 9, number = 6, pages = {}, note = {In press.}, annote = {}, inlibrary = LIBIJSEKE, abstract = {Highly reliable software is becoming an essential ingredient in many systems. However, assuring reliability often entails time-consuming costly development processes. One cost-effective strategy is to target reliability-enhancement activities to those modules that are likely to have the most problems. Software quality prediction models can predict the number of faults expected in each module early enough for reliability enhancement to be effective. % This paper introduces a case-based reasoning technique for the prediction of software quality factors. Case-based reasoning is a technique that seeks to answer new problems by identifying similar ``cases'' from the past. A case-based reasoning system can function as a software quality prediction model. To our knowledge, this study is the first to use case-based reasoning systems for predicting quantitative measures of software quality. % A case study applied case-based reasoning to software quality modeling of a family of full-scale industrial software systems. The case-based reasoning system's accuracy was much better than a corresponding multiple linear regression model in predicting the number of design faults. When predicting faults in code, its accuracy was significantly better than a corresponding multiple linear regression model for two of three test data sets and statistically equivalent for the third.}, keywords = {case-based reasoning, multiple linear regression, software quality, software reliability, software metrics} } @INPROCEEDINGS{JHKA99:CSMR, author = {Wendell D. Jones and John P. Hudepohl and Taghi M. Khoshgoftaar and Edward B. Allen}, month = mar, year = 1999, title = {Application of a Usage Profile in Software Quality Models}, booktitle = {Proceedings of the Third European Conference on Software Maintenance and Reengineering}, pages = {148--157}, address = {Amsterdam, Netherlands}, organization = IEEECS, annote = {}, isbn = {0-7695-0090-0}, inlibrary = {Khoshgoftaar}, abstract = {Faults discovered by customers are an important aspect of software quality. The working hypothesis of this paper is that variables derived from an execution profile can be useful in software quality models. An execution profile of a software system consists of the probability of execution of each module during operations. Execution represents opportunities for customers to discover faults. However, an execution profile over an entire customer-base can be difficult to measure directly. Deployment records of past releases can be a valuable source of data for calculating an approximation to the probability of execution. In this paper, we analyze a metric derived from deployment records which is a practical surrogate for an execution profile in the context of a software quality model. We define ``usage'' as the proportion of systems in the field which have a module deployed. This paper presents a case study of a very large legacy telecommunications system. We developed models to predict whether software modules will have any faults discovered by customers on systems in the field. Static software product metrics and usage were independent variables. The significance levels of variables in logistic regression models were analyzed, and models with and without usage as an independent variable were compared. The case study was empirical evidence that usage can be a significant contributor to a software quality model.}, keywords = {Software Maintenance, Software Assessment, Software Reliability, Operational Profile, Execution Profile, Usage Profile, Software Product Metrics, Fault-Prone Modules, Classification, Logistic Regression} } @ARTICLE{KA99:ESE, author = {Taghi M. Khoshgoftaar and Edward B. Allen}, month = {}, year = 1999, title = {A Comparative Study of Ordering and Classification of Fault-Prone Software Modules}, journal = ESE, volume = 4, number = {}, pages = {159--186}, annote = {}, inlibrary = LIBESE, abstract = {Software quality models can predict the quality of modules early enough for cost-effective prevention of problems. For example, software product and process metrics can be the basis for predicting reliability. Predicting the exact number of faults is often not necessary; classification models can identify fault-prone modules. However, such models require that ``fault-prone'' be defined before modeling, usually via a threshold. This may not be practical due to uncertain limits on the amount of reliability-improvement effort. In such cases, predicting the rank-order of modules is more useful. This paper summarizes the concept of module-order models for software reliability enhancement. A module-order model predicts the rank-order of modules according to a quantitative quality factor, such as the number of faults. The contribution of this paper is to demonstrate how module-order models can be used for classification, and to compare them with conventional software quality classification models. This is the first such comparative study that we know of. Two case studies of full-scale industrial software systems compared nonparametric discriminant analysis with module-order models. One case study examined a military command, control, and communications system. The other studied a large legacy telecommunications system. We found that module-order models give management more flexible reliability enhancement strategies than classification models, and in these case studies, yielded more accurate results than corresponding discriminant models.}, keywords = {software reliability, fault-prone modules, software quality models, module-order models, multiple linear regression, nonparametric discriminant analysis, principal components analysis} } @INPROCEEDINGS{KA99:HASE, author = {Taghi M. Khoshgoftaar and Edward B. Allen}, month = nov, year = 1999, title = {Predicting Fault-Prone Software Modules in Embedded Systems with Classification Trees}, booktitle = {Proceedings: Fourth {IEEE} International Symposium on High-Assurance Systems Engineering}, pages = {105--112}, address = {Washington, DC USA}, organization = IEEECS, abstract = {Embedded-computer systems have become essential elements of the modern world. For example, telecommunications systems are the backbone of society's information infrastructure. Embedded systems must have highly reliable software. The consequences of failures may be severe; down-time may not be tolerable; and repairs in remote locations are often expensive. Moreover, today's fast-moving technology marketplace mandates that embedded systems evolve, resulting in multiple software releases embedded in multiple products. Software quality models can be valuable tools for software engineering of embedded systems, because some software-enhancement techniques are so expensive or time-consuming that it is not practical to apply them to all modules. Targeting such enhancement techniques is an effective way to reduce the likelihood of faults discovered in the field. Research has shown software metrics to be useful predictors of software faults. A software quality model is developed using measurements and fault data from a past release. The calibrated model is then applied to modules currently under development. Such models yield predictions on a module-by-module basis. This paper examines the Classification And Regression Trees (CART) algorithm for predicting which software modules have high risk of faults to be discovered during operations. CART is attractive because it emphasizes pruning to achieve robust models. This paper presents details on the CART algorithm in the context of software engineering of embedded systems. We illustrate this approach with a case study of four consecutive releases of software embedded in a large telecommunications system. The level of accuracy achieved in the case study would be useful to developers of an embedded system. The case study indicated that this model would continue to be useful over several releases as the system evolves.}, keywords = {High Assurance, Embedded Systems, Software Reliability, Software Metrics, Fault-Prone Modules, Classification Trees, CART} } @INCOLLECTION{KA99:RARQE, author = {Taghi M. Khoshgoftaar and Edward B. Allen}, editor = {Hoang Pham}, month = {}, year = 1999, title = {Modeling Software Quality with Classification Trees}, booktitle = {Recent Advances in Reliability and Quality Engineering}, chapter = {}, pages = {}, note = {In press.}, publisher = {World Scientific}, address = {Singapore}, annote = {}, isbn = {}, inlibrary = {}, abstract = {High software quality is an important attribute of mission-critical systems. Software quality models are tools for focusing efforts to find faults early in development. Such models yield timely predictions of quality on a module-by-module basis, enabling one to target enhancement techniques. This paper introduces the Classification And Regression Trees (CART) algorithm to practitioners in software engineering. This paper draws practical lessons learned on building classification trees for software quality modeling, including a way to control the balance between misclassification rates. A case study of a very large telecommunications system used CART to build software quality models. The models predicted whether or not modules were fault-prone, based on various sets of software product and process metrics as predictor variables. The case study illustrated practical aspects of using classification trees for software quality modeling.}, keywords = {Software Quality, Fault-Prone Modules, Classification Trees, CART, Telecommunications, Software Product Metrics, Software Process Metrics} } @ARTICLE{KA99:RQSE, author = {Taghi M. Khoshgoftaar and Edward B. Allen}, month = dec, year = 1999, title = {Logistic Regression Modeling of Software Quality}, journal = {International Journal of Reliability, Quality and Safety Engineering}, volume = 6, number = 4, pages = {303--317}, note = {}, annote = {See KA97:FAU24}, abstract = {Reliable software is mandatory for complex mission-critical systems. Classifying modules as fault-prone, or not, is a valuable technique for guiding development processes, so that resources can be focused on those parts of a system that are most likely to have faults. Logistic regression offers advantages over other classification modeling techniques, such as interpretable coefficients. There are few prior applications of logistic regression to software quality models in the literature, and none that we know of account for prior probabilities and costs of misclassification. A contribution of this paper is the application of prior probabilities and costs of misclassification to a logistic regression-based classification rule for a software quality model. This paper also contributes an integrated method for using logistic regression in software quality modeling, including examples of how to interpret coefficients, how to use prior probabilities, and how to use costs of misclassifications. A case study of a major subsystem of a military, real-time system illustrates the techniques.}, keywords = {Software Process; Process Measures; Software Metrics; Fault-Prone Modules; Software Reuse; Spiral Life Cycle; Software Quality Modeling; Logistic Regression.} } @ARTICLE{KAJH99:IJSEKE, author = {Taghi M. Khoshgoftaar and Edward B. Allen and Wendell D. Jones and John P. Hudepohl}, month = {}, year = 1999, title = {Data Mining for Predictiors of Software Quality}, journal = IJSEKE, volume = 9, number = 5, pages = {547--563}, annote = {see KAJH98:FAU3}, inlibrary = LIBIJSEKE, abstract = {``Knowledge discovery in data bases'' (KDD) for software engineering is a process for finding useful information in the large volumes of data that are a byproduct of software development, such as data bases for configuration management and for problem reporting. % This paper presents guidelines for extracting innovative process metrics from these commonly available data bases. This paper also adapts the Classification And Regression Trees algorithm, \textsc{cart}, to the KDD process for software engineering data. To our knowledge, this algorithm has not been used previously for empirical software quality modeling. In particular, we present an innovative way to control the balance between misclassification rates. A KDD case study of a very large legacy telecommunications software system found that variables derived from source code, configuration management transactions, and problem reporting transactions can be useful predictors of software quality. The KDD process discovered that for this software development environment, out of forty software attributes, only a few of the predictor variables were significant. This resulted in a model that predicts whether modules are likely to have faults discovered by customers. Software developers need such predictions early in development to target software enhancement techniques to the modules that need improvement the most.}, keywords = {Knowledge Discovery, Data Mining, Software Quality, Fault-Prone Modules, Classification Trees, CART, Telecommunications, Software Product Metrics, Software Process Metrics} } @INPROCEEDINGS{KAJH99:ISSRE, author = {Taghi M. Khoshgoftaar and Edward B. Allen and Wendell D. Jones and John P. Hudepohl}, month = nov, year = 1999, title = {Classification Tree Models of Software Quality over Multiple Releases}, booktitle = {Proceedings: The Tenth International Symposium on Software Reliability Engineering}, pages = {116--125}, address = {Boca Raton, Florida USA}, organization = IEEECS, abstract = {Software quality models are tools for focusing software enhancement efforts. Such efforts are essential for mission-critical embedded software, such as telecommunications systems, because customer-discovered faults have very serious consequences and are very expensive to repair. This paper presents an empirical study that evaluated software quality models over several releases to address the question, ``How long will a model yield useful predictions?'' This paper also introduces the Classification And Regression Trees (CART) algorithm to software reliability engineering practitioners. We present our method for exploiting CART features to achieve a preferred balance between the two types of misclassification rates. This is desirable because misclassifications of fault-prone modules often have much more severe consequences than misclassifications of those that are not fault-prone. We developed two classification-tree models based on four consecutive releases of a very large legacy telecommunications system. Forty-two software product, process, and execution metrics were candidate predictors. The first software quality model used measurements of the first release as the training data set and measurements of the subsequent three releases as evaluation data sets. The second model used measurements of the second release as the training data set and measurements of the subsequent two releases as evaluation data sets. Both models had accuracy that would be useful to developers. One might suppose that software quality models lose their value very quickly over successive releases due to evolution of the product and the underlying development processes. We found the models remained useful over all the releases studied. Much of the software metrics literature has shown that software product metrics can be significant predictors of {\em fault-prone} modules. This case study showed that process and execution metrics can also be significant predictors.}, keywords = {Software Reliability, Software Metrics, Fault-Prone Modules, Classification Trees, CART} } @ARTICLE{KAJH99:JSM , AUTHOR = { Taghi M. Khoshgoftaar and Edward B. Allen and Wendell D. Jones and John P. Hudepohl } , TITLE = { Which Software Modules Have Faults that Will Be Discovered by Customers? } , JOURNAL = JSM , YEAR = 1999 , MONTH = jan , VOLUME = 11 , NUMBER = 1 , PAGES = {1--18} , NOTE = {} , KEYWORDS = { software maintenance, software quality, software metrics, product metrics, process metrics, fault-prone modules, classification, logistic regression } , ANNOTE = {} , INLIBRARY = LIBJSM , ABSTRACT = { Software is the medium for implementing increasingly sophisticated features during the maintenance phase as successive releases are developed. Software quality models can predict which software modules are likely to have faults that will be discovered by customers. Such models are key components of a system such as Enhanced Measurement for Early Risk Assessment of Latent Defects ({\sc emerald}). It is a sophisticated system of decision support tools used by software designers and managers at Nortel to assess risk and improve software quality and reliability of legacy software systems. This paper reports an approach to software quality modeling that is suitable for industrial systems such as \textsc{emerald}. We conducted a case study of a large legacy telecommunication system in the maintenance phase to predict whether each module will be considered fault-prone. The case study is distinctive in the following respects. (1) Fault-prone modules were defined in terms of faults discovered by customers, which represent only a small fraction of the modules in the system. (2) We developed models based on software product and process metrics that can make useful predictions at the end of the coding phase and at the time of release. (3) The modeling approach is suitable for very large systems. We anticipate that this case study's models will be incorporated into \textsc{emerald}. A similar approach could be taken for other systems. } } @ARTICLE{KANJH99:IJSEKE, author = {Taghi M. Khoshgoftaar and Edward B. Allen and Archana Naik and Wendell D. Jones and John P. Hudepohl}, month = {}, year = 1999, title = {Using Classification Trees for Software Quality Models: {L}essons Learned}, journal = IJSEKE, volume = 9, number = 2, pages = {217--231}, annote = {revised version of KANJH98:HASE}, inlibrary = LIBIJSEKE, abstract = {\ldots This paper introduces the Classification And Regression Trees (CART) algorithm to practitioners in high-assurances systems engineering. This paper presents practical lessons learned on building classification trees for software quality modeling, including an innovative way to control the balance between misclassification rates. \ldots}, keywords = {Software Quality, Fault-Prone Modules, Classification Trees, CART, Software Product Metrics, Software Process Metrics} } @INPROCEEDINGS{KATMV99:ASSET, author = {Taghi M. Khoshgoftaar and Edward B. Allen and Wai Hong Tang and Christoph C. Michael and Jeffrey M. Voas}, month = mar, year = 1999, title = {Identifying Modules Which Do Not Propagate Errors}, booktitle = {Proceedings: 1999 {IEEE} Symposium on Application-Specific Systems and Software Engineering and Technology}, pages = {185--193}, publisher = {}, address = {Richardson, Texas USA}, organization = IEEECS, annote = {}, isbn = {0-7695-0122-2}, inlibrary = {Khoshgoftaar}, abstract = {Our goal is to identify software modules that have some locations which do not propagate errors induced by a suite of test cases. This paper focuses on whether or not data state errors can propagate from a location in the code to the outputs or observable data state during random testing with inputs drawn from an operational distribution. If a code-location's probability of propagation is estimated to be zero, then a fault in that location could escape detection during testing. Because testing is never exhaustive, there is a risk that failures due to such latent faults could occur during operations. Fault injection is a technique for directly measuring the probability of propagation. However, measurement for every location in the code of a full-scale program is often prohibitively computation-intensive. Our objective is a practical, useful alternative to direct measurement. We present empirical evidence that static software product metrics can be useful for identifying software modules where the effects of a fault in that module are not observable. A case study of an intricate computer game program revealed a useful empirical relationship between static software product metrics and propagation of errors. The case study program was an order of magnitude larger than previously reported studies.}, keywords = {Software Product Metrics, Software Reliability, Testability, Propagation of Errors, Fault Injection, Data Mutation, Software Quality Modeling, Logistic Regression} } @INPROCEEDINGS{KAYJH99:ICSM, author = {Taghi M. Khoshgoftaar and Edward B. Allen and Xiaojing Yuan and Wendell D. Jones and John P. Hudepohl}, month = aug, year = 1999, title = {Preparing Measurements of Legacy Software for Predicting Operational Faults}, booktitle = {Proceedings: International Conference on Software Maintenance}, pages = {359--368}, address = {Oxford, England}, organization = IEEECS, abstract = {Software quality modeling can be used by a software maintenance project to identify a limited set of software modules that probably need improvement. A model's goal is to recommend a set of modules to receive special treatment. The purpose of this paper is to report our experiences modeling software quality with classification trees, including necessary preprocessing of data. We conducted a case study on two releases of a very large legacy telecommunications system. A module was considered fault-prone if any faults were discovered by customers, and not fault-prone otherwise. Software product, process, and execution metrics were the basis for predictors. The TREEDISC algorithm for building classification trees was investigated, because it emphasizes statistical significance. Numeric data, such as software metrics, are not suitable for TREEDISC. Consequently, we transformed measurements into discrete ordinal predictors by grouping. This case study investigated the sensitivity of modeling results to various groupings. We found that robustness, accuracy, and parsimony of the models were influenced by the maximum number of groups. Models based on two sets of candidate predictors had similar sensitivity.}, keywords = {Software Quality, Fault-Prone Modules, Classification Trees, TREEDISC, Telecommunications, Software Metrics} } @INPROCEEDINGS{KAYJH99:METRICS, author = {Taghi M. Khoshgoftaar and Edward B. Allen and Xiaojing Yuan and Wendell D. Jones and John P. Hudepohl}, month = nov, year = 1999, title = {Assessing Uncertain Predictions of Software Quality}, booktitle = {Proceedings of the Sixth International Software Metrics Symposium}, pages = {159--168}, address = {Boca Raton, Florida USA}, organization = IEEECS, abstract = {Many development organizations try to minimize faults in the software as a means for improving customer satisfaction. Assuring high software quality often entails time-consuming and costly development processes. A software quality model based on software metrics can be used to guide enhancement efforts by predicting which modules are fault-prone. This paper presents a way to determine which predictions by a classification-tree model should be considered uncertain. We conducted a case study of a large legacy telecommunications system. One release was the basis for the training data set, and the subsequent release was the basis for the evaluation data set. We built a classification tree using the TREEDISC algorithm, which is based on chi-squared tests of contingency tables. The model predicted whether a module was likely to have faults discovered by customers, or not, based on software product, process, and execution metrics. We simulated practical use of the model by classifying the modules in the evaluation data set. The model achieved useful accuracy, in spite of the very small proportion of fault-prone modules in the system. We assessed whether the classes assigned to the leaves were appropriate by examining the details of the full tree, and found sizable subsets of modules with substantially uncertain classification. Discovering modules with uncertain classifications allows one to employ sophisticated enhancement strategies to resolve uncertainties. Moreover, TREEDISC is especially well-suited to identifying uncertain classifications.}, keywords = {Software Metrics, Classification Trees, Fault-Prone Modules, Uncertain Classifications, TREEDISC} } @INPROCEEDINGS{SK99:RQD, author = {Robert M. Szabo and Taghi M. Khoshgoftaar}, editor = {Hoang Pham and Ming-Wei Lu}, month = aug, year = 1999, title = {The Detection of High Risk Software Modules in an Object-Oriented System}, booktitle = {Proceedings: Fifth {ISSAT} International Conference on Reliability and Quality in Design}, pages = {142--147}, note = {Invited paper.}, address = {Las Vegas, Nevada USA}, organization = {International Society of Science and Applied Technologies}, keywords = {Classification, Discriminant Analysis, Principal Components Analysis, Procedural Software Metrics, Object-Oriented Software Metrics Software Quality} } @MASTERSTHESIS{Shan99:MS, author = {Ruqun Shan}, month = dec, year = 1999, title = {Modeling Software Quality with Classification Trees Using Principal Components Analysis}, note = {Advised by Taghi M. Khoshgoftaar.}, address = {Boca Raton, Florida}, school = {Florida Atlantic University}, keywords = {Regression Trees, Classification Trees, Software Metrics, Fault-Prone Modules, S-Plus, CART, Principal Components Analysis} } @MASTERSTHESIS{Yuan99:MS, author = {Xiaojing Yuan}, month = dec, year = 1999, title = {Modeling Software Quality with {TREEDISC}}, note = {Advised by Taghi M. Khoshgoftaar.}, address = {Boca Raton, Florida}, school = {Florida Atlantic University}, keywords = {Classification Trees, Software Metrics, Fault-Prone Modules, TREEDISC} }