Bibliographies thématiques / SOFTWARE FAULT PRONENESS / Articles de revues

Articles de revues sur le sujet « SOFTWARE FAULT PRONENESS »

Pour voir les autres types de publications sur ce sujet consultez le lien suivant : SOFTWARE FAULT PRONENESS.
Auteur : Grafiati
Publié le 11 septembre 2023

Créez une référence correcte selon les styles APA, MLA, Chicago, Harvard et plusieurs autres

Choisissez une source :

Consultez les 50 meilleurs articles de revues pour votre recherche sur le sujet « SOFTWARE FAULT PRONENESS ».

À côté de chaque source dans la liste de références il y a un bouton « Ajouter à la bibliographie ». Cliquez sur ce bouton, et nous générerons automatiquement la référence bibliographique pour la source choisie selon votre style de citation préféré : APA, MLA, Harvard, Vancouver, Chicago, etc.

Vous pouvez aussi télécharger le texte intégral de la publication scolaire au format pdf et consulter son résumé en ligne lorsque ces informations sont inclues dans les métadonnées.

Parcourez les articles de revues sur diverses disciplines et organisez correctement votre bibliographie.

1

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

Texte intégral
Résumé :
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.
Styles APA, Harvard, Vancouver, ISO, etc.
2

Gatrell, Matt, et 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 (avril 2012) : 69–88. http://dx.doi.org/10.4018/jismd.2012040103.

Texte intégral
Résumé :
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.
Styles APA, Harvard, Vancouver, ISO, etc.
3

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

Texte intégral
Résumé :
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.
Styles APA, Harvard, Vancouver, ISO, etc.
4

Shatnawi, Raed, et 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 (janvier 2021) : 62–78. http://dx.doi.org/10.4018/ijitsa.2021010104.

Texte intégral
Résumé :
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.
Styles APA, Harvard, Vancouver, ISO, etc.
5

Singh, Rajvir, Anita Singhrova et 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 (juillet 2018) : 15–35. http://dx.doi.org/10.4018/ijossp.2018070102.

Texte intégral
Résumé :
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%.
Styles APA, Harvard, Vancouver, ISO, etc.
6

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

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
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 (26 juillet 2021) : 159–72. http://dx.doi.org/10.3233/kes-210061.

Texte intégral
Résumé :
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.
Styles APA, Harvard, Vancouver, ISO, etc.
8

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

Texte intégral
Résumé :
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.
Styles APA, Harvard, Vancouver, ISO, etc.
9

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

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
10

Gatrell, Matt, et 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.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
11

Mizuno, Osamu, Naoki Kawashima et Kimiaki Kawamoto. « Fault-Prone Module Prediction Approaches Using Identifiers in Source Code ». International Journal of Software Innovation 3, no 1 (janvier 2015) : 36–49. http://dx.doi.org/10.4018/ijsi.2015010103.

Texte intégral
Résumé :
Prediction of fault-prone modules is an important area of software engineering. The authors assumed that the occurrence of faults is related to the semantics in the source code modules. Semantics in a software module can be extracted from identifiers in the module. Identifiers such as variable names and function names in source code are thus essential information to understand code. The naming for identifiers affects on code understandability; thus, the authors expect that they affect software quality. In this study, the authors examine the relationship between the length of identifiers and existence of software faults in a software module. Furthermore, the authors analyze the relationship between occurrence of “words” in identifiers and the existence of faults. From the experiments using the data from open source software, the authors modeled the relationship between the fault occurrence and the length of identifiers, and the relationship between the fault occurrence and the word in identifiers by the random forest technique. The result of the experiment showed that the length of identifiers can predict the fault-proneness of the software modules. Also, the result showed that the word occurrence model is as good a measure as traditional CK and LOC metrics models.
Styles APA, Harvard, Vancouver, ISO, etc.
12

Gupta, Mansi, Kumar Rajnish et Vandana Bhattacharjee. « Impact of Parameter Tuning for Optimizing Deep Neural Network Models for Predicting Software Faults ». Scientific Programming 2021 (11 juin 2021) : 1–17. http://dx.doi.org/10.1155/2021/6662932.

Texte intégral
Résumé :
Deep neural network models built by the appropriate design decisions are crucial to obtain the desired classifier performance. This is especially desired when predicting fault proneness of software modules. When correctly identified, this could help in reducing the testing cost by directing the efforts more towards the modules identified to be fault prone. To be able to build an efficient deep neural network model, it is important that the parameters such as number of hidden layers, number of nodes in each layer, and training details such as learning rate and regularization methods be investigated in detail. The objective of this paper is to show the importance of hyperparameter tuning in developing efficient deep neural network models for predicting fault proneness of software modules and to compare the results with other machine learning algorithms. It is shown that the proposed model outperforms the other algorithms in most cases.
Styles APA, Harvard, Vancouver, ISO, etc.
13

Lee, Shou-Yu, W. Eric Wong, Yihao Li et William Cheng-Chung Chu. « Software Fault-Proneness Analysis based on Composite Developer-Module Networks ». IEEE Access 9 (2021) : 155314–34. http://dx.doi.org/10.1109/access.2021.3128438.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
14

Ishrat. « Pattern Trees for Fault-Proneness Detection in Object-Oriented Software ». Journal of Computer Science 6, no 10 (1 octobre 2010) : 1078–82. http://dx.doi.org/10.3844/jcssp.2010.1078.1082.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
15

Khan, R. A., et K. Mustafa. « Fault Proneness Model for Object-Oriented Software : Design Phase Perspective ». Information Technology Journal 7, no 4 (1 mai 2008) : 698–701. http://dx.doi.org/10.3923/itj.2008.698.701.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
16

Li, Yihao, W. Eric Wong, Shou-Yu Lee et Franz Wotawa. « Using Tri-Relation Networks for Effective Software Fault-Proneness Prediction ». IEEE Access 7 (2019) : 63066–80. http://dx.doi.org/10.1109/access.2019.2916615.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
17

Bassey, Isong. « Enhancing Software Maintenance via Early Prediction of Fault-Prone Object-Oriented Classes ». International Journal of Software Engineering and Knowledge Engineering 27, no 04 (mai 2017) : 515–37. http://dx.doi.org/10.1142/s021819401750019x.

Texte intégral
Résumé :
Object-oriented software (OOS) is dominating the software development world today and thus, has to be of high quality and maintainable. However, their recent size and complexity affects the delivering of software products with high quality as well as their maintenance. In the perspective of software maintenance, software change impact analysis (SCIA) is used to avoid performing change in the “dark”. Unfortunately, OOS classes are not without faults and the existing SCIA techniques only predict impact set. The intuition is that, if a class is faulty and change is implemented on it, it will increase the risk of software failure. To balance these, maintenance should incorporate both impact and fault-proneness (FP) predictions. Therefore, this paper propose an extended approach of SCIA that incorporates both activities. The goal is to provide important information that can be used to focus verification and validation efforts on the high risk classes that would probably cause severe failures when changes are made. This will in turn increase maintenance, testing efficiency and preserve software quality. This study constructed a prediction model using software metrics and faults data from NASA data set in the public domain. The results obtained were analyzed and presented. Additionally, a tool called Class Change Recommender (CCRecommender) was developed to assist software engineers compute the risks associated with making change to any OOS class in the impact set.
Styles APA, Harvard, Vancouver, ISO, etc.
18

Reddy, N. Rajasekhar. « Risk chain prediction metrics for predicting fault proneness in Software Systems ». IOSR Journal of Engineering 02, no 08 (août 2012) : 190–95. http://dx.doi.org/10.9790/3021-0281190195.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
19

Sikka, Geeta, Renu Dhir et N. A. Aarti. « Grey relational classification algorithm for software fault proneness with SOM clustering ». International Journal of Data Mining, Modelling and Management 12, no 1 (2020) : 28. http://dx.doi.org/10.1504/ijdmmm.2020.10027275.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
20

