Software development method based on cloud computing

Abstract

The invention discloses a software development method based on cloud computing, particularly relates to the field of micro-service management, is used for solving the problem of feature mark optimization and cleaning in software development, and realizes accurate fragmentation management by performing system performance consistency analysis and dependency path complexity evaluation on each feature mark. And the performance consistency and stability of the system are obviously improved. A Neo4j graph database is utilized to construct a real-time update dependency graph of characteristic signs, code modules and configuration items, a function redundancy index and an adjustment cost index are calculated based on the real-time update dependency graph, optimization and cleaning suggestions are generated in combination with an optimization warning coefficient, unused or redundant characteristic signs are effectively recognized and processed, resource waste is reduced, and the method is suitable for popularization and application. Warning signals are distributed in real time through an automatic tool and a CI / CD pipeline, it is ensured that development, operation and maintenance teams and a monitoring module respond in time, dynamic adjustment and intelligent management of characteristic marks are carried out, the robustness and the resource utilization rate of the system are improved, and continuous optimization and robust development of the system are ensured.

Description

Technical Field

[0001] The present invention relates to the field of microservice management, and more specifically, to a software development method based on cloud computing. Background Art

[0002] In modern cloud computing and microservice architecture, the complexity of the system continues to increase. Feature flags, as an important mechanism for controlling the enabling and disabling of software functions, have become an indispensable part of the software development and operation process. Feature flags allow development teams to enable or disable specific features without redeploying applications, thereby achieving more flexible feature management and faster development iterations. However, as the number of feature flags increases, the complexity of their management and maintenance also increases. Especially in the process of multi-environment deployment and high-frequency version releases, how to ensure the consistency and stability of feature flags in different environments, and how to effectively manage their dependencies and functional redundancy have become urgent issues to be solved.

[0003] The core problem of existing technologies in feature flag management is that they cannot effectively handle the complex dependencies of feature flags, resulting in high system coupling and difficult maintenance. The dependencies between feature flags in multiple code modules often change and are difficult to track. Traditional manual maintenance and simple configuration file management methods cannot accurately quantify and manage these dependencies, resulting in unstable system performance and frequent failures. In addition, due to the lack of intelligent decision support and automated analysis tools, existing technologies have difficulty identifying and optimizing redundant and inefficient parts of these dependencies, and cannot provide scientific optimization and cleanup suggestions, which limits the scalability and maintainability of the system.

[0004] In order to solve the above problems, a technical solution is now provided. Summary of the invention

[0005] In order to overcome the above-mentioned defects of the prior art, the embodiment of the present invention provides a software development method based on cloud computing, which realizes accurate sharding management by comprehensively evaluating the environmental adaptability spectrum and cross-module dependency entropy of feature flags, and effectively improves the performance consistency and stability of the system. The environmental adaptability spectrum provides consistent data of feature flags in different execution environments, ensures its stability in development, testing and production environments, and reduces performance fluctuations caused by environmental differences. Cross-module dependency entropy quantifies the dependency relationship between feature flags in multiple code modules, reduces the system coupling, reduces the complexity of dependency paths, and improves the maintainability and scalability of the system. The comprehensive scoring method optimizes the allocation strategy of feature flags, allocates feature flags with high adaptability and high consistency to key microservice modules, ensures the high performance and high stability of core modules, and isolates and optimizes feature flags with low adaptability and high complexity, gradually improves their performance, and ensures the balance and efficient operation of the system. The Neo4j graph database is used to build a dependency graph of feature flags, code modules and configuration items, realizes real-time update and precise management, and significantly improves the scientificity and accuracy of dependency management. By calculating the functional redundancy index and adjustment cost index, and combining the optimization warning coefficient to generate optimization and cleanup suggestions, it is possible to effectively identify and process unused or redundant feature flags, reduce system complexity and resource waste. Warning signals are distributed in real time through automated tools and CI / CD pipelines to ensure that the development team, operation and maintenance team, and monitoring module respond to and process the optimization and cleanup needs of feature flags in a timely manner, realize dynamic adjustment and intelligent management of feature flags, enhance the robustness and resource utilization of the system, and provide a scientific decision-making basis for the continuous optimization and steady development of the system, so as to solve the problems raised in the above background technology.

[0006] To achieve the above object, the present invention provides the following technical solutions:

[0007] S1, in the microservice architecture, conduct system performance consistency analysis and dependency path complexity evaluation for each feature flag, obtain the environmental adaptability spectrum and cross-module dependency entropy respectively, and perform precise sharding management on the feature flags based on this;

[0008] S2, build a Neo4j graph database, construct nodes of feature flags, code modules, and configuration items, and edges of dependencies, regularly extract and import feature flags and their dependencies, and form a dependency graph that is updated in real time;

[0009] S3, using the query and analysis capabilities of the Neo4j graph database, calculates the functional redundancy index and adjustment cost index of the feature flag, generates optimization and cleanup suggestions based on the optimization warning coefficient, distributes red, yellow, and green signals, and guides priority optimization, monitoring evaluation, and regular inspections;

[0010] S4, based on the analysis results of the graph database, generates warning signals that are distributed in real time through automation tools and CI / CD pipelines.

[0011] In a preferred embodiment, the logic for obtaining the environmental adaptability spectrum is:

[0012] a1, records system performance data in different execution environments when feature flags are enabled;

[0013] a2, denoising and normalizing the time series to ensure data quality;

[0014] a3, convert the time domain signal into the frequency domain signal through fast Fourier transform and extract the spectrum features;

[0015] a4, calculate the differences in spectrum characteristics under different environments and measure the spectrum differences of characteristic marks under different environments;

[0016] a5, calculate the spectrum difference between the development environment and the test environment, the development environment and the production environment, and the test environment and the production environment. The spectrum difference is obtained by subtracting the cosine similarity from 1;

[0017] a6, calculate the sum of the spectrum differences of all environment pairs to obtain the total spectrum difference, and then calculate the environmental adaptability spectrum based on the total spectrum difference. The environmental adaptability spectrum is obtained by dividing 1 by 1 plus the total spectrum difference.

[0018] In a preferred embodiment, the logic for obtaining cross-module dependency entropy is:

[0019] b1, collect the dependency data of feature flags in different modules in the code repository, and record the dependency call path and frequency;

[0020] Extract the dependency relationship of feature flags in each module from the code repository to form a dependency call path. The dependency call path represents the call sequence of feature flags between different modules. Each call path records the call frequency and path identifier.

[0021] b2, deduplicate and standardize dependency data;

[0022] b3, build the dependency call path tree of feature flags in different modules and record the call frequency of each path;

[0023] The standardized dependency call path P i and its calling frequency C i ′ is organized into a tree structure, with the root node being the feature mark and the child nodes being the dependent modules. Each path starts from the root node and passes through multiple child nodes to form a complete call path;

[0024] b4, calculate the complexity of each dependent call path, using the path complexity formula; calculate the length L(P i );

[0025] Path length formula: Among them, n i For path P i The number of nodes on d j,j+1 is the distance from node j to node j+1; the path complexity C(P i );

[0026] Path complexity formula: C(P i )=-L(P i )log(C i ′+ε), where C i ′ is the normalized call frequency; ε is a very small constant to prevent the logarithmic zero value;

[0027] b5, the sum of the complexity of all dependency call paths is converted to the base of the natural logarithm, and the cross-module dependency entropy is calculated to comprehensively measure the dependency complexity of the feature flag;

[0028] Calculate the sum of the complexity S of all dependent call paths, the sum formula is: m is the total number of paths;

[0029] Calculate the cross-module dependency entropy. The specific formula is as follows: CMDE = (1 + e S ) -1 .

[0030] In a preferred embodiment, c1, the environmental adaptability spectrum and the cross-module dependency entropy are normalized;

[0031] c2, extracting high-order characteristics of environmental adaptability spectrum and cross-module dependency entropy, and constructing a multi-dimensional feature space;

[0032] Construct the feature interaction matrix M of the environmental adaptability spectrum and cross-module dependency entropy, where M ov =EAS o ×CMDE v It represents the interactive relationship between the oth characteristic flag in terms of adaptability and dependence;

[0033] The interaction matrix is ​​used to generate high-order features, including quadratic, cubic, and polynomial features, to capture the complex relationship between environmental adaptability spectra and cross-module dependency entropy;

[0034] Generate secondary features: such as EAS 2 ,CMDE 2 ,EAS×CMDE;

[0035] Generate three-dimensional features: such as EAS 3 ,CMDE 3 , EAS 2 ×CMDE,EAS×CMDE 2 ;

[0036] c3, use the random forest regression model to train high-order features and evaluate the feature importance of each feature;

[0037] c4, based on the feature importance analysis results, select the most important features for combination; select the top k features with the highest feature importance scores for combination; combine the selected high-order features to construct a new feature vector for comprehensive score calculation;

[0038] c5, calculates the comprehensive score through feature combination and optimizes the feature flag shard management;

[0039] Calculate the feature score for each feature flag and combine the top k features with the highest feature importance scores;

[0040] The final comprehensive score is calculated by comprehensively considering the interactive effects of high-level features and feature combinations;

[0041] The comprehensive score S is: Importance o is the feature importance of the oth feature;

[0042] c6, compare the comprehensive score with the first classification threshold and the second classification threshold respectively:

[0043] For feature flags whose comprehensive scores are greater than the second classification threshold, they are allocated to high-priority microservice modules; for feature flags whose comprehensive scores are greater than or equal to the first classification threshold and less than or equal to the second classification threshold, they are allocated to medium-priority microservice modules; for feature flags whose comprehensive scores are less than the second classification threshold, they are allocated to low-priority microservice modules or isolated environments.

[0044] In a preferred embodiment, step S2 includes the following contents:

[0045] S2.1, build the node and edge model of Neo4j graph database on the cloud platform. The nodes include feature flags, code modules and configuration items, and the edges represent dependencies and call paths;

[0046] S2.2, preprocessing and formatting the feature flag dependency data generated in step S1;

[0047] The feature flag dependency data includes the dependency frequency of each feature flag in each module, the complexity of the dependency path, and the structured representation of these dependencies;

[0048] S2.3, import the preprocessed feature flags, code modules and configuration item data into the Neo4j graph database to build an initial dependency graph;

[0049] S2.4, regularly extract the latest feature flags and their dependency data from the code repository and system logs, and import the extracted new data into the Neo4j graph database.

[0050] In a preferred embodiment, the logic for obtaining the functional redundancy index is:

[0051] d1, extract the functional characteristics of each characteristic mark to form a functional feature vector;

[0052] Define a functional feature set G for each feature flag, including input parameters, output results, key operations, and involved modules;

[0053] Convert the functional features into feature vector X a ;X a =[g1,g2,...,g m ];

[0054] gl represents the lth functional characteristic value of the sex mark; m represents the total number of functional characteristics;

[0055] d2, calculate the functional similarity between each pair of feature markers;

[0056] Use cosine similarity to measure the similarity between functional feature vectors. The cosine similarity formula is:

[0057] X a , X b Functional feature vector representing characteristic flags; ||X a || represents the modulus of the eigenvector;

[0058] Calculate the functional similarity between all feature flag pairs to form a functional similarity matrix M, with matrix elements: M ab =CosSim(X a ,X b );

[0059] d3, evaluate the functional overlap of each feature marker;

[0060] Calculate the functional overlap between the feature flag and all other feature flags. The functional overlap formula is:

[0061] O a represents the functional overlap of characteristic mark a; N represents the total number of characteristic marks;

[0062] d4, introduces function importance and adjusts the weight of overlap;

[0063] Assign a feature importance weight Q to each feature flag a , based on its criticality in the system, the importance weight formula is:

[0064] Criticality a Indicates the criticality of feature flag a; c is a variable index used to traverse each feature flag in the system, ranging from 1 to N;

[0065] Calculate the weighted functional overlap. The weighted overlap formula is:

[0066] d5, based on the weighted functional overlap, calculate the functional redundancy index of each characteristic marker;

[0067] Combine the weighted overlap and functional similarity matrix to calculate the functional redundancy index FRI. The redundancy index formula is:

[0068] FRI a Indicates the functional redundancy index of characteristic mark a; M ab Indicates the functional similarity between feature flags a and b.

[0069] In a preferred embodiment, the acquisition logic of the adjustment cost index is:

[0070] e1, evaluates the difficulty of modifying feature flags in the code to form a functional complexity score;

[0071] Count the number of files and modules in the code base that the feature flag touches, marked as D a ;

[0072] Evaluate the logic paths and function call chain lengths that may be affected by code modifications of feature flags, marked as I a ;

[0073] Combine the code distribution breadth and modification impact range to calculate the code modification complexity C a ,formula:

[0074] C a =D a ×log(I a +1);

[0075] e2, evaluate the coverage of feature flags in the test and form a functional test coverage score;

[0076] Calculates coverage of feature flags in unit tests, marked as U a ;

[0077] Calculates the coverage of feature flags in integration tests, marked as J a ;

[0078] Combine unit test and integration test coverage to calculate functional test coverage T a ,formula:

[0079] e3, evaluates the impact of feature flag adjustments on the system deployment process and forms a deployment impact score;

[0080] Calculate the deployment frequency of the module where the feature flag is located, marked as L a ;

[0081] Evaluate the impact of feature flag changes on other services and modules, marked as R a ;

[0082] Combine the deployment frequency and impact scope to calculate the deployment impact score P a ,formula:

[0083] e4, calculates the adjustment cost index by combining code modification complexity, test coverage, and deployment impact;

[0084] The adjustment cost index ACI is calculated by comprehensively considering the complexity of code modification, test coverage, and deployment impact. a ,formula:

[0085] In a preferred embodiment, the query function of Neo4j is used to analyze the imported data, calculate the functional redundancy index and adjustment cost index of each characteristic mark, and combine the two to obtain the optimization warning coefficient;

[0086] For characteristic signs whose optimization warning coefficient is greater than the second warning threshold, it is recommended to prioritize optimization and cleanup to generate a red signal;

[0087] For optimization warning coefficients greater than or equal to the first warning threshold and less than or equal to the second warning threshold, it is recommended to maintain monitoring and regularly evaluate its status to generate a yellow warning signal;

[0088] For characteristic marks whose optimized warning coefficient is less than the first warning threshold, it is recommended not to make any changes temporarily and generate a green warning signal.

[0089] The technical effects and advantages of the software development method based on cloud computing of the present invention are as follows:

[0090] 1. The present invention achieves accurate sharding management by comprehensively evaluating the environmental adaptability spectrum and cross-module dependency entropy of feature flags, effectively improving the performance consistency and stability of the system. The environmental adaptability spectrum provides performance consistency data of feature flags in different execution environments, ensuring the stability of feature flags in development, testing and production environments, and reducing performance fluctuations caused by environmental differences. Cross-module dependency entropy reduces the coupling degree of the system, reduces the complexity of dependency paths, and improves the maintainability and scalability of the system by quantifying the dependency relationship between feature flags in multiple code modules. The comprehensive scoring method further optimizes the allocation strategy of feature flags, allocates feature flags with high adaptability and high consistency to key microservice modules, and ensures the high performance and high stability of these core modules. At the same time, feature flags with low adaptability and high complexity are isolated and optimized, and their performance is gradually improved to ensure the balance and efficient operation of the entire system. This comprehensive evaluation and sharding management strategy not only enhances the robustness of the system in multiple environments, but also improves the work efficiency of the development team, reduces the debugging and maintenance time caused by complex dependencies, and provides reliable guarantees for continuous integration and continuous delivery. Through scientific data analysis and intelligent decision support, the management of feature flags becomes more efficient and controllable, thereby promoting the continuous optimization and steady development of the cloud software development process.

[0091] 2. The present invention uses the Neo4j graph database to construct a dependency graph of feature flags, code modules, and configuration items, thereby achieving real-time updates and precise management, and significantly improving the scientificity and accuracy of dependency management. By calculating the functional redundancy index and adjustment cost index of feature flags, and combining the optimization warning coefficient to generate optimization and cleanup suggestions, it is possible to effectively identify and process unused or redundant feature flags, reducing system complexity and resource waste. Warning signals are distributed in real time through automated tools and CI / CD pipelines to ensure that the development team, operation and maintenance team, and monitoring module respond to and process the optimization and cleanup needs of feature flags in a timely manner. This innovative method ensures a significant improvement in the efficient operation and stability of the system, realizes dynamic adjustment and intelligent management of feature flags, provides a scientific decision-making basis, enhances the robustness and resource utilization of the system, and lays a solid foundation for the continuous optimization and steady development of the system. BRIEF DESCRIPTION OF THE DRAWINGS

[0092] Figure 1 It is a flowchart of the software development method based on cloud computing of the present invention. DETAILED DESCRIPTION

[0093] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0094] Example 1

[0095] Figure 1 The present invention provides a software development method based on cloud computing, comprising:

[0096] S1, in the microservice architecture, conduct system performance consistency analysis and dependency path complexity evaluation for each feature flag, obtain the environmental adaptability spectrum and cross-module dependency entropy respectively, and perform precise sharding management on the feature flags based on this;

[0097] S2, build a Neo4j graph database, construct nodes of feature flags, code modules, and configuration items, and edges of dependencies, regularly extract and import feature flags and their dependencies, and form a dependency graph that is updated in real time;

[0098] S3, using the query and analysis capabilities of the Neo4j graph database, calculates the functional redundancy index and adjustment cost index of the feature flag, generates optimization and cleanup suggestions based on the optimization warning coefficient, distributes red, yellow, and green signals, and guides priority optimization, monitoring evaluation, and regular inspections;

[0099] S4, based on the analysis results of the graph database, generates warning signals that are distributed in real time through automation tools and CI / CD pipelines.

[0100] In modern cloud computing environments, microservice architecture has become the mainstream paradigm for software development. By splitting applications into multiple independent service modules, it achieves high flexibility and scalability. However, with the increase in system complexity, how to effectively manage and optimize feature flags has become a key challenge. As a mechanism for controlling the enablement or disablement of software functions, feature flags have an important impact on system performance and stability. In different execution environments, feature flags may show different adaptability, and their dependencies between modules may also increase system complexity. Therefore, it is particularly important to manage feature flags reasonably based on scientific evaluation methods. Through the comprehensive analysis of the environmental adaptability spectrum and cross-module dependency entropy, the performance consistency and dependency complexity of feature flags in different environments can be accurately measured, thereby providing a solid data foundation for the optimization management of feature flags. This not only helps to improve the overall performance of the system, but also effectively reduces the maintenance difficulty caused by complex dependencies, and provides strong support for continuous integration and continuous delivery in the software development process. In this context, in-depth analysis and evaluation of each feature flag, and obtaining the environmental adaptability spectrum and cross-module dependency entropy have become a necessary prerequisite for achieving precise sharding management.

[0101] Step S1 includes the following contents:

[0102] In modern cloud computing and software development, the consistency and adaptability of system performance are important factors to ensure the stable operation of applications. As applications frequently switch between development, testing, and production environments, feature flags, as a key mechanism for controlling software functions, may perform significantly differently in different environments. The introduction of the environmental adaptability spectrum aims to provide a quantitative basis by scientifically evaluating the performance consistency of feature flags in different execution environments to ensure the stable performance of each feature flag in multiple environments. By recording performance data such as system response time, CPU usage, and memory usage, and combining spectrum analysis technology, the environmental adaptability spectrum can comprehensively reflect the adaptability characteristics of feature flags in multiple environments, providing solid data support for the optimal configuration of feature flags. This analysis method not only helps to identify and solve the performance bottlenecks of feature flags in different environments, but also lays the foundation for accurate sharding management under the microservice architecture, improving the reliability and maintainability of the overall system.

[0103] The logic for obtaining the environmental adaptability spectrum is:

[0104] a1, records system performance data in different execution environments when feature flags are enabled.

[0105] In development, test, and production environments, collect every performance metric of the system during the time the feature flag is enabled, including response time, CPU utilization, and memory utilization.

[0106] A time series is formed for each performance data of the system.

[0107] a2. De-noise and normalize the time series to ensure data quality.

[0108] Wavelet transform denoising is used to decompose and reconstruct time series data to remove high-frequency noise.

[0109] Normalize the denoised data and scale it to the [0,1] interval.

[0110] a3, convert the time domain signal into the frequency domain signal through fast Fourier transform (FFT) and extract the spectrum features.

[0111] The normalized time series data is subjected to fast Fourier transform to obtain the frequency domain signal.

[0112] The amplitude spectrum of the frequency domain signal is extracted to obtain the spectrum characteristics of each environment.

[0113] a4, calculate the differences in spectrum characteristics under different environments and measure the spectrum differences of characteristic marks under different environments.

[0114] Cosine Similarity is used to measure the similarity of spectral features in different environments.

[0115] Calculate the spectral similarity between development, test, and production environments:

[0116] Sim dev-test =Sim(|X dev (f)|,|X test (f));

[0117] Sim dev-prod =Sim(|X dev (f)|,|X prod (f)|);

[0118] Sim test-prod =Sim(|X test (f)|,|X prod (f)|);

[0119] |X dev (f)|: Spectral feature vector of the development environment. It is the amplitude spectrum of the frequency domain signal extracted from the time series signal of the development environment by fast Fourier transform. It is used to represent the spectral characteristics of the system performance in the development environment as part of the similarity calculation.

[0120] |X test(f)|: Spectral feature vector of the test environment. It is the amplitude spectrum of the frequency domain signal extracted from the time series signal of the test environment by fast Fourier transform. It is used to represent the spectral characteristics of the system performance in the test environment as part of the similarity calculation.

[0121] |X prod (f)|: Spectral feature vector of the production environment. It is the amplitude spectrum of the frequency domain signal extracted from the time series signal of the production environment through fast Fourier transform. It is used to represent the spectral characteristics of the system performance in the production environment as part of the similarity calculation.

[0122] Sim dev-test : The spectrum similarity between the development environment and the test environment. The spectrum feature vectors of the development environment and the test environment are calculated using the cosine similarity formula |X dev (f)| and |X test (f) | Similarity. Measures the performance consistency between the development environment and the test environment in the frequency domain.

[0123] Sim dev-prod : The spectrum similarity between the development environment and the production environment. The spectrum feature vectors of the development environment and the production environment are calculated using the cosine similarity formula |X dev (f)| and |X prod (f) | Similarity. Measures the performance consistency between the development environment and the production environment in the frequency domain.

[0124] Sim test-prod : The spectrum similarity between the test environment and the production environment. The spectrum feature vectors of the test environment and the production environment are calculated using the cosine similarity formula |X test (f)| and |X prod (f) | Similarity. Measures the performance consistency between the test environment and the production environment in the frequency domain.

[0125] a5, calculate the environmental adaptability spectrum (EAS) based on the spectrum difference to measure the adaptability of the characteristic mark in different environments.

[0126] Calculate the spectrum differences between the development environment and the test environment, the development environment and the production environment, and the test environment and the production environment. The spectrum difference is obtained by subtracting the cosine similarity from 1. The closer the value is to 0, the smaller the difference.

[0127] a6, calculate the sum of the spectrum differences of all environment pairs to obtain the total spectrum difference. Then, calculate the environmental adaptability spectrum based on the total spectrum difference. The environmental adaptability spectrum is obtained by dividing 1 by 1 plus the total spectrum difference. The smaller the spectrum difference, the higher the EAS value, indicating that the characteristic mark has better adaptability in different environments.

[0128] The environmental adaptability spectrum is used to measure the performance consistency and adaptability of feature tags in development, testing, and production environments. The larger the environmental adaptability spectrum value, the stronger the adaptability of the feature tag in different environments and the more consistent the performance; the smaller the environmental adaptability spectrum value, the poorer the adaptability of the feature tag in different environments and the significant difference in performance. In shard management, feature tags with high environmental adaptability spectrum values ​​are preferentially assigned to highly relevant code modules and microservices to ensure the stability and consistency of the system in different environments; feature tags with low environmental adaptability spectrum values ​​need to be further optimized and adjusted to ensure their adaptability in different environments, thereby improving the overall performance and management efficiency of the system.

[0129] In the cloud computing driven microservice architecture, dependency management of feature flags is an important part of ensuring efficient operation and maintenance of the system. The call frequency and path complexity of feature flags between different code modules directly affect the complexity and stability of the system. As a key indicator to measure the dependency complexity of feature flags, cross-module dependency entropy provides accurate data support for system dependency management by analyzing the dependencies and call paths of feature flags in each module. By extracting dependency data from the code repository, building a dependency call path tree, and calculating the complexity of the path, cross-module dependency entropy can fully reveal the dependency pattern of feature flags between multiple modules. This indicator not only helps the development team identify and optimize complex dependencies and reduce the coupling of the system, but also improves the maintainability and scalability of feature flags. In the context of continuous integration and continuous delivery, the application of cross-module dependency entropy provides a scientific basis for feature flag management under the microservice architecture, ensuring that the system remains efficient and stable during rapid iteration.

[0130] The logic for obtaining cross-module dependency entropy is:

[0131] b1, collect the dependency data of feature flags in different modules in the code repository, and record the dependency call path and frequency.

[0132] Extract the dependency relationship of feature flags in each module from the code repository to form a dependency call path. The dependency call path represents the calling order of feature flags in different modules.

[0133] Each call path records the call frequency and path identifier.

[0134] b2. De-duplicate and standardize dependency data to ensure data quality.

[0135] Remove duplicate dependency call paths to ensure that each path is unique. Normalize the call frequency and scale the frequency value to the [0,1] interval.

[0136] b3, build the dependency call path tree of feature flags in different modules and record the call frequency of each path.

[0137] The standardized dependency call path P i and its calling frequency C i ′ is organized into a tree structure. The root node is the feature mark, and the child nodes are the dependent modules. Each path starts from the root node and passes through multiple child nodes to form a complete call path.

[0138] b4, calculate the complexity of each dependent call path using the path complexity formula.

[0139] Calculate the length L(P i ).

[0140] Path length formula: Among them, n i For path P i The number of nodes on d j,j+1 is the distance from node j to node j+1.

[0141] Calculate the path complexity C(P i ).

[0142] Path complexity formula: C(P i )=-L(P i )log(C i ′+ε), where C i ′ is the normalized call frequency; ε is a very small constant to prevent the logarithmic zero value.

[0143] b5, the sum of the complexity of all dependency call paths is converted to the base of the natural logarithm, and the cross-module dependency entropy is calculated to comprehensively measure the dependency complexity of the feature flag.

[0144] Calculate the sum of the complexity S of all dependent call paths, the sum formula is: m is the total number of paths.

[0145] Calculate the cross-module dependency entropy. The specific formula is as follows: CMDE = (1 + e S ) -1 .

[0146] Cross-module dependency entropy is used to indicate the dependency complexity and consistency of feature flags between multiple code modules. A larger cross-module dependency entropy indicates that the dependency path of the feature flag is complex and scattered, and cross-module calls are frequent and the path is complex, which may increase the difficulty of management and maintenance, and the stability and consistency of the system may be affected. A smaller cross-module dependency entropy indicates that the dependency path of the feature flag is simple and concentrated, with fewer cross-module calls and simple paths, which is easy to manage and maintain, and helps to improve the stability and consistency of the system. Therefore, cross-module dependency entropy helps optimize the management of feature flag shards by quantifying the dependency relationship between feature flags and ensures the efficiency and stability of the cloud software development process.

[0147] The sharding management of feature flags is optimized by comprehensively considering the complex interaction between the environmental adaptability spectrum (EAS) and the cross-module dependency entropy (CMDE).

[0148] c1, normalize the environmental adaptability spectrum and cross-module dependency entropy and scale them to the [0,1] interval for subsequent calculations.

[0149] c2, extracts high-order characteristics of environmental adaptability spectrum and cross-module dependency entropy, and constructs a multi-dimensional feature space.

[0150] Construct the feature interaction matrix M of the environmental adaptability spectrum and cross-module dependency entropy, where M ov =EAS o ×CMDE v Represents the interactive relationship between the oth characteristic flag in terms of adaptability and dependency.

[0151] The interaction matrix is ​​used to generate high-order features, including quadratic, cubic, and polynomial features, to capture the complex relationship between environmental adaptability spectra and cross-module dependency entropy.

[0152] Generate secondary features: such as EAS 2 ,CMDE 2 ,EAS×CMDE;

[0153] Generate three-dimensional features: such as EAS 3 ,CMDE 3 , EAS 2 ×CMDE,EAS×CMDE 2 ;

[0154] c3, through feature importance analysis, identify the features that have the greatest impact on the overall score.

[0155] A random forest regression model is used to train high-order features and the feature importance of each feature is evaluated.

[0156] Training data: Use preprocessed EAS and CMDE data and their high-order features;

[0157] Model training: Build a random forest regression model, train and evaluate the importance of features;

[0158] c4, based on the results of feature importance analysis, select the most important features for combination.

[0159] The top k features with the highest feature importance scores are selected for combination (eg, k=5).

[0160] The selected high-order features are combined to construct a new feature vector for comprehensive score calculation.

[0161] c5, calculate the comprehensive score through feature combination and optimize the feature flag shard management.

[0162] Calculate the feature score for each feature flag, using the previously selected high-order features and feature combination results.

[0163] The interactive effects of high-order features and feature combinations are comprehensively considered to calculate the final comprehensive score.

[0164] For example, the feature score vector F is a combination of selected high-order features, and the comprehensive score S is:

[0165] Among them, Importance o is the feature importance of the o-th feature.

[0166] The application of multi-dimensional interaction scoring method in feature flag sharding management can provide more accurate and comprehensive feature flag evaluation by comprehensively considering the complex interaction between environmental adaptability spectrum (EAS) and cross-module dependency entropy (CMDE). First, the feature interaction matrix and high-order feature generation steps capture the deep relationship between feature flags in adaptability and dependency, so that the calculation results do not just stay at the comparison of surface values, but deeply explore the mutual influence between the two. The feature importance analysis of the random forest regression model ensures that the most critical features are selected for comprehensive scoring, avoids noise interference caused by redundant features, and improves the reliability of the scoring. Through feature selection and combination, the feature scoring is further refined to ensure that the comprehensive scoring can accurately reflect the performance of feature flags in different environments and dependency paths. The final intelligent sharding decision and dynamic adjustment mechanism reasonably allocates and optimizes feature flags based on the comprehensive score, ensuring the efficiency and stability of the system in different environments and dependency changes. Overall, this calculation and processing method not only improves the accuracy and efficiency of feature flag sharding management, but also enhances the adaptability and maintainability of the system, ensuring the continuous optimization and robust operation of the cloud software development process.

[0167] c6, compare the comprehensive score with the first classification threshold and the second classification threshold respectively:

[0168] For feature flags with a comprehensive score greater than the second classification threshold, they are assigned to high-priority microservice modules. These modules are usually core modules that require high stability and high performance.

[0169] For feature flags whose comprehensive scores are greater than or equal to the first classification threshold and less than or equal to the second classification threshold, they are assigned to medium-priority microservice modules. These modules handle non-critical tasks and can tolerate certain performance fluctuations.

[0170] For feature flags whose comprehensive scores are less than the second classification threshold, they are assigned to low-priority microservice modules or isolated environments for observation and optimization.

[0171] The present invention realizes accurate sharding management by comprehensively evaluating the environmental adaptability spectrum and cross-module dependency entropy of feature flags, and effectively improves the performance consistency and stability of the system. The environmental adaptability spectrum provides the performance consistency data of feature flags in different execution environments, ensures the stability of feature flags in development, testing and production environments, and reduces performance fluctuations caused by environmental differences. Cross-module dependency entropy reduces the coupling degree of the system, reduces the complexity of dependency paths, and improves the maintainability and scalability of the system by quantifying the dependency relationship between feature flags in multiple code modules. The comprehensive scoring method further optimizes the allocation strategy of feature flags, allocates feature flags with high adaptability and high consistency to key microservice modules, and ensures the high performance and high stability of these core modules. At the same time, feature flags with low adaptability and high complexity are isolated and optimized, and their performance is gradually improved to ensure the balance and efficient operation of the entire system. This comprehensive evaluation and sharding management strategy not only enhances the robustness of the system in multiple environments, but also improves the work efficiency of the development team, reduces the debugging and maintenance time caused by complex dependencies, and provides reliable guarantee for continuous integration and continuous delivery. Through scientific data analysis and intelligent decision support, the management of feature flags becomes more efficient and controllable, thereby promoting the continuous optimization and steady development of the cloud software development process.

[0172] In modern cloud computing and microservice architecture, the complexity and dynamic nature of dependencies make the management of feature flags particularly important. In order to ensure the efficiency and stability of the system, a method that can update and analyze dependencies in real time is needed. The Neo4j graph database, with its powerful graph processing capabilities and efficient query performance, has become an ideal tool for handling such complex dependencies. By building nodes of feature flags, code modules, configuration items, and edges of dependencies, and regularly extracting and importing the latest dependency data, a real-time updated dependency graph can be formed. This not only intuitively displays the interconnection and interaction of various elements in the system, but also provides accurate data support for subsequent optimization and cleanup. This process will greatly improve the scientificity and accuracy of dependency management, and provide a solid foundation for the continuous optimization and stable operation of the system.

[0173] Step S2 includes the following contents:

[0174] S2.1, build the node and edge model of Neo4j graph database on the cloud platform. The nodes include feature flags, code modules and configuration items, and the edges represent dependencies and call paths.

[0175] S2.2, preprocessing and format conversion of the feature flag dependency data generated in step S1 to ensure that the data complies with the import specification of Neo4j, including the normalization of node attributes and the clarification of edge relationships.

[0176] The feature flag dependency data includes the dependency frequency of each feature flag in each module, the complexity of the dependency path, and the structured representation of these dependencies. Specifically, it includes the following:

[0177] Feature flag node data: unique identifier, name, related environmental adaptability spectrum (EAS) value and cross-module dependency entropy (CMDE) value of each feature flag.

[0178] Code module node data: each code module's unique identifier, name, and relationship to feature flags.

[0179] Configuration item node data: each configuration item's unique identifier, name, and relationship to feature flags.

[0180] Dependency edge data: describes the call paths and dependencies between feature flags and code modules, and feature flags and configuration items, including information such as call frequency and path complexity.

[0181] Data preprocessing and format conversion:

[0182] The unique identifier, name, environmental adaptability spectrum (EAS) value, and cross-module dependency entropy (CMDE) value of the characteristic mark are standardized to ensure data consistency.

[0183] Normalize the unique identifiers and names of code modules to ensure clear associations with feature flags.

[0184] Standardize the unique identifiers and names of configuration items to ensure clear associations with feature flags.

[0185] The dependency data is formatted to ensure that each dependency contains information such as source node (feature flag), target node (code module or configuration item), call frequency, and path complexity.

[0186] S2.3, import the preprocessed feature flags, code modules and configuration item data into the Neo4j graph database, establish the initial dependency graph, and ensure that the graph database can reflect the current dependency structure of the system.

[0187] S2.4, regularly extract the latest feature flags and their dependency data from the code repository and system logs to ensure the timeliness and accuracy of the data, and import the extracted new data into the Neo4j graph database to achieve real-time updates of the dependency graph and ensure that the dependencies in the database are always consistent with the actual system conditions.

[0188] In complex cloud computing and microservice environments, the optimization and cleanup of feature flags are crucial to the efficient operation and stability of the system. Traditional manual management methods can no longer meet the ever-changing and expanding system requirements. By leveraging the powerful query and analysis capabilities of the Neo4j graph database, automatically identifying unused or redundant feature flags and generating optimization and cleanup suggestions can significantly improve management efficiency and accuracy. Through an intelligent decision-making model, combined with the functional redundancy index and the adjustment cost index, the status of feature flags is dynamically adjusted to ensure the reasonable distribution and efficient operation of each feature flag in the system. This prospective vision can not only optimize the utilization of system resources, reduce unnecessary complexity and waste of resources, but also help development and operation teams respond to and handle potential problems in a timely manner through a real-time early warning mechanism, ensuring that the system maintains optimal performance and stability in a changing environment.

[0189] Step S3 includes the following contents:

[0190] The logic for obtaining the functional redundancy index is:

[0191] d1, extract the functional characteristics of each feature flag and form a functional feature vector.

[0192] A functional feature set G is defined for each feature flag, including input parameters, output results, key operations, involved modules, etc.

[0193] Convert the functional features into feature vector X a .Xa =[g1,g2,...,g m ];

[0194] g l The lth functional characteristic value of the representative mark; m represents the total number of functional characteristics.

[0195] d2, calculates the functional similarity between each pair of feature landmarks.

[0196] Use cosine similarity to measure the similarity between functional feature vectors. The cosine similarity formula is:

[0197] X a , X b Functional feature vector representing characteristic flags; ||X a || represents the modulus of the eigenvector.

[0198] Calculate the functional similarity between all feature flag pairs to form a functional similarity matrix M. Matrix element: M ab =CosSim(X a ,X b ).

[0199] d3, evaluates the functional overlap of each feature flag.

[0200] Calculate the functional overlap between the feature flag and all other feature flags. Functional overlap formula:

[0201] O a represents the functional overlap of characteristic mark a; N represents the total number of characteristic marks.

[0202] d4, introduces function importance and adjusts the weight of overlap.

[0203] Assign a feature importance weight Q to each feature flag a , based on its criticality in the system. Importance weight formula:

[0204] Criticality a Indicates the criticality of feature flag a; c is a changing index used to traverse each feature flag in the system, ranging from 1 to N.

[0205] Calculate the weighted functional overlap. Weighted overlap formula:

[0206] d5, based on the weighted functional overlap, calculate the functional redundancy index of each feature marker.

[0207] Combine the weighted overlap and the functional similarity matrix to calculate the functional redundancy index FRI. Redundancy index formula:

[0208] FRI a Indicates the functional redundancy index of characteristic mark a; M ab Indicates the functional similarity between feature flags a and b.

[0209] The functional redundancy index is used to indicate the functional redundancy of a feature mark in the system. It is quantified by evaluating the overlap between its functional characteristics and other feature marks. A larger value indicates that the function of the feature mark has a higher degree of overlap with the functions of other feature marks in the system, and there is a higher redundancy, which may lead to increased system complexity and resource waste; a smaller value indicates that the function of the feature mark is more unique and has low redundancy, which helps simplify and optimize the system. In this scenario, by calculating the functional redundancy index, you can identify and optimize redundant feature marks in the system, reduce unnecessary functional duplication, improve system performance and resource utilization, and ensure system efficiency and stability.

[0210] The logic for obtaining the adjustment cost index is:

[0211] e1, evaluates the difficulty of modifying feature flags in the code to form a functional complexity score.

[0212] Count the number of files and modules in the code base that the feature flag touches, marked as D a .

[0213] Evaluate the logic paths and function call chain lengths that may be affected by code modifications of feature flags, marked as I a .

[0214] The purpose of evaluating the logical paths and function call chain lengths that may be affected by code modifications of feature flags is to fully understand the scope and complexity of the impact of feature flags in the system. Specifically, this step analyzes all logical paths involving feature flags in the code base, including the execution path of the feature flag under different conditions, the interaction with other modules or components, and the length of the function call chain. The function call chain length refers to the total length of all function calls from the function where the feature flag is located to the final execution completion. In this way, the scope of impact that the modification of feature flags may have on the system can be determined, the potential risks and workload that these modifications may cause can be evaluated, and the complexity of code modification can be quantified. This comprehensive analysis helps to more accurately understand the role and dependencies of feature flags in the system, and provides a scientific basis for optimizing and adjusting feature flags.

[0215] Combine the code distribution breadth and modification impact range to calculate the code modification complexity C a Formula: C a =D a ×log(I a +1);

[0216] e2, evaluate the coverage of feature flags in the test and form a functional test coverage score.

[0217] Calculates coverage of feature flags in unit tests, marked as U a .

[0218] The coverage rate in unit testing is one of the important indicators to measure the quality of software testing, which refers to the degree of coverage of source code by unit test cases. Specifically, unit test coverage rate evaluates the completeness and effectiveness of test cases by analyzing the number of code lines, functions or methods, branches and paths covered by test cases during execution. The higher the coverage rate, the more code is executed and verified by the test cases, which helps to find potential errors and defects. Common types of coverage rate include line coverage rate, branch coverage rate and path coverage rate, among which line coverage rate refers to the proportion of code lines covered by test cases to the total code lines, branch coverage rate refers to the proportion of code branches covered by test cases to the total branches, and path coverage rate refers to the proportion of code execution paths covered by test cases to the total paths. By improving the unit test coverage rate, the reliability and stability of the code can be enhanced, ensuring that the software can run normally in various situations, and providing a solid foundation for system quality assurance.

[0219] Calculates the coverage of feature flags in integration tests, marked as J a .

[0220] The coverage rate in integration testing refers to the degree of test coverage of the interactions between modules or components in the software system during the integration testing process. Specifically, integration testing focuses on the behavior and performance of each module or component when working together to ensure that they can work together correctly. The coverage rate measures the proportion of code paths, function calls, and logic branches covered by test cases in integration testing. A high coverage rate means that most module interaction scenarios are covered by test cases, thereby verifying the overall functionality and reliability of the system. By calculating the coverage rate of integration testing, the comprehensiveness and effectiveness of test cases can be evaluated, potential interaction problems and defects in the system can be discovered, and the software can be ensured to run stably in a complex integrated environment. This indicator is of great significance for ensuring software quality and improving system reliability, and is a key parameter for evaluating the adequacy and effectiveness of testing.

[0221] Combine unit test and integration test coverage to calculate functional test coverage T a . formula:

[0222] e3, evaluates the impact of feature flag adjustments on the system deployment process and forms a deployment impact score.

[0223] Calculate the deployment frequency of the module where the feature flag is located, marked as L a .

[0224] The deployment frequency of the module where the feature flag is located refers to the frequency of the module being deployed to the production environment or other execution environment during the software development and operation and maintenance process. This frequency reflects the frequency of updates and releases of the module, including code modifications, function iterations, and new version releases. A module with a high deployment frequency usually means that the code and functions of the module change frequently, which may be associated with multiple feature flags and may involve more dependencies and interaction interfaces. Evaluating the deployment frequency of the module where the feature flag is located helps understand the impact of changes in the feature flag on the overall stability of the system and the continuous integration / continuous delivery process, and helps the development team better predict and manage potential deployment risks and costs when optimizing and adjusting feature flags, thereby ensuring smooth operation and efficient delivery of the system.

[0225] Evaluate the impact of feature flag changes on other services and modules, marked as R a .

[0226] The degree of impact of feature flag adjustment on other services and modules refers to the chain reaction and impact that these changes may have on other related services and modules in the system when a feature flag is modified or cleaned up. Specifically, this includes the dependency relationship between feature flags between different services and modules, and the errors, performance issues, or functional failures that may be caused by adjusting the feature flag. In order to evaluate this impact, it is necessary to analyze the call relationship and data interaction between feature flags and other services and modules, and determine which services and modules directly or indirectly depend on the feature flag. It is also necessary to consider the strength and importance of these dependencies. For example, some core services have a high degree of dependence on feature flags, and adjustments may cause problems in key functions of the system. Therefore, evaluating the impact of feature flag adjustments on other services and modules helps to fully understand and quantify the risks and impacts that these changes may have on the entire system, provide data support for formulating scientific adjustment strategies, and ensure the stability and reliability of the system.

[0227] Combine the deployment frequency and impact scope to calculate the deployment impact score P a . formula:

[0228] e4, calculates the adjustment cost index by combining code modification complexity, test coverage, and deployment impact.

[0229] The adjustment cost index ACI is calculated by comprehensively considering the complexity of code modification, test coverage, and deployment impact. a .

[0230] formula: ;

[0231] The adjustment cost index is used to represent the comprehensive cost required to modify, test, and deploy feature flags in the system. A larger value indicates that the adjustment of the feature flag has a greater impact on the system, involving high modification complexity, low test coverage, high deployment frequency, and a wide impact range, which means that adjusting the feature flag will consume more resources and time; a smaller value indicates that the adjustment of the feature flag has a smaller impact on the system, with low modification complexity, high test coverage, low deployment frequency, and a limited impact range, which means that adjusting the feature flag is relatively simple and has low resource and time costs. In this scenario, by calculating the adjustment cost index, the development team can reasonably evaluate and plan the adjustment priority of feature flags, optimize the management and adjustment strategy of feature flags, ensure the overall performance and stability of the system, and effectively control development and operation and maintenance costs.

[0232] Using the query function of Neo4j, the imported data is analyzed to calculate the functional redundancy index and adjustment cost index of each feature flag, and the two are combined to obtain the optimization warning coefficient. Based on the optimization warning coefficient, optimization and cleanup suggestions for the feature flag are generated.

[0233] For example, the optimization warning coefficient can be calculated using the following formula:

[0234] Among them, OCC represents the optimization warning coefficient; FRI norm and ACI norm are the normalized functional redundancy index and adjustment cost index respectively; α and β are the preset proportional coefficients of the normalized functional redundancy index and adjustment cost index respectively, and both are greater than zero.

[0235] The optimization warning coefficient is used to indicate the combined impact of the adjustment cost and functional redundancy of feature flags in the system. A larger value indicates that the adjustment and cleanup of the feature flag has a greater impact on the system and there is a higher functional redundancy, which means that the feature flag may increase system complexity and waste resources, and needs to be optimized and cleaned up first; a smaller value indicates that the adjustment and cleanup of the feature flag has a smaller impact on the system and has a lower degree of functional redundancy, a lower adjustment cost, and a limited impact on system performance. By calculating the optimization warning coefficient, the development team can identify and prioritize feature flags that need to be optimized and cleaned up, provide a scientific basis for decision-making, ensure the overall performance and stability of the system, and effectively control development and operation and maintenance costs. Through the early warning mechanism, timely respond to feature flags with high optimization warning coefficients to prevent potential risks from having a significant impact on the system, and achieve continuous optimization and stable operation of the system.

[0236] The specific steps are as follows:

[0237] For feature flags whose optimization warning coefficient is greater than the second warning threshold, it is recommended to prioritize optimization and cleanup to generate red signals. These feature flags have high adjustment costs and functional redundancy, which may lead to increased complexity and waste of resources. Specific suggestions include code refactoring, function merging or removal, simplifying dependencies, and increasing test coverage.

[0238] For optimization warning coefficients greater than or equal to the first warning threshold and less than or equal to the second warning threshold, it is recommended to maintain monitoring and regularly evaluate their status to generate yellow warning signals. The adjustment cost and functional redundancy of these feature flags are at a medium level, and optimization adjustments are made when necessary. Specific recommendations include optimizing some code paths, improving test coverage, and monitoring performance indicators.

[0239] For feature flags whose optimization warning coefficient is less than the first warning threshold, it is recommended not to make any changes for the time being and generate a green warning signal. These feature flags have low adjustment costs and functional redundancy, and have limited impact on system performance. Specific recommendations include maintaining regular inspections to ensure that low costs and low redundancy are maintained during system evolution.

[0240] Step S4 includes the following contents:

[0241] The generated warning signals are distributed to the relevant microservices in real time through automation tools and monitoring systems. The automatic distribution of signals is achieved through the integrated CI / CD pipeline. The red warning signals are sent to the development team and operation and maintenance team responsible for the feature flags to trigger an immediate processing flow. The yellow warning signals are distributed to the monitoring modules of the relevant microservices, indicating the need for regular evaluation and optimization. The green signals are kept in a state of regular inspection through logging and status monitoring tools. This real-time distribution mechanism can ensure that each team and microservice module can respond to and handle the optimization and cleanup needs of the feature flags in a timely manner, ensuring the efficient operation and stability of the system.

[0242] The present invention uses the Neo4j graph database to construct a dependency graph of feature flags, code modules, and configuration items, thereby achieving real-time updates and precise management, and significantly improving the scientificity and accuracy of dependency management. By calculating the functional redundancy index and adjustment cost index of feature flags, and combining the optimization warning coefficient to generate optimization and cleanup suggestions, it is possible to effectively identify and process unused or redundant feature flags, reducing system complexity and resource waste. Warning signals are distributed in real time through automated tools and CI / CD pipelines to ensure that the development team, operation and maintenance team, and monitoring module respond to and process the optimization and cleanup needs of feature flags in a timely manner. This innovative method ensures a significant improvement in the efficient operation and stability of the system, realizes dynamic adjustment and intelligent management of feature flags, provides a scientific decision-making basis, enhances the robustness and resource utilization of the system, and lays a solid foundation for the continuous optimization and steady development of the system.

[0243] The above formulas are all dimensionless and numerical calculations. The formula is a formula for the most recent real situation obtained by collecting a large amount of data and performing software simulation. The preset parameters in the formula are set by technicians in this field according to actual conditions.

[0244] The above description is only by way of illustration of certain exemplary embodiments of the present invention. It is undoubted that those skilled in the art can modify the described embodiments in various ways without departing from the spirit and scope of the present invention. Therefore, the above drawings and descriptions are illustrative in nature and should not be construed as limiting the scope of protection of the claims of the present invention.

[0245] It should be noted that, in this article, if there are relational terms such as first and second, etc., they are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or device. In the absence of further restrictions, the elements defined by the sentence "including a..." do not exclude the existence of other identical elements in the process, method, article or device including the elements.

[0246] The above is only a specific implementation of the present application, but the protection scope of the present application is not limited thereto. Any person skilled in the art who is familiar with the present technical field can easily think of changes or substitutions within the technical scope disclosed in the present application, which should be included in the protection scope of the present application. Therefore, the protection scope of the present application should be based on the protection scope of the claims.

Claims

1. A software development method based on cloud computing, characterized in that: Includes steps: S1, in the microservice architecture, conduct system performance consistency analysis and dependency path complexity evaluation for each feature flag, obtain the environmental adaptability spectrum and cross-module dependency entropy respectively, and perform precise sharding management on the feature flags based on this; S2, build a Neo4j graph database, construct nodes of feature flags, code modules, and configuration items, and edges of dependencies, regularly extract and import feature flags and their dependencies, and form a dependency graph that is updated in real time; S3, using the query and analysis capabilities of the Neo4j graph database, calculates the functional redundancy index and adjustment cost index of the feature flag, generates optimization and cleanup suggestions based on the optimization warning coefficient, distributes red, yellow, and green signals, and guides priority optimization, monitoring evaluation, and regular inspections; S4, based on the analysis results of the graph database, generates warning signals that are distributed in real time through automation tools and CI / CD pipelines.

2. The cloud computing-based software development method according to claim 1, characterized in that: The logic for obtaining the environmental adaptability spectrum is: a1, records system performance data in different execution environments when feature flags are enabled; a2, denoising and normalizing the time series to ensure data quality; a3, convert the time domain signal into the frequency domain signal through fast Fourier transform and extract the spectrum features; a4, calculate the differences in spectrum characteristics under different environments and measure the spectrum differences of characteristic marks under different environments; a5, calculate the spectrum difference between the development environment and the test environment, the development environment and the production environment, and the test environment and the production environment. The spectrum difference is obtained by subtracting the cosine similarity from 1; a6, calculate the sum of the spectrum differences of all environment pairs to obtain the total spectrum difference, and then calculate the environmental adaptability spectrum based on the total spectrum difference. The environmental adaptability spectrum is obtained by dividing 1 by 1 plus the total spectrum difference.

3. The cloud computing-based software development method according to claim 2, characterized in that: The logic for obtaining cross-module dependency entropy is: b1, collect the dependency data of feature flags in different modules in the code repository, and record the dependency call path and frequency; Extract the dependency relationship of feature flags in each module from the code repository to form a dependency call path. The dependency call path represents the call sequence of feature flags between different modules. Each call path records the call frequency and path identifier. b2, deduplicate and standardize dependency data; b3, build the dependency call path tree of feature flags in different modules and record the call frequency of each path; The standardized dependency call path P i and its calling frequency C′ i Organized into a tree structure, the root node is the feature mark, the child nodes are the dependent modules, and each path starts from the root node and passes through multiple child nodes to form a complete call path; b4, calculate the complexity of each dependent call path, using the path complexity formula; calculate the length L(P i ); Path length formula: Among them, n i For path P i The number of nodes on d j,j+1 is the distance from node j to node j+1; the path complexity C(P i ); Path complexity formula: C(P i )=-L(P i )log(C′ i +ε), where C′ i is the normalized call frequency; ε is a very small constant to prevent the logarithmic zero value; b5, the sum of the complexity of all dependency call paths is converted to the base of the natural logarithm, and the cross-module dependency entropy is calculated to comprehensively measure the dependency complexity of the feature flag; Calculate the sum of the complexity S of all dependent call paths, the sum formula is: m is the total number of paths; Calculate the cross-module dependency entropy. The specific formula is as follows: CMDE = (1 + e S ) -1 .

4. The cloud computing-based software development method according to claim 3, characterized in that: c1, normalization of environmental adaptability spectrum and cross-module dependency entropy; c2, extracting high-order characteristics of environmental adaptability spectrum and cross-module dependency entropy, and constructing a multi-dimensional feature space; Construct the feature interaction matrix M of the environmental adaptability spectrum and cross-module dependency entropy, where M ov =EAS o ×CMDE v It represents the interactive relationship between the oth characteristic flag in terms of adaptability and dependence; The interaction matrix is ​​used to generate high-order features, including quadratic, cubic, and polynomial features, to capture the complex relationship between environmental adaptability spectra and cross-module dependency entropy; Generate secondary features: such as EAS 2 ,CMDE 2 ,EAS×CMDE; Generate three-dimensional features: such as EAS 3 ,CMDE 3 , EAS 2 ×CMDE,EAS×CMDE 2 ; c3, use the random forest regression model to train high-order features and evaluate the feature importance of each feature; c4, based on the results of feature importance analysis, select the most important features for combination; Select the top k features with the highest feature importance scores for combination; combine the selected high-order features to construct a new feature vector for comprehensive score calculation; c5, calculates the comprehensive score through feature combination and optimizes the feature flag shard management; Calculate the feature score for each feature flag and combine the top k features with the highest feature importance scores; The final comprehensive score is calculated by comprehensively considering the interactive effects of high-level features and feature combinations; The comprehensive score S is: Importance o is the feature importance of the oth feature; c6, compare the comprehensive score with the first classification threshold and the second classification threshold respectively: For feature flags with a comprehensive score greater than the second classification threshold, they are assigned to high-priority microservice modules; for feature flags with a comprehensive score greater than or equal to the first classification threshold and less than or equal to the second classification threshold, they are assigned to medium-priority microservice modules; For feature flags whose comprehensive scores are less than the second classification threshold, they are assigned to low-priority microservice modules or isolated environments.

5. The cloud computing-based software development method according to claim 4, characterized in that: Step S2 includes the following contents: S2.1, build the node and edge model of Neo4j graph database on the cloud platform. The nodes include feature flags, code modules and configuration items, and the edges represent dependencies and call paths; S2.2, preprocessing and formatting the feature flag dependency data generated in step S1; The feature flag dependency data includes the dependency frequency of each feature flag in each module, the complexity of the dependency path, and the structured representation of these dependencies; S2.3, import the preprocessed feature flags, code modules and configuration item data into the Neo4j graph database to build an initial dependency graph; S2.4, regularly extract the latest feature flags and their dependency data from the code repository and system logs, and import the extracted new data into the Neo4j graph database.

6. The cloud computing-based software development method according to claim 5, characterized in that: The logic for obtaining the functional redundancy index is: d1, extract the functional characteristics of each characteristic mark to form a functional feature vector; Define a functional feature set G for each feature flag, including input parameters, output results, key operations, and involved modules; Convert the functional features into feature vector X a ;X a =[g1,g2,...,g m ]; g l The lth functional characteristic value of the representative mark; m represents the total number of functional characteristics; d2, calculate the functional similarity between each pair of feature markers; Use cosine similarity to measure the similarity between functional feature vectors. The cosine similarity formula is: X a , X b Functional feature vector representing characteristic flags; ||X a || represents the modulus of the eigenvector; Calculate the functional similarity between all feature flag pairs to form a functional similarity matrix M, with matrix elements: M ab =CosSim(X a ,X b ); d3, evaluate the functional overlap of each feature marker; Calculate the functional overlap between the feature flag and all other feature flags. The functional overlap formula is: O a represents the functional overlap of characteristic mark a; N represents the total number of characteristic marks; d4, introduces function importance and adjusts the weight of overlap; Assign a feature importance weight Q to each feature flag a , based on its criticality in the system, the importance weight formula is: Criticality a Indicates the criticality of feature flag a; c is a variable index used to traverse each feature flag in the system, ranging from 1 to N; Calculate the weighted functional overlap. The weighted overlap formula is: d5, based on the weighted functional overlap, calculate the functional redundancy index of each characteristic marker; Combine the weighted overlap and functional similarity matrix to calculate the functional redundancy index FRI. The redundancy index formula is: FRI a Indicates the functional redundancy index of characteristic mark a; M ab Indicates the functional similarity between feature flags a and b.

7. The cloud computing-based software development method according to claim 6, characterized in that: The logic for obtaining the adjustment cost index is: e1, evaluates the difficulty of modifying feature flags in the code to form a functional complexity score; Count the number of files and modules in the code base that the feature flag touches, marked as D a ; Evaluate the logic paths and function call chain lengths that may be affected by code modifications of feature flags, marked as I a ; Combine the code distribution breadth and modification impact range to calculate the code modification complexity C a ,formula: C a =D a ×log(I a +1); e2, evaluate the coverage of feature flags in the test and form a functional test coverage score; Calculates coverage of feature flags in unit tests, marked as U a ; Calculates the coverage of feature flags in integration tests, marked as J a ; Combine unit test and integration test coverage to calculate functional test coverage T a ,formula: e3, evaluates the impact of feature flag adjustments on the system deployment process and forms a deployment impact score; Calculate the deployment frequency of the module where the feature flag is located, marked as L a ; Evaluate the impact of feature flag changes on other services and modules, marked as R a ; Combine the deployment frequency and impact scope to calculate the deployment impact score P a ,formula: e4, calculates the adjustment cost index by combining code modification complexity, test coverage, and deployment impact; The adjustment cost index ACI is calculated by comprehensively considering the complexity of code modification, test coverage, and deployment impact. a ,formula:

8. The cloud computing-based software development method according to claim 7, characterized in that: Using Neo4j's query function, we analyze the imported data, calculate the functional redundancy index and adjustment cost index of each feature flag, and combine the two to obtain the optimization warning coefficient; For characteristic signs whose optimization warning coefficient is greater than the second warning threshold, it is recommended to prioritize optimization and cleanup to generate a red signal; For optimization warning coefficients greater than or equal to the first warning threshold and less than or equal to the second warning threshold, it is recommended to maintain monitoring and regularly evaluate its status to generate a yellow warning signal; For characteristic marks whose optimized warning coefficient is less than the first warning threshold, it is recommended not to make any changes temporarily and generate a green warning signal.

Images