Relevant bibliographies by topics / SOFTWARE FAULT PRONENESS

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Book chapters
  4. Conference papers

Academic literature on the topic 'SOFTWARE FAULT PRONENESS'

Author: Grafiati
Published: 11 September 2023

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'SOFTWARE FAULT PRONENESS.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Journal articles on the topic "SOFTWARE FAULT PRONENESS"

1

Denaro, Giovanni, Mauro Pezzè, and Sandro Morasca. "Towards Industrially Relevant Fault-Proneness Models." International Journal of Software Engineering and Knowledge Engineering 13, no. 04 (August 2003): 395–417. http://dx.doi.org/10.1142/s0218194003001366.

Full text
Abstract:
Estimating software fault-proneness early, i.e., predicting the probability of software modules to be faulty, can help in reducing costs and increasing effectiveness of software analysis and testing. The many available static metrics provide important information, but none of them can be deterministically related to software fault-proneness. Fault-proneness models seem to be an interesting alternative, but the work on these is still biased by lack of experimental validation. This paper discusses barriers and problems in using software fault-proneness in industrial environments, proposes a method for building software fault-proneness models based on logistic regression and cross-validation that meets industrial needs, and provides some experimental evidence of the validity of the proposed approach.
APA, Harvard, Vancouver, ISO, and other styles
2

Gatrell, Matt, and Steve Counsell. "Faults and Their Relationship to Implemented Patterns, Coupling and Cohesion in Commercial C# Software." International Journal of Information System Modeling and Design 3, no. 2 (April 2012): 69–88. http://dx.doi.org/10.4018/jismd.2012040103.

Full text
Abstract:
This paper documents a study of fault proneness in commercial, proprietary software and attempts to determine whether a relationship exists between class faults and the design context of a class, namely the coupling and cohesion of a class, and whether the class is a participant of common design patterns. The authors studied a commercial software system for a 24 month period and identified design pattern participants by inspecting the design documentation and source code; coupling and cohesion metrics were measured by inspecting the source code with a tool; we also extracted fault data for the same period to determine whether a relationship existed between the design context and the fault propensity of a class. Results showed that design pattern participant classes were marginally more fault-prone than non-participant classes, The Adaptor, Method and Singleton patterns were found to be the most fault-prone of thirteen patterns explored. Coupling was found to have a significant relationship with the fault proneness of classes in the system; efferent coupling was a stronger indicator of fault propensity than afferent coupling. Cohesion, when measured using the LCOM(HS) metric, was not found to have a strong relationship with fault proneness.
APA, Harvard, Vancouver, ISO, and other styles
3

Bhandari, Guru Prasad, Ratneshwer Gupta, and Satyanshu Kumar Upadhyay. "An approach for fault prediction in SOA-based systems using machine learning techniques." Data Technologies and Applications 53, no. 4 (September 3, 2019): 397–421. http://dx.doi.org/10.1108/dta-03-2019-0040.

Full text
Abstract:
Purpose Software fault prediction is an important concept that can be applied at an early stage of the software life cycle. Effective prediction of faults may improve the reliability and testability of software systems. As service-oriented architecture (SOA)-based systems become more and more complex, the interaction between participating services increases frequently. The component services may generate enormous reports and fault information. Although considerable research has stressed on developing fault-proneness prediction models in service-oriented systems (SOS) using machine learning (ML) techniques, there has been little work on assessing how effective the source code metrics are for fault prediction. The paper aims to discuss this issue. Design/methodology/approach In this paper, the authors have proposed a fault prediction framework to investigate fault prediction in SOS using metrics of web services. The effectiveness of the model has been explored by applying six ML techniques, namely, Naïve Bayes, Artificial Networks (ANN), Adaptive Boosting (AdaBoost), decision tree, Random Forests and Support Vector Machine (SVM), along with five feature selection techniques to extract the essential metrics. The authors have explored accuracy, precision, recall, f-measure and receiver operating characteristic curves of the area under curve values as performance measures. Findings The experimental results show that the proposed system can classify the fault-proneness of web services, whether the service is faulty or non-faulty, as a binary-valued output automatically and effectively. Research limitations/implications One possible threat to internal validity in the study is the unknown effects of undiscovered faults. Specifically, the authors have injected possible faults into the classes using Java C3.0 tool and only fixed faults are injected into the classes. However, considering the Java C3.0 community of development, testing and use, the authors can generalize that the undiscovered faults should be few and have less impact on the results presented in this study, and that the results may be limited to the investigated complexity metrics and the used ML techniques. Originality/value In the literature, only few studies have been observed to directly concentrate on metrics-based fault-proneness prediction of SOS using ML techniques. However, most of the contributions are regarding the fault prediction of the general systems rather than SOS. A majority of them have considered reliability, changeability, maintainability using a logging/history-based approach and mathematical modeling rather than fault prediction in SOS using metrics. Thus, the authors have extended the above contributions further by applying supervised ML techniques over web services metrics and measured their capability by employing fault injection methods.
APA, Harvard, Vancouver, ISO, and other styles
4

Shatnawi, Raed, and Alok Mishra. "An Empirical Study on Software Fault Prediction Using Product and Process Metrics." International Journal of Information Technologies and Systems Approach 14, no. 1 (January 2021): 62–78. http://dx.doi.org/10.4018/ijitsa.2021010104.

Full text
Abstract:
Product and process metrics are measured from the development and evolution of software. Metrics are indicators of software fault-proneness and advanced models using machine learning can be provided to the development team to select modules for further inspection. Most fault-proneness classifiers were built from product metrics. However, the inclusion of process metrics adds evolution as a factor to software quality. In this work, the authors propose a process metric measured from the evolution of software to predict fault-proneness in software models. The process metrics measures change-proneness of modules (classes and interfaces). Classifiers are trained and tested for five large open-source systems. Classifiers were built using product metrics alone and using a combination of product and the proposed process metric. The classifiers evaluation shows improvements whenever the process metrics were used. Evolution metrics are correlated with quality of software and helps in improving software quality prediction for future releases.
APA, Harvard, Vancouver, ISO, and other styles
5

Singh, Rajvir, Anita Singhrova, and Rajesh Bhatia. "Optimized Test Case Generation for Object Oriented Systems Using Weka Open Source Software." International Journal of Open Source Software and Processes 9, no. 3 (July 2018): 15–35. http://dx.doi.org/10.4018/ijossp.2018070102.

Full text
Abstract:
Detection of fault proneness classes helps software testers to generate effective class level test cases. In this article, a novel technique is presented for an optimized test case generation for ant-1.7 open source software. Class level object oriented (OO) metrics are considered as effective means to find fault proneness classes. The open source software ant-1.7 is considered for the evaluation of proposed techniques as a case study. The proposed mathematical model is the first of its kind generated using Weka open source software to select effective OO metrics. Effective and ineffective OO metrics are identified using feature selection techniques for generating test cases to cover fault proneness classes. In this methodology, only effective metrics are considered for assigning weights to test paths. The results indicate that the proposed methodology is effective and efficient as the average fault exposition potential of generated test cases is 90.16% and test cases execution time saving is 45.11%.
APA, Harvard, Vancouver, ISO, and other styles
6

Gondra, Iker. "Applying machine learning to software fault-proneness prediction." Journal of Systems and Software 81, no. 2 (February 2008): 186–95. http://dx.doi.org/10.1016/j.jss.2007.05.035.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Shatnawi, Raed. "Software fault prediction using machine learning techniques with metric thresholds." International Journal of Knowledge-based and Intelligent Engineering Systems 25, no. 2 (July 26, 2021): 159–72. http://dx.doi.org/10.3233/kes-210061.