Aarti, N. A., Geeta Sikka et Renu Dhir. « Grey relational classification algorithm for software fault proneness with SOM clustering ». International Journal of Data Mining, Modelling and Management 12, no 1 (2020) : 28. http://dx.doi.org/10.1504/ijdmmm.2020.105599.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
21

Abidi, Mouna, Md Saidur Rahman, Moses Openja et Foutse Khomh. « Are Multi-Language Design Smells Fault-Prone ? An Empirical Study ». ACM Transactions on Software Engineering and Methodology 30, no 3 (mai 2021) : 1–56. http://dx.doi.org/10.1145/3432690.

Texte intégral
Résumé :
Nowadays, modern applications are developed using components written in different programming languages and technologies. The cost benefits of reuse and the advantages of each programming language are two main incentives behind the proliferation of such systems. However, as the number of languages increases, so do the challenges related to the development and maintenance of these systems. In such situations, developers may introduce design smells (i.e., anti-patterns and code smells) which are symptoms of poor design and implementation choices. Design smells are defined as poor design and coding choices that can negatively impact the quality of a software program despite satisfying functional requirements. Studies on mono-language systems suggest that the presence of design smells may indicate a higher risk of future bugs and affects code comprehension, thus making systems harder to maintain. However, the impact of multi-language design smells on software quality such as fault-proneness is yet to be investigated. In this article, we present an approach to detect multi-language design smells in the context of JNI systems. We then investigate the prevalence of those design smells and their impacts on fault-proneness. Specifically, we detect 15 design smells in 98 releases of 9 open-source JNI projects. Our results show that the design smells are prevalent in the selected projects and persist throughout the releases of the systems. We observe that, in the analyzed systems, 33.95% of the files involving communications between Java and C/C++ contain occurrences of multi-language design smells. Some kinds of smells are more prevalent than others, e.g., Unused Parameters , Too Much Scattering , and Unused Method Declaration . Our results suggest that files with multi-language design smells can often be more associated with bugs than files without these smells, and that specific smells are more correlated to fault-proneness than others. From analyzing fault-inducing commit messages, we also extracted activities that are more likely to introduce bugs in smelly files. We believe that our findings are important for practitioners as it can help them prioritize design smells during the maintenance of multi-language systems.
Styles APA, Harvard, Vancouver, ISO, etc.
22

Kapila, Heena, et Satwinder Singh. « Analysis of CK Metrics to Predict Software Fault-Proneness using Bayesian Inference ». International Journal of Computer Applications 74, no 2 (26 juillet 2013) : 1–4. http://dx.doi.org/10.5120/12854-9152.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
23

Briand, L. C., W. L. Melo et J. Wust. « Assessing the applicability of fault-proneness models across object-oriented software projects ». IEEE Transactions on Software Engineering 28, no 7 (juillet 2002) : 706–20. http://dx.doi.org/10.1109/tse.2002.1019484.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
24

Al Dallal, Jehad. « Predicting Fault-Proneness of Reused Object-Oriented Classes in Software Post-Releases ». Arabian Journal for Science and Engineering 43, no 12 (18 décembre 2017) : 7153–66. http://dx.doi.org/10.1007/s13369-017-3012-2.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
25

Zhao, Yangyang, Yibiao Yang, Hongmin Lu, Yuming Zhou, Qinbao Song et Baowen Xu. « An empirical analysis of package-modularization metrics : Implications for software fault-proneness ». Information and Software Technology 57 (janvier 2015) : 186–203. http://dx.doi.org/10.1016/j.infsof.2014.09.006.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
26

Boucher, Alexandre, et Mourad Badri. « Software metrics thresholds calculation techniques to predict fault-proneness : An empirical comparison ». Information and Software Technology 96 (avril 2018) : 38–67. http://dx.doi.org/10.1016/j.infsof.2017.11.005.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
27

Al Dallal, Jehad. « Predicting Object-Oriented Class Fault-Proneness : A Replication Study ». Journal of Software 13, no 5 (mai 2018) : 269–76. http://dx.doi.org/10.17706/jsw.13.5.269-276.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
28

Aggarwal, K. K., Yogesh Singh, Arvinder Kaur et Ruchika Malhotra. « Investigating effect of Design Metrics on Fault Proneness in Object-Oriented Systems. » Journal of Object Technology 6, no 10 (2007) : 127. http://dx.doi.org/10.5381/jot.2007.6.10.a5.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
29

Ohlsson, Magnus C., Anneliese Amschler Andrews et Claes Wohlin. « Modelling fault-proneness statistically over a sequence of releases : a case study ». Journal of Software Maintenance and Evolution : Research and Practice 13, no 3 (2001) : 167–99. http://dx.doi.org/10.1002/smr.229.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
30

Pattnaik, Saumendra, et Binod Kumar Pattanayak. « Empirical analysis of software quality prediction using a TRAINBFG algorithm ». International Journal of Engineering & ; Technology 7, no 2.6 (11 mars 2018) : 259. http://dx.doi.org/10.14419/ijet.v7i2.6.10780.

Texte intégral
Résumé :
Software quality plays a major role in software fault proneness. That’s why prediction of software quality is essential for measuring the anticipated faults present in the software. In this paper we have proposed a Neuro-Fuzzy model for prediction of probable values for a predefined set of software characteristics by virtue of using a rule base. In course of it, we have used several training algorithms among which TRAINBFG algorithm is observed to be the best one for the purpose. There are various training algorithm available in MATLAB for training the neural network input data set. The prediction using fuzzy logic and neural network provides better result in comparison with only neural network. We find out from our implementation that TRAINBFG algorithm can provide better predicted value as compared to other algorithm in MATLAB. We have validated this result using the tools like SPSS and MATLAB.
Styles APA, Harvard, Vancouver, ISO, etc.
31

Kozlov, Denis. « Fault-Proneness of Open Source Software : Exploring its Relations to Internal Software Quality and Maintenance Process ». Open Software Engineering Journal 7, no 1 (22 février 2013) : 1–23. http://dx.doi.org/10.2174/1874107x01307010001.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
32

ISONG, BASSEY, et EKABUA OBETEN. « A SYSTEMATIC REVIEW OF THE EMPIRICAL VALIDATION OF OBJECT-ORIENTED METRICS TOWARDS FAULT-PRONENESS PREDICTION ». International Journal of Software Engineering and Knowledge Engineering 23, no 10 (décembre 2013) : 1513–40. http://dx.doi.org/10.1142/s0218194013500484.

Texte intégral
Résumé :
Object-oriented (OO) approaches of software development promised better maintainable and reusable systems, but the complexity resulting from its features usually introduce some faults that are difficult to detect or anticipate during software change process. Thus, the earlier they are detected, found and fixed, the lesser the maintenance costs. Several OO metrics have been proposed for assessing the quality of OO design and code and several empirical studies have been undertaken to validate the impact of OO metrics on fault proneness (FP). The question now is which metrics are useful in measuring the FP of OO classes? Consequently, we investigate the existing empirical validation of CK + SLOC metrics based on their state of significance, validation and usefulness. We used systematic literature review (SLR) methodology over a number of relevant article sources, and our results show the existence of 29 relevant empirical studies. Further analysis indicates that coupling, complexity and size measures have strong impact on FP of OO classes. Based on the results, we therefore conclude that these metrics can be used as good predictors for building quality fault models when that could assist in focusing resources on high risk components that are liable to cause system failures, when only CK + SLOC metrics are used.
Styles APA, Harvard, Vancouver, ISO, etc.
33

Al Dallal, Jehad, et Sandro Morasca. « Investigating the impact of fault data completeness over time on predicting class fault-proneness ». Information and Software Technology 95 (mars 2018) : 86–105. http://dx.doi.org/10.1016/j.infsof.2017.11.001.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
34

