Inter-version compatibility credibility quantitative evaluation method based on Java open source software
By defining incompatibility metrics and constructing a compatibility credibility metric model, combining Boltzmann entropy formula and golden ratio, evaluating compatibility between Java open source software versions, it solves the difficulty in detecting and evaluating between versions in the existing technology. Compatibility issues improve the quality and reliability of the software.
Patent Information
- Application Number
- CN202411036321.7
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-07-31
- Publication Date
- 2024-11-15
AI Technical Summary
The existing technology is difficult to effectively detect and evaluate compatibility issues between Java open source software versions, resulting in increased complexity, costly and time-consuming software development.
Using the quantitative evaluation method of inter-version compatibility trustworthiness between versions based on Java open source software, the Boltzmann entropy formula is combined with the Boltzmann entropy formula and Golden Segment Ratio, Evaluating the Compatibility and Credibility between Software Versions.
It provides a comprehensive compatibility evaluation method and tool to help developers manage compatibility issues during the software version upgrade process, improve software quality and reliability, and ensure that the software runs normally in different environments.
Smart Images

Figure CN118963832A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of computer technology, and in particular to a method for quantitatively evaluating the compatibility credibility between versions of Java open source software. Background Art
[0002] With the development of the open source software community, various types of open source software have emerged. These open source software versions are iterating rapidly, driving the development of the entire software industry. As an important part of software development, Java open source software plays an irreplaceable role in the development of modern applications, because its strength is not only reflected in the language itself, but also in its huge ecosystem, including rich and diverse Java third-party libraries. Java third-party libraries are reusable software components created by developers, usually open source, providing Java developers with rich functions and promoting development efficiency. Open source software includes complete applications, frameworks or tool sets with open source code, including multiple third-party libraries, which together build the Java ecosystem. Although the widespread use of Java third-party libraries has brought great convenience to developers, it is accompanied by an important challenge, namely the incompatibility problem between versions, and the new version is not fully compatible with the old version.
[0003] The detection of incompatibility issues between versions of Java open source software has received widespread attention in both industry and academia. The industry usually uses standardized project management tools such as Maven and Gradle to solve this problem. However, these tools can only detect duplicate classes or libraries and issue warnings to remind developers, but cannot detect all possible causes of operational abnormalities. In academia, incompatibility issues are usually detected by static analysis of source code or regression testing. However, these methods still have some limitations, such as only detecting obvious dependency conflicts and involving a large amount of manual testing and manual analysis. As the complexity of software projects continues to increase, the cost will become more expensive and time-consuming, and it will be difficult to handle complex compatibility issues. Therefore, it is crucial to find a more efficient, accurate and comprehensive method to detect and evaluate compatibility issues between software versions.
[0004] At present, rich achievements have been made in the measurement and evaluation of software credibility at home and abroad, but no relevant research has been found on the credibility measurement of compatibility between software versions.
[0005] In order to solve the above problems, the present invention proposes a method for quantitatively evaluating the compatibility credibility between versions of Java open source software. Summary of the invention
[0006] The purpose of the present invention is to propose a method for quantitatively evaluating the compatibility credibility between versions of Java open source software to solve the problems raised in the background technology:
[0007] There is no research on the reliability measurement of compatibility between software versions in the prior art.
[0008] In order to achieve the above object, the present invention adopts the following technical solutions:
[0009] The method for quantitatively evaluating the compatibility credibility between versions of Java open source software includes the following steps:
[0010] S1: Classify changes based on source code API level and define incompatible metrics;
[0011] S2: Design a comprehensive version compatibility detection tool to detect incompatibilities between different versions of Java open source software and generate a compatibility analysis report;
[0012] S3: Construct a compatibility credibility measurement model, count and analyze the number of occurrences of incompatible metric indicators and the corresponding severity levels, evaluate the compatibility credibility between software versions, and provide corresponding metric values;
[0013] S4: Construct a compatibility credibility measurement grading model, combine relevant data, and grading the compatibility between software versions to evaluate the compatibility credibility level between open source software versions.
[0014] Preferably, in S1, the change of source code API level between open source software versions is defined, and the incompatible API detection rules of the incompatibility problem detection tool between two open source software versions are preprocessed to obtain the source code change rules.
[0015] Preferably, the incompatibility problem detection tools between the two open source software versions are Java API ComplianceChecker and Revapi; and the source code change rules obtained by the preprocessing operation are defined as incompatibility measurement indicators.
[0016] Preferably, in step S2, the comprehensive version compatibility detection tool is a Java open source software version incompatibility detection tool Jcbjare, which is comprehensively designed based on detection tools Java API Compliance Checker, Revapi and incompatibility measurement indicators.
[0017] Preferably, the Java open source software version incompatibility detection tool Jcbjare is used to obtain an analysis report on incompatibility issues between versions, wherein the incompatibility issues between versions include incompatibility issue types, incompatibility severity levels, incompatibility issue sources, and incompatibility issue detailed descriptions.
[0018] Preferably, in step S3, the compatibility credibility measurement model between open source software versions is designed based on the number of occurrences of the incompatible measurement indicator, the severity level corresponding to the incompatible measurement indicator and the Boltzmann entropy formula;
[0019] The Boltzmann entropy formula is as follows:
[0020] S=k*lnΩ
[0021] Among them, S is a measure of the disorder of matter from a macroscopic perspective; Ω is a physical quantity from a microscopic perspective; k represents the Boltzmann constant;
[0022] The Boltzmann entropy of the incompatibility severity level between open source software versions is calculated by combining the number of occurrences of incompatibility metrics between open source software versions and the severity level corresponding to the incompatibility metrics as follows:
[0023] S i =α i *log z (n i +1),i∈(h,m,l,o)
[0024]
[0025] Among them, S i Including S h , S m , S l and S o , respectively represent the Boltzmann entropy of the incompatibility severity levels of High, Medium, Low and No between open source software versions; z is the Boltzmann parameter; n i Include h 、n m 、n l and n o , which represent the number of occurrences of incompatibility issues with severity levels of High, Medium, Low, and No, respectively; α i Including α h , α m , α l and α o , representing the risk weights of severity levels High, Medium, Low, and No, respectively; λ i Including Lambda h , m ,l and λ o , representing risk factors with severity levels of High, Medium, Low, and No, respectively;
[0026] The incompatibility entropy between open source software versions is calculated as follows:
[0027]
[0028] Among them, H represents the incompatibility entropy between open source software versions;
[0029] The compatibility confidence metric is calculated as follows:
[0030] T=e -H
[0031] Among them, T is the compatibility trust value between open source software versions; H is the incompatibility entropy between open source software versions.
[0032] Preferably, in step S4, the open source software version compatibility credibility measurement grading model is designed based on the compatibility credibility measurement value obtained by the open source software version compatibility credibility measurement model, the incompatible change density of each severity level and the golden section ratio method, wherein the golden section ratio is approximately 1:1.618;
[0033] The density of incompatible changes for each severity level is as follows:
[0034]
[0035] Among them, d i Included h ,d m ,d l and d o , which represent the density of incompatible changes with severity levels of High, Medium, Low, and No, respectively;
[0036] The trust metric grading model divides trust levels based on the compatibility trust metric value and the incompatible change density of each severity level, and the trust level division intervals are divided according to the golden section ratio, wherein the golden section ratio is approximately 1:1.618.
[0037] Compared with the prior art, the present invention provides a method for quantitatively evaluating the compatibility credibility between versions of Java open source software, which has the following beneficial effects:
[0038] The present invention provides a trusted quantitative analysis framework to evaluate the compatibility between software versions. It includes the design of incompatible measurement indicators, the production of detection tools, the construction of a compatibility credibility measurement model, and the implementation of a measurement classification model to evaluate the compatibility between different versions. To ensure that the software can run normally in different environments and usage scenarios, a more comprehensive open source software version compatibility evaluation method and tool can be provided for software developers to help them better manage compatibility issues during software version upgrades, thereby improving the quality and reliability of the software. BRIEF DESCRIPTION OF THE DRAWINGS
[0039] Figure 1 This is a flow chart of the method mentioned in Example 1 of the present invention;
[0040] Figure 2 This is a framework diagram of the method mentioned in Example 1 of the present invention. DETAILED DESCRIPTION
[0041] The technical solutions in the embodiments of the present invention will be described clearly and completely below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, rather than all the embodiments.
[0042] The present invention provides a trusted quantitative analysis framework to evaluate the compatibility between software versions. It includes the design of incompatibility metrics, the production of detection tools, the construction of a compatibility credibility measurement model, and the implementation of a measurement grading model to evaluate the compatibility between different versions. To ensure that the software can run normally in different environments and usage scenarios, it can provide software developers with a more comprehensive open source software version compatibility evaluation method and tool to help them better manage compatibility issues during software version upgrades, thereby improving the quality and reliability of the software. Specifically includes the following content.
[0043] Embodiment 1:
[0044] See also Figure 1-2 The present invention is based on the inter-version compatibility credibility quantitative evaluation method of Java open source software, comprising the following steps:
[0045] S1. Define incompatibility metrics: From the perspective of source code changes between software versions, classify the various changes at the source code API level and define incompatibility metrics to provide a basis for subsequent compatibility credibility analysis;
[0046] Specifically, from the perspective of source code changes between open source software versions, the manifestations that lead to incompatibility between open source software versions are studied, and incompatibility metrics are further determined. In software development, APIs are the core components of software source code, including classes, interfaces, methods, fields, etc. Therefore, when updating versions, monitoring and analyzing changes in these APIs can better understand the incompatibility between open source software versions. For each API of open source software, both Japicc and Revapi incompatibility detection tools define incompatibility detection rules and detect incompatible APIs. Therefore, source code incompatibility metrics between open source software versions are defined according to the incompatibility detection rules of these two tools. The detection rules of the two tools are extracted, and comprehensive source code change rules are obtained after screening, deduplication, merging and normalization operations, which are defined as the incompatibility metrics of the present invention. As shown in the first column of Table 1.
[0047] Table 1 Incompatibility metrics, severity levels, and descriptions between Java open source software versions
[0048]
[0049]
[0050]
[0051]
[0052] S2. Design of incompatibility detection tool: A comprehensive version compatibility detection tool was designed. The tool can detect incompatibility issues between different versions of Java open source software and generate detailed compatibility analysis reports to provide developers with more comprehensive information and provide data support for compatibility trust measurement and evaluation.
[0053] Specifically, a comprehensive version compatibility detection tool designed by the present invention is a Java open source software version incompatibility detection tool Jcbjare obtained after comprehensive design based on detection tools Japicc, Revapi and incompatibility metrics, which is used to obtain a more complete and detailed version incompatibility problem analysis report, including incompatibility problem type (Metrics), incompatibility severity level (Severity), incompatibility problem source (API) and incompatibility problem detailed description (Description). Examples of the detection report content are shown in Table 2.
[0054] Table 2 Example of incompatibility analysis report between versions generated by Jcbjare
[0055]
[0056] The severity levels of the incompatible metrics of the tool Jcbjare are divided into High, Medium, Low and No. The division is based on the severity classification rules of the incompatible detection rules of the two tools Japicc and Revapi, and the mapping relationship is shown in Table 3. The classification rules of the Japicc tool are High, Medium, Low and Safe. Among them, Safe means no risk, which is mapped to No in Jcbjare. The classification rules of the Revapi tool are breaking, potentially breaking, equivalent and non breaking. Among them, breaking means destructive changes, which are mapped to High in Jcbjare, potentially breaking means potential destructive changes, which are mapped to Medium, equivalent and non breaking mean equivalent changes and non-destructive changes respectively, both of which mean no risk and are mapped to No. In this way, the severity levels of all metrics are completely defined and divided, as shown in the second column of Table 1.
[0057] Table 3 Mapping relationship between incompatibility severity levels
[0058] Japicc Revapi Jcbjare High breaking High Medium potentially breaking Medium Low - Low Safe equivalent、non breaking No
[0059] S3. Constructing a compatibility credibility measurement model: Based on theories such as Boltzmann entropy, a compatibility credibility measurement model between open source software versions is constructed. This model is used to evaluate the compatibility credibility between software versions by counting and analyzing the number of occurrences of incompatible metrics and the corresponding severity levels, and provides corresponding measurement values;
[0060] Specifically, the compatibility trust measurement model between open source software versions is designed based on the number of occurrences of incompatible measurement indicators, the severity level corresponding to the incompatible measurement indicators, and the Boltzmann entropy formula.
[0061] The Boltzmann entropy formula is:
[0062] S=k*lnΩ
[0063] Among them, S is a measure of the disorder of matter from a macroscopic perspective; Ω is a physical quantity from a microscopic perspective; k represents the Boltzmann constant; this formula shows that the macroscopic state of matter can be reflected by the microscopic state.
[0064] In the compatibility credibility assessment between open source software versions, there are multiple incompatibility metrics with different severity levels. The number of times they appear reflects the risk level that causes the software to enter an unexpected state, which belongs to the micro-state of the system. The compatibility credibility between software versions reflects the state behavior of the software, which belongs to the macro-state of the system. Therefore, the macro-state of the compatibility credibility between software versions can be expressed by the micro-state of risk. Therefore, the Boltzmann entropy can be used to reflect the impact on the compatibility between open source software versions through the number of occurrences of metrics corresponding to various incompatibility severity levels. The Boltzmann entropy of the incompatibility severity level between open source software versions is defined as: The Boltzmann entropy of the incompatibility severity level between open source software versions refers to the degree of incompatibility between open source software versions caused by each severity level under the influence of the incompatibility metrics in different severity levels. The calculation formula is:
[0065] S i =α i *log z (n i +1),i∈(h,m,l,o)
[0066]
[0067] Among them, S i Including S h , S m , S l and S o , respectively represent the Boltzmann entropy of the incompatibility severity levels of High, Medium, Low and No between open source software versions; z is the Boltzmann parameter. Since the decimal system is used, the value of z is set to 10; n i Include h 、n m 、n l and n o , which represent the number of occurrences of incompatibility issues with severity levels of High, Medium, Low, and No, respectively. When the number of occurrences is 0, log 10 No practical significance, so take log 10 (n i +1). When n i When it is 0, entropy S i 0 means no compatibility risk;
[0068] α i Including α h , α m , α l and α o , respectively representing the risk weights of severity levels High, Medium, Low and No; the calculation formula is:
[0069]
[0070] Among them, λ i Including Lambda h , m , l and λ o , which are risk factors with severity levels of High, Medium, Low, and No. Their values are set to 0.9, 0.7, 0.4, and 0.1, respectively, based on the gradual decrease of the ratio between 0 and 1 that is close to the golden ratio, which can be approximately 1:1.618.
[0071] The compatibility credibility measurement between open source software versions takes into account the number of occurrences of metrics of various severity levels. Because the source code of the new and old versions is fixed, the more serious the incompatibility problem and the more times it occurs, the greater the degree of incompatibility between versions, and the entropy will also increase. Taking into account that the incompatibility severity levels of different metrics are different and the impact on the trust value is also different, the entropy of incompatibility between software versions is obtained by weighted summing up the entropies of severity levels High, Medium, Low, and No, that is, the Boltzmann entropy of the incompatibility severity levels between open source software versions is summed. The incompatibility entropy between open source software versions is defined as: The incompatibility entropy between open source software versions refers to the degree of incompatibility between software versions caused by all severity levels under the influence of incompatibility metrics of different severity levels. The calculation formula is:
[0072]
[0073] Among them, H represents the incompatibility entropy between open source software versions.
[0074] The larger the incompatibility entropy value between open source software versions, the higher the severity level corresponding to the metric or the more times it occurs, and the greater the degree of incompatibility between open source software versions. The incompatibility issues between open source software versions affect the compatibility credibility value, where the higher the severity level or the more incompatibilities that appear in each severity level, the faster the credibility decreases. It can be seen that the compatibility credibility measurement model between open source software versions satisfies the characteristics of an exponential function. Among them, the compatibility credibility value between open source software versions refers to the degree of compatibility credibility between open source software versions caused by incompatibility metrics of all severity levels under the influence of incompatibility metrics of different severity levels. The constructed compatibility credibility measurement model between open source software versions is: The compatibility credibility measurement model between open source software versions is defined as:
[0075] T=e -H
[0076] Among them, T is the compatibility trust value between open source software versions, and its value range is (0,1]. The larger the trust value T is, the higher the compatibility trust between open source software versions is, and the more compatible the two versions are; H is the incompatibility entropy between open source software versions, and its value is always greater than or equal to 0. The larger the entropy value H is, the higher the incompatibility between open source software versions is, and the more incompatible the two versions are.
[0077] S4. Construct a compatibility credibility measurement grading model: Design a compatibility credibility measurement grading model between software versions based on the method of approximating the golden ratio. By combining the credibility value and the density of incompatible changes of each severity level, the compatibility credibility between software versions is graded to evaluate the compatibility credibility level between open source software versions.
[0078] Specifically, the compatibility credibility measurement grading model is designed based on the compatibility credibility measurement value obtained by the compatibility credibility measurement model, the density of incompatible changes of each severity level and the method of approximating the golden ratio. The incompatibility between open source software versions considered by the present invention is actually the incompatibility between the source codes of the two versions, that is, the incompatibility of APIs. The compatibility credibility value between open source versions is directly related to the scale of changes in the two software versions. If the scale of the entire project is considered, such as the number of lines of code or the total number of APIs, it is not very reasonable. Because its substantial relationship with the incompatibility between versions is not close enough, the scale between the two versions of the software is generally not much different, and the main difference is the change in API. The larger the scale of the change, the higher the incompatibility and the lower the credibility. Therefore, the scale of source code changes between versions, that is, the number of API changes, is mainly considered. However, API changes include benign changes (backward compatible changes: severity is No) and destructive changes (backward incompatible changes: severity is High, Medium, Low). Therefore, when considering the compatibility trust metric between versions, not only the number of incompatible changes with severity levels of High, Medium, and Low should be considered, but also the number of compatible changes with severity level No should be considered to assist in calculating the compatibility trust level between versions.
[0079] When classifying the levels of trustworthy metrics for compatibility between versions, consider using the number of incompatible changes and the trustworthy value as constraints for classification. However, it is difficult to determine the threshold for the number of incompatible changes when defining the classification rules, so consider using the density of incompatible changes as one of the conditions for trustworthy classification. Because the density can be directly obtained by calculation, the value range is [0,1], the threshold is easy to set, and it can also reflect the number of incompatible changes. The more incompatible changes there are, the greater the density and the lower the trustworthiness. The density of incompatible changes between open source software versions is defined as: The density of incompatible changes between open source software versions refers to the ratio of the number of incompatible metrics of different severity levels to the number of all incompatible metrics. The calculation formula is:
[0080]
[0081] Among them, d i Included h ,d m ,d l and d o , which represent the density of incompatible changes with severity levels of High, Medium, Low, and No, respectively;
[0082] Based on the trust value obtained by the trustworthiness measurement model of compatibility between open source software versions and the incompatible change density calculated by the incompatible change density between open source software versions, a trustworthiness measurement grading model for compatibility between open source software versions is designed. The specific trustworthiness grading conditions are shown in Table 4.
[0083] Table 4. Compatibility trustworthiness metric grading model between open source software versions
[0084] Trust Level Credibility value T requirement Incompatible with changing density requirements V-Class 0.9<=T dh=0;dm=0;dl<=0.4 Level IV 0.7<=T<0.9 or 0.9<=T and cannot be rated as V level dh=0;dm<=0.4;dl<=0.7 Level III 0.4<=T<0.7 or 0.7<=T and cannot be rated as IV or above dh<=0.4;dm<=0.7 Level II 0.2<=T<0.4 or 0.4<=T and cannot be rated as level III or above dh<=0.7 Level I 0<=T<0.2 or 0.2<=T and cannot be rated as II or above none
[0085] Where T represents the credible value, d h ,d m ,d l Respectively represent the density of incompatible changes with trust levels of High, Medium, and Low.
[0086] Regarding the trust level classification conditions of the trust measurement classification model for compatibility between open source software versions, the design basis of this embodiment is:
[0087] For the trust value T: the value range is (0,1]. Since the higher the trust value, the greater the trust level, and the higher the requirement for the density of incompatible changes. Therefore, the division intervals in the trust measurement grading model for compatibility between open source software versions are not equidistant. The trust level value decreases from the highest level downward, and the division intervals are set to increase according to the approximate golden ratio, which can be approximately 1:1.618.
[0088] For the density of incompatible changes: the value range is [0,1], and the non-equidistant division method is also used. The approximate golden ratio division method of setting the trust level to decrease while increasing the incompatible severity level and the incompatible change density is used. The rationality of this method lies in adjusting the trust level of the software version according to the density of incompatible changes of different severity levels. It is conducive to a more balanced difference between the trust levels under different severity levels and change densities, and better reflects the impact of changes of different densities on the compatibility trustworthiness of the software.
[0089] Experimental example
[0090] The data used in the experiment are all from the open source software version pairs used by software developers in the actual development process, including compatible and incompatible version pairs. An empirical study is conducted on the compatibility credibility measurement model and credibility measurement grading model between open source software versions constructed based on the present invention, and the specific credibility measurement and grading results are shown in Table 5. Among them, nh, nm, nl, no represent the number of severity levels of High, Medium, Low and No, dh, dm, dl, do represent the change density of severity levels of High, Medium, Low and No, respectively, T and Level represent the compatibility credibility value and level between open source software versions, respectively. The larger the value of T and Level, the higher the compatibility credibility level and the fewer compatibility issues between versions.
[0091] Table 5: Empirical study on the trustworthiness measurement and classification of compatibility between Java open source software versions
[0092]
[0093] Through the empirical research in Table 5, we have conducted an in-depth discussion and analysis of the compatibility issues between multiple Java open source software versions and found that:
[0094] For the trust value: it is a key indicator for evaluating the trustworthiness of compatibility between versions. The higher the value, the better the compatibility between versions and the fewer compatibility issues. The trust value of mybatis-plus is 1.0, indicating that no compatibility issues were found between versions 3.3.1 and 3.4.2. The trust values of compatibility between two versions of other software are 0.737, 0.515, 0.312, 0.282, 0.173, 0.119, 0.095 and 0.059 from high to low. The compatibility issues they have are increasing in turn, resulting in a decrease in the trust value of compatibility. Among them, the trust value of compatibility between Tomcat versions 7.0.108 and 9.0.75 is 0.059, which is the lowest among all software.
[0095] For the density of incompatible changes: it considers the proportion of the number of changes of each severity level in the total number of changes, and evaluates the impact of changes of each severity level on the overall system compatibility from a comprehensive perspective. All compatibility change densities in mybatis-plus are 0, indicating that the versions are fully compatible. The medium severity change density of joda-time is 0.385, indicating that there are certain compatibility issues between versions. The high severity change density of Apache-MINA, swagger-core, and Java-Chassis is relatively high, which are 0.32, 0.427, and 0.516, respectively, indicating that there are more compatibility challenges between versions of these software. Tomcat has the highest high severity change density, with a value of 0.54, indicating that there are quite a few serious compatibility issues that need to be resolved in version iteration.
[0096] Regarding the trust level: it is an overall assessment of the compatibility between software versions by combining the two dimensions of compatibility trust value and incompatible change density, which directly reflects the compatibility status between versions. The trust level of mybatis-plus is V, indicating that there are no compatibility issues between versions. joda-time is IV level, indicating that there are certain compatibility issues, but they are relatively small. Xchart, Apache-MINA, and swagger-core are III, II, and II levels respectively, indicating that there are certain degrees of compatibility issues between the specified versions. Tomcat, jedis, lwjgl3, and Java-Chassis are all I level, indicating that there are a large degree of compatibility issues.
[0097] Overall, this paper provides a comprehensive empirical analysis of the compatibility issues between Java open source software versions, revealing the potential compatibility risks between different software versions. These findings not only help developers better understand and evaluate the compatibility between software versions, but also provide valuable references and suggestions for software selection, deployment and maintenance. At the same time, these research results also provide guidance for the software open source community, encouraging them to strengthen software maintenance and compatibility testing, and promote the healthy development of the open source software ecosystem.
[0098] The above description is only a preferred specific implementation manner of the present invention, but the protection scope of the present invention is not limited thereto. Any technician familiar with the technical field can make equivalent replacements or changes according to the technical scheme and inventive concept of the present invention within the technical scope disclosed by the present invention, which should be covered by the protection scope of the present invention.
Claims
1. A method for quantitatively evaluating the compatibility credibility between versions of Java open source software, characterized in that: The steps include: S1: Classify changes based on source code API level and define incompatible metrics; S2: Design a comprehensive version compatibility detection tool to detect incompatibilities between different versions of Java open source software and generate a compatibility analysis report; S3: Construct a compatibility credibility measurement model, count and analyze the number of occurrences of incompatible metric indicators and the corresponding severity levels, evaluate the compatibility credibility between software versions, and provide corresponding metric values; S4: Construct a compatibility credibility measurement grading model, combine relevant data, and grading the compatibility between software versions to evaluate the compatibility credibility level between open source software versions.
2. The method for quantitatively evaluating the compatibility credibility between versions of Java open source software according to claim 1 is characterized in that: In S1, the change of source code API level between open source software versions is defined, and the incompatible API detection rules of the incompatibility problem detection tool between two open source software versions are preprocessed to obtain the source code change rules.
3. The method for quantitatively evaluating the compatibility credibility between versions of Java open source software according to claim 2 is characterized in that: The incompatibility problem detection tools between the two open source software versions are Java API ComplianceChecker and Revapi; and the source code change rules obtained by the preprocessing operation are defined as incompatibility measurement indicators.
4. The method for quantitatively evaluating the compatibility credibility between versions of Java open source software according to claim 3 is characterized in that: In step S2, the comprehensive version compatibility detection tool is a Java open source software version incompatibility detection tool Jcbjare, which is comprehensively designed based on detection tools Java API Compliance Checker, Revapi and incompatibility measurement indicators.
5. The method for quantitatively evaluating the compatibility credibility between versions of Java open source software according to claim 4 is characterized in that: The Java open source software version incompatibility detection tool Jcbjare is used to obtain an analysis report on incompatibility issues between versions. The incompatibility issues between versions include incompatibility issue types, incompatibility severity levels, incompatibility issue sources, and incompatibility issue detailed descriptions.
6. The method for quantitatively evaluating the compatibility credibility between versions of Java open source software according to claim 5, characterized in that: In step S3, the compatibility credibility measurement model between open source software versions is designed based on the number of occurrences of the incompatible measurement indicator, the severity level corresponding to the incompatible measurement indicator and the Boltzmann entropy formula; The Boltzmann entropy formula is as follows: S=k*lnΩ Among them, S is a measure of the disorder of matter from a macroscopic perspective; Ω is a physical quantity from a microscopic perspective; k represents the Boltzmann constant; The Boltzmann entropy of the incompatibility severity level between open source software versions is calculated by combining the number of occurrences of incompatibility metrics between open source software versions and the severity level corresponding to the incompatibility metrics as follows: S i =a i *log z (n i +1),i∈(h,m,l,o) Among them, S i Including S h , S m , S l and S o , respectively represent the Boltzmann entropy of the incompatibility severity levels of High, Medium, Low and No between open source software versions; z is the Boltzmann parameter; n i Include h 、n m 、n l and n o , which represent the number of occurrences of incompatibility issues with severity levels of High, Medium, Low, and No, respectively; α i Including α h , α m , α l and α o , representing the risk weights of severity levels High, Medium, Low, and No, respectively; λ i Including Lambda h , m , l and λ o , representing risk factors with severity levels of High, Medium, Low, and No, respectively; The incompatibility entropy between open source software versions is calculated as follows: Among them, H represents the incompatibility entropy between open source software versions; The compatibility confidence metric is calculated as follows: T=e -H Among them, T is the compatibility trust value between open source software versions; H is the incompatibility entropy between open source software versions.
7. The method for quantitatively evaluating the compatibility credibility between versions of Java open source software according to claim 6 is characterized in that: In step S4, the open source software version compatibility credibility measurement grading model is designed based on the compatibility credibility measurement value obtained by the open source software version compatibility credibility measurement model, the incompatible change density of each severity level and the golden section ratio method, wherein the golden section ratio is approximately 1:1.618; The density of incompatible changes for each severity level is as follows: Among them, d i Included h d m d l and d o , which represent the density of incompatible changes with severity levels of High, Medium, Low, and No, respectively; The trust metric grading model divides trust levels based on the compatibility trust metric value and the incompatible change density of each severity level, and the trust level division intervals are divided according to the golden section ratio, wherein the golden section ratio is approximately 1:1.618.