Full text
Abstract:
BACKGROUND: Fault data is vital to predicting the fault-proneness in large systems. Predicting faulty classes helps in allocating the appropriate testing resources for future releases. However, current fault data face challenges such as unlabeled instances and data imbalance. These challenges degrade the performance of the prediction models. Data imbalance happens because the majority of classes are labeled as not faulty whereas the minority of classes are labeled as faulty. AIM: The research proposes to improve fault prediction using software metrics in combination with threshold values. Statistical techniques are proposed to improve the quality of the datasets and therefore the quality of the fault prediction. METHOD: Threshold values of object-oriented metrics are used to label classes as faulty to improve the fault prediction models The resulting datasets are used to build prediction models using five machine learning techniques. The use of threshold values is validated on ten large object-oriented systems. RESULTS: The models are built for the datasets with and without the use of thresholds. The combination of thresholds with machine learning has improved the fault prediction models significantly for the five classifiers. CONCLUSION: Threshold values can be used to label software classes as fault-prone and can be used to improve machine learners in predicting the fault-prone classes.
APA, Harvard, Vancouver, ISO, and other styles
8

Khanna, Munish, Abhishek Toofani, Siddharth Bansal, and Mohammad Asif. "Performance Comparison of Various Algorithms During Software Fault Prediction." International Journal of Grid and High Performance Computing 13, no. 2 (April 2021): 70–94. http://dx.doi.org/10.4018/ijghpc.2021040105.

Full text
Abstract:
Producing software of high quality is challenging in view of the large volume, size, and complexity of the developed software. Checking the software for faults in the early phases helps to bring down testing resources. This empirical study explores the performance of different machine learning model, fuzzy logic algorithms against the problem of predicting software fault proneness. The work experiments on the public domain KC1 NASA data set. Performance of different methods of fault prediction is evaluated using parameters such as receiver characteristics (ROC) analysis and RMS (root mean squared), etc. Comparison is made among different algorithms/models using such results which are presented in this paper.
APA, Harvard, Vancouver, ISO, and other styles
9

J. Pai, Ganesh, and Joanne Bechta Dugan. "Empirical Analysis of Software Fault Content and Fault Proneness Using Bayesian Methods." IEEE Transactions on Software Engineering 33, no. 10 (October 2007): 675–86. http://dx.doi.org/10.1109/tse.2007.70722.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Gatrell, Matt, and Steve Counsell. "Size, Inheritance, Change and Fault-proneness in C# software." Journal of Object Technology 9, no. 5 (2010): 29. http://dx.doi.org/10.5381/jot.2010.9.5.a2.

Full text
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "SOFTWARE FAULT PRONENESS"

1

Abdilrahim, Ahmad, and Caesar Alhawi. "Studying the Relation BetweenChange- and Fault-proneness : Are Change-prone Classes MoreFault-prone, and Vice-versa?" Thesis, Linnéuniversitetet, Institutionen för datavetenskap och medieteknik (DM), 2020. http://urn.kb.se/resolve?urn=urn:nbn:se:lnu:diva-97168.

Full text
Abstract:
Software is the heartbeat of modern technology. To keep up with the new demands and expansion of requirements, changes are constantly introduced to the software, i.e., changes can also be made to fix an existing fault/defect. However, these changes might also cause further faults/defects in the software. This study aims to investigate the possible correlation between change-proneness and fault-proneness in object- oriented systems. Forty releases of five different open-source systems are analysed to quantify change- and fault-proneness; Beam, Camel, Ignite, Jenkins, and JMe- ter, then statistic evidence is presented as to answer the following: (1) Is there is a relationship between change-proneness and fault-proneness for classes in object- oriented systems? (2) Is there a relationship between size and fault-proneness for classes in object-oriented systems? and (3) Is there a relationship between size and change-proneness for classes in object-oriented systems? Using the Wilcoxon rank- sum test, the results show that: (1) there is a correlation between change- and fault- proneness at a statistically significant level and (2) a correlation also exists betweenclass size and its change- and fault-proneness at a statistically significant level.
APA, Harvard, Vancouver, ISO, and other styles
2

Duc, Anh Nguyen. "The impact of design complexity on software cost and quality." Thesis, Blekinge Tekniska Högskola, Sektionen för datavetenskap och kommunikation, 2010. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-5708.

Full text
Abstract:
Context: Early prediction of software cost and quality is important for better software planning and controlling. In early development phases, design complexity metrics are considered as useful indicators of software testing effort and some quality attributes. Although many studies investigate the relationship between design complexity and cost and quality, it is unclear what we have learned from these studies, because no systematic synthesis exists to date. Aim: The research presented in this thesis is intended to contribute for the body of knowledge about cost and quality prediction. A major part of this thesis presents the systematic review that provides detail discussion about state of the art of research on relationship between software design metric and cost and software quality. Method: This thesis starts with a literature review to identify the important complexity dimensions and potential predictors for predicting external software quality attributes are identified. Second, we aggregated Spearman correlation coefficients and estimated odds ratios from univariate logistic regression models from 59 different data sets from 57 primary studies by a tailored meta-analysis approach. At last, it is an attempt to evaluate and explain for disagreement among selected studies. Result: There are not enough studies for quantitatively summarizing relationship between design complexity and development cost. Fault proneness and maintainability is the main focused characteristics that consume 75% total number of studies. Within fault proneness and maintainability studies, coupling and scale are two complexity dimensions that are most frequently used. Vote counting shows evidence about positive impact of some design metrics on these two quality attributes. Meta analysis shows the aggregated effect size of Line of code (LOC) is stronger than those of WMC, RFC and CBO. The aggregated effect sizes of LCOM, DIT and NOC are at trivial to small level. In subgroup analysis, defect collections phase explains more than 50% of observed variation in five out of seven investigated metrics. Conclusions: Coupling and scale metrics are stronger correlated to fault proneness than cohesion and inheritance metrics. No design metrics are stronger single predictors than LOC. We found that there is a strong disagreement between the individual studies, and that defect collection phase is able to partially explain the differences between studies.
APA, Harvard, Vancouver, ISO, and other styles
3

Deniz, Berkhan. "Investigation Of The Effects Of Reuse On Software Quality In An Industrial Setting." Master's thesis, METU, 2013. http://etd.lib.metu.edu.tr/upload/12615318/index.pdf.

Full text
Abstract:
Software reuse is a powerful tool in order to reduce development and maintenance time and cost. Any software life cycle product can be reused, not only fragments of source code. A high degree of reuse correlates with a low defect density. In the literature, many theoretical and empirical researches have examined the relationship of software reuse and quality. In this thesis, the effects of reuse on software quality are investigated in an industrial setting. Throughout this study, we worked with Turkey&rsquo
s leading defense industry company: Aselsan&rsquo
s software engineering department. We aimed to explore their real-life software projects and interpret reuse and quality relations for their projects. With this intention, we defined four different hypotheses to determine reuse and quality relations
and in order to confirm these hypotheses
we designed three separate case studies. In these case studies, we collected and calculated reuse and quality metrics i.e. Object-oriented quality metrics, reuse rates and performance measures of individual modules, fault-proneness of software components, and productivity rates of different products. Finally, by analyzing these measurements, we developed suggestions to further benefit from reuse in Aselsan through systematic improvements to the reuse infrastructure and process. Similar case studies have been reported in the literature, however, in Turkey, there are not many case studies using real-life project data, particularly in the defense industry.
APA, Harvard, Vancouver, ISO, and other styles
4

BANSAL, ANKITA. "DEVELOPMENT OF TECHNIQUES AND MODELS FOR IMPROVING SOFTWARE QUALITY." Thesis, 2016. http://dspace.dtu.ac.in:8080/jspui/handle/repository/14692.