Gatrell, M., et S. Counsell. « The effect of refactoring on change and fault-proneness in commercial C# software ». Science of Computer Programming 102 (mai 2015) : 44–56. http://dx.doi.org/10.1016/j.scico.2014.12.002.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
35

Qusef, Abdallah, Mahmoud O. Elish et David Binkley. « An Exploratory Study of the Relationship Between Software Test Smells and Fault-Proneness ». IEEE Access 7 (2019) : 139526–36. http://dx.doi.org/10.1109/access.2019.2943488.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
36

Sikka, Sunil, Utpal Shrivastava et Pooja . « Role of CK Metrics to Identify Fault-Proneness in Object Oriented Software A Survey ». International Journal of Computer Sciences and Engineering 6, no 5 (31 mai 2018) : 1162–64. http://dx.doi.org/10.26438/ijcse/v6i5.11621164.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
37

Aarti, Geeta Sikka et Renu Dhir. « Novel Grey Relational Feature Extraction Algorithm for Software Fault-Proneness Using BBO (B-GRA) ». Arabian Journal for Science and Engineering 45, no 4 (25 mars 2020) : 2645–62. http://dx.doi.org/10.1007/s13369-020-04445-2.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
38

Mahdieh, Mostafa, Seyed-Hassan Mirian-Hosseinabadi, Khashayar Etemadi, Ali Nosrati et Sajad Jalali. « Incorporating fault-proneness estimations into coverage-based test case prioritization methods ». Information and Software Technology 121 (mai 2020) : 106269. http://dx.doi.org/10.1016/j.infsof.2020.106269.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
39

Bavota, Gabriele, Mario Linares-Vasquez, Carlos Eduardo Bernal-Cardenas, Massimiliano Di Penta, Rocco Oliveto et Denys Poshyvanyk. « The Impact of API Change- and Fault-Proneness on the User Ratings of Android Apps ». IEEE Transactions on Software Engineering 41, no 4 (1 avril 2015) : 384–407. http://dx.doi.org/10.1109/tse.2014.2367027.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
40

Mala, D. Jeya. « Investigating the Effect of Sensitivity and Severity Analysis on Fault Proneness in Open Source Software ». International Journal of Open Source Software and Processes 8, no 1 (janvier 2017) : 42–66. http://dx.doi.org/10.4018/ijossp.2017010103.

Texte intégral
Résumé :
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.
Styles APA, Harvard, Vancouver, ISO, etc.
41

Huang, Peng, et Jie Zhu. « Predicting the fault-proneness of class hierarchy in object-oriented software using a layered kernel ». Journal of Zhejiang University-SCIENCE A 9, no 10 (octobre 2008) : 1390–97. http://dx.doi.org/10.1631/jzus.a0720073.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
42

Koteswara Rao, K., et G. S. V. P. Raju. « Reducing interactive fault proneness in software application using genetic algorithm based optimal directed random testing ». International Journal of Computers and Applications 41, no 4 (19 janvier 2018) : 296–305. http://dx.doi.org/10.1080/1206212x.2017.1417769.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
43

Shatnawi, Raed, et Ziad Al Sharif. « A guided oversampling technique to improve the prediction of software fault-proneness for imbalanced data ». International Journal of Knowledge Engineering and Data Mining 2, no 2/3 (2012) : 200. http://dx.doi.org/10.1504/ijkedm.2012.051241.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
44

Wong, W. Eric, Joseph R. Horgan, Michael Syring, Wayne Zage et Dolores Zage. « Applying design metrics to predict fault-proneness : a case study on a large-scale software system ». Software : Practice and Experience 30, no 14 (2000) : 1587–608. http://dx.doi.org/10.1002/1097-024x(20001125)30:14<1587 ::aid-spe352>3.0.co;2-1.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
45

Shatnawi, Raed, et Qutaibah Althebyan. « An Empirical Study of the Effect of Power Law Distribution on the Interpretation of OO Metrics ». ISRN Software Engineering 2013 (30 janvier 2013) : 1–18. http://dx.doi.org/10.1155/2013/198937.

Texte intégral
Résumé :
Context. Software metrics are surrogates of software quality. Software metrics can be used to find possible problems or chances for improvements in software quality. However, software metrics are numbers that are not easy to interpret. Previous analysis of software metrics has shown fat tails in the distribution. The skewness and fat tails of such data are properties of many statistical distributions and more importantly the phenomena of the power law. These statistical properties affect the interpretation of software quality metrics. Objectives. The objective of this research is to validate the effect of power laws on the interpretation of software metrics. Method. To investigate the effect of power law properties on software quality, we study five open-source systems to investigate the distribution and their effect on fault prediction models. Results. Study shows that power law behavior has an effect on the interpretation and usage of software metrics and in particular the CK metrics. Many metrics have shown a power law behavior. Threshold values are derived from the properties of the power law distribution when applied to open-source systems. Conclusion. The properties of a power law distribution can be effective in improving the fault-proneness models by setting reasonable threshold values.
Styles APA, Harvard, Vancouver, ISO, etc.
46

Isong, Bassey, et Obeten Ekabua. « State-of-the-Art in Empirical Validation of Software Metrics for Fault Proneness Prediction : Systematic Review ». International Journal of Computer Science & ; Engineering Survey 6, no 6 (31 décembre 2015) : 1–18. http://dx.doi.org/10.5121/ijcses.2015.6601.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
47

Al Dallal, Jehad. « Categorisation-based approach for predicting the fault-proneness of object-oriented classes in software post-releases ». IET Software 14, no 5 (1 octobre 2020) : 525–34. http://dx.doi.org/10.1049/iet-sen.2019.0326.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
48

Aggarwal, K. K., Yogesh Singh, Arvinder Kaur et Ruchika Malhotra. « Empirical analysis for investigating the effect of object-oriented metrics on fault proneness : a replicated case study ». Software Process : Improvement and Practice 14, no 1 (janvier 2009) : 39–62. http://dx.doi.org/10.1002/spip.389.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
49

Mutha, Chetan, David Jensen, Irem Tumer et Carol Smidts. « An integrated multidomain functional failure and propagation analysis approach for safe system design ». Artificial Intelligence for Engineering Design, Analysis and Manufacturing 27, no 4 (24 avril 2013) : 317–47. http://dx.doi.org/10.1017/s0890060413000152.

Texte intégral
Résumé :
AbstractEarly system design analysis and fault removal is an important step in the iterative design process to avoid costly repairs in the later stages of system development. System complexity is increasing with increased use of software to control the physical system. There is a dearth of techniques to evaluate inconsistencies, incompatibility, and fault proneness of the system design in an integrated manner. The early design analysis technique presented in this paper aids a designer to understand the interplay between the multifaceted components and evaluate his/her design in an integrated manner. The technique allows simultaneous propagation of different types of faults from various domains and evaluates their functional impact over a period of time. The structure of the technique is explained using domain-specific conceptual metamodels, whereas the execution is based on the event sequence diagram, which is one of the established reliability and safety analysis techniques. One of the notable features of the proposed technique is the object-oriented nature of the system design representation. The technique is demonstrated with the help of a case study, and the execution results of two scenarios are evaluated to demonstrate the analysis capability of the proposed technique.
Styles APA, Harvard, Vancouver, ISO, etc.
50

Guerrouj, Latifa, Zeinab Kermansaravi, Venera Arnaoudova, Benjamin C. M. Fung, Foutse Khomh, Giuliano Antoniol et Yann-Gaël Guéhéneuc. « Investigating the relation between lexical smells and change- and fault-proneness : an empirical study ». Software Quality Journal 25, no 3 (9 mai 2016) : 641–70. http://dx.doi.org/10.1007/s11219-016-9318-6.

Texte intégral
Styles APA, Harvard, Vancouver, ISO, etc.
Nous offrons des réductions sur tous les plans premium pour les auteurs dont les œuvres sont incluses dans des sélections littéraires thématiques. Contactez-nous pour obtenir un code promo unique!

Vers la bibliographie