CN116303026B - A software architecture corruption prediction method, device and equipment based on evolution history - Google Patents

Abstract

The present invention relates to the technical field of software measurement and evaluation, and specifically relates to a software architecture corruption prediction method, device and equipment based on evolution history. The method includes the following steps: extracting the evolution operations performed by each evolution of the software architecture based on the evolution history, according to The functional classification of the evolution operation in the evolution records the type and quantity of the evolution operation; calculates the quality attributes of the software architecture before and after evolution and calculates the corruption degree of the software architecture based on it; based on the evolution operation, the Build a corruption prediction model with quality attributes and the corruption degree; extract information about the pre-evolution software architecture, where the information includes evolution operations and quality attributes of the pre-evolution architecture; calculate the result based on the corruption prediction model and the information. Describe the degree of corruption of the pre-evolution architecture. The present invention predicts the corruption of software architecture based on its characteristics, quality and evolution plan, so that the prediction results are highly targeted, intuitive and accurate.

Description

A software architecture corruption prediction method, device and equipment based on evolution history

Technical field

The present invention relates to the technical field of software measurement and evaluation, and specifically relates to a software architecture corruption prediction method, device and equipment based on evolution history.

Background technique

Software architecture is an important part of software. When the software architecture is corrupted, it will have negative impacts such as reducing the quality and performance of the software. Therefore, before the software architecture evolves, predicting whether the current evolution plan will cause software architecture corruption based on the evolution history data of the software architecture is of great significance to avoid software architecture corruption and save evolution costs. However, there is currently no technical solution in the industry that can effectively predict software architecture corruption.

In view of this, the present invention proposes a software architecture corruption prediction method based on evolution history.

Contents of the invention

The purpose of the present invention is to provide a method, device and equipment for predicting software architecture corruption based on evolution history, to solve the problem of the lack of prediction methods for software architecture corruption in the prior art, so as to effectively and accurately predict the degree of software architecture corruption. technical effects.

In order to achieve the above objects, the present invention provides the following solutions:

The first aspect of this application provides a software architecture corruption prediction method based on evolution history, which includes the following steps:

Extract the evolution operations performed for each evolution of the software architecture based on the evolution history; wherein the evolution history has multiple versions and there are differences between versions;

Record the type and quantity of the evolution operation according to the functional classification of the evolution operation in the evolution; wherein the type of the evolution operation includes at least one of adding new functions, improving existing functions and repairing faults;

Calculate the quality attributes of the software architecture before and after evolution respectively;

Calculate the degree of corruption of the software architecture based on the quality attributes before and after evolution;

A corruption prediction model is constructed based on the classified evolution operation, the quality attribute and the degree of corruption; wherein the corruption prediction model is a multiple regression describing that the degree of corruption depends on the evolution operation and the quality attribute equation;

Extract information about the pre-evolution software architecture, where the information includes evolution operations and quality attributes of the pre-evolution architecture;

The corruption degree of the pre-evolution architecture is calculated based on the corruption prediction model and the information.

Further, the quality attributes include at least one of ease of understanding, ease of modification, and ease of testing.

Further, the separately calculating the quality attributes of the software architecture before and after evolution includes:

Calculate the understandability of the software architecture described:

In the formula, U represents the understandability of the current software architecture, n represents the number of components in the current software architecture, C _i represents the i-th component in the current software architecture, C _j represents the j-th component in the current software architecture, f(C _i ,C _j ) represents the calling relationship between C _i and C _j . When C _i calls C _j , the value of f(C _i ,C _j ) is 1. Otherwise, the value of f(C _i ,C _j ) is 0, the symbol ∧ represents the calling relationship;

Calculate the ease of modification of the software architecture:

In the formula, M represents the ease of modification of the current software architecture, n represents the number of components in the current software architecture, C _i represents the i-th component in the current software architecture, and g(C _i ) represents the calling depth of C _i at the component layer;

Calculate the testability of the software architecture described:

In the formula, T represents the testability of the current software architecture, n represents the number of components in the current software architecture, C _i represents the i-th component in the current software architecture, h(C _i ) represents whether C _i needs a driver module, if so , the value of h(C _i ) is 1, otherwise the value of h(C _i ) is 0;

Based on the above three calculation formulas, the measurement values of the understandability, testability and modification of the pre-evolution and post-evolution software architecture are calculated respectively.

Further, calculating the degree of corruption of the software architecture based on the evolution operation includes:

Calculate the degree of corruption ED(a,b) according to the following formula:

In the formula, a represents the software architecture before evolution, b represents the software architecture after evolution, ED (a, b) represents the average difference between the quality attributes of a and b, N is the set of quality attributes of the software architecture, | N| is the number of elements contained in N, N _{i_a} is the measurement value of the i-th quality attribute of a, N _{i_b} is the measurement value of the i-th quality attribute of b

Further, building a corruption prediction model based on the evolution operation, the quality attribute and the degree of corruption includes:

Calculate the weight of the evolution operation, the quality attribute and the corruption degree;

Build a corruption prediction model based on the weight of the evolution operation, the quality attribute and the degree of corruption:

E＝w ₁ *U+w ₂ *M+w ₃ *T+w ₄ *A+w ₅ *I+w ₆ *F+C

In the formula, E represents the degree of software architecture corruption, w ₁ represents the weight of understandability, w ₂ represents the weight of ease of modification, w ₃ represents the weight of ease of testing, w ₄ represents the weight of adding new functions, and w ₅ represents improvement. The weight of existing functions, w ₆ represents the weight of repairing faults, and C represents a constant.

Further, the software architecture is expressed in the form of a component dependency diagram.

Further, the number of versions of the evolution history is no less than 9.

The second aspect of this application provides a software architecture corruption prediction device based on evolution history, including:

The extraction module extracts the evolution operations performed by each evolution of the software architecture based on the evolution history; wherein the evolution history has multiple versions and there are differences between versions;

A recording module, configured to record the type and quantity of the evolution operation according to the function classification of the evolution operation in the evolution; wherein the type of the evolution operation includes at least one of adding new functions, improving existing functions and repairing faults. kind;

The first calculation module is used to calculate the quality attributes of the software architecture before and after evolution respectively;

The second calculation module is used to calculate the corruption degree of the software architecture based on the quality attributes before and after evolution;

A model building module configured to construct a corruption prediction model based on the classified evolution operation, the quality attribute and the corruption degree; wherein the corruption prediction model describes that the corruption degree depends on the evolution operation and the corruption degree. Multiple regression equation describing quality attributes;

An extraction module, configured to extract information about the pre-evolution software architecture, where the information includes evolution operations and quality attributes of the pre-evolution architecture;

A third calculation module, configured to calculate the corruption degree of the pre-evolution architecture based on the corruption prediction model and the information.

A third aspect of this application also provides an electronic device, including:

at least one processor;

a memory communicatively connected to the at least one processor;

Wherein, the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor, so that the at least one processor can execute the method described in the first aspect of this application. method.

A fourth aspect of the present application provides a non-transitory computer-readable storage medium storing computer instructions, the computer instructions being used to cause the computer to execute the method described in the first aspect of the present application.

Beneficial effects:

1. As can be seen from the above technical solution, the technical solution of the present invention provides a software architecture corrosion prediction method, device and equipment based on evolution history, which predicts the corrosion from the perspective of the software architecture itself, making the prediction results more targeted. ;

2. The present invention measures the corruption degree of the software architecture based on the quality of the software architecture, making the corruption degree prediction results more intuitive;

3. The present invention predicts the degree of corruption based on the evolution operation of the software architecture. The parameters of the corruption prediction model include a number of factors that affect the evolution effect of the software architecture to reduce prediction errors and improve the accuracy of the prediction results.

It should be understood that all combinations of the foregoing concepts as well as additional concepts described in more detail below can be considered part of the inventive subject matter of the present disclosure so long as such concepts are not inconsistent with each other.

The foregoing and other aspects, embodiments and features of the present teachings will be more fully understood from the following description taken in conjunction with the accompanying drawings. Additional aspects of the invention, such as features and/or advantages of the exemplary embodiments, will be apparent from the description which follows, or may be learned by practice of specific embodiments in accordance with the teachings of the invention.

Description of the drawings

The drawings are not intended to be drawn to scale. In the drawings, each identical or approximately identical component shown in various figures may be designated by the same reference numeral. For clarity, not every component is labeled in each figure. Embodiments of various aspects of the invention will now be described by way of example and with reference to the accompanying drawings, in which:

Figure 1 is a schematic flowchart of the method in the embodiment of the present application.

Detailed ways

In order to make the purpose and technical solutions of the embodiments of the present invention clearer, the technical solutions of the present invention will be clearly and completely described below in conjunction with the embodiments of the present invention. Obviously, the described embodiments are some, but not all, of the embodiments of the present invention. Based on the described embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts fall within the scope of protection of the present invention.

It will be understood by one of ordinary skill in the art that, unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs. It should also be understood that terms such as those defined in general dictionaries are to be understood to have meanings consistent with their meaning in the context of the prior art, and are not to be taken in an idealized or overly formal sense unless defined as herein. explain.

After a software product has been in operation for a period of time, the project scale usually continues to increase due to adjustments in requirements and changes in developers, code base confusion, accumulation of errors, etc., which eventually leads to the corruption of the software structure and the degree of corruption becomes increasingly difficult to control and maintain.

In response to the phenomena that are prone to occur during the operation of software products mentioned above, the existing methods are usually partial or global reconstruction of their architecture, but reconstruction means a large investment of manpower and material resources. Therefore, before the software architecture evolves, predicting whether the current evolution plan will cause software architecture corruption based on the evolution history data of the software architecture is of great significance to avoid software architecture corruption and save evolution costs. However, at this stage, there is a lack of research on this part, and methods that can accurately predict the degree of software architecture corruption are still lacking. The specific situation is as follows:

(1) There is a lack of methods to predict software architecture corruption. Software architecture is a high-level abstraction of source code, so it is quite different from software source code in terms of quality measurement, corruption analysis, cost estimation, etc. Therefore, it is necessary to estimate the corruption of software architecture based on the characteristics of software architecture;

(2) There is a lack of methods to correlate software architecture quality with software architecture corruption. The measure of software architecture corruption is whether the quality of the software architecture decreases after the software architecture evolves. However, there is currently a lack of methods to correlate software architecture quality with software architecture corruption;

(3) There is a lack of methods to correlate evolution plans with software architecture corruption. Whether the software architecture will corrupt depends on what evolution operations are performed during the evolution process. However, there is currently a lack of method to correlate the evolution plan with the corruption of the software architecture.

Based on the above current situation, embodiments of the present invention start from the characteristics, quality and evolution plan of the software architecture. When establishing the prediction model, multiple factors that affect the evolution effect of the software architecture are listed as parameters of the prediction model to improve the reliability of the model and ensure its reliability. It can provide more accurate results when specifically testing the corruption degree of software architecture.

Embodiments of the present invention provide a method, apparatus and equipment for predicting software architecture corruption based on evolution history, which will be described separately below.

As shown in Figure 1, it is a schematic flow chart of a software architecture corruption prediction method based on evolution history according to an embodiment of the present invention. The method includes the following steps:

Step 101: Extract the evolution operations performed for each evolution of the software architecture based on the evolution history; wherein the evolution history has multiple versions and there are differences between versions.

Step 102: Record the type and quantity of the evolution operation according to its functional classification during evolution; wherein the type of the evolution operation includes at least one of adding new functions, improving existing functions, and repairing faults.

Step 103: Calculate the quality attributes of the software architecture before and after evolution respectively.

Step 104: Calculate the corruption degree of the software architecture based on the quality attributes before and after evolution.

Step 105: Construct a corruption prediction model based on the classified evolution operation, the quality attribute and the corruption degree; wherein the corruption prediction model describes that the corruption degree depends on the evolution operation and the quality attribute The multiple regression equation.

Step 106: Extract information about the pre-evolution software architecture; where the information includes evolution operations and quality attributes of the pre-evolution architecture.

Step 107: Calculate the corruption degree of the pre-evolution architecture based on the corruption prediction model and the information.

For the convenience of description, this embodiment uses the evolution history of 9 versions in the following Table 1 for illustration. In some embodiments, the number of versions of the evolution history in step 101 is not limited to the 9 mentioned above. To ensure the accuracy of the calculation model, the selected minimum sample size should be no less than 9. That is, the number of versions of the evolution history used in step S101 is no less than 9. During specific implementation, the number of version statistical samples of the evolution history can be increased to further improve the subsequent corruption prediction model established based on the evolution history. prediction accuracy.

The quantity information of various evolution operations in the evolution history of the above nine versions is shown in Table 1 below:

Table 1 Quantity information of various types of evolution operations

In some embodiments, the quality attributes in step 103 include at least one of ease of understanding, ease of modification, and ease of testing.

In order to improve the accuracy of the calculation of the degree of corruption and further ensure the accuracy of the prediction results, in this embodiment, the quality attributes include three types: ease of understanding, ease of modification, and ease of testing. Calculate the above three types of before and after evolution. The software architecture includes the following steps:

Calculate the understandability of the software architecture described:

In the formula, U represents the understandability of the current software architecture, n represents the number of components in the current software architecture, C _i represents the i-th component in the current software architecture, C _j represents the j-th component in the current software architecture, f(C _i ,C _j ) represents the calling relationship between C _i and C _j . When C _i calls C _j , the value of f(C _i ,C _j ) is 1. Otherwise, the value of f(C _i ,C _j ) is 0, the symbol ∧ represents the calling relationship.

Calculate the ease of modification of the software architecture:

In the formula, M represents the ease of modification of the current software architecture, n represents the number of components in the current software architecture, C _i represents the i-th component in the current software architecture, and g(C _i ) represents the calling depth of C _i at the component layer.

Calculate the testability of the software architecture described:

In the formula, T represents the testability of the current software architecture, n represents the number of components in the current software architecture, C _i represents the i-th component in the current software architecture, h(C _i ) represents whether C _i needs a driver module, if so , the value of h(C _i ) is 1, otherwise the value of h(C _i ) is 0.

After the calculation process of the above three quality attributes, the measurement values of the quality attributes from version 1 to version 9 in Table 1 are obtained respectively. The specific data are shown in Table 2 below:

Table 2 Measurement values of quality attributes

ComprehensibilityU Ease of modification M Ease of testabilityT version 1 0.61 0.8 0.51 Version 2 0.67 0.7 0.77 Version 3 0.55 1.05 0.59 Version 4 0.8 0.76 0.64 Version 5 0.7 0.86 0.59 Version 6 0.45 0.87 0.94 Version 7 0.5 0.88 0.71 Version 8 0.73 0.8 0.76 Version 9 0.54 0.64 0.61

In some embodiments, the specific process of step 104 is as follows:

Calculate the degree of corruption ED(a,b) according to the following formula:

In the formula, a represents the software architecture before evolution, b represents the software architecture after evolution, ED (a, b) represents the average difference between the quality attributes of a and b, N is the set of quality attributes of the software architecture, | N| is the number of elements contained in N, _{Ni_a} is the measurement value of the i-th quality attribute of a, and _{Ni_b} is the measurement value of the i-th quality attribute of b.

Through the above formula, the corruption degree of the software architecture can be calculated. When the corruption degree is less than or equal to 0, the software architecture is not corrupted. When the corruption degree is greater than 0, the software architecture is corrupted. The higher the value, the more serious the degree of corruption.

In this embodiment, the quality attributes of the above nine versions and the metric values calculated in step 103 are still used as parameters of the prediction model. After the above step 104, the software architecture corruption degrees corresponding to versions 1 to 9 are calculated. , the specific data is shown in Table 3 below:

Table 3 Software architecture corruption degree

version 1 Version 2 Version 3 Version 4 Version 5 Version 6 Version 7 Version 8 Version 9 0.10631 0.20457 0.34007 0.21468 0.08808 0.13639 0.40116 0.52717 0.46724

In some embodiments, the specific process of step 105 is as follows:

Calculate the weight of the evolution operation and the quality attribute based on the corruption degree;

Build a corruption prediction model based on the classified evolution operation, the weight of the quality attribute and the degree of corruption:

E＝w ₁ *U+w ₂ *M+w ₃ *T+w ₄ *A+w ₅ *I+w ₆ *F+C

It can be seen from the above formula that in this embodiment, the corruption prediction model is a six-element linear regression model that describes the degree of corruption depending on the evolution operation and the quality attribute. The evolution operation and the weight of the quality attribute Corresponding to the regression coefficients in the formula respectively. In the formula, E represents the software architecture corruption degree, w ₁ represents the regression coefficient of understandability U, w ₂ represents the regression coefficient of ease of modification M, w ₃ represents the regression coefficient of testability T, and w ₄ represents the addition of new function A. The regression coefficient of w ₅ represents the regression coefficient of improving the existing function I, w ₆ represents the regression coefficient of repairing the fault F, and C represents a constant. It should be noted that the corruption prediction model is not limited to the six-element linear regression model mentioned above. The number of dependent variables represented by U, M, A, etc. in the formula can be selected as needed during specific implementation, that is, , if a total of p evolution operations and quality attributes are taken into account, the corresponding corruption prediction model is a p-element regression model.

In this embodiment, the evolution history of the above nine versions is still used as an example, and the corruption is calculated by combining the evolution operation, the quality attribute and the corruption degree data obtained in the above steps 101 to 104. Each parameter value in the prediction model, the specific data is shown in Table 4 below:

Table 4 Each parameter value in the software architecture corrosion prediction model

w ₁ w ₂ w ₃ w ₄ w ₅ w ₆ C 0.3276 0.3814 0.0443 -0.0224 -0.0812 -0.0520 0.2079

The corruption prediction model is obtained based on the data in Table 4 above:

E＝0.3276U+0.3814M+0.0443T-0.0224A-0.0812T-0.0520I+0.2079

In some embodiments, the step 106 is illustrated with a certain pre-evolution software architecture. The information of the pre-evolution software architecture is as shown in Table 5 below:

Table 5 Information about pre-evolved software architecture

ComprehensibilityU Ease of modification M Ease of testabilityT Add new function A Improve existing functionality I Repair fault F 0.67 0.57 0.44 0 3 2

In some embodiments, still taking the pre-evolution software architecture illustrated in step 106 and the information in Table 5 as an example, the pre-evolution software architecture is calculated based on the corruption prediction model obtained in step 105. Corruption:

E＝w ₁ *U+w ₂ *M+w ₃ *T+w ₄ *A+w ₅ *I+w ₆ *F+C

＝0.3276*0.67+0.3814*0.57+0.0443*0.44-0.0224*0-0.0812*3-0.0520*2+0.2079＝0.30736

It can be seen from the measurement results that the predicted corruption degree of the software architecture based on the information of the current software architecture is 0.30736, indicating that the software architecture is corrupted.

Based on the above distributed program slicing method based on natural language processing, embodiments of the present invention also provide a distributed program slicing device based on natural language processing.

For example, the distributed program slicing method based on natural language processing can be divided into multiple modules. The multiple modules are stored in the memory and executed by the processor to complete the present invention. The multiple modules or units may be a series of computer program instruction segments capable of completing specific functions. The instruction segments are used to describe the execution process of the distributed program slicing method based on natural language processing. For example, recording module, extraction module, etc. The specific functions of each module are as follows:

The recording module is used to extract the evolution operations performed by each evolution of the software architecture based on the evolution history, and record the number according to the functions of the evolution operations in the evolution; wherein the evolution history has multiple versions and there are differences between the versions. sex;

The first calculation module is used to calculate the quality attributes of the software architecture before and after evolution respectively;

The second calculation module is used to calculate the corruption degree of the software architecture based on the quality attributes before and after evolution;

A model building module, configured to build a corruption prediction model based on the evolution operation, the quality attribute and the degree of corruption;

An extraction module, configured to extract information about the pre-evolution software architecture, where the information includes evolution operations and quality attributes of the pre-evolution architecture;

A third calculation module, configured to calculate the corruption degree of the pre-evolution architecture based on the corruption prediction model and the information.

Correspondingly, an embodiment of the present invention also provides an electronic device, including:

at least one processor;

a memory communicatively connected to the at least one processor;

Wherein, the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor, so that the at least one processor can execute the instructions in any embodiment of the present invention. Methods.

These computer programs may also be loaded onto a computer or other programmable data processing device such that a series of operating steps are performed on the computer or other programmable device to produce computer-implemented processes, thereby causing instructions to be executed on the computer or other programmable device Provides steps for implementing the functions specified in one process or multiple processes in the flowchart and/or one or multiple boxes in the block diagram, and corresponding to different steps can be implemented through different modules.

The above-mentioned programs can be run in the processor, or can also be stored in the memory (also known as computer-readable media). Computer-readable media include permanent and non-permanent, removable and non-removable media that can be stored in memory by any method or technology to achieve information storage. Information may be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), and read-only memory. (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, Magnetic tape cassettes, tape magnetic disk storage or other magnetic storage devices or any other non-transmission medium can be used to store information that can be accessed by a computing device. As defined in this article, computer-readable media does not include transitory media, such as modulated data signals and carrier waves.

Correspondingly, the present invention also provides a non-transitory computer-readable storage medium storing computer instructions. The computer instructions are used to cause the computer to execute the method described in any embodiment of the present invention.

Although the present invention has been disclosed above in terms of preferred embodiments, these are not intended to limit the present invention. Those with ordinary skill in the technical field to which the present invention belongs can make various modifications and modifications without departing from the spirit and scope of the present invention. Therefore, the protection scope of the present invention shall be determined by the claims.

Claims (6)

1. The evolution history-based software architecture degradation prediction method is characterized by comprising the following steps of:

extracting evolution operation executed by each evolution of the software architecture based on the evolution history; wherein the evolution history has a plurality of versions and has differences between versions;

recording the type and the number of the evolution operation according to the function classification of the evolution operation in evolution; wherein the type of evolution operation includes at least one of adding new functionality, promoting existing functionality, and repairing a failure;

the quality attributes of the software architecture before evolution and after evolution are calculated respectively, wherein the quality attributes comprise at least one of easy comprehensibility, easy modification and easy testability:

calculating an understandability in the quality attribute:

in the above formula, U represents the understandability of the current software architecture, n represents the number of components in the current software architecture, and C _i Representing the ith component, C, in the current software architecture _j Represents the jth component, f (C _i ,C _j ) Represent C _i And C _j When C is the calling relation of _i Call C _j F (C) _i ,C _j ) Has a value of 1, otherwise f (C _i ,C _j ) The value of (2) is 0;

calculating easy modification in the quality attribute:

in the above formula, M represents an easy-to-modify modification of the current software architecture, n represents the number of components in the current software architecture, and C _i Represents the ith component, g (C _i ) Represent C _i Calling depth at component layer;

calculating testability in the quality attributes:

in the above formula, T represents testability of the current software architecture, n represents the number of components in the current software architecture, and C _i Represents the ith component, h (C _i ) Represent C _i Whether a drive module is required, if so, h (C _i ) Has a value of 1, otherwise h (C _i ) The value of (2) is 0;

calculating the degree of degradation of the software architecture corresponding to an evolution history formed by a software architecture from a pre-evolution version to a post-evolution version based on the quality attributes before evolution and after evolution;

in the above formula, a represents a pre-evolution software architecture corresponding to an evolution history, b represents a post-evolution software architecture corresponding to the evolution history, wherein N is a set of quality attributes of the software architecture, N is the number of elements contained in N, and N _{i_a} Is the metric value of the ith quality attribute of a, N _{i_b} Is the metric value of the ith quality attribute of b;

constructing a degradation prediction model based on the classified evolution operation, the quality attribute and the degradation degree:

E＝w ₁ *U+w ₂ *M+w ₃ *T+w ₄ *A+w ₅ *I+w ₆ *F+C

in the above description, E represents the software architecture decomposition degree, w ₁ Weights indicating intelligibility U, w ₂ Weights, w, representing easy-to-modify M ₃ Weights, w, representing testability T ₄ Indicating the addition of the weight of the new function A, w ₅ Represents the weight of the lifting existing function I, w ₆ Representing the weight of repairing the fault F, and C represents a constant;

extracting information of a pre-development software architecture; wherein the information includes evolution operations and quality attributes of the pre-evolved software architecture;

calculating the degree of decay of the pre-evolved software architecture based on the decay prediction model and the information.

2. The method of claim 1, wherein the software architecture is represented in the form of a component dependency graph.

3. The method of claim 1, wherein the evolution history has a number of versions of no less than 9.

4. The utility model provides a software architecture corruption prediction unit based on evolution history which characterized in that includes:

the extraction module is used for extracting evolution operation executed by each evolution of the software architecture based on the evolution history; wherein the evolution history has a plurality of versions and has differences between versions;

the recording module is used for recording the types and the quantity of the evolution operation according to the function classification of the evolution operation in the evolution; wherein the type of evolution operation includes at least one of adding new functionality, promoting existing functionality, and repairing a failure;

the first computing module is configured to compute quality attributes of the software architecture before evolution and after evolution, where the quality attributes include at least one of understandability, modifiable and testability:

calculating an understandability in the quality attribute:

in the above formula, U represents the understandability of the current software architecture, n represents the number of components in the current software architecture, and C _i Representing the ith component, C, in the current software architecture _j Represents the jth component, f (C _i ,C _j ) Represent C _i And C _j When C is the calling relation of _i Call C _j F (C) _i ,C _j ) Has a value of 1, otherwise f (C _i ,C _j ) The value of (2) is 0;

calculating easy modification in the quality attribute:

in the above formula, M represents an easy-to-modify modification of the current software architecture, n represents the number of components in the current software architecture, and C _i Represents the ith component, g (C _i ) Represent C _i Calling depth at component layer;

calculating testability in the quality attributes:

in the above formula, T represents testability of the current software architecture, n represents the number of components in the current software architecture, and C _i Represents the ith component, h (C _i ) Represent C _i Whether a drive module is required, if so, h (C _i ) Has a value of 1, otherwise h (C _i ) The value of (2) is 0;

the second calculation module is used for calculating the degree of degradation of the software architecture corresponding to the evolution history formed by the software architecture from the version before evolution to the version after evolution based on the quality attributes before evolution and after evolution:

in the above formula, a represents a pre-evolution software architecture corresponding to an evolution history, b represents a post-evolution software architecture corresponding to the evolution history, wherein N is a set of quality attributes of the software architecture, N is the number of elements contained in N, and N _{i_a} Is the metric value of the ith quality attribute of a, N _{i_b} Is the ith mass of bA measure of sex;

the model construction module is used for constructing a decomposition prediction model based on the classified evolution operation, the classified quality attribute and the classified decomposition degree:

E＝w ₁ *U+w ₂ *M+w ₃ *T+w ₄ *A+w ₅ *I+w ₆ *F+C

in the above description, E represents the software architecture decomposition degree, w ₁ Weights indicating intelligibility U, w ₂ Weights, w, representing easy-to-modify M ₃ Weights, w, representing testability T ₄ Indicating the addition of the weight of the new function A, w ₅ Represents the weight of the lifting existing function I, w ₆ Representing the weight of repairing the fault F, and C represents a constant;

the extraction module is used for extracting information of the pre-developed software architecture, wherein the information comprises evolution operation and quality attribute of the pre-developed software architecture;

and the third calculation module is used for calculating the decomposition degree of the pre-development software architecture based on the decomposition prediction model and the information.

5. An electronic device, comprising:

at least one processor;

a memory communicatively coupled to the at least one processor;

wherein the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1 to 3.

6. A non-transitory computer readable storage medium storing computer instructions for causing the computer to perform the method of any one of claims 1 to 3.