Full text
Abstract:
ABSTRACT Prediction of quality attributes to improve software quality is gaining significant importance in the research. A number of metrics measuring important aspects of an object oriented program such as coupling, cohesion, inheritance and polymorphism have been proposed in the literature. Using these metrics, the quality attributes such as maintainability, fault proneness, change proneness, reliability etc. can be predicted during the early phases of the software development life cycle. Various models establishing the relationship between software metrics and quality attributes can be constructed, which can be used by researchers and practitioners in improving the software quality. Faults and changes in the software are inevitable. This is due to large sized, complex software and presence of inadequate resources (time, money and manpower) to completely test the software. Additionally, there are ongoing changes in the software due to multiple reasons such as change in user requirements, change in technology, competitive pressure etc. Given this scenario, it is very important to predict the changes and faults during the early phases of software development life cycle leading to better quality and maintainable software at a low cost. Identification of change and fault prone parts of the software, help managers to allocate resources more judiciously, thereby leading to reduction of costs associated with software development and maintenance. Testing and inspection activities can be disproportionately focused on the change and fault prone parts of the design and code. In literature, there are few prediction models proposed to predict change prone parts of the software. Therefore, a structured review is very important to provide commonalities and differences between the results of these studies. We have formulated various research questions according to which we have compared and reviewed a number of the software change proneness models for object oriented software. The research questions formulated in the review helped in identifying gaps in the current research and future guidelines have been proposed which can be used by software practitioners in future research. To gather insights into the quality and reliability of the open source software, we have used a number of popular open source software for the purpose of empirical validation. The literature shows that majority of the prediction models are trained using the historical data of the same project. There are broadly two approaches for predictive analysis, machine learning and statistical. Both these approaches are inherently different, raising the question that which approach is better than the other. Besides this, another question that keeps revolving in the minds of researchers is, “Among multiple machine learning techniques available, which classifier should be used for accurate prediction?” To investigate these questions, we have compared the performance of 15 data analysis techniques (14 machine learning and one statistical) on five official versions of the Android operating system. In other words, we have constructed various metric models using the machine learning and statistical techniques. Literature shows that metric models are widely used for identification of change and fault prone classes. However, training these models using machine learning and statistical techniques is a time consuming task and thus, it is not feasible on a daily basis to use these models. An alternative is to define thresholds of metrics which can be used for predicting change and fault prone parts. Thresholds, also known as risk indicators, define an upper bound on the metric values such that the classes having metric value above thresholds are considered to be potentially problematic. Identifying thresholds helps developers, designers and testers to pay focused and careful attention on these risky (or problematic) classes. We have identified threshold values of various object - oriented metrics of different open source software to predict change and fault proneness. A statistical approach based on logistic regression is used to calculate the threshold values. Another approach to calculate the threshold values is based on receiver operating characteristics curve. We have explored both the approaches to calculate threshold values of the metrics of different software. There are studies of inter - project validation for fault prediction; however, there is limited research regarding cross-project validation for change prediction. In this research, we have conducted inter - project validation for change prediction using 12 open source datasets obtained from three software. Testing the prediction models on the same data from which they are derived is some what intuitive, hence inter - project validation can help in obtaining generalizable results.
APA, Harvard, Vancouver, ISO, and other styles
5

BANSAL, ANJALI. "COMPARATIVE ANALYSIS OF CLASSIFICATION AND ENSEMBLE METHODS FOR PREDICTING SOFTWARE FAULT PRONENESS USING PROCESS METRICS." Thesis, 2021. http://dspace.dtu.ac.in:8080/jspui/handle/repository/18929.

Full text
Abstract:
Various researchers have worked in the subject of software defect prediction to group the modules into defective or non-defective classes. But most of the previous studies done in this field utilize static code metrics to find the predicted value. The principal motive of this study is to evaluate the impact of process metrics on fault prediction performance using various classification techniques and ensemble techniques. In this study, we have analyzed the prediction performance of several classification and ensemble techniques based on three models: models that solely contain process metrics, models that solely contain static code metrics, and models containing different combinations of both metrics. In other terms, we can say these three models work as independent variables and dependent variables are actual bug values. We have used Naive Bayes classifiers, Logistic Regression, Support Vector Machines, K-Nearest Neighbors, and Decision Trees for implementation, and data sets are collected from publicly available repositories. We have also used four ensemble techniques: Stacking, Voting, Bagging, and Boosting to evaluate the impact of process metrics on fault prediction performance. We have also analyzed which process metrics give the best result among all selected process metrics. We have analyzed the prediction performance based on AUC (Area under ROC) performance measure and we have also used Friedman test with Nemenyi post hoc test to check whether the predictive performance of various classification techniques and ensemble techniques differ significantly. The result of this study shows that the use of process metrics in fault prediction gives effective results. In most of the cases, NR metric is effective when combined with static code metrics. If we consider combined model of 2 process metrics with static code metrics then combined model of NR, NDC metric with static code metrics gives effective result. If we consider combined model of 3 process metrics with static code metrics then combined model of NR, NDC, NDPV metric with static code metrics gives effective result.
APA, Harvard, Vancouver, ISO, and other styles
6

Jaafar, Fehmi. "Analysing artefacts dependencies to evolving software systems." Thèse, 2013. http://hdl.handle.net/1866/10514.

Full text
Abstract:
Les logiciels sont en constante évolution, nécessitant une maintenance et un développement continus. Ils subissent des changements tout au long de leur vie, que ce soit pendant l'ajout de nouvelles fonctionnalités ou la correction de bogues. Lorsque les logiciels évoluent, leurs architectures ont tendance à se dégrader et deviennent moins adaptables aux nouvelles spécifications des utilisateurs. En effet, les architectures de ces logiciels deviennent plus complexes et plus difficiles à maintenir à cause des nombreuses dépendances entre les artefacts. Par conséquent, les développeurs doivent comprendre les dépendances entre les artefacts des logiciels pour prendre des mesures proactives qui facilitent les futurs changements et ralentissent la dégradation des architectures des logiciels. D'une part, le maintien d'un logiciel sans la compréhension des les dépendances entre ses artefacts peut conduire à l'introduction de défauts. D'autre part, lorsque les développeurs manquent de connaissances sur l'impact de leurs activités de maintenance, ils peuvent introduire des défauts de conception, qui ont un impact négatif sur l'évolution du logiciel. Ainsi, les développeurs ont besoin de mécanismes pour comprendre comment le changement d'un artefact impacte le reste du logiciel. Dans cette thèse, nous proposons trois contributions principales : La spécification de deux nouveaux patrons de changement et leurs utilisations pour fournir aux développeurs des informations utiles concernant les dépendances de co-changement. La spécification de la relation entre les patrons d'évolutions des artefacts et les fautes. La découverte de la relation entre les dépendances des anti-patrons et la prédisposition des différentes composantes d'un logiciel aux fautes.
Program maintenance accounts for the largest part of the costs of any program. During maintenance activities, developers implement changes (sometimes simultaneously) on artefacts to fix bugs and to implement new requirements. Thus, developers need knowledge to identify hidden dependencies among programs artefacts and detect correlated artefacts. As programs evolved, their designs become more complex over time and harder to change. In the absence of the necessary knowledge on artefacts dependencies, developers could introduce design defects and faults that causes development and maintenance costs to rise. Therefore, developers must understand the dependencies among program artefacts and take proactive steps to facilitate future changes and minimize fault proneness. On the one hand, maintaining a program without understanding the different dependencies between their artefacts may lead to the introduction of faults. On the other hand, when developers lack knowledge about the impact of their maintenance activities, they may introduce design defects, which have a negative impact on program evolution. Thus, developers need mechanisms to understand how a change to an artefact will impact the rest of the programs artefacts and tools to detect design defects impact. In this thesis, we propose three principal contributions. The first contribution is two novel change patterns to model new co-change and change propagation scenarios. We introduce the Asynchrony change pattern, corresponding to macro co-changes, i.e., of files that co-change within a large time interval (change periods), and the Dephase change pattern, corresponding to dephase macro co-changes, i.e., macro co-changes that always happen with the same shifts in time. We present our approach, named Macocha, and we show that such new change patterns provide interesting information to developers. The second contribution is proposing a novel approach to analyse the evolution of different classes in object-oriented programs and to link different evolution behaviour to faults. In particular, we define an evolution model for each class to study the evolution and the co-evolution dependencies among classes and to relate such dependencies with fault-proneness. The third contribution concerns design defect dependencies impact. We propose a study to mine the link between design defect dependencies, such as co-change dependencies and static relationships, and fault proneness. We found that the negative impact of design defects propagate through their dependencies. The three contributions are evaluated on open-source programs.
APA, Harvard, Vancouver, ISO, and other styles

Book chapters on the topic "SOFTWARE FAULT PRONENESS"

1

Singh, Yogesh, Arvinder Kaur, and Ruchika Malhotra. "Predicting Software Fault Proneness Model Using Neural Network." In Lecture Notes in Business Information Processing, 215–17. Berlin, Heidelberg: Springer Berlin Heidelberg, 2008. http://dx.doi.org/10.1007/978-3-540-68255-4_26.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Luo, Yunfeng, Kerong Ben, and Lei Mi. "Software Metrics Reduction for Fault-Proneness Prediction of Software Modules." In Lecture Notes in Computer Science, 432–41. Berlin, Heidelberg: Springer Berlin Heidelberg, 2010. http://dx.doi.org/10.1007/978-3-642-15672-4_36.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Ostrand, Thomas J., and Elaine J. Weyuker. "Can File Level Characteristics Help Identify System Level Fault-Proneness?" In Hardware and Software: Verification and Testing, 176–89. Berlin, Heidelberg: Springer Berlin Heidelberg, 2012. http://dx.doi.org/10.1007/978-3-642-34188-5_16.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Sharma, Pooja, and Amrit Lal Sangal. "Soft Computing Approaches to Investigate Software Fault Proneness in Agile Software Development Environment." In Algorithms for Intelligent Systems, 217–33. Singapore: Springer Singapore, 2020. http://dx.doi.org/10.1007/978-981-15-3357-0_15.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Takagi, Tomohiko, and Mutlu Beyazıt. "Optimized Test Case Generation Based on Operational Profiles with Fault-Proneness Information." In Software Engineering Research, Management and Applications, 15–25. Cham: Springer International Publishing, 2014. http://dx.doi.org/10.1007/978-3-319-11265-7_2.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Dalal, Renu, Manju Khari, and Dimple Chandra. "Evaluation of Software Fault Proneness with a Support Vector Machine and Biomedical Applications." In Bioelectronics and Medical Devices, 77–103. Boca Raton: Apple Academic Press, 2021. http://dx.doi.org/10.1201/9781003054405-4.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Singh, Rajvir, Anita Singhrova, and Rajesh Bhatia. "Optimized Test Case Generation for Object Oriented Systems Using Weka Open Source Software." In Research Anthology on Usage and Development of Open Source Software, 596–618. IGI Global, 2021. http://dx.doi.org/10.4018/978-1-7998-9158-1.ch032.

Full text
Abstract:
Detection of fault proneness classes helps software testers to generate effective class level test cases. In this article, a novel technique is presented for an optimized test case generation for ant-1.7 open source software. Class level object oriented (OO) metrics are considered as effective means to find fault proneness classes. The open source software ant-1.7 is considered for the evaluation of proposed techniques as a case study. The proposed mathematical model is the first of its kind generated using Weka open source software to select effective OO metrics. Effective and ineffective OO metrics are identified using feature selection techniques for generating test cases to cover fault proneness classes. In this methodology, only effective metrics are considered for assigning weights to test paths. The results indicate that the proposed methodology is effective and efficient as the average fault exposition potential of generated test cases is 90.16% and test cases execution time saving is 45.11%.
APA, Harvard, Vancouver, ISO, and other styles
8

Malhotra, LinRuchika, and Ankita Jain Bansal. "Prediction of Change-Prone Classes Using Machine Learning and Statistical Techniques." In Advanced Research and Trends in New Technologies, Software, Human-Computer Interaction, and Communicability, 193–202. IGI Global, 2014. http://dx.doi.org/10.4018/978-1-4666-4490-8.ch019.

Full text
Abstract:
For software development, availability of resources is limited, thereby necessitating efficient and effective utilization of resources. This can be achieved through prediction of key attributes, which affect software quality such as fault proneness, change proneness, effort, maintainability, etc. The primary aim of this chapter is to investigate the relationship between object-oriented metrics and change proneness. Predicting the classes that are prone to changes can help in maintenance and testing. Developers can focus on the classes that are more change prone by appropriately allocating resources. This will help in reducing costs associated with software maintenance activities. The authors have constructed models to predict change proneness using various machine-learning methods and one statistical method. They have evaluated and compared the performance of these methods. The proposed models are validated using open source software, Frinika, and the results are evaluated using Receiver Operating Characteristic (ROC) analysis. The study shows that machine-learning methods are more efficient than regression techniques. Among the machine-learning methods, boosting technique (i.e. Logitboost) outperformed all the other models. Thus, the authors conclude that the developed models can be used to predict the change proneness of classes, leading to improved software quality.
APA, Harvard, Vancouver, ISO, and other styles
9

Mala, D. Jeya. "Investigating the Effect of Sensitivity and Severity Analysis on Fault Proneness in Open Source Software." In Research Anthology on Recent Trends, Tools, and Implications of Computer Programming, 1743–69. IGI Global, 2021. http://dx.doi.org/10.4018/978-1-7998-3016-0.ch078.

Full text
Abstract:
Fault prone components in open source software leads to huge loss and inadvertent effects if not properly identified and rigorously tested. Most of the reported studies in the literature have applied design metrics alone, to identify such critical components. But in reality, some of the components' criticality level can be identified only by means of dynamic code analysis; as some of the components seem to be normal but still have higher level of impact on the other components. This leads to an insight on the need of a rigorous analysis based on how sensitive a component is and how severe will be the impact of it on other components in the system. To achieve this, an efficient mechanism of evaluating the criticality index of each component by means of sensitivity and severity analysis using the static design metrics and dynamic source code metrics has been proposed. Then, testing is conducted rigorously on these components using both unit testing and pair-wise integration testing.
APA, Harvard, Vancouver, ISO, and other styles

Conference papers on the topic "SOFTWARE FAULT PRONENESS"

1

Destefanis, Giuseppe, Roberto Tonelli, Ewan Tempero, Giulio Concas, and Michele Marchesi. "Micro Pattern Fault-Proneness." In 2012 38th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA). IEEE, 2012. http://dx.doi.org/10.1109/seaa.2012.63.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Denaro, Giovanni, Sandro Morasca, and Mauro Pezzè. "Deriving models of software fault-proneness." In the 14th international conference. New York, New York, USA: ACM Press, 2002. http://dx.doi.org/10.1145/568760.568824.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Jaafar, Fehmi, Foutse Khomh, Yann-Gael Gueheneuc, and Mohammad Zulkernine. "Anti-pattern Mutations and Fault-proneness." In 2014 14th International Conference on Quality Software (QSIC). IEEE, 2014. http://dx.doi.org/10.1109/qsic.2014.45.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Denaro, Giovanni. "Estimating software fault-proneness for tuning testing activities." In the 22nd international conference. New York, New York, USA: ACM Press, 2000. http://dx.doi.org/10.1145/337180.337592.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Hamid, Bushra, Eisa bin Abdullah Aleissa, and Abdul Rauf. "Anticipating Software Fault Proneness using Classifier Ensemble: An Optimize Approach." In Software Engineering. Calgary,AB,Canada: ACTAPRESS, 2012. http://dx.doi.org/10.2316/p.2012.780-021.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Afzal, Wasif. "Using Faults-Slip-Through Metric as a Predictor of Fault-Proneness." In 2010 17th Asia Pacific Software Engineering Conference (APSEC). IEEE, 2010. http://dx.doi.org/10.1109/apsec.2010.54.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Hata, Hideaki, Osamu Mizuno, and Tohru Kikuno. "Comparative Study of Fault-Proneness Filtering with PMD." In 2008 IEEE International Symposium on Software Reliability Engineering (ISSRE). IEEE, 2008. http://dx.doi.org/10.1109/issre.2008.49.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Seliya, N., T. M. Khoshgoftaar, and S. Zhong. "Analyzing software quality with limited fault-proneness defect data." In Ninth IEEE International Symposium on High-Assurance Systems Engineering. IEEE, 2005. http://dx.doi.org/10.1109/hase.2005.4.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Morasca, Sandro, and Luigi Lavazza. "Slope-based fault-proneness thresholds for software engineering measures." In EASE '16: 20th International Conference on Evaluation and Assessment in Software Engineering. New York, NY, USA: ACM, 2016. http://dx.doi.org/10.1145/2915970.2915997.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Luo Yunfeng and Ben Kerong. "Metrics selection for fault-proneness prediction of software modules." In 2010 International Conference on Computer Design and Applications (ICCDA 2010). IEEE, 2010. http://dx.doi.org/10.1109/iccda.2010.5541206.

Full text
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'SOFTWARE FAULT PRONENESS' for particular source types:
Journal articles
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography