CN113778872A - Open source software reliability modeling method for fault introduction and decline change - Google Patents

Open source software reliability modeling method for fault introduction and decline change Download PDF

Info

Publication number
CN113778872A
CN113778872A CN202111045789.9A CN202111045789A CN113778872A CN 113778872 A CN113778872 A CN 113778872A CN 202111045789 A CN202111045789 A CN 202111045789A CN 113778872 A CN113778872 A CN 113778872A
Authority
CN
China
Prior art keywords
source software
fault
open source
model
faults
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
CN202111045789.9A
Other languages
Chinese (zh)
Other versions
CN113778872B (en
Inventor
王金勇
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Shanxi University
Original Assignee
Shanxi University
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Shanxi University filed Critical Shanxi University
Priority to CN202111045789.9A priority Critical patent/CN113778872B/en
Publication of CN113778872A publication Critical patent/CN113778872A/en
Application granted granted Critical
Publication of CN113778872B publication Critical patent/CN113778872B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/36—Preventing errors by testing or debugging software
    • G06F11/3604—Software analysis for verifying properties of programs
    • G06F11/3608—Software analysis for verifying properties of programs using formal methods, e.g. model checking, abstract interpretation
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/36—Preventing errors by testing or debugging software
    • G06F11/362—Software debugging
    • G06F11/366—Software debugging using diagnostics

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Computer Hardware Design (AREA)
  • Quality & Reliability (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Software Systems (AREA)
  • Stored Programmes (AREA)

Abstract

The invention belongs to the technical field of software reliability models, and particularly relates to an open source software reliability modeling method for fault introduction and drop change. Open source software is developed mainly by developers, volunteers and users all over the world, and its reliability is widely questioned. When an open source software failure is detected, the volunteer or user sends it to the developer via email or the network. After the developer confirms the failure, it will be randomly assigned to the debugger, which may be the developer, volunteer, or user. These open source community contributors also have a learning phenomenon when removing faults. When the detected faults are cleared, the number of introduced faults gradually decreases. Therefore, a software reliability model with a descending fault introduction rate in the process of developing and testing open-source software is provided. The effectiveness of the model and the accuracy of residual fault prediction are verified through experiments.

Description

Open source software reliability modeling method for fault introduction and decline change
Technical Field
The invention belongs to the technical field of software reliability models, and particularly relates to an open source software reliability modeling method for fault introduction and drop change.
Background
In recent years, the rise of open-source software has become another way of development with respect to closed-source software. Since the development and testing of open source software is mainly done by developers, volunteers and users all over the world, its reliability is widely questioned. Although the current open source software adopts the strategy of 'early release and frequent release' to improve the reliability of the software, the determination of the release time of the open source software is not an easy problem. Moreover, the method has too strong human factors and subjective factors, which is not beneficial to improving and improving the reliability of the actual open source software.
In view of the change in volunteer or user interest during the development and testing of open source software, Li et al propose an open source software reliability model with increased and then decreased fault detection. Secondly, Wang and Mi research the trend of the decline of the fault detection rate in the development and test processes of the open source software and provide a reliability model of the open source software based on the decline change of the fault detection rate. Wang also proposes that fault introduction obeys pareto distribution, and establishes a corresponding reliability model of single-version released open-source software. In addition to the two single-version open source software reliability models, Singh et al propose a multi-version published open source software reliability model by studying entropy change of open source software source codes. By researching the distribution of the open source software in the fault detection process, Tandon and the like provide a corresponding open source software multi-version release software reliability model.
It should be noted here that the single-version release open-source software reliability model and the multi-version release open-source software reliability model are different in that they are two modeling ideas. The former assumes that failures in each version of open source software are substantially independent of each other. The latter assumes that failures in the current version are related to failures in the previous version, which also affect failure detection and troubleshooting in the later version.
Although some of the above-mentioned open source software reliability models can effectively evaluate the reliability of open source software under certain conditions, another phenomenon, that is, the number of introduced faults is gradually reduced with the passage of time, is not considered in the process of developing and testing the open source software. The reason for introducing the reduction of the number of faults is closely related to the learning phenomenon of an open source software debugger and the hobbies, interests and professional skills of the open source software debugger. Aiming at the situation, the invention provides an open source software reliability model based on fault introduction and decline change, and related experiments verify the effectiveness and accuracy of the model.
Disclosure of Invention
The invention provides an open source software reliability modeling method for fault introduction and drop change aiming at the problems.
In order to achieve the purpose, the invention adopts the following technical scheme:
an open source software reliability modeling method for fault introduction and drop change comprises the following steps:
step 1, proposing an assumption of a model:
(1) fault detection of open source software follows a non-homogeneous poisson process;
(2) the number of faults detected in the open source software is related to the number of faults remaining in the software;
(3) when the fault in the open source software is eliminated, a new fault can be introduced;
(4) in the fault elimination process of the open source software, a debugger has a learning phenomenon;
(5) in the development and test process of open source software, the number of introduced faults is gradually reduced;
step 2, obtaining an expression of the model:
step 2.1, considering the inhomogeneous poisson process in hypothesis (1) as a counting process, denoted by n (x) as follows:
Figure BDA0003251150670000021
wherein Pr { } represents probability, ξ (x) represents a mean function, x represents a random variable, and k represents a non-negative integer;
step 2.2, deriving from hypotheses (1) and (2) the following formula:
Figure BDA0003251150670000031
φ(t)＝ηF(t)+C (3)
where ξ (t) represents the cumulative number of faults expected to be detected, i.e. the mean function, ψ (t) represents the fault detection rate function, Φ (t) represents the fault content function, t represents the time variable, η represents the total number of faults introduced initially, f (t) represents the distribution function, represents the total number of faults expected to be detected initially, C represents the total number of faults expected to be detected initially;
step 2.3, deriving from hypothesis (4) the following equation:
Figure BDA0003251150670000032
where ψ represents a fault detection rate, γ represents a knee factor, and t represents a test time;
step 2.4, according to the assumptions (3) and (5), a distribution function f (t) considering that the fault introduction is in a descending trend with time is given, and the expression is as follows:
Figure BDA0003251150670000033
where μ is a scale parameter and t is a time variable;
step 2.5, simultaneous equations (2) to (5), the following formula can be obtained:
Figure BDA0003251150670000034
and 2.6, solving the formula (6) to obtain an expression of the model:
Figure BDA0003251150670000041
wherein i is 0,1,2, 3. j ═ 0,1,2,3,. ·, m; m represents a non-negative integer, and n represents a non-negative integer.
The derivation of equation (7) is as follows:
Figure BDA0003251150670000042
suppose that
Figure BDA0003251150670000043
Then
Figure BDA0003251150670000044
Formula (A.1) is multiplied by two sidesTo be provided with
Figure BDA0003251150670000045
Figure BDA0003251150670000046
Figure BDA0003251150670000047
Figure BDA0003251150670000048
Figure BDA0003251150670000049
The taylor formula is used to extend the following equation,
Figure BDA0003251150670000051
Figure BDA0003251150670000052
Figure BDA0003251150670000053
then it is determined that,
Figure BDA0003251150670000054
Figure BDA0003251150670000055
Figure BDA0003251150670000056
let t be 0, ζ (t) be 0, so,
Figure BDA0003251150670000057
substituting the formulae (A.2), (A.3) and (A.8) into (A.7),
Figure BDA0003251150670000058
Figure BDA0003251150670000059
further, the model parameters are estimated using a least squares method, expressed as:
Figure BDA0003251150670000061
where Θ represents the least squares expression, ξ (t)i) Represents to tiThe cumulative number of failures expected to be detected up to the time, OtiRepresents to tiThe number of faults observed by the moment;
partial differential is taken at both sides of the formula (8) to establish an equation as follows,
Figure BDA0003251150670000062
by solving equation set (9), the parameter values for which the model estimates are proposed can be derived.
The reason why the fault introduction is gradually reduced in the development and test process of open source software is as follows:
we believe that there are three main reasons for introducing faults during open source software development and testing: firstly, learning factors; second, the interests and hobbies of developers or volunteers; third, the expertise of the developer or volunteer.
1) Learning factor
After the open source software fault is sent to a developer through an electronic mail or a network, the developer firstly confirms whether the fault is a real fault or not and then randomly distributes the fault to a corresponding debugger. When a debugger clears a fault, the debugger has a continuously rich experience and insight into the corresponding open source software function or product. With current software development and testing, fewer and fewer faults are detected, and the experience or knowledge of the debugger is also growing, which is a learning process. Thus, when a detected fault is cleared, the number of introduced faults will be less and less. With the development and testing of open source software, the introduction of faults is less and less.
2) Interests and hobbies of developers or volunteers
These debuggers are also enthusiasts of open source software; they are very interested in the development of open source software projects. This encourages them to locate the cause of the fault with all intentions, to try to remove the fault with the best effort, and to minimise the introduction of new faults.
3) Professional skills of developers or volunteers
Generally, the debugger is an expert in the field itself. They have profound insights, rich experience and knowledge on the development of software. When they clear the fault, the probability of introducing a new fault is very small. With the development of open source software.
Compared with the prior art, the invention has the following advantages:
1) it is first proposed that the number of faults introduced during open source software development and testing be gradually reduced.
2) The number of faults introduced is related to the process of learning, expertise, interests and hobbies of the debugger.
3) The reduced variation of fault introduction conforms to the actual development and testing process of open source software.
4) The model can be used for reliability evaluation and residual fault prediction in the actual open-source software development and test process.
Drawings
FIG. 1 is a comparison of the fitting and predicted performance of open-source software reliability models, and FIGS. 1(a), 1(b) and 1(c) show a comparison of the fitting performance of open-source software reliability models using 100% DS1-1, DS1-2 and DS1-3, respectively. FIGS. 1(d) and 1(e) show the predicted performance comparisons of the open-source software reliability models using 90% DS2-1 and DS2-2, respectively. FIG. 1(f) shows a comparison of the predicted performance of the open source software reliability model using 80% DS 2-3.
Detailed Description
Example 1
Open source software fault detection is generally subject to a non-homogeneous poisson process (NHPP). In other words, the open source software failure detection process can be regarded as a counting process, which is denoted by n (x). It is defined as follows:
Figure BDA0003251150670000081
pr { } denotes probability. ξ (x) represents the mean function. x represents a random variable.
The assumptions for the proposed model are as follows:
1) fault detection of open source software follows a non-homogeneous poisson process.
2) The number of faults detected in the open source software is related to the number of faults remaining in the software.
3) When the fault in the open source software is cleared, it is possible to introduce a new fault.
4) In the process of troubleshooting open source software, a debugger has a learning phenomenon.
5) During open source software development and testing, the number of incoming faults is gradually reduced.
The following can be derived from assumptions 1 and 2,
Figure BDA0003251150670000082
φ(t)＝ηF(t)+C (3)
here, ξ (t) represents the cumulative number of faults expected to be detected, i.e., the mean function. ψ (t) represents a fault detection rate function. Phi (t) represents the fault content function. t represents a time variable. η represents the total number of faults introduced initially. F (t) represents a distribution function representing the total number of faults expected to be initially detected.
As can be derived from the assumption 4 that,
Figure BDA0003251150670000083
here, ψ represents a failure detection rate. γ represents a corner factor.
Finally, according to assumptions 3 and 5, we present a distribution function that considers the time-dependent decline of fault introduction,
Figure BDA0003251150670000084
μ is a scale parameter. t is a time variable.
The following formula can be obtained by simultaneous equations (2-5),
Figure BDA0003251150670000091
the above formula (6) can be solved,
Figure BDA0003251150670000092
the formula (7) is the model proposed by the present invention.
In general, there are two methods for estimating the parameters of the reliability model of open source software, one is Maximum Likelihood Estimation (MLE) and the other is Least Squares Estimation (LSE). The two parameter estimation methods have advantages and disadvantages respectively. First, in the case of small sample data, the Maximum Likelihood Estimation (MLE) is slightly worse than the Least Squares Estimation (LSE). Second, the maximum likelihood function values for the model parameters may not be present when estimating. Considering that the scale of the open source software fault data set is small, if the parameter value cannot be estimated, the performance comparison of the model cannot be fully performed, and the method adopts a least square method to estimate the model parameters.
The least-squares method can be expressed as,
Figure BDA0003251150670000093
where Θ represents a least-squares expression. Xi (t)i) Represents to tiBy time, it is desirable to detect the cumulative number of failures.
Figure BDA0003251150670000094
Represents to tiThe number of faults observed by the moment.
Partial differential is taken at both sides of the formula (8) to establish an equation as follows,
Figure BDA0003251150670000101
by solving equation set (9), the parameter values for which the model estimates are proposed can be derived.
Example 2
1) Open source software fault data set
We use the website bug to track the failure data sets of two open source software projects in the system (https:// issues. Apache. org /), which are the Apache Storm and Apache Chemistry OpenCMIS projects, respectively. And 3 pieces of continuously released software are selected from each project to be used as the object of collecting fault data of the open-source software. For the Apache Storm project, STORM 1.0.1, STORM 1.0.2, and STORM 1.0.3 versions are renamed to Release-1(DS1-1), Release-2(DS1-2), Release-3(DS1-3), respectively, of the first failure data set (DS 1). For the Apache Chemistry OpenCMIS project, versions OpenCMIS 0.4.0, OpenCMIS 0.5.0, and OpenCMIS 0.6.0 are renamed Release-1(DS2-1), Release-2(DS2-2), Release-3(DS2-3), respectively, of the second failure data set (DS 2).
In the bug tracking system, each fault (issue) report has some attributes, such as fault type, fault keyword, fault id, fault summary, fault assigner, fault reporter, fault priority, fault status, fault resolution, fault creation and fault update, etc. When collecting fault data of open source software, some faults marked as repeated, problem-free, invalid and unrepairable faults are removed from the fault solution. The present invention refers to factors that affect the quality of open source software as Faults (Faults). Between 12 months 2013 and 2016 and 7 months, DS1-1 co-detected a failure of 33. The DS1-2 collected a failure of 61 altogether 3 months 2015 to 2016 7 months. The DS1-3 co-collected the fault 70 between 11 and 2017 months in 2015. From 3 months 2010 to 6 months 2011, 40 faults were detected in DS 2-1. From 5 months 2011 to 11 months 2011, 20 failures were collected in DS 2-2. Between 8 months 2011 and 12 months 2011, 31 faults were obtained in DS 2-3. Table 1 details the failure data set.
TABLE 1 open Source software Fault data set
Figure BDA0003251150670000111
2) Open source software model comparison standard
In order to effectively evaluate the performance of the model, five classical software reliability model evaluation standards such as Mean Square Error (MSE), square error prediction sum (PSSE) and R are adopted2Theil Statistics (TS), Variance (Variance), and Bias. At the same time, MSE and R are respectively adopted2The fitting performance of the model was compared for TS and Bias. The predicted performance of the model was compared using PSSE, TS, Variance and Bias.
1) MSE may be defined as the following equation:
Figure BDA0003251150670000112
where ξ (t)j) Representing the mean function, i.e. to tjBy time, it is desirable to detect the cumulative number of failures.
Figure BDA0003251150670000113
Represents to tjThe number of faults observed by the moment. n represents the sample size of the failure data set.
2)R2Can be expressed as follows:
Figure BDA0003251150670000121
the symbols in formula (11) are as defined above for formula (10).
3) The PSSE can be expressed as:
Figure BDA0003251150670000122
the symbols in formula (12) are as defined above for formula (10). By t1To tn-kEstimating parameter values of the model at each time point; by tn-k+1To tnThe performance of the model is predicted at each point in time. k-1, 2,3.., n-2.
4) TS may be defined as:
Figure BDA0003251150670000123
TS represents the average percent deviation between the model estimate and the number of faults actually observed. The symbols in formula (13) are as defined above for formula (10).
5) Variance can be expressed as:
Figure BDA0003251150670000124
the symbols in formula (14) are as defined above for formula (10). Variance is the standard deviation of the actual observed and model estimates.
6) The Bias can be expressed as:
Figure BDA0003251150670000125
the symbols in formula (15) are as defined above for formula (10). And | represents taking an absolute value.
The smaller the MSE, PSSE, TS, Variance, and Bias, the better the performance of the model. R2The smaller the fit, the worse the model will fit.
3) Open source software comparison model
To compare the performance of the models, we used five open-source software reliability models, including two single-release (version) open-source software reliability models (such as the Li single-release model and the Wang single-release model) and two multi-release (version) open-source software reliability models (such as the Yang multi-release model, the Singh multi-release model, and the Tandon multi-release model). Specifically, Li et al consider that the fault detection rate increases and then decreases over time, and establish a corresponding reliability model of single-version open-source software. Wang and Mi consider that the fault detection rate is in a descending trend along with the test time, and establish a corresponding reliability model of single release (version) of open-source software. Yang et al propose a multi-release (version) reliability model considering the delay between open source software fault detection and fault correction. Singh et al propose a reliability model for multi-version releases of entropy-based open-source software source code changes. Taking into account that the test work follows weibull distribution, Tandon et al established a corresponding open-source software multi-release (version) reliability model.
4) Fitting performance comparison of open source software reliability models
To be able to compare well the fit performance of the open source software single and multiple issue reliability models, we compared the fit performance of the models using a 100% failure data set (DS 1). As can be seen from tables 2-4, the proposed model has the best fit performance among all models. The fitting performance of the proposed model is stable, but the fitting performance of other models is unstable. For example, in Table 2, the Singh multiple issue model is ranked second, and in Table 4, the Tandon multiple issue model is ranked second.
From table 2, we can see that the last row is the Wang single issue model, which has an MSE almost five times that of the proposed model. In table 3, the last row is also the Wang single issue model, which has an MSE almost 11 times that of the proposed model. From table 4, we can see that the worst is the Yang multi-issue model, which has an MSE of approximately one hundred and fifty-two times that of the proposed model.
Overall, the fitting performance of the proposed model is the best of all models. The fitting performance of the Singh multi-release model is equivalent to that of the Tandon multi-release model and is superior to that of other models except the proposed model. The Wang single publication model is comparable to the Yang multiple publication model in terms of fitness and inferior to the others. From fig. 1(a), fig. 1(b) and fig. 1(c), we can clearly see the comparison result of the model fitting performance proposed by the present invention.
5) Comparison of predicted performance of open source software reliability models
We estimated the parameter values of the model with 90% of the fault data and compared the predicted performance of the model with the remaining fault data. As can be seen from tables 5-7, the proposed model has better prediction performance than other models. However, the predictive performance of other models varies from one open source software development to another and from one test environment to another. Table 8 lists the parameter values for the proposed model estimated using 100% DS1(DS1-1, DS1-2 and DS1-3) and 90% DS2(DS2-1, DS2-2), respectively.
To randomly select samples, we compared the predicted performance of the models using 90% fault data set (DS2-1), 90% fault data set (DS2-2), and 80% fault data set (DS2-3), respectively. In table 5, the proposed model is best, the second is the Singh multiple issue model, and worst is the Li single issue model. The PSSE of the proposed model is almost 12 times that of the Li single release model. As can be seen from table 6, the first is the proposed model, the second is the Li single issue model, and the last is the Tandon multiple issue model. The PSSE of the proposed model is almost three times that of the Tandon multiple issue model. As can be seen from table 7, the proposed model has the best predictive performance among all models. The second is a Li single issue model, and the last is a Singh multiple issue model. The PSSE of the proposed model is almost 14 times that of the Li single release model. As can be seen from fig. 1, the predictive power of the proposed model is superior to other models.
In summary, the prediction performance of the proposed model is the best among all models. Furthermore, as can be seen from tables 5-7, the proposed model has the best stability among all models. But the predictive performance of other models is not stable. From tables 2-7, we can conclude that the proposed model has the best fit and prediction performance. Uncertainty and instability exist in the fitting and prediction performance of other models as the open source software development and testing environment changes.
TABLE 2 comparison of fitting Performance of open Source software reliability models with 100% DS1-1
Figure BDA0003251150670000151
TABLE 3 comparison of fitting Performance of open Source software reliability models with 100% DS1-2
Figure BDA0003251150670000152
TABLE 4 comparison of fitting Performance of open Source software reliability models with 100% DS1-3
Figure BDA0003251150670000153
TABLE 5 comparison of predicted Performance of open Source software reliability models with 90% DS2-1
Figure BDA0003251150670000154
TABLE 6 comparison of predicted Performance of open Source software reliability models with 90% DS2-2
Figure BDA0003251150670000161
TABLE 7 comparison of predicted Performance of open Source software reliability models with 80% DS2-3
Figure BDA0003251150670000162
TABLE 8 parameter values for model estimation
Figure BDA0003251150670000163

Claims (2)

1. An open source software reliability modeling method for fault introduction and drop change is characterized by comprising the following steps:
step 1, proposing an assumption of a model:
(1) fault detection of open source software follows a non-homogeneous poisson process;
(2) the number of faults detected in the open source software is related to the number of faults remaining in the software;
(3) when the fault in the open source software is eliminated, a new fault can be introduced;
(4) in the fault elimination process of the open source software, a debugger has a learning phenomenon;
(5) in the development and test process of open source software, the number of introduced faults is gradually reduced;
step 2, obtaining an expression of the model:
step 2.1, considering the inhomogeneous poisson process in hypothesis (1) as a counting process, denoted by n (x) as follows:
Figure FDA0003251150660000011
wherein Pr { } represents probability, ξ (x) represents a mean function, x represents a random variable, and k represents a non-negative integer;
step 2.2, deriving from hypotheses (1) and (2) the following formula:
Figure FDA0003251150660000012
φ(t)＝ηF(t)+C (3)
where ξ (t) represents the cumulative number of faults expected to be detected, i.e. the mean function, ψ (t) represents the fault detection rate function, Φ (t) represents the fault content function, t represents the time variable, η represents the total number of faults introduced initially, f (t) represents the distribution function, represents the total number of faults expected to be detected initially, C represents the total number of faults expected to be detected initially;
step 2.3, deriving from hypothesis (4) the following equation:
Figure FDA0003251150660000021
where ψ represents a fault detection rate, γ represents a knee factor, and t represents a test time;
step 2.4, according to the assumptions (3) and (5), a distribution function f (t) considering that the fault introduction is in a descending trend with time is given, and the expression is as follows:
Figure FDA0003251150660000022
where μ is a scale parameter and t is a time variable;
step 2.5, simultaneous equations (2) to (5), the following formula can be obtained:
Figure FDA0003251150660000023
and 2.6, solving the formula (6) to obtain an expression of the model:
Figure FDA0003251150660000024
wherein i is 0,1,2, 3. j ═ 0,1,2,3,. ·, m; m represents a non-negative integer, and n represents a non-negative integer.
2. The open-source software reliability modeling method for fault introduction degradation variation according to claim 1, characterized in that a least square method is adopted to estimate model parameters, which are expressed as:
Figure FDA0003251150660000025
where Θ represents the least squares expression, ξ (t)i) Represents to tiThe cumulative number of failures expected to be detected up to the time, OtiRepresents to tiThe number of faults observed until time, i ═ 0,1,2,3, ·, n; n represents a non-negative integer;
partial differential is taken at both sides of the formula (8) to establish an equation as follows,
Figure FDA0003251150660000031
by solving equation set (9), the parameter values for which the model estimates are proposed can be derived.
CN202111045789.9A 2021-09-07 2021-09-07 Open source software reliability modeling method for fault introduction descent change Active CN113778872B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202111045789.9A CN113778872B (en) 2021-09-07 2021-09-07 Open source software reliability modeling method for fault introduction descent change

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202111045789.9A CN113778872B (en) 2021-09-07 2021-09-07 Open source software reliability modeling method for fault introduction descent change

Publications (2)

Publication Number Publication Date
CN113778872A true CN113778872A (en) 2021-12-10
CN113778872B CN113778872B (en) 2023-09-22

Family

ID=78841706

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202111045789.9A Active CN113778872B (en) 2021-09-07 2021-09-07 Open source software reliability modeling method for fault introduction descent change

Country Status (1)

Country Link
CN (1) CN113778872B (en)

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20080313501A1 (en) * 2007-06-14 2008-12-18 National Tsing Hua University Method and system for assessing and analyzing software reliability
CN109766281A (en) * 2019-01-29 2019-05-17 山西大学 A kind of imperfect debugging software reliability model of fault detection rate decline variation
CN111488281A (en) * 2020-05-28 2020-08-04 山西大学 Open source software reliability modeling method based on random introduced fault
CN111737113A (en) * 2020-05-29 2020-10-02 山西大学 Open source software reliability modeling method for fault detection and introduction of nonlinear change

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20080313501A1 (en) * 2007-06-14 2008-12-18 National Tsing Hua University Method and system for assessing and analyzing software reliability
CN109766281A (en) * 2019-01-29 2019-05-17 山西大学 A kind of imperfect debugging software reliability model of fault detection rate decline variation
CN111488281A (en) * 2020-05-28 2020-08-04 山西大学 Open source software reliability modeling method based on random introduced fault
CN111737113A (en) * 2020-05-29 2020-10-02 山西大学 Open source software reliability modeling method for fault detection and introduction of nonlinear change

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
王金勇: "考虑故障引进的软件可靠性增长模型研究", 《中国博士学位论文全文数据库信息科技辑》, no. 02 *
王金勇;张策;米晓萍;郭新峰;李济洪;: "Weibull分布引进故障的软件可靠性增长模型", 软件学报, no. 06 *

Also Published As

Publication number Publication date
CN113778872B (en) 2023-09-22

Similar Documents

Publication Publication Date Title
US10324989B2 (en) Microblog-based event context acquiring method and system
Gardes et al. Weibull tail-distributions revisited: a new look at some tail estimators
CN111045939B (en) Weibull distributed fault detection open source software reliability modeling method
Aggarwal et al. Multi-release software reliability growth assessment: an approach incorporating fault reduction factor and imperfect debugging
De la Sen et al. On an Sir Epidemic Model for the COVID‐19 Pandemic and the Logistic Equation
JP7110929B2 (en) Knowledge Complementary Program, Knowledge Complementary Method, and Knowledge Complementary Device
Daskalakis et al. Alignment-free phylogenetic reconstruction: Sample complexity via a branching process analysis
CN114978956A (en) Method and device for detecting abnormal performance mutation points of network equipment in smart city
CN111737113B (en) Open source software reliability modeling method for fault detection and introduction of nonlinear change
Linton When will the Covid-19 pandemic peak?
CN114415488A (en) Atomic clock error data anomaly detection and correction method and system
CN113778872A (en) Open source software reliability modeling method for fault introduction and decline change
CN116701950B (en) Click rate prediction model depolarization method, device and medium for recommendation system
CN111045938B (en) Reliability modeling method for introducing open-source software based on Pareto distributed faults
CN109857581B (en) Method for optimizing and selecting software reliability growth model
CN111539545B (en) Oil temperature prediction method and device and computer readable storage medium
Wang et al. Software reliability model of open source software based on the decreasing trend of fault introduction
Zhang et al. Butter: An approach to bug triage with topic modeling and heterogeneous network analysis
CN113609009B (en) Open source software reliability modeling method based on multiple versions
Clark et al. Evaluation of Heckman selection model method for correcting estimates of HIV prevalence from sample surveys
Rosychuk et al. Bias correction of two‐state latent Markov process parameter estimates under misclassification
US20200394527A1 (en) Prediction model
CN108764607B (en) User monthly data review method, device, equipment and storage medium
Kolotilin et al. Estimation of a scale-free network formation model
CN113626323B (en) Method for testing and evaluating quality of software life cycle at each stage

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